c++ programmierung µc

[Bernd S. (mms)]

Hallo,

ich möchte meinen ersten mikrocontroller programmieren - leider ist es 
schon ein ARM7, allerdings in einer einfachen schaltung - sprich als 
erstes ziel hab ihc mir gesetzt, die serielle schnittstelle zum leben zu 
erwecken (damit ich mit im hyper terminal sachen ausgeben kann).

Wie sieht die prinzipielle Struktur von so einem Programm aus - am 
anfang muss ich ein startup-file haben, in dem nach einem reset ständig 
alle ports etc. richtig geschalten werden und wird hier dann auch gleich 
die main routine aufgerufen? die main routine besitzt wahrscheinlich 
keinen return-wert, oder (weil dieser an niemanden zurückgegeben werden 
kann)?

Wie spreche ich das externe Flash z.B. an? oder einzelne Ports? Muss ich 
hier PortB als variable definieren? Kennt jmd. gute seiten, in denen 
erklärt wird wie man am besten mit c oder besser c++ einen 
mikrocontroller programmiert bzw. welche strukturen man einhalten muss?

Bernd

[Peter D. (peda)]

Bernd Schuster wrote:
> ich möchte meinen ersten mikrocontroller programmieren - leider ist es
> schon ein ARM7, allerdings in einer einfachen schaltung

Naja, mit externen Flash drangepappt ist das keine einfache Schaltung 
mehr, da ist schon ne ganze Menge Holz auf dem Board. Den Schaltplan 
hast Du doch  und weißt ihn zu lesen?


> Wie sieht die prinzipielle Struktur von so einem Programm aus

Du mußt auf nichts Rücksicht nehmen, alles ist erlaubt.
Strukturier Dein Programm ganz so, wie es Dir gefällt.
Es muß eine main-Funktion drin stehen, das ist alles.


> - am
> anfang muss ich ein startup-file haben, in dem nach einem reset ständig
> alle ports etc. richtig geschalten werden

Nö, das Startup kümmert sich nur um die Compilersachen (Stack, 
Interruptvertoren, Variablen initialisieren)

Wenn Du Ports verwenden willst, mußt Du Dich selber drum kümmern.


> und wird hier dann auch gleich
> die main routine aufgerufen? die main routine besitzt wahrscheinlich
> keinen return-wert, oder (weil dieser an niemanden zurückgegeben werden
> kann)?

Main darf nie enden (Endlos-Schleife).


> Wie spreche ich das externe Flash z.B. an? oder einzelne Ports?

ARM ist nicht gleich ARM, ohne genaue Typangabe kann keiner was dazu 
sagen.

Die ARM von NXP haben z.B. das lustige Feature, daß es für die Ports 
getrennte Setz- und Löschregister gibt.

Du mußt also den Schaltplan und das Datenblatt (Usermanual) Deines ARM 
zur Hand nehmen.

Und da beginnt dann auch der Unterschied zu nem AVR-MC. Beim AVR ist die 
Beschreibung noch handlich, beim ARM wirst Du förmlich erschlagen (über 
tausend Seiten auf viele PDFs verteilt).

Richtig lustig wirds aber erst, wenn Du Interrupts programmierst (wird 
ne ganze Weile dauern).


> Muss ich
> hier PortB als variable definieren?

Ich kenne die ARM nur mit numerierten Ports (PORT0, Port1 usw.).
Z.B. bei den ST-ARM werden die Ports über Pointer mit Offset 
angesprochen, sonst macht sich der ARM tot mit ständig neue Adressen 
laden. Sieht allerding nicht sehr leserlich aus. Ist ne Sache, wie der 
Compilerhersteller die Headerfiles angelegt hat.


Peter

[Michael G. (linuxgeek)]

Hallo Bernd,

hat es einen realistischen Grund, dass Du gleich mit so einem starken 
Controller anfangen willst? Wenn Du Dich uebernimmst kannst Du leicht 
das Interesse verlieren, gerade am Anfang.

Michael

[Bernd S. (mms)]

>Den Schaltplan hast Du doch  und weißt ihn zu lesen?

das Board hab ich zum Testen bekommen - also hardware-technisch dürfte 
es auf jeden fall funktionieren.

>hat es einen realistischen Grund, dass Du gleich mit so einem starken
>Controller anfangen willst? Wenn Du Dich uebernimmst kannst Du leicht
>das Interesse verlieren, gerade am Anfang.

