-         

Ergebnis 1 bis 5 von 5

Thema: Hilfestellung zu UART

  1. #1

    Hilfestellung zu UART

    Anzeige

    abend
    bin noch ein ziemlicher newbie also bitte seit nett zu mir...*gg*

    zuerst einmal, was ist der unterschied zwischen RS232 und uart??kann ich ein uart-signal einfach mit meinem usbtoserial-converter empfangen?brauch ich dafür nur 2 leitungen??

    ausgangssituation: ich habe ein evaluationboard mit aduc7024 (programmiere mit keil uvision 3) und generiere damit ein 3phasen pwm signal um einen linearmotor anzusteuern. funzt alles.
    nun muss ich dem uC über RS232 (oder uart?!?) einen sollwert vorgeben, zu dem er fahren soll.

    beim uC waren einige code examples dabei, check aba net ganz warum man da nicht einfach printf oda so nimmt?!?!?

    wie funkt das mit dem empfangen auf dem uc?muss ich da jedesmal einen interrupt auslösen??

    hier die 2 code examples
    Code:
    #include <ADuC7024.h>
    
                 
    void senddata(short);
    void delay(int);
    char hex2ascii(char);
    
    int main (void)  {
    
    unsigned short SOMEDATA[1024];
    int i;
    
       	GP0CON = 0x10000000; 		// enable ECLK output on P0.5
    
     	// configures GPIO to flash LED P4.2
    	GP4DAT = 0x04000000;		// P4.2 configured as an output. LED is turned on	
    
    	// Setup tx & rx pins on SPM 0 and SPM 1
    	GP1CON = 0x011;
    
         // Start setting up UART at 9600bps
       	COMCON0 = 0x080;			// Setting DLAB
       	COMDIV0 = 0x093;			// Setting DIV0 and DIV1 to DL calculated
       	COMDIV1 = 0x000;
       	COMCON0 = 0x007;			// Clearing DLAB
    
    	for (i=0; i <1024; i++)
    	{
    		SOMEDATA[i]=i;
    	}	
    	
    	while(1)
    	{
    	for (i=0; i <1024; i++)
    	{
    		senddata (SOMEDATA[i]);
    	}
    	GP4DAT ^= 0x00040000;		// Complement P4.2
    	delay(2000);
    	}
    }
    
    
    void delay (int length)
    {
    	while (length >=0)
        	length--;
    }
    
    void senddata(short to_send)
    {
    	while(!(0x020==(COMSTA0 & 0x020))){}
    		COMTX = 0x0A;						// output LF 
    	while(!(0x020==(COMSTA0 & 0x020))){}
    		COMTX = 0x0D;						// output CR 
    	while(!(0x020==(COMSTA0 & 0x020))){}
    		COMTX = hex2ascii ((to_send >> 8) & 0x0F);
    	while(!(0x020==(COMSTA0 & 0x020))){}
    		COMTX = hex2ascii ((to_send >> 4) & 0x0F);						
    	while(!(0x020==(COMSTA0 & 0x020))){}
    		COMTX = hex2ascii (to_send & 0x0F);							
    }
    
    
    char hex2ascii(char toconv)
    {
    	if (toconv<0x0A) 
    	{
    		toconv += 0x30;
    	}
    	else 
    	{
    		toconv += 0x37;
    	}
    	
    	return (toconv);
    }
    Code:
    #include <ADuC7024.h>
    
    #define CR     0x0D
     	
    int write (int file, char * ptr, int len);	// Functions used to 
    int getchar (void);							// to output data 	 
    int putchar(int);                     		// Write character to Serial Port  
    
    
    int main (void)  {
      unsigned char jchar = 0x30;
    
    	char output1[13] = "Hello World\n";
    	
    	// Setup tx & rx pins on P1.0 and P1.1
    	GP1CON = 0x011;
    
       	// Start setting up UART at 9600bps
       	COMCON0 = 0x080;				// Setting DLAB
       	COMDIV0 = 0x093;				// Setting DIV0 and DIV1 to DL calculated
       	COMDIV1 = 0x000;
       	COMCON0 = 0x007;				// Clearing DLAB
    
    	GP4DAT = 0x04000000;			// P4.2 configured as an output. LED is turned on
    
    	while(1)
    	{
    
    		GP4DAT ^= 0x00040000;		// Complement P4.2
    		write(0,output1,13);		// Output Data
    		jchar = getchar();			// RX Data, Single Byte
    		write(0,&jchar,1);			// Output Rxed Data
    	}
    }
    
    int putchar(int ch)  {                   /* Write character to Serial Port  */
    
    	if (ch == '\n')  {
        	while(!(0x020==(COMSTA0 & 0x020)))
        	{}
    		COMTX = CR;							/* output CR */
    		}
        while(!(0x020==(COMSTA0 & 0x020)))
        {}
     
     	return (COMTX = ch);
    }
    
    
    int getchar (void)  {                      /* Read character from Serial Port */
    
       	while(!(0x01==(COMSTA0 & 0x01)))
       	{}
      	return (COMRX);
    }
    
    int write (int file, char * ptr, int len) {
      int i;
    
      for (i = 0; i < len; i++) putchar (*ptr++);
      return len;
    }
    hoff ihr seit schlauer als ich

    danke im voraus

  2. #2
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    30.12.2005
    Ort
    Tann / ZH
    Alter
    61
    Beiträge
    264
    Salü Chisi,

    RS-232 definiert die physikalischen und elektrischen Eigenschaften der seriellen Schnittstelle:
    1. Stecker
    2. Spannungspegel
    Siehe dazu auch:
    http://www.roboternetz.de/wissen/index.php/RS232
    http://de.wikipedia.org/wiki/RS232

    Das UART ist das Modul oder der Chip der die Wandlung der
    parallel vorliegenden Daten in den seriellen Datenstrom vornimmt.
    Siehe dazu auch:

    http://www.roboternetz.de/wissen/index.php/UART
    http://de.wikipedia.org/wiki/UART

    Damit Du nun die Daten mit dem uC austauschen kannst, muss das UART
    konfiguriert werden:
    1. Baudrate (Geschwindigkeit)
    2. Anzahl Startbits
    3. Anzahl Datenbits
    4. Anzahl Stoppbits
    5. Parität

    Diese Parameter müssen zwingend auf beiden Seiten
    (PC und uC) übereinstimmen.

    RS-232 selber definiert kein Protokoll. PrintF selber kannst Du verwenden
    wenn Du einfach nur Daten zum PC senden und dort anzeigen willst.

    Wenn Du aber Befehle zum uC senden willst, musst Du ein Protokoll
    für die RS-232 implementieren. Dieses ist im Beispiel gemacht.

    Normalerweise programmiert man den uC so, dass sobald der uC ein Zeichen empfängt, ein Interrupt ausgelöst wird.

    Denke Du kannst das Beispielprogramm als Ausgangspunkt verwenden,
    musst es aber an deine Bedürfnisse (Hardware, Protokoll) anpassen.
    MfG
    Ruedi

  3. #3
    danke mal.

    also das UART ist schon richtig konfiguriert im programmbeispiel. also kann ich mit einem terminalprogramm daten zum uc schicken, zum beispiel einen neuen sollwert. hab im datenblatt gelesen, dass ein interrupt ausgelöst wird, wenn COMRX voll ist: "Set automatically when COMRX is full. Cleared by reading COMRX."
    das funktioniert aber nur zeichenweise oder? also jedes zeichen einzeln?wenn ich das dann in einem array speichern will, woher weiß ich die länge des arrays, das ich definieren muss?

    daten zum pc z.b. aktueller istwert, kann ich einfach über printf, wenn die schnittstelle konfiguriert ist oder?

    wie meinst du das mit wenn ich befehle zu uc senden will?was sind befehle? sind ja auch nur daten oder?

  4. #4
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    30.12.2005
    Ort
    Tann / ZH
    Alter
    61
    Beiträge
    264
    Wie Du richtig bemerkt hast, wird beim Empfang eines Zeichens
    ein Interrupt ausgelöst. Dieses Zeichen solltest Du in deiner ISR
    abholen und in einen Buffer ablegen. Dies ist ein Array. Die Grösse
    des Arrays ist natürlich abhängig davon wie lang den Befehl ist.

    Bsp. Dein Befehl ist: (ohne Hochkomma)
    Chr(STX) + "DR2000" + Chr(13) = Drehe Rechts 2000 Schritte
    Dies sind 8 Zeichen. Deshalb muss dein Buffer mindestens 8
    Zeichen aufnehmen können.

    In diesem Beispiel setzt Du wenn Du das Zeichen <STX> empfängst ein
    Flag dass Du einen neuen Befehl empfängst. Du Kopierst das Zeichen in deinen Buffer.
    Wenn Du das Zeichen Chr(13) empfängst weisst Du dass Du den ganzen Befehl empfangen hast und kannst diesen nun auswerten.
    Du setzt also in deiner ISR das Flag zurück. Dieses Wertest du nun aus.
    Das ganze ist das, was ich unter dem Protokonll angedeutet habe.
    Oftmals werden in den Befehl auch Informationen zur Fehlerkorrektur
    eingebettet.

    http://de.wikipedia.org/wiki/Netzwerkprotokoll
    MfG
    Ruedi

  5. #5
    danke erstmal.

    ich habe es diese woche geschafft (nach großen ärgernissen und dann programmupdate) dass ich beim empfang eines zeichens einen interrupt auslöse. das funktioniert soweit.

    jetzt brauchte ich z.b. wenn ich 4 zeichen (zahlen) abhole und in ein array[4] speichere, dass ich dass dann in eine normale zahl "umwandle", also wenn array[4] = {1,2,3,4} dann soll wert = 1234 herauskommen.
    ist das möglich?

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •