Mit dem Intel Galileo-Mainboard eine Alarmanlage bauen

Diese Beispielanwendung soll zeigen, wie das Intel® Galileo-Mainboard mit einem Näherungssensor verwendet werden kann. Wann immer sich ein Objekt innerhalb eines drei Zentimeter großen Radius um den Näherungssensor befindet, löst das System einen Signalton aus und lässt eine LED kontinuierlich aufblinken, bis das Objekt wird außerhalb der Sensorreichweite ist.

Dieser Beispielcode verwendet das Live-USB-Image des Internet of Things (IoT) Development Kit, um ein Host-System auszuführen, das mit den Yocto* Application Development Tools (ADT) und Eclipse* Sketches auf das Intel® Galileo-Mainboard übertragen kann.

Dieser Artikel geht von den folgenden Annahmen aus:

  • Das Intel® Galileo-Mainboard wird mit dem SD-Image, das ebenfalls im IoT Development Kit enthalten ist, gestartet.
  • Die Leser wissen, wie man ein C-Programm mit dem Eclipse-Plugin entwickelt und den Code auf das Mainboard überträgt.

Hardwareanforderungen:

  • Entwicklungs-Mainboard Intel® Galileo
  • Entweder ein Jumper zwischen 3,3 V und 5 V des Intel Galileo-Mainboards oder eine externe 5-Volt-Spannungsversorgung (Im Beispiel unten wurde eine externe Spannungsversorgung verwendet.)
  • Näherungssensor, der digitale Daten an das Board ausgibt
  • Signaltongeber
  • 2N2222-Transistor
  • 1000-Ohm-Widerstand
  • Steckplatine

Zuerst erstellen wir den Schaltkreis für diese Anwendung. Anschließend sehen wir uns das C-Programm an, das die einzelnen GPIO-Pins steuert, um die LED und den Signalton basierend auf dem Eingabewert des Näherungssensors ein- oder auszuschalten.

Schließen Sie die Spannungsversorgung an Ihr Intel Galileo-Mainboard und die Steckplatine an. Befolgen Sie die Angaben unten für die Schaltungen.

PIN-Belegung auf dem Mainboard und entsprechende Funktion:

http://software.intel.com/sites/default/files/managed/cc/95/18021f1.png

Schaltkreis:

http://software.intel.com/sites/default/files/managed/a0/b2/18021f2.jpg

(Hinweis: Die Ports des Intel Galileo-Mainboards entsprechen denen des Arduino*-Mainboards.)

  1. Dieses Beispiel verwendet GPIO 13 und PWM 3 als Ausgänge und GPIO 8 als Eingang.
  2. Wir verwenden eine 3,3-Volt-Spannungsversorgung für den Näherungssensor.
  3. Mit GPIO 13 wird die LED zum Blinken gebracht.
  4. PWM 3 wird für die Modulation der Strommenge verwendet, die wir in die Transistorbasis fließen lassen. Basierend auf diesem Strom verändert der Transistor die Strommenge, die in den Signaltongeber fließt. Um sicherzustellen, dass unser PWM-Pin sicher ist, fügen wir zwischen PWM 3 und der Transistorbasis einen 1000-Ohm-Widerstand ein.
  5. GPIO 8 ist unsere Digitaleingabe des Näherungssensors. Wenn sich ein Objekt innerhalb der Reichweite des Näherungssensors befindet, gibt der Sensor für die Spannung HIGH zurück, andernfalls LOW.
  6. Basierend auf dem Eingabewert von GPIO 8 setzt das Programm die Spannungsversorgung von GPIO 13 auf HIGH, um die LED einzuschalten. Wir werden auch den Tastgrad von PWM 3 variieren. Basierend auf den Tastgradveränderungen wird der Signaltongeber einen Ton erzeugen, der dem eines Krankenwagens ähnelt.

Die logische Darstellung jedes GPIO ist im Verzeichnis /sys/class/gpio verfügbar; die PWM-Pins finden Sie im Verzeichnis /sys/class/pwm. Sergeys Blog „Intel Galileo – Programming GPIO From Linux“ bietet hervorragende Informationen zu den Modulen und der Belegung der GPIOs und PWMs. Wir empfehlen Ihnen, dieses Blog zu lesen, bevor Sie fortfahren.

C-Programm:

Als Nächstes folgt der Beispielcode. Dieser Code führt die Schritte aus, die für die Änderung der GPIOs erforderlich sind:

 1) Export der GPIO-Nummer in die /sys/class/gpio/export-Datei

 2) Festlegen der Richtung: „in“ für Eingabe, „out“ für Ausgabe

Diese Schritte werden mit der openGPIO-Funktion implementiert. Sie öffnet die entsprechende Datei und gibt die Datei-Kennung für künftige Schreib- oder Lesevorgänge (je nach deklarierter Richtung) zurück.

int openGPIO(int gpio, int direction )
{
        char buffer[256];
        int fileHandle;
        int fileMode;

  //Export GPIO
        fileHandle = open("/sys/class/gpio/export", O_WRONLY);
        if(ERROR == fileHandle)
        {
               puts("Error: Unable to opening /sys/class/gpio/export");
               return(-1);
        }
        sprintf(buffer, "%d", gpio);
        write(fileHandle, buffer, strlen(buffer));
        close(fileHandle);

   //Direction GPIO
        sprintf(buffer, "/sys/class/gpio/gpio%d/direction", gpio);
        fileHandle = open(buffer, O_WRONLY);
        if(ERROR == fileHandle)
        {
               puts("Unable to open file:");
               puts(buffer);
               return(-1);
        }

        if (direction == GPIO_DIRECTION_OUT)
        {
               // Set out direction
               write(fileHandle, "out", 3);
               fileMode = O_WRONLY;
        }
        else
        {
               // Set in direction
               write(fileHandle, "in", 2);
               fileMode = O_RDONLY;
        }
        close(fileHandle);


   //Open GPIO for Read / Write
        sprintf(buffer, "/sys/class/gpio/gpio%d/value", gpio);
        fileHandle = open(buffer, fileMode);
        if(ERROR == fileHandle)
        {
               puts("Unable to open file:");
               puts(buffer);
               return(-1);
        }

        return(fileHandle);  //This file handle will be used in read/write and close operations.
}

Dieser Code führt die Schritte aus, die für die Veränderung der PWM-Pins erforderlich sind:

 1) Export der PWM-Nummer in die /sys/class/pwm/pwmchip0/export-Datei

int openPWM(int port)
{
        char buffer[256];
        int fileHandle;
        int fileMode;

        //Export GPIO
        fileHandle = open("/sys/class/pwm/pwmchip0/export", O_WRONLY);

        if(ERROR == fileHandle)

        {
               puts("Error: Unable to opening /sys/class/pwm/pwmchip0/export");
               return(-1);
        }
        sprintf(buffer, "%d", port);
        write(fileHandle, buffer, strlen(buffer));
        close(fileHandle);
        sleep(1);
        return 0;
}

2) PWM-Pin aktivieren

int enablePWM(int enable,int port)
{
		char buffer[256];

		int fileHandle;


		//Enable PWM
        sprintf(buffer, "/sys/class/pwm/pwmchip0/pwm%d/enable", port);
        fileHandle = open(buffer, O_WRONLY);
        if(ERROR == fileHandle)
        {
               puts("Unable to open file:");

               puts(buffer);

               return(-1);

        }

		sprintf(buffer, "%d", enable);
        write(fileHandle, buffer, strlen(buffer));
        return 0;
}

3) PWM-Periode aktivieren

int setPWMPeriod(int period, int port)
{
       //Open GPIO for Read / Write
		char buffer[256];
		int fileHandle;


		sprintf(buffer, "/sys/class/pwm/pwmchip0/pwm%d/period", port);

        fileHandle = open(buffer, O_WRONLY);
        if(ERROR == fileHandle)
        {
               puts("Unable to open file:");

               puts(buffer);

               return(-1);
        }
		sprintf(buffer, "%d", period);
        write(fileHandle, buffer, strlen(buffer));

        close(fileHandle);
        return(0);

}

4) Tastgrad festlegen

