Alle Beiträge von Tobias Guggenberger

Ein Arduino sendet PUSH Nachrichten

Wenn man einem Arduino ein Ethernet Shield spendiert ist dieser im Netzwerk ansprechbar. Aber außer ein par Sensoren zu betreiben und LEDs an und aus zu schalten kann er auch PUSH Meldungen senden.



Als erstes benötigt man einen Account bei einem PUSH Dienst. In meinem Beispiel verwende ich den Dienst pushingbox.com.

Weil es den Rahmen hier sprengen würde die vielen Möglichkeiten des Dienstes zu erklären hier ein kleines Video für den „Erstkontakt“.

Nun kann man im Bereich API sich den Sketch für einen Arduino ansehen.

https://www.pushingbox.com/api.php

Hier nun mal der Sketch von pushingbox.com (Stand 2018)

////
//
// General code from http://www.pushingbox.com for Arduino + Ethernet Shield (official) v1.2
//
////

#include <SPI.h>
#include <Ethernet.h>

  /////////////////
 // MODIFY HERE //
/////////////////
byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x19 };   // Be sure this address is unique in your network

//Your secret DevID from PushingBox.com. You can use multiple DevID  on multiple Pin if you want
char DEVID1[] = "Your_DevID_Here";        //Scenario : "The mailbox is open"

//Numeric Pin where you connect your switch
uint8_t pinDevid1 = 3; // Example : the mailbox switch is connect to the Pin 3

// Debug mode
boolean DEBUG = true;
  //////////////
 //   End    //
//////////////


char serverName[] = "api.pushingbox.com";
boolean pinDevid1State = false;                // Save the last state of the Pin for DEVID1
boolean lastConnected = false;                 // State of the connection last time through the main loop


// Initialize the Ethernet client library
// with the IP address and port of the server 
// that you want to connect to (port 80 is default for HTTP):
EthernetClient client;

void setup() {
  Serial.begin(9600);
  pinMode(pinDevid1, INPUT);
  
  // start the Ethernet connection:
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // no point in carrying on, so do nothing forevermore:
    while(true);
  }
  else{
    Serial.println("Ethernet ready");
    // print the Ethernet board/shield's IP address:
    Serial.print("My IP address: ");
    Serial.println(Ethernet.localIP());
  }
  // give the Ethernet shield a second to initialize:
  delay(1000);
}

void loop()
{
      ////
      // Listening for the pinDevid1 state
      ////
      if (digitalRead(pinDevid1) == HIGH && pinDevid1State == false) // switch on pinDevid1 is ON 
      {
        if(DEBUG){Serial.println("pinDevid1 is HIGH");}
        pinDevid1State = true;
        //Sending request to PushingBox when the pin is HIGH
        sendToPushingBox(DEVID1);
      }
       if (digitalRead(pinDevid1) == LOW && pinDevid1State == true) // switch on pinDevid1 is OFF
      {
        if(DEBUG){Serial.println("pinDevid1 is LOW");}
        pinDevid1State = false;
        //Sending request to PushingBox when the pin is LOW
        //sendToPushingBox(DEVID1);    //Here you can run an other scenario by creating a DEVID2 variable
      }
      
      
      //DEBUG part
      // this write the respons from PushingBox Server.
      // You should see a "200 OK"
      if (client.available()) {
        char c = client.read();
        if(DEBUG){Serial.print(c);}
      }
      
      // if there's no net connection, but there was one last time
      // through the loop, then stop the client:
      if (!client.connected() && lastConnected) {
        if(DEBUG){Serial.println();}
        if(DEBUG){Serial.println("disconnecting.");}
        client.stop();
      }
      lastConnected = client.connected();
}


//Function for sending the request to PushingBox
void sendToPushingBox(char devid[]){
  client.stop();
  if(DEBUG){Serial.println("connecting...");}

  if (client.connect(serverName, 80)) {
    if(DEBUG){Serial.println("connected");}

    if(DEBUG){Serial.println("sendind request");}
    client.print("GET /pushingbox?devid=");
    client.print(devid);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.println(serverName);
    client.println("User-Agent: Arduino");
    client.println();
  } 
  else {
    if(DEBUG){Serial.println("connection failed");}
  }
}

