TSL2561 Lichtsensor mit dem STM32F4

Der Blog ist umgezogen: http://scholtyssek.org/blog/de/2014/11/24/tsl2561-lichtsensor-mit-dem-stm32f4/

Der TSL2561 ist ein Sensor, der die Lichtintensität messen und in einen 16-bit aufgelösten, digitalen Wert transformieren kann. Auf dem Sensor sind zwei Fotodioden enthalten, die das Lichtspektrum messen und in einen digitalen 16-Bit Wert transformieren. Die erste Fotodiode misst das Lichtspektrum inklusive dem infraroten Anteil. Die zweite Diode misst lediglich die infraroten Lichtbereich. Die synchron aufgezeichneten Messwerte werden über eigene Kanälen in Datenregister transferiert (channel0 und channel1). Die Idee dabei ist, dass beide Werte dazu verwendet werden, den infraroten Lichtanteil durch eine Subtraktion zu herauszurechnen. Das resultierende Lichtspektrum entspricht somit dem, welches das menschliche Auge erfassen kann.
Die Messwerte können über den I2C oder den SMBus ausgelesen werden. In diesem Artikel wird eine Kommunikation über den I2C-Bus eingesetzt, um Daten zwischen dem STM32F4 und dem TSL2561 auszutauschen.

Den Sensor anschließen

Der TSL2561 arbeitet mit einer Spannung von 3.8V, verwenden Sie nicht den 5V Pin des STM32F4, sonst laufen Sie Gefahr, den Sensor zu zerstören. Es gibt zwei Anschlüssen für die I2C-Kommunikation (SDA und SCL). Der SDA Pin ist für den Datenaustausch mit dem Sensor, währen SCL für den Bustakt verwendet wird. Der ADDR Pin ermöglicht es, den Sensor mit einer I2C Adresse zu konfigurieren. Solange die Standardadresse auf dem Bus nicht für ein anderes Gerät verwendet wird, kann diese problemlos verwendet werden. Die Standardadresse für den Sensor lautet 0x39, diese kann aber auf die Adressen 0x29 bzw. 0x49 angepasst werden. Außerdem kann der Sensor einen Interrupt auslösen, sodass es nicht notwendig ist, diesen zu pollen. In dieser Beispielimplementierung wird allerdings auf die Verwendung eines Sensorinterrupts verzichtet.

TSL2561 Lichtsensor

Die Software

Der STM32F4 Controller verfügt über mehrere I2C Schnittstellen. In diesem Beispiel wird I2C1 verwendet, welcher an den IOs GPIO6 (SCL) und GPIO7 (SDA) angeschlossen ist. Die Konfiguration ist übrigens in einer Konfigurationsdatei gekapselt, sodass diese leicht angepasst werden kann. Die Software kann aus dem Repository (Projektname TSL2561_example) runtergeladen werden. Die Taktfrequenz für die I2C Kommunikation liegt bei 400 kHz, diese ist, wie auch die IOs, in der Konfigurationsdatei hinterlegt. Die init_lightsensor(void) Methode konfiguriert alle benötigten IOs und die Peripherie für die I2C Kommunikation mittels initLightSensorI2C(void).
Die Messwerte werden in insgesamt vier Registern hinterlegt (zwei für jeden Kanal), welche ausgelesen werden können. Diese Register enthalten die Messwerte als 8 Bit low bzw high bytes.

Adresse 0x00	Beschreibung control register
0x8C	low byte (channel0)
0x8D	high byte (channel0)
0x8E	low byte (channel1)
0x8F	high byte (channel1)

Um Bytes aus den Registern des Moduls zu lesen, wird vorab die Registeradresse an das Control Register (0x00) des Moduls geschickt. Außerdem muss das sogenannte Command Bit gesetzt werden, damit das Modul korrekt auf die Anfragen reagiert.
Die empfangenen Daten können in die SI-Einheit LUX umgerechnet werden. Diese Berechnung ist bereits in dem Beispielprogramm enthalten. Die read_lightness_value() Methode empfängt die Datenbytes und führt die Transformation durch.

Appendix

http://www.adafruit.com/datasheets/TSL2561.pdf

STM32F4 mit ERIKA Enterprise RTOS OSEK

Dieser Blog ist umgezogen: http://scholtyssek.org/blog/de/2014/11/21/stm32f4-mit-erika-enterprise-rtos-osek/

Erika Enterprise ist ein open source OSEK konformes Echtzeitbetriebssystem (RTOS), das den STM32F4-Discovery Controller unterstützt. Außerdem gibt es eine eclipse Integration, sodass es möglich ist, Software direkt in der IDE zu entwickeln. In Kombination mit dem GNU ARM Eclipse Plugin und dem stlink Debugger/Programmer, sowie den GNU Tools for ARM Embedded Processors, wird eclipse zu einer Entwicklungsumgebung, die neben der eigentlichen Entwicklung des Codes, auch das Flashen und Debuggen auf der Hardware (in-circuit-debugging) von ERIKA RTOS basierten Anwendugen für den STM32F4-Discovery Controller ermöglicht. ERIKA kann auf der Projektseite runtergeladen werden. Um weitere Informationen zu der Installation bzw. Einrichtung der Plugins oder ERIKA zu erhalten, schauen Sie bitte in die entsprechenden Wikis und Foren auf den verlinkten Seiten.

ERIKA wird über ein oil-File konfiguriert, welches die Parameter für den Kernel enthält. In dieser Datei gibt es verschiedene Einstellungsmöglichkeiten, die das Verhalten des Kernels beeinflussen. Neben diesen werden aber auch Abhängigkeiten zu externen Bibliotheken, wie beispielsweise dem Microcontroller Software Interface Standard (CMSIS), festgelegt.
Der Kernel unterstützt verschiedene Klassen von tasks (basic und extended tasks). Im Vergleich zu den basic tasks, unterstützen die extended tasks eine eventgesteuerte Synchronisation. Mehr Informationen zu den Klassen gibt es in der offiziellen Dokumentation, an dieser Stelle soll nicht weiter auf die Unterschiede eingegangen werden.

Der folgende Abschnitt beschreibt die Verwendung von ERIKA Enterprise mit extended tasks, also einem eventgesteuerten Scheduling auf dem STM32F4 Controller. Um diese Kernelkonfiguration einzusetzten, gibt es ein paar Parameter, die in der Konfigrationsdatei (*.oil) gesetzt werden müssen. Eine entsprechende Konfiguration sieht wie folgt aus:
   

