Programmieren einer UART-Befehlseingabe

[Externer (Gast)]

Hallo,

ich habe folgendes Problem:
Ich arbeite zum ersten mal mit einem ARM Cortex-M3 Controller und möchte 
eine Compilervalidierung vollziehen. Dafür muss ich auf die 
UART-Schnittstelle zugreifen und möchte über ein Eingabeterminal (PuTTy) 
eine Funktion aufrufen. Was ich schon geschafft habe ist, dass ich den 
UART so konfiguriert habe und mir diverse Zeichenketten ausgegeben 
wurden. Was ich aber nicht schaffe ist, dass ich sozusagen dazu komme 
irgendwas einzugeben. Habe es schon mit der 
scanf/printf-Funktionskombination probiert, aber da hängt sich das 
Programm nur dabei auf. Zeichen sende und empfange ich ja über COMTX 
bzw. COMRX. Wie schaffe ich es jetzt Zeichen zu senden über COMRX? Der 
Controller ist ein ADuCM301 von Analog Devices.
Ich habe schon im Internet recherchiert, aber nix brauchbares gefunden.
Wäre dankbar wenn mir jemand helfen könnte.

[Alex (Gast)]

Hallo,

ich kenne mich mit deinem Controller nicht aus,
aber es gibt folgendes Problem:
Wenn du mit deiner Tastatur Worte etc. eingeben willst, woher soll die 
Empfangsroutine wissen, wann die Eingabe beendet ist??
besser du verwendest ein Zeichen zur Funktionsauswahl. Und du verwendest 
GetChr(), also jedes einzelne Zeichen auslesen.

[Dr. Datensalat (Gast)]

Hallo Externer,

mit Deinen Angaben ist es etwas schwierig Dir zu helfen.
Ist das Dein erster Mikrocontroller mit dem Du programmierst?

Wenn Du an Deinen Controller Werte schickst müssen die ja auch irgendwo 
herkommen, da hast Du keine Aussage dazu gemacht.

Etwas Programmcode wäre auch hilfreich. Printf und scanf sind in einer 
Interruptroutine wohl auch nicht das optimale.

Grüße

[Externer (Gast)]

Dr. Datensalat schrieb:
> Hallo Externer,mit Deinen Angaben ist es etwas schwierig Dir zu helfen.Ist das 
Dein erster Mikrocontroller mit dem Du programmierst?Wenn Du an Deinen Controller 
Werte schickst müssen die ja auch irgendwoherkommen, da hast Du keine Aussage dazu 
gemacht.Etwas Programmcode wäre auch hilfreich. Printf und scanf sind in 
einerInterruptroutine wohl auch nicht das optimale.Grüße

Nein, das ist nicht mein erster Controller, aber meine erste 
UART-Schnittstelle die ich programmiere um darüber Daten senden und 
empfangen zu können.
Ich habe bisher ohne Interrupts gearbeitet, da ich diese für den ersten 
Test nicht als allzu notwendig empfinde. Ich habe dazu größtenteils 
versucht 
[[http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART|dieses 
AVR-GCC-Tutorial]] für den ARM nachzuvollziehen was bis zum Empfangsweg 
auch geklappt hat. Senden kann ich über die Eingabe noch nichts.
Ich poste mal hier kurz den Code:

#include "ioadcm301.h"
#include <stdio.h>
#include <stdlib.h>

//Prototypes
void Initialize(void);
void config_Clk(void);
void config_UART(void);
void UART_test(void);
void uart_puts(const char *s);
static inline int uart_putc(const char c);

//Global
char eingabe[] = "start";   //RX String

int main(void)
{
    unsigned char c;           //Sending Sign
    
    T3CON = 0;        // Stop Watch Dog
    
    Initialize();     //Initialize all

    COMTX = 0x0A;     // LF
    while((COMLSR & (1 << 6))==0);  // Wait till TX shift is empty
    COMTX = 0x0D;     // CR
    
    while(1){

      for(int i = 0; i <= 9; ++i)
      {
        c = i + '0';
        while((COMLSR & (1 << 6))==0);  // Wait till TX shift is empty
        COMTX = c;
      }

      while((COMLSR & (1 << 6))==0);  // Wait till TX shift is empty
      COMTX = 0x0D;   // CR
      printf("\n\n");
      
      uart_puts(eingabe);
      uart_puts("start");
      
      if(eingabe=="start")
        UART_test();
          
      for(int i = 0; i < 100000; ++i);
      GP4TGL = (1 << 2);  // Toggle LED
      
    }
    
    
//    return 0;
}

