Tux trifft MSP430-Launchpad
Aus BraLUG-Wiki
Derzeit noch Baustelle...!
Inhaltsverzeichnis |
Warum ein MSP430-Launchpad?
Uwe meinte irgendwann: "Bisher waren die AVRs von Atmel die Favoriten für meine Mikrocontroller-Projekte. Für das Projekt "Scopeclock" scheint allerdings die Performance dieser MCUs nicht mehr auszureichen...! ...Ok, wie sieht es eigentlich bei den MCUs von Texas Instruments aus, gibt es da etwas performanteres, was mit vertretbaren Mitteln programmiert werden kann? ...jupp, sieht gut aus! Aber wenn wir schon bei TI sind, können wir uns zuerst auch mal mit dem MSP430-Launchpad beschäftigen, oder...?"
...have fun!
Hardware
MSP430
MSP430-Launchpad
Das MSP-EXP430G2 LaunchPad vom TI bietet ideale Moglichkeiten für den Einstieg in die MSP430-Welt. Kauft man sich dieses Board für wenig Geld (je nach dem wo, weit unter 10€), findet man folgendes in der kleinen Schachtel:
- das Launchpad-Board selbst
- ein Mini-USB-B Kabel
- zwei MSP430-MCUs (bei Launchpad Rev. 1.5: MSP430G2553, MSP430G2452)
- einen 32,768kHz Uhrenquarz (damit kann man das Board entsprechend nachbestücken, siehe Dokumentation)
- zwei 10-polige Stiftleisen, eine kleine Anleitung und ein paar Sticker
Das Launchpad-Board ist mit allem ausgerüstet, was man für die ersten Experimente benötigt:
- ein 20-pin DIP Sockel, in den alle MSP430G2xxx mit 14 oder 20 Pins passen sollten (sämtliche Pins sind auf Stiftleisten herausgeführt)
- zwei "frei programmierbare" LEDs
- ein "frei programmierbarer" Taster
- ein Reset-Taster
- ein Programmier- und Debugging-Interface (cool, innerhalb der Atmel-Welt muss man sich soetwas für viel Geld dazukaufen!)
- ein paar Jumper zur Hardware-Konfiguration des Boards (sind beschriftet bzw. auch in der entsprechenden Dokumentation beschrieben)
- ein USB-Anschluß
Auf dem mitgelieferten MSP430G2553 ist ein Beispielprogramm vorinstalliert (blinkende LEDs, Abfrage des internen Temperatursensors usw.), aber wir wollen ja selbst ein paar Programme schreiben... Wenn man mal die "Windowslastigkeit" aus acht läßt, vermittelt dieser kleine Workshop einige Grundlagen zur Programmierung von MSP430-MCUs.
Das Lauchpad-Board ist mit sogenannten BoosterPacks aufrüstbar. Das Konzept ist mit den Arduino-Shields vergleichbar.
MSP430G2452
Wichtigste Hardwareeigenschaften:
- 16-Bit RISC CPU
- Versorgungsspannung: 1,8V ... 3,6V
- geringer Stromverbrauch
- CPU-Takt bis 16MHz intern konfigurierbar
- 8kByte Flash
- 256Byte RAM
- 16 I/O-Ports
- 1 16-Bit-Timer,
- WatchDog-Timer
- 1x USI (I2C/SPI)
- 8 Kanäle 10-bit ADC
MSP430G2553
Wichtigste Hardwareeigenschaften:
- 16-Bit RISC CPU
- Versorgungsspannung: 1,8V ... 3,6V
- geringer Stromverbrauch
- CPU-Takt bis 16MHz intern konfigurierbar
- 16kByte Flash
- 512Byte RAM
- 16 I/O-Ports
- 2 16-Bit-Timer
- WatchDog-Timer
- 1x USCI (I2C/SPI/UART/IrDA)
- 8 Kanäle 10-bit ADC
Toolchain
Von TI werden für die MSP430-Serie (und damit auch für das MSP430-Launchpad) diverse Entwicklungsumgebungen empfohlen und angeboten. Diese sind allerdings ausschließlich nur für Windows-Betriebssysteme verfügbar und in den kostenlosen Versionen im Funktionsumfang teilweise stark beschränkt...
Wir wollen uns natürlich auf die Linux-Plattform konzentrieren! Dort sind leistungsfähige (und 100% freie) Alternativen verfügbar.
Die üblichen Kommandozeilen-Tools...
Folgende Pakete sind Bestandteil vieler Debian-Derivate (z.B. auch Ubuntu) und bilden die notwendige Entwicklungsumgebung für MSP430-MCUs unter Linux:
- binutils-msp430
- gcc-msp430
- gdb-msp430
- msp430-libc
- msp430mcu
- mspdebug
Dazu kommt natürlich noch ein geeigneter Texteditor zum Erstellen der Quelltext-Dateien.
Energia
Wer von der Arduino-Fraktion kommt bzw. Mikrocontroller-Einsteiger ist, wird vielleicht Gefallen an Energia, als "Arduino-IDE-ähnliche" Toolchain finden. Die Programmierung erfolgt mit einer C/C++-ähnlichen Sprache. Für Einsteiger vorteilhaft ist, dass hardwarenahe Programmierung in Standard-Funktionen des Sprachumfangs gekapselt sind. Zum Lernen ganz gut, aber irgendwann sollte man native auf C-(bzw. ASM-)Programme umschwenken...!
Folgende Boards werden durch Energia in der derzeitigen Stable-Version unterstützt:
- MSP430 LaunchPad (mit MSP430G2231, MSP430G2452 und MSP430G2553)
- MSP430 FraunchPad
- Stellaris LaunchPad
(Anmerkung zum Stellaris LaunchPad: für einen erfolgreichen Upload der Programme in die MCU via Energia muss das Tool lm4flash im entsprechenden Energia-Verzeichnis mit einem, aus den Originalquellen erzeugtes, Binary ausgetauscht werden)
Ein blinkendes "Hello World" würde mit Energia ungefähr so aussehen:
//
// "Hello World" --> rote LED blinkt im Sekundentakt
//
// Hardware initialisieren
void setup() {
pinMode(RED_LED, OUTPUT); // LED-Pin alös Output definieren
}
// "Hauptendlosschleife" (hier springt MCU nach Initialisierung rein)
void loop() {
digitalWrite(RED_LED, HIGH); // LED an
delay(1000); // eine Sekunde warten
digitalWrite(RED_LED, LOW); // LED aus
delay(1000); // eine Sekunde warten
}
Es gibt ein gutes Forum, welches sich mit Energia beschäftigt. Hier sind auch diverse Erweiterungs-Bibliotheken zu finden.
"Hello World"
In der Folge soll kurz beschrieben werden, wie man ein (einfaches) Programm für einen MSP430-Launchpad übersetzt und auf die MCU überträgt. Weiterhin wird kurz aufgezeigt, wie man mit dem Debugger direkt auf der MCU arbeiten kann.
Das Programm
Das erste Programm ist immer ein "Hello World". Bei einem Mikrocontroller bietet es sich dazu an, ein paar Ausgänge zyklisch ein- und auszuschalten. Hier der entsprechende C-Quelltext, mit dem die beiden, auf dem Launchpad vorhandenen LEDs als Wechselblinker zyklisch angesteuert werden:
#include <msp430.h>
#define LED_RED BIT0 // rote LED an PIN0
#define LED_GREEN BIT6 // gruene Led an PIN6
//***************************************
void delay_ms(unsigned int ms){
while(ms--){
__delay_cycles(1000);
}
}
//***************************************
int main(void){
WDTCTL = WDTPW + WDTHOLD; // watchdog ausschalten
P1DIR = LED_RED | LED_GREEN; // LED-Pins als Ausgaenge
P1OUT = LED_GREEN; // gruene LED ein
while(1) { // Enlosschleife
P1OUT ^= LED_RED + LED_GREEN; // LEDs toggle
delay_ms(500); // 500ms Pause
}
}
Programm übersetzen und auf MCU übertragen
C-Quelltext übersetzen, wobei der Code für einen MSP430G2452 erzeugt wird:
msp430-gcc -mmcu=msp430g2452 -o blink.elf blink.c
Die Übertragung auf den Mikrocontroller erfolgt mit Hilfe des Kommandozeilen-Tools mspdebug:
> mspdebug rf2500 ... (msdebug) prog blink.elf Erasing... Programming... Writing 186 bytes to e000 [section: .text]... Writing 32 bytes to ffe0 [section: .vectors]... Done, 218 bytes written
Innerhalb der mspdebug-Shell kann das Programm mit dem Befehl run gestartet werden:
(mspdebug) run Running. Press Ctrl+C to interrupt...
Natürlich läuft das Programm auch ohne mspdebug. Dazu beendet man das Tool mit dem Befehl exit.
Da man obige Befehlsfolgen wahrscheinlich nicht immer wieder neu eingeben möchte, hier ein entsprechendes Makefile, in dem alle notwendigen Aktionen zusammengefasst sind:
PROJ=blink
CC=msp430-gcc
MCU=msp430g2452
CFLAGS=-Os -g -Wall -mmcu=$(MCU)
LDFLAGS=-g -mmcu=$(MCU)
OBJS=$(PROJ).o
all:$(OBJS)
$(CC) $(LDFLAGS) -o $(PROJ).elf $(OBJS)
msp430-size $(PROJ).elf
clean:
rm -fr $(PROJ).elf $(OBJS)
flash:
mspdebug rf2500 'erase' 'load $(PROJ).elf' 'exit'
Debuggen
Debugproxy auf Port 2000 starten:
> mspdebug rf2500 ... (mspdebug) gdb Bound to port 2000. Now waiting for connection...
Kommadozeilen-Debugger starten und mit Debugproxy verbinden:
> msp430-gdb blink.elf ... (gdb) target remote localhost:2000 ... (gdb)
(Anmerkung: Inhalt von z.B. P1OUT ausgeben → print/x __P1OUT)
...oder etwas komfortabler, z.B. mit KDbg:
> kdbg -r localhost:2000 blink.elf
MSP430-Hardware mit Software erforschen
Port-Input
Taste betätigt?
#include <msp430.h>
#define LED BIT0
#define BUTTON BIT3
//***************************************
int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // WatchDog ausschalten
P1DIR = LED; // LED-Pin als Ausgang
P1DIR &= ~BIT3; // Button als Eingang
P1REN |= BUTTON; // Pull-Up-Widerstand einschalten
P1OUT &= ~LED; // LED ausschalten
while (1) { // Endlosschleife
if ((P1IN & BUTTON) == 0) { // Taste gedrueckt?
P1OUT |= LED; // ja --> LED an
} else {
P1OUT &= ~LED; // nein --> LED aus
}
}
}
Ein-/Aus-Schalter mit Entprellung
#include <msp430.h>
#define LED BIT0
#define BUTTON BIT3
#define DEBOUNCE_MS 50
//***************************************
void delay_ms(unsigned int ms){
while(ms--){
__delay_cycles(1000);
}
}
//***************************************
char button_pressed(void) {
if ((P1IN & BUTTON) == 0) {
delay_ms(DEBOUNCE_MS);
if ((P1IN & BUTTON) == 0) return 1;
}
return 0;
}
//***************************************
int main(void)
{
char toggle = 0;
WDTCTL = WDTPW + WDTHOLD;
P1DIR = LED;
P1DIR &= ~BIT3;
P1REN |= BUTTON;
P1OUT &= ~LED;
while (1) {
if (button_pressed()) {
if (!toggle) {
P1OUT ^= LED;
toggle = 1;
}
} else {
toggle = 0;
}
}
}
Watchdog-/Port-Interrupt
Ein-/Aus-Schalter über Port- und Watchdog-Interrupt
#include <msp430.h>
#define LED BIT0
#define BUTTON BIT3
//***************************************
int main(void)
{
WDTCTL = WDTPW+WDTHOLD; // WatchDog ausschalten
P1DIR = LED; // Ausgang
P1DIR &= ~BUTTON; // Eingang
P1REN |= BUTTON; // Pull-Up ein
P1IES |= BUTTON; // Interrupt Port 1 bei Hight --> Low
P1IFG &= ~BUTTON; // Interrupt-Flag fuer Button-Pin loeschen
P1IE |= BUTTON; // Interrupt fuer Button-Pin einschalten
P1OUT &= ~LED; // LED aus
_BIS_SR(LPM0_bits+GIE); // Low Power Mode 0 und Interrupts generell ein
return 0;
}
//***************************************
// Interrupt-Routine Port 1
//***************************************
#pragma vector=PORT1_VECTOR
__interrupt void PORT1_ISR(void)
{
static unsigned char toggle = 0;
P1IFG &= ~BUTTON; // Interrupt-Flag fuer Button-Pin loeschen
P1IE &= ~BUTTON; // Interrupt fuer Button-Pin ausschalten
WDTCTL = WDT_MDLY_32; // WatchDog-Timer 32ms starten
IFG1 &= ~WDTIFG; // Interrupt-Flag fuer WatchDog loeschen
IE1 |= WDTIE; // WatchDog-Interrupt einschalten
if (!toggle) {
P1OUT ^= LED; // LED umschalten
toggle = 1;
P1IES &= ~BUTTON; // Interrupt Port 1 bei Low --> Hight
} else {
toggle = 0;
P1IES |= BUTTON; // Interrupt Port 1 bei Hight --> Low
}
}
//***************************************
// Interrupt-Routine Watchdog
//***************************************
#pragma vector=WDT_VECTOR
__interrupt void WDT_ISR(void)
{
IE1 &= ~WDTIE; // WatchDog-Interrupt ausschalten
IFG1 &= ~WDTIFG; // Interrupt-Flag fuer WatchDog loeschen
WDTCTL = WDTPW + WDTHOLD; // WatchDog ausschalten
P1IE |= BUTTON; // Interrupt fuer Button-Pin einschalten
}
Anmerkung: Bei meinem Lauchpad scheint der Taster ab und zu länger wie 32ms zu prellen und damit verschluckt sich die Logik machmal. Eigentlich ist es also sinnvoller, die Entprellung über einen Timer zu realisieren, den man an die spezifischen Hardwaregegebenheiten anpassen kann.
Timer
Wechselblinker mit Timer
#include <msp430.h>
#define LED_RED BIT0 // rote LED an PIN0
#define LED_GREEN BIT6 // gruene Led an PIN6
//***************************************
int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // WatchDog ausschalten
P1DIR = LED_RED | LED_GREEN; // LED-Pins als Ausgaenge
P1OUT = LED_GREEN; // gruene LED ein
TACTL = TASSEL_2 + MC_2; // Timer A: SMCLCK, Continuous-Mode
CCTL0 = CCIE; // Capture-/Compare-Interrupt ein
_BIS_SR(LPM0_bits+GIE); // Low Power Mode 0 und Interrupts generell ein
return 0;
}
//***************************************
// Interrupt-Routine TimerA0
//***************************************
#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A(void)
{
static unsigned char counter = 0;
counter++;
if (!(counter%4)) // Takt noch ein wenig teilen...
P1OUT ^= LED_RED + LED_GREEN; // LEDs toggle
}
PWM (LED dimmen)
#include <msp430.h>
#define LED BIT6;
//***************************************
int main(void)
{
WDTCTL = WDT_MDLY_32; // Watchdog 32ms
IE1 |= WDTIE; // Watchdog-Interrupt ein
P1DIR |= LED; // LED als Ausgang
P1SEL |= LED; // LED angesteuert via PWM (Timer A0)
TA0CCR0 = 1000; // PWM-Periode
TA0CCR1 = 1; // PWM-Duty-Cycle (initial)
TA0CCTL1 = OUTMOD_7; // PWM-Output-Mode (siehe Datenblatt...)
TA0CTL = TASSEL_2 + MC_1; // Timer A: SMCLK (1MHz) und CCR0 aufwaerts
_BIS_SR(LPM0_bits + GIE); // Low Power Mode 0 und Interrupte ein
return 0;
}
//***************************************
// Interrupt-Routine WatchDog
//***************************************
#pragma vector=WDT_VECTOR
__interrupt void watchdog_timer(void)
{
static int direction = 1;
TA0CCR1 += direction*20; // PWM-Duty-Cycle neu setzen
if( TA0CCR1 > 980 || TA0CCR1 < 20 ) // Richtung umschalten
direction = -direction;
}
Serielle Schnittstelle (Uart)
Um mit dem Controller kommunizieren zu können, macht sich für die Ein- und Ausgabe von Daten eine serielle Schnittstelle ganz gut. Das MSP430-Lauchpad emuliert diese über USB an /dev/ttyACMx (siehe dmesg) mit, hardwarebedingt, maximal 9600 Baud.
Je nach eingesetzter MCU auf dem Launchpad (Rev. 1.5) kann die Art und Weise der Implementierung der seriellen Schnittstelle z.B. aus diesem Software-Archive gewählt werden:
- MSP430G2452 → nur Software-Uart möglich
- MSP430G2553 → Software- oder Hardware-Uart
In der Folge sind ein paar einfache Beispiel für die serielle Schnittstelle in Hardware aufgeführt.
Hardware-Uart
RXD-/TXD-Jumper auf Launchpad entsprechend setzen (siehe Dokumentation...)!
Einfaches serielles Echo (mit Energia-IDE)
uint8_t rx;
void setup()
{
Serial.begin(9600); // serielle Schnittstelle 9600Baud
Serial.println("*****");
}
void loop () {
if (Serial.available()) { // Zeichen an serieller Schnittstelle?
rx=Serial.read(); // Zeichen lesen
if (rx==13) { // CR --> NewLine ausgeben
Serial.println("");
}
Serial.write(rx); // Zeichen selbst ausgeben
}
}
Serielle Schnittstelle mit Empfangspuffer
#include "msp430.h"
#include <string.h>
#define LED_RED BIT0
#define LED_GREEN BIT6
#define UART_RXBUFLEN 16 // Groesse RX-Puffer
volatile uint8_t uart_rxbuf[UART_RXBUFLEN]; // RX-Puffer
volatile uint8_t uart_rxsize = 0; // momentane Groesse RX-Puffer
// ***************************
void uart_init(void) {
BCSCTL1 = CALBC1_1MHZ; // Set DCO
DCOCTL = CALDCO_1MHZ;
P1SEL = BIT1 + BIT2 ; // P1.1 = RXD, P1.2=TXD
P1SEL2 = BIT1 + BIT2 ; // P1.1 = RXD, P1.2=TXD
UCA0CTL1 |= UCSSEL_2; // SMCLK
UCA0BR0 = 104; // 1MHz 9600
UCA0BR1 = 0; // 1MHz 9600
UCA0MCTL = UCBRS0; // Modulation UCBRSx = 1
UCA0CTL1 &= ~UCSWRST; // **Initialize USCI state machine**
IE2 |= UCA0RXIE; // Enable USCI_A0 RX interrupt
}
// ***************************
void uart_putc(uint8_t c) {
while (!(IFG2 & UCA0TXIFG)); // USCI_A0 TX bereit?
UCA0TXBUF = c; // raus damit...!
}
// ***************************
void uart_puts(const char *s) {
while(*s) uart_putc(*s++);
}
// ***************************
uint8_t uart_getc(void) {
static uint8_t uart_rxstart = 0;
uint8_t c;
while (uart_rxsize == 0); // warten bis was im RX-Puffer steht...
c = uart_rxbuf[uart_rxstart++]; // Zeichen zurueckgeben ...
if (uart_rxstart == UART_RXBUFLEN) uart_rxstart = 0; // ... und Puffer-"Zeiger"
uart_rxsize--; // verwalten
return c;
}
// ***************************
#pragma vector=USCIAB0RX_VECTOR
__interrupt void USCI0RX_ISR(void) { // RX-Interrupt
static uint8_t uart_rxstop = 0;
uint8_t c;
P1OUT ^= LED_RED; // Debug...
c = UCA0RXBUF; // empfangenes Zeichen einlesen...
if (uart_rxsize < UART_RXBUFLEN) { // ...und in RX-Puffer schreiben
uart_rxbuf[uart_rxstop++] = c;
if (uart_rxstop >= UART_RXBUFLEN) uart_rxstop = 0;
uart_rxsize++;
}
}
// ***************************
int main(void) {
uint8_t c;
WDTCTL = WDTPW + WDTHOLD;
P1DIR = LED_RED | LED_GREEN; // rote und gruene LED als Ausgang
uart_init(); // serielle Schnittstelle initialisieren
__bis_SR_register(GIE); // Interrupts einschalten
uart_puts("UART ready!\n\r");
while (1) { // Hauptschleife
c = uart_getc();
uart_putc(c); // Echo
if (c == 'G') P1OUT |= LED_GREEN;
if (c == 'g') P1OUT &= ~LED_GREEN;
}
return 0;
}
Software-Uart
Wenn die MCU keine serielle Schnittstelle mit ihrer Hardware unterstützt, brauch man etwas, was das Ganze in Software emuliert. Eine Bibliothek mit Beispiel ist ebenfalls in diesem Software-Archiv zu finden.
RXD-/TXD-Jumper auf Launchpad entsprechend setzen (siehe Dokumentation...)!
ADC
Interner Temperatursensor
#include <stdio.h>
#include "msp430.h"
#include "uart.h"
#define LED_RED BIT0 // rote LED an PIN0
#define LED_GREEN BIT6 // gruene Led an PIN6
uint16_t temp, temp_old;
char buffer[6];
// ***************************
// ***************************
// ***************************
int main(void) {
WDTCTL = WDTPW + WDTHOLD; // Watchdog ausschalten
BCSCTL1 = CALBC1_1MHZ; // MCU-Taktrate
DCOCTL = CALDCO_1MHZ;
P1DIR = LED_RED | LED_GREEN; // LED-Pins als Ausgaenge
uart_init(9600); // serielle Schnittstelle initialisieren
// ADC konfigurieren
ADC10CTL1 = INCH_10 + ADC10DIV_3; // Temp.Sensor ADC10CLK/4
ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON + ADC10IE; // Referenz etc.
__delay_cycles(1000); // etwas Warten damit sich Referenz einstellt
while (1) {
ADC10CTL0 |= ENC + ADC10SC; // Sampling and conversion start
__bis_SR_register(CPUOFF + GIE); // LPM0 mit Interrupts einschalten
temp = ADC10MEM;
P1OUT &= ~LED_GREEN; // LEDs je nach Temp.diff setzen
P1OUT &= ~LED_RED;
if (temp<temp_old) {
P1OUT |= LED_GREEN;
} else if (temp>temp_old)
P1OUT |= LED_RED;
sprintf(buffer, "%d°C\n\r", ((temp - 630) * 761) / 1024); // Formel aus LP-Demo
uart_puts(buffer); // Temperatur via Uart ausgeben
temp_old = temp;
__delay_cycles(1000000); // 1s warten
}
return 0;
}
// ***************************
// ADC10 interrupt service routine
#pragma vector=ADC10_VECTOR
__interrupt void ADC10_ISR (void){ // feuert, wenn ADC-Wandlung fertig
__bic_SR_register_on_exit(CPUOFF); // MCU in aktiven Mode schalten
}
Interner Temperatursensor (mit Energia-IDE)
#define Vref 1500 // Vref = 1500mV
#define COUNT 16 // Anzahl Teilmessungen
#define LED_DOWN GREEN_LED // Temperatur konstant/sinkt
#define LED_UP RED_LED // Temperatur steigt
uint32_t milli_volt;
uint32_t temperature_cal = 0;
uint32_t temperature = 0;
uint8_t i = 0;
void setup()
{
pinMode(LED_DOWN, OUTPUT);
pinMode(LED_UP, OUTPUT);
analogReference(INTERNAL1V5); // ADC-Referenz 1,5V
analogRead(TEMPSENSOR); // eine Dummy-Messung
Serial.begin(9600); // serielle Schnittstelle 9600Baud
Serial.println("*****");
}
void loop () {
if (i < COUNT) {
// ...weiter messen, um spaeter Mittelwert berechnen zu koennen
milli_volt = (Vref*(uint32_t)analogRead(TEMPSENSOR))/1024; // Berechnung Spannungswert
temperature += (((milli_volt - 986)*1000)/355) ; // Datenblatt: V=0,00355*T+0,986
i++;
delay(50);
} else {
// ...Mittelwert berechnen und Folgeaktionen
temperature = temperature/COUNT;
Serial.print(temperature/10);
Serial.print(".");
Serial.print(temperature-((temperature/10)*10));
Serial.println("°C");
digitalWrite(LED_DOWN, LOW);
digitalWrite(LED_UP, LOW);
if (temperature > temperature_cal) { // LEDs schalten...
digitalWrite(LED_UP, HIGH);
} else {
digitalWrite(LED_DOWN, HIGH);
}
temperature_cal = temperature;
temperature = 0;
i = 0;
}
}
Tipps und Tricks
Zugriff auf /dev/ttyACMx als Nicht-root-Benutzer für MSP430-Launchpad
Über /dev/ttyACMx (siehe dsmeg-Meldungen nach Einstöpseln des Launchpads) erfolgt die Kommunikation zwischen Linux-PC und Launchpad. Gibt es keine entsprechende udev-Regel, kann nur root auf diese Schnittstelle zugreifen. Also macht sich eine entsprechende Konfiguration für Nicht-Root-User ganz sinnvoll:
Erzeugung der Datei /etc/udev/rules.d/60-tilaunchpad.rules mit folgendem Inhalt:
# Zugriff auf TIs MSP430-Launchpad regeln
SUBSYSTEM=="usb",ATTR{idVendor}=="0451",ATTR{idProduct}=="f432",GROUP="dialout",MODE="666"
Statt "dialout" kann auch eine andere Gruppe benutzt werden, der jeweilige Benutzer muss Mitglied dieser Gruppe sein.
Nach dem Restart von udev (Befehl: /etc/init.d/udev restart) kann man auch als Nicht-root zugreifen.
Serielle Schnittstelle
Das MSP430-Launchpad verhält sich (unter Linux) etwas merkwürdig an der seriellen Schnittstelle. Dieser Hinweis/Tipp schafft, zu mindestens bei mir, Abhilfe...!
Weiterführende Links
Datenblätter:
Toolchain & IDEs:
- http://wiki.ubuntuusers.de/MSP430-Toolchain
- http://recursive-labs.com/static/courses/rl100/samples/mspstart.pdf
- http://www.itopen.it/2013/03/01/msp430-energia-on-linux/
- http://launchpadlinux.blogspot.de/2012/10/making-thinks-easier-with-make-and-geany.html
mspdebug:
MSP430-Basics:
- http://processors.wiki.ti.com/index.php/Category:MSP430
- http://dbindner.freeshell.org/msp430/
- http://www.mikrocontroller.net/articles/MSP430_Codebeispiele
- http://homepages.ius.edu/RWISMAN/C335/HTML/msp430Timer.HTM
- http://forum.43oh.com/forum/18-msp430-technical-forums/
GDB:
- http://www.cs.umd.edu/~srhuang/teaching/cmsc212/gdb-tutorial-handout.pdf
- http://www.mail-archive.com/mspgcc-users@lists.sourceforge.net/msg10262.html