int setPWMDutyCycle(int dutycycle, int port)
{
       //Open GPIO for Read / Write
		char buffer[256];
		int fileHandle;


		sprintf(buffer, "/sys/class/pwm/pwmchip0/pwm%d/duty_cycle", port);

        fileHandle = open(buffer, O_WRONLY);
        if(ERROR == fileHandle)
        {
               puts("Unable to open file:");

               puts(buffer);

               return(-1);
        }
		sprintf(buffer, "%d", dutycycle);
        write(fileHandle, buffer, strlen(buffer));
        close(fileHandle);
        return(0);

}

Diese Schritte werden mit der openGPIO-Funktion implementiert. Sie öffnet die entsprechende Datei und gibt die Datei-Kennung für künftige Schreib- oder Lesevorgänge (je nach deklarierter Richtung) zurück.

In der Hauptfunktion:

 1. GPIO 8 als Eingabe öffnen

openGPIO(GP_PROXY, GPIO_DIRECTION_IN);

2. GPIO 13 als Ausgabe öffnen

openGPIO(GP_LED, GPIO_DIRECTION_OUT);

3. PWM 3 öffnen, für Eingabe aktivieren, Periode festlegen und Tastgrad initialisieren

//set PWM parameters
openPWM(GP_PWM);
setPWMPeriod(1000000,GP_PWM);
enablePWM(1,GP_PWM);
setPWMDutyCycle(0,GP_PWM);

Nun starten wir eine Endlosschleife und lesen kontinuierlich die Daten des Näherungssensors aus. Wenn der Näherungswert HIGH entspricht (im Programm 1), wird der Tastgrad der PWM-3-Ausgabe geändert. Durch Umschalten des duty_cycle-Werts zwischen 200000 und 500000 wird ein Ton erzeugt, der dem Signalhorn eines Krankenwagens ähnelt. Gemeinsam mit der Tastgrad-Änderung für PWM 3 wird auch die LED über GPIO 13 umgeschaltet. 
Der GPIO-Lesevorgang basiert auf der folgenden Logik:

{
        int value;
        //Reopening the file again in read mode, since data was not refreshing.
        fileHandle = openFileForReading(gpio);
        read(fileHandle, &value, 1);

        if('0' == value)
        {
             // Current GPIO status low
               value = 0;
        }
        else
        {
             // Current GPIO status high
               value = 1;
        }
        close(fileHandle);
        return value;
}

Der GPIO-Schreibvorgang basiert auf der folgenden Logik:

{
        if(val ==  0)

        {
               // Set GPIO low status
               write(fHandle, "0", 1);
        }
        else

        {
               // Set GPIO high status
               write(fHandle, "1", 1);

        }
        return(0);

}

Die Schleife der Hauptfunktion ist unten dargestellt.

    //Start an infinite loop to keep polling for proximity info
     int proxyValue = 0;
     while(1==1)
     {
proxyValue = readGPIO(fileHandleGPIO_PROXY,GP_PROXY);
if(proxyValue == 1)
{
	if(duty_cycle == 500000)
	{
	duty_cycle = 200000;
       	writeGPIO(fileHandleGPIO_LED, 0);
	}
	else
	{
	duty_cycle = 500000;
       	writeGPIO(fileHandleGPIO_LED, 1);
	}
	setPWMDutyCycle(duty_cycle,GP_PWM);
}
else
{
	duty_cycle = 50000;
	setPWMDutyCycle(0,GP_PWM);
      	writeGPIO(fileHandleGPIO_LED, 0);
}
     	usleep(1000*400);
     }

Schließen Sie nun die GPIO- und PWM-Ports.Den vollständigen Code finden Sie hier. Um ihn auszuführen, öffnen Sie das „Hello World“-Beispiel, das im Live-USB-Image des IoT Development Kit enthalten ist, und ersetzen Sie dort den Code durch den aus der BurglarAlarm.c-Datei. Der Code sollte sich problemlos ausführen lassen.

closeGPIO(GP_LED, fileHandleGPIO_LED);
closeGPIO(GP_PROXY, fileHandleGPIO_PROXY);
closePWM(GP_PWM);

 

Einzelheiten zur Compiler-Optimierung finden Sie in unserem Optimierungshinweis.