void uart_puts(const char *s){
  do{
    uart_putc(*s);
  }
  while(*s++);
}

static inline int uart_putc(const char c){
   while((COMLSR & (1 << 6))==0);  // Wait till TX shift is empty
   COMRX = c;                      // Send sign
   return 1;
}

void UART_test(void){
   printf("Die Testfunktion konnte erfolgreich aufgerufen werden!\n");
}

void Initialize(void){
    config_Clk();     // Clock configuration

    // General Purpose I/O configuration
    GP1CON = (2 << (2 * 1))   // Set P1.1 to UART TXD and P1.0 to UART RXD Mode
            |(1 << (2 * 0));
    
    GP4CON = (1 << (2 * 2));    // P4.2 GPIO LED
    GP4OEN = (1 << 2);         
    GP4PUL = (1 << 2);
    GP4OUT = (1 << 2);
    
    config_UART();    // UART configuration
}

void config_Clk(void){
    CLKCON = 0x0000;  // Choose Internal Oscillator with 16MHz in active mode
}

void config_UART(void){
   // Baud rate = UCLK (16MHz) / (2x16xCOMDIV) / (M + N/2048)
   // Where COMDIV = 1 to 65536, M = 1 to 3 and N = 0 to 2047
   
   COMCON = 0x0000;   // Enable UART
   
   // Set Baud rate to 9600
   COMDIV = 17;           //UART Clock Divider set to 17
   COMFBR = (1   << 15)   //At 16MHz set M to 3 and N to 131 to obtain fractional Baud rate of 9600
           |(3   << 11)
           |(131 <<  0);
   
   //Interrupt enable
//   COMIEN = 0x0F;     //Modem Status interrupt, RX status Interrupt, Transmit buffer empty interrupt, Receive buffer full interrupt
   //Control registers
   COMLCR = (0 << 6)     //Word length of 8 Bits, 1 Start bit and 1 Stop bit = 10 Bits
           |(0 << 5)
           |(0 << 4)
           |(0 << 3)    // no Parity
           |(0 << 2)
           |(3 << 0);
             
   COMMCR = 0x00;     //Normal mode, Force RTS and DTR to 1
}

[Karl H. (kbuchegg)]

Externer schrieb:

> Ich habe bisher ohne Interrupts gearbeitet, da ich diese für den ersten
> Test nicht als allzu notwendig empfinde.

Passt doch.
Machs halt erst mal ohne Interrupts.
Erster SChritt: ein einzelnes Zeichen zu empfangen und gleich wieder 
zurückzusenden.


> AVR-GCC-Tutorial]] für den ARM nachzuvollziehen was bis zum Empfangsweg
> auch geklappt hat. Senden kann ich über die Eingabe noch nichts.

Bitte gewöhn dich daran, dass die Begriffe Senden/Empfangen aus Sicht 
des µC gesehen werden.

Wenn der µC sendet, dann gehen die Zeichen von ihm aus und werden vom 
Terminal empfangen und dargestellt

Wenn das Terminal sendet, dann gehen die Zeichen vom Terminal zum µC und 
werden vom µC empfangen.

Da es hier um die Programmierung des µC geht, sind die Begriffe Senden 
und Empfangen aus seiner Sicht zu sehen. Das bedeutet: nicht du 'kannst 
noch nichts über die Eingabe senden', sondern du weißt noch nicht wie du 
die UART im µC abfragst, ob sie etwas empfangen hat.

Diese Verwirrung hattest du schon mal in einem vorhergehenden Post. Ich 
habs damals einem Postingfehler zugeschrieben. Da derselbe 
Begriffsdreher hier nochmal auftaucht, bin ich mir sicher, dass das kein 
Zufall war.

Warum ist das interessant. Weil es keinen Menschen interessiert (und 
schon gar nicht den µC), wer oder was am anderen Ende des Kabels hängt. 
Die UART empfängt etwas und dein Programm muss damit was machen.

[Karl H. (kbuchegg)]

PS:
Deine Schreibweise mit den vielen direkt im Code geschriebenen Zahlen 
ist natürlich nicht besonders angetan, das man nachvollziehen kann, was 
du da eigentlich konfigurierst.

Zb. wirst du ja wohl irgendwo den Transmitter der UART eingeschaltet 
haben (wenn das so funktioniert, dass man Transmitter und Receiver 
getrennt einschalten kann). In deinem Code mit den vielen Zahlen ist das 
aber absolut nicht erkennbar, wo das sein könnte.

Sei es wies sei: Auch diese UART wird irgendwo ein Statusregister haben, 
in dem es ein Bit gibt, welches aussagt, das die UART ein Byte empfangen 
hat.