CPU mySystem {
 OS myOs {
  CPU_CLOCK = 168.0;
  MODEL = M4;
   
  APP_SRC = "src/code.c";
  APP_SRC = "src/pwm.c";
  COMPILER_TYPE = GNU;
  MULTI_STACK = TRUE {
   IRQ_STACK = TRUE {
    SYS_SIZE = 512;
   };
  };

  EE_OPT = "DEBUG";
  CFLAGS = "-std=c99";
};

MCU_DATA = STM32 {
 MODEL = STM32F4xx;
};

Der STM32F4-discovery verfügt über einen ARM Cortex-M4 Prozessor, welcher mit 168 MHz getaktet wird. Der genaue Takt hängt von dem verwendeten Modell ab, in diesem  Beispiel wurde ein STM32F407VG verwendet. Der APP_SRC Paramter listet die *.c Dateien auf, die mit dem Kernel kompiliert werden sollen. Um mehrere Dateien anzugeben, dann der Parameter einfach wiederholt werden. Die Entwicklung basiert auf dem GNU ARM Compiler und Debugger, deshalb wird der Parameter COMPILER_TYPE für die GNU toolchain konfiguriert. Um extended tasks zu verwenden, muss ein sogenannter MULTI_STACK mit einer statischen Größe konfiguriert werden. Der letzte Block in dem Ausschnitt der Konfigurationsdatei setzt den Controller.
Die Konfigurationsdatei wird außerdem dazu verwendet externe Bibliotheken, wie beispielsweise den ARM spezifischen CMSIS, einzubinden. Der folgende Ausschnitt zeigt, wie diese Bibliotheken eingebunden werden:

EE_OPT = "__USE_CMSIS_ALL__";
EE_OPT = "__USE_SPD_ALL__";
EE_OPT = "__USE_SYSTICK__";
EE_OPT = "__ADD_LIBS__";

LIB = ENABLE {
 NAME = "ST_CMSIS";
};

LIB = ENABLE {
  NAME = "STM32F4XX_SPD";
  STM32F4XX_SPD = ENABLE {
   USETIM = TRUE; 
   USEI2C = TRUE;
   USEMISC = TRUE;
   USESPI = TRUE;
   USEUSART = TRUE;
  };
};
  
LIB = ENABLE {
  NAME = "STM32F4_DISCOVERY";
};

Die Parameter sind spezifisch für den STM32F4 Controller. Als nächstes wird das Scheduling des ERIKA Kernels konfiguriert. Der Kernel unterstützt insgesamt vier Klassen, die das Scheduling beieinflussen, sogenannte conformance classes (ECC1, ECC2, BCC1, BCC2). Die BCC Klassen unterstützen basic tasks, während die ECC Klassen die extended tasks unterstützen. Extended tasks erweitern die basic tasks um die Eigenschaft, durch events aktiviert zu werden. Für weitere Informationen zu diesen Klassen, schauen Sie bitte in das ERIKA reference manual. Um in der Konfigurationsdatei eine conformance class zu definieren, wird der folgende Paramter gesetzt:

KERNEL_TYPE = ECC1;

Als nächstes werden events und tasks definiert. In diesem Beispiel wird ein task definiert, der über ein event aktiviert werden kann. Dieser Task wird setPwmTask heißen und auf ein pwmEvent reagieren. Generell können tasks auf mehrere events reagieren. Diese müssen nur entsprechend in der Konfigurationsdatei festgelegt werden. Eine entsprechende Konfiguration eines tasks mit einem event sieht wie folgt aus:

EVENT pwmEvent {
  MASK = AUTO;
};
 
TASK setPwmTask {
  PRIORITY = 0x03; /* lower priority */
  AUTOSTART = FALSE;
  STACK = PRIVATE {
    SYS_SIZE = 512;
};
  ACTIVATION = 1;  /* only one pending activation */
  SCHEDULE = FULL;
  EVENT = pwmEvent;
};

Anschließend werden der task und das event in der Implementierung deklariert, damit der task durch die Software aktiviert werden kann:

DeclareTask(setPwmTask);
DeclareEvent(pwmEvent);

TASK( setPwmTask) {
  EventMaskType current;
  while (1) {
    if(WaitEvent(pwmEvent) == E_OK){
    /* error handling */
  }
  getEvent(setPwmTask, &current); /* save event */
  ClearEvent(pwmEvent);

  /* do some fancy task work */
  }
  TerminateTask(); // never reached
}

Der letzte Schritt ist die Initialisierung des Kernels. Wurde diese durchgeführt, kann das eventbasierte Scheduling verwendet werden. Der folgende Codeausschnitt zeigt wie die Initialisierung des Kernels und die periodische Aktivierung des setPwmTask durch das pwmEvent durchgeführt werden kann:

#include "ee.h"
#include "ee_api.h"
#include "kernel/oo/inc/ee_oo_api.h"

int main(void) {
  /* Initialize Erika related stuff */
  EE_system_init();

  while (1) {
    SetEvent(setPwmTask, pwmEvent);  
    Delay(MILLISECONDS_TO_TICKS(100, SystemCoreClock));
  }
}

Mit ERIKA Enterprise bekommt man ein sehr schönes open source Echtzeitbetriebssystem, welche direkt in die eclipse IDE integriert werden kann. Die STM32F4 Unterstützung bietet einem alle netten features eines RTOS auf diesem Controller.