So, nun nur noch deine „Your_DevID_Here“ ändern. Diese kannst du unter „My Service“ neu anlegen.

In meinem Beispiel twittert nun der Arduino bei einem Ereigniss am PIN3.
Natürlich kann man auch einen entsprechenden Dienst aussuchen um eine PUSH Nachricht auf dein Handy zu bekommen.

So einfach ….

DLNA! Oder Videos im ganzen Netzwerk Zuhause

Für alle digitalen Endgeräte die DLNA unterstutzen stellt minidlna den passenden Server zur verfügung. DLNA/UPnP Gerate erkennt der Medienserver automatisch. Der Inhalt des Medienservers kann auf Ihnen als Stream abgerufen werden.

Bevor man allerdings schauen kann muss Installiert werden.

sudo apt-get install minidlna

Als nächster Schritt muss die Konfiguration des minidlna geändert werden. Hierzu muss das File mit einem Editor als root geöffnet werden.

sudo nano /etc/minidlna.conf

Nachfolgende Punkte sind zu ändern:

media_dir=V,/path/to/media
db_dir=/var/lib/minidlna
log_dir=/var/log
log_level=warn
friendly_name=MiniDLNA
inotify=yes
  • media_dir: Das V steht für Video, A fuer Audio und P fuer Bilder gefolgt vom entsprechendem Pfad.
  • db_- und log_dir immer setzen um Fehler leichter zu finden.
  • log_level auf warn lassen. kann recht Hilfreich sein.
  • inotify scannt automatisch Änderungen. Dieser Befehl dient dazu neue Dateien einzupflegen.
  • friendly_name ist der Name des DLNA Servers im Netzwerk.

Nun werden noch die Maximalen Beobachter erhöht. (max_user_watches).

gksudo gedit /etc/sysctl.conf

Wie immer an das Ende springen und folgende Zeile hinzufuegen:

fs.inotify.max_user_watches=1048576

Nun speichern! Mit dem nächsten Befehl werden die Änderungen wirksam gemacht

sudo sysctl -p

Nun noch den Dienst RE-Starten. (reload)

sudo /etc/init.d/minidlna force-reload

Servos mit dem Raspberry ansteuern

Einen Servo an einem Raspberry zu betreiben ist mit der richtigen Bibliothek einfacher als man denkt. Das Stichwort dafuer ist „ServoBlaster“.

ServoBlaster installieren

mkdir -p ~/servoblaster/ 
cd ~/servoblaster/
git clone https://github.com/richardghirst/PiBits
mv PiBits/ServoBlaster/ . && rm -rf PiBits
cd ServoBlaster/user
sudo make install

Mehr ist es nicht. Jetzt noch den Servo mit den GPIO’s des Raspberry verbiden.

  • 5V (Plus)
  • GND (Minus)
  • PIN17 die Datenleitung

Es ist zu empfehlen den Servo direkt an die 5V Stromquelle anzuschliessen. Der Betriebsstrom des Servos kann unter umstaenden Schaeden im Raspberry hervorrufen.

Nachfolgen noch eine Uebersicht welcher P1 Header welchen GPIO anspricht.

 Servo number    GPIO number   Pin in P1 header
          0               4             P1-7
          1              17             P1-11
          2              18             P1-12
          3             21/27           P1-13
          4              22             P1-15
          5              23             P1-16
          6              24             P1-18
          7              25             P1-22

Nun ist es aber an der Zeit fuer den ersten Test in der shell .

echo 1=90 > /dev/servoblaster
sleep 1
echo 1=150 > /dev/servoblaster
sleep 1
echo 1=250 > /dev/servoblaster

Hierbei ist die 1 nach dem echo Befehl der Servo aus der obigen Liste. Also in unserem Beispiel bedeutet es das durch echo 1=90 der Servo an GPIO 17 auf 90 Grad gestellt wird.