mit einem Atmega8 hab ich schon so ganz kleine standard-sachen 
programiert in assembler (wie Leds an aus, Taster mit speziellen 
funktionien wie LEDs leuchten, und Interrupts - aber alles ganz basic 
(der Code war stets ca. ne seite auf monitor)...  jetzt möchte ich mich 
mit diesem ARM7 Board vertraut machen (ganz langsam und step by step)... 
also zuerst einmal die LEDs ansprechen und RS232 ansprechen (das wäre 
super, wenn ich da schon mal dann auch einen rückkanal hätte, damit ich 
sehe was ich mache...

deshalb suche ich auch nach praktischen beispielen, an denen ich lernen 
kann (also muss nicht auf den prozessor zugeschnitten sein, sondern mir 
nur zeigen wie ich was anspreche (blöd ausgedrückt - also z.B. wie 
abstrakt ich schon mit C oder C++ gegenüber Assembler sein darf bzw. wie 
ich die Register ansprechen muss (oder ob ich schon eine ebene darüber 
arbeite).. vielleicht hat jmd. einen bsp-code für mich, in dem nur 
vielleicht eine led an einem port aktiviert wird und auf ein paar 
register oder speicherstellen zugegriffen wird bzw. Werte gespeichert 
werden (gut dokumentiert)... ich glaub, dadurch könnte ich mir schon 
einiges ablesen, wie ich arbeiten muss... auch so der Aufbau - eine 
Main-Funktion und (in C), dann viele einzelne Funktionen, die nach 
einander oder bei bestimmten (Interrupts) Zuständen, aus Main aufgerufen 
werden --> dann muss ja alles wichtige gespeichert werden und nach der 
Interrupt-Methode wieder aus dem Speicher geholt werden...

Bernd

[Peter D. (peda)]

Bernd Schuster wrote:
>>Den Schaltplan hast Du doch  und weißt ihn zu lesen?
>
> das Board hab ich zum Testen bekommen - also hardware-technisch dürfte
> es auf jeden fall funktionieren.

Um das Funktionieren geht es nicht, sondern darum, zu erkennen, wie und 
in welche Adreßbereiche der Flash und sonstige Peripherie gemappt ist, 
wie man in den Bootloader kommt usw.


> jetzt möchte ich mich
> mit diesem ARM7 Board vertraut machen (ganz langsam und step by step)...
> also zuerst einmal die LEDs ansprechen und RS232 ansprechen

Da dürfte die beste Quelle das Exampleverzeichnis Deiner 
Tools-Installation zu dem Board sein.

Ich nehme mal an, das Board war nicht nackt, sondern ne CD dazu und 
vielleicht sogar ein JTAG-USB-Debugger.


Es nimmt Dir auch keiner übel, wenn Du endlich mal damit rausrücken 
würdest um welchen ARM7 (Hersteller, Bezeichnung) es überhaupt geht.

Solange das keiner weiß, können die Antworten nur abstrakt sein.


Peter

[Gast (Gast)]

anbei mal eine ARM Code den ich in der FH geschrieben hab...

#include <stdio.h>

/* define segments in terms of IO lines */
#define SEG_A (1 << 10)
#define SEG_B (1 << 11)
#define SEG_C (1 << 12)
#define SEG_D (1 << 13)
#define SEG_E (1 << 14)
#define SEG_G (1 << 15)
#define SEG_F (1 << 16)

#define DISP_0 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F)
#define DISP_1 (SEG_B | SEG_C)
#define DISP_2 (SEG_A | SEG_B | SEG_G | SEG_E | SEG_D)
#define DISP_3 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_G)
#define DISP_4 (SEG_B | SEG_C | SEG_F | SEG_G)
#define DISP_5 (SEG_A | SEG_C | SEG_D | SEG_F | SEG_G)
#define DISP_6 (SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define DISP_7 (SEG_A | SEG_B | SEG_C)
#define DISP_8 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define DISP_9 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_F | SEG_G)
#define DISP_A (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G)
#define DISP_B (SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define DISP_C (SEG_A | SEG_D | SEG_E | SEG_F)
#define DISP_D (SEG_B | SEG_C | SEG_D | SEG_E | SEG_G)
#define DISP_E (SEG_A | SEG_D | SEG_E | SEG_F | SEG_G)
#define DISP_F (SEG_A | SEG_E | SEG_F | SEG_G)

/*Funktion zur Intialisierung der LEDs und Sieben-Segment
  Ãœbergabewerte:  -keine-
  Rückgabewerte:  -keine-*/
void io_init(volatile unsigned int *);

/*Funktion um die LEDs auf den übergebenen Wert setzen
  Ãœbergabewerte:  char  wert  0-0xF
  Rückgabewerte:  -keine-*/
void leds(char wert,volatile  unsigned int *);

/*Funktion zum Einlesen der Schalter
  Ãœbergabewerte:  -keine-
  Rückgabewerte:  char  0-0xF*/
char schalter(volatile unsigned int *);

/*Funktion zum Setzen der Siebensegmentanzeige
  Ãœbergabewerte:  char  wert 0-0x0F
  Rückgabewerte:  -keine-*/
void segment(char wert,volatile  unsigned int *);


static const unsigned numeric_display[] = { DISP_0, DISP_1, DISP_2, DISP_3, DISP_4, DISP_5, DISP_6,
      DISP_7, DISP_8, DISP_9, DISP_A, DISP_B, DISP_C, DISP_D, DISP_E, DISP_F };
      
int main (void)
{
  volatile unsigned int *z_iopmod,*z_iopdata;
  char i;
  
  z_iopdata=(volatile unsigned *)(0x03FF0000 + 0x5008);
  z_iopmod=(volatile unsigned *)(0x03FF0000 + 0x5000);
  
  io_init(z_iopmod);
/*10 mal Hallo Welt ! auf der Konsole ausgeben*/
  for(i=0;i<10;i++)    
  {
    printf("Hallo Welt !");
    fflush(stdout);
  }
/*Alle möglichen Kombinationen auf LED und 7-Segmentanzeige ausgeben*/
  for(i=0;i<16;i++)
  {
    leds(i,z_iopdata);
    segment(i,z_iopdata);
  }
/*SChalter einlesen und auf LED und 7-Segmentanzeige ausgeben*/
  while(1)
  {
    i=schalter(z_iopdata);
    leds(i,z_iopdata);
    segment(i,z_iopdata);
  
  }

  return 0;
}

void io_init(volatile unsigned int *z_iopmod)
{
  *z_iopmod = ((1<<4)|(1<<5)|(1<<6)|(1<<7));
  // wo LEDS dran als Output
  *z_iopmod |= ((1<<10)|(1<<11)|(1<<12)|(1<<13)|(1<<14)|(1<<15)|(1<<16));
  // wo Sieben-Segment dran als Output
}

void leds(char wert,volatile  unsigned int *z_iopdata)
{
  wert &= (1|(1<<1)|(1<<2)|(1<<3));
  //schneide Wert passend zu
  *z_iopdata &=~ ((1<<4)|(1<<5)|(1<<6)|(1<<7));
  //lösche alten Wert
  *z_iopdata |= wert<<4;
  //schreibe Wert von 0 bis 0xF auf LEDs
}

char schalter(volatile unsigned int *z_iopdata)
{
  return (*z_iopdata & (1|(1<<1)|(1<<2)|(1<<3)));
  //hole Wert der Schalter und maskiere den Rest
}

void segment(char wert,volatile  unsigned int *z_iopdata)
{
  wert &= (1|(1<<1)|(1<<2)|(1<<3));
  //schneide Wert passend zu
  *z_iopdata &=~  ((1<<10)|(1<<11)|(1<<12)|(1<<13)|(1<<14)|(1<<15)|(1<<16));
  //lösche alten Wert
  *z_iopdata |= numeric_display[wert];
  //Passe wert an und suche dann passende Kombination aus dem Array numeric_display raus.
}

printf landet hierbei über JTAG im Debugger(PC-Software)

an ein 4 Pins hängen Schalter, an 4 LEDs, und dann noch ne 7-Segment 
Anzeige

ist aber alles herstellerabhängig, jeder Hersteller kann die Adresswerte 
anders verteilen...

Interrupt sind noch komplizierter, weil du alles selber schreiben musst 
bzw jeder Hersteller den IRQ Controller anders implementieren kann

da ARM eine Lizenz zum bauen von Kernen verkauft und selber keine CPUs 
verkauft

[Bernd S. (mms)]

>Um das Funktionieren geht es nicht, sondern darum, zu erkennen, wie und
>in welche Adreßbereiche der Flash und sonstige Peripherie gemappt ist,
>wie man in den Bootloader kommt usw.

der Addressbereich steht im Datenblatt sehr gut aufgeschlüsselt drinnen. 
Benötigt man auch zu Beginn gleich einen Bootloader? Eigentlich wollte 
ich ganz ohne allem erst mal anfangen... der prozessor ist der LPC2212. 
Bei dem Board war eine CD mit dabei, mit Bootloader U-Boot und dazu 
Beispielprogrammen, aber ich möchte halt zuerst mal ohne Bootloader 
auskommen...


@Gast

vielen dank für dein beispiel, werde es mir morgn mal genau anschauen. 
Aber ein paar Fragen hab ich gleich beim Durchlesen gefunden.

1. was bedeutet denn fflush genau?
2. ist eine endlosschleife ohne abbruchkriterium gang und gebe?
3. das mit den ganzen defines muss ich mir noch mal anschauen
  genauso wie die Zeile
  z_iopdata=(volatile unsigned *)(0x03FF0000 + 0x5008);


Im Prinzip geht es mir darum, zu erlernen wie man was programmiert bzw. 
wie man vorgeht.

Bernd

[Gast (Gast)]

zu 1. ist nur interessant wenn du eine Online Debugger hast...

fflush leert den Buffer in den Klammern, sonst kann es bei printf 
passieren das die Ausgabe erst erscheint wenn der Buffer irgendwann mal 
voll ist

(Standard C Fkt)

zu 2.

ja im µC Berich schon, weil was willst du den reinschreiben als Abbruch

zu 3.

z_io... ist ein zeiger im C, dessen Adresse wird auf den angegeben Wert 
gelegt dadurch kann man auf das Register zugreifen (die Register sind in 
diesem Fall memory mapped)