USART >> Array vom PC zum mC

[Michael A. (ammannm)]

Guten Tag miteinander!

Ich weiss dass dieses Thema schon mehrmals hier behandelt wurde und ich 
habe schon einiges gelernt beim durchstöbern.
Mein erstes USART Programm findet ihr im Anhang!

Beschreibung:

Die Daten die ich vom PC sende sind Binär und 35 Bit lang.Immer 8 bit's 
werden zu einem byte und diese werden zum ansteuern der Ports verwendet 
(35 Bit = ca. 5 Ports). Die empfangenen Daten möchte ich in ein Array 
packen und auslesen können.
PORTA = zeichen[1];
PORTB = zeichen[2]; usw.

Das Array sollte ein zweisimensionales (array[5][200]) sein und würde 
max. 200(zeilen) auf 5(spalten) sein. Beim ausschalten und wieder 
einschalten sollten die Daten noch vorhanden sein!

Nun meine Fragen:

-Funktioiert dieses Programm so wie es im Anhang ist überhaupt(soll nur 
daten auslesen)?
- wie bringe ich die Daten in ein Array?
- Wie speichere ich die Daten ab?

Vielen dank für die Hilfe!!

MfG Michael

[Jean P. (fubu1000)]

> Ich weiss dass dieses Thema schon mehrmals hier behandelt wurde und ich
> habe schon einiges gelernt beim durchstöbern.
> Mein erstes USART Programm findet ihr im Anhang!
Naja, ich sag lieber nix.

> Die Daten die ich vom PC sende sind Binär und 35 Bit lang.Immer 8 bit's
> werden zu einem byte und diese werden zum ansteuern der Ports verwendet
> (35 Bit = ca. 5 Ports). Die empfangenen Daten möchte ich in ein Array
> packen und auslesen können.
> PORTA = zeichen[1];
> PORTB = zeichen[2]; usw.
Also byte empfangen und z.B. ne Variable hochzählen welcher Port gerade 
dran ist.

> Das Array sollte ein zweisimensionales (array[5][200]) sein und würde
> max. 200(zeilen) auf 5(spalten) sein. Beim ausschalten und wieder
> einschalten sollten die Daten noch vorhanden sein!
Dann brauchste nen µC mit mehr als 1kB RAM, sowie EEPROM zum speichern 
der Daten, welche du bei Reset dir wieder holst.

> -Funktioiert dieses Programm so wie es im Anhang ist überhaupt(soll nur
> daten auslesen)?
Nein.

> - wie bringe ich die Daten in ein Array?
> - Wie speichere ich die Daten ab?
In dem du die Daten ins array speicherst ;-)
Und vorm ausmachen ins EEPROM verschiebst.


Hier mal nen Ausschnitt für die USART.c:
1.)SendSign sendet nen einzelnes Byte
2.)GetSign schltet Uart Empfang Interrupt frei
3.)init und DeInit sind selbst erklrärend

#include "USART.h"

#define CLOCK 16000000UL
#define BAUD 38400UL
#define UBRRVAL (CLOCK/(BAUD*16)-1)


void USARTSendSign(unsigned char byte)
{
  while (!(UCSRA & (1<<UDRE))) 
  ;
  UDR = byte;
}


unsigned char USARTGetSign()
{
  UCSRB |= (1 << RXCIE);
  sei();
  return 0;  
}


void USART_init()
{
  UBRRH = (unsigned char) UBRRVAL >> 8;    
    UBRRL = (unsigned char) UBRRVAL;      

  UCSRC |= (1<<URSEL)|(3<<UCSZ0);
  UCSRB |= (1<<TXEN) | (1 << RXEN);
}


void USART_DeInit()
{
  UCSRB &= ~(1 << TXEN);
  UCSRB &= ~(1 << RXEN);
  UCSRB &= ~(1 << RXCIE);
}

[Jean P. (fubu1000)]

So, dann würde ich im USART.h ne struct deklarieren, z.B. so:

struct MyStruct
{
  char puffer[5][200];
  unsigned char port;
}UsartRam;

Jetzt musst du nur noch den Spalten, welche vermutlich für die Ports 
stehen, die bytes zuweisen. Dafür würde ich Pc seitig nen byte voraus 
schicken, um zu wissen, welcher Port es ist. Z.B. A = PORTA, B = 
PORTB.....; 0 bedeutet kein Empfang. Anfangs Zustand der Variablen port 
im struct muss natürlich irgend ein Zeichen sein was du nit brauchst. 
Und nach Ende der Übertragung muss die Variable wieder zurück gesetzt 
werden.
Nachteil dabei wäre das ein Steuerzeichen für deine Ports weg fällt.

Andere Möglichkeit wäre nen byte voraus zu schicken und die Länge des 
folgenden Arrays anzugeben, dann füllst du solange das Array[0][x], bis 
die Länge des ersten bytes(Länge) erreicht ist. Dann schickste wieder 
nen byte für die Länge Array[1][x] und so weiter. Gibt noch jede Menge 
andere quick and dirty Methoden das zu machen.....
Die ISR würde ich so gestalten:

ISR(USART_RXC_vect)
{  
  unsigned char byte = UDR;
  
  //Speicher dein ARRAY, irgendwie ab!
  //DIESE STELLE probierst du erstmal selbst.
  //falls du es nit schaffst deine Ergebnnisse zeigen
  //um guten Willen zu zeigen und dir wird geholfen ;-)
}

[Michael A. (ammannm)]

Vielen Dank erstmal!
Setze mich nun dahinter und versuche mal es hinzubekommen!

[Michael A. (ammannm)]

Habe nun nach ca. 3 stunden etwas geschrieben, nur funktioniert es nicht 
wie ich will. Es ist nicht viel aber meiner Meinung nach müste es 
gehen?!
Habe herausgefunden dass ich mich mit der ANSI-C Programmiersprache noch 
viel beschäftigen muss!

Nun zu meinem Progrämchen.

#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include "usart.h"
#include <usart.c>

int pos = 0;

int main(void){

  while(1){
    //Ram auslesen und PORT's ansteuern
  }
}


ISR(USART_RXC_vect)
{  

    unsigned char byte;
  byte = UDR;    //daten auslesen und an byte übergeben

  if (pos ==6){
  
    pos = 0;
  
  }else{

    UsartRam.port[pos] = byte;
    pos++;

  }

}

Und die USART.H datei die ich abgeändert habe.

struct datenarray
{
  char port1[200];
  char port2[200];
  char port3[200];
  char port4[200];
  char port5[200];
  
}UsartRam;

Die Daten möchte ich ins Flash speichern da ich einen atmega64 verwende 
und mein Programm höchstens 10k braucht von 64k.

Michael

[Jean P. (fubu1000)]

Michael Ammann schrieb:
> Habe nun nach ca. 3 stunden etwas geschrieben, nur funktioniert es nicht
> wie ich will. Es ist nicht viel aber meiner Meinung nach müste es
> gehen?!
Mal im Ernst, was soll das Programm denn machen. Du hast ja nit mal den 
Interrupt aktiviertl geschweige denn den Uart initialisiert.

> Habe herausgefunden dass ich mich mit der ANSI-C Programmiersprache noch
> viel beschäftigen muss!
Mag sein.

Ich habe mir mal erlaubt dein Proggi zu verändern, mit den von mir oben 
geposteten Code, allerdings musste die Usart_init und so selber 
auslagern. Habe jetzt mal alles in eine datei sozusagen geschrieben:
OHNR GEWÄHR ALLES AUSM KOPF, ABER DENKE DAS PASST, TESTE ALSO MAL IN 
DEINER WHILE(1), OB ÜBERHAUPT WAS ANKOMMT !

#include <avr/io.h>
#include <avr/interrupt.h>

#define CLOCK 16000000UL
#define BAUD 38400UL
#define UBRRVAL (CLOCK/(BAUD*16)-1)
 
struct datenarray
 {
   char port1[200];
   char port2[200];
   char port3[200];
   char port4[200];
   char port5[200];
 }UsartRam;
 
volatile int pos; 

int main(void)
{
  pos = 0;

  //Usart_init();
  UBRR0H = (unsigned char) UBRRVAL >> 8;    
  UBRR0L = (unsigned char) UBRRVAL;      
  UCSR0C |= (3<<UCSZ00);
  UCSR0B |= (1<<TXEN0) | (1 << RXEN0);

  //UsartGetSign();
  UCSR0B |= (1 << RXCIE0);
  sei();
 
   while(1)
   {
     //Ram auslesen und PORT's ansteuern
     //darauf achten das überhaupt was im UsartRam.portX[y] steht,
     //also prüfen
   }
 }
 
 
 ISR(USART_RXC_vect)
 {
 
   unsigned char byte;
   byte = UDR;    //daten auslesen und an byte übergeben
 
   if (pos ==6){
 
    pos = 0;
 
   }else{
 
     UsartRam.port1[pos++] = byte;  //ich schreibe erstmal nur port1,        //denn Rest machst du schon ;-) 
   }
 
 }

>




>Die Daten möchte ich ins Flash speichern da ich einen atmega64 verwende
>und mein Programm höchstens 10k braucht von 64k.
Glaube ich nit.

Gruß

[Michael A. (ammannm)]

Also, ich glaube so könnte es funktionieren aber habe noch irgendwo 
einen schreibfehler drin da es fehlermeldungen beim compilieren gibt.

#include <stdio.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <usart.h>

#define CLOCK 16000000UL
#define BAUD 38400UL
#define UBRRVAL (CLOCK/(BAUD*16)-1)
#define arrayimflash;
 
volatile int pos; 
volatile int portnr;

int main(void)
{
  int i;
  char a;
    
  DDRB = 0b00000000;

  pos = 0;

    //Usart_init();
    UBRRH = (unsigned char) UBRRVAL >> 8;    
    UBRRL = (unsigned char) UBRRVAL;      
    UCSRC |= (3<<UCSZ2);
    UCSRB |= (1<<TXEN) | (1 << RXEN);

    //UsartGetSign();
    UCSRB |= (1 << RXCIE);
    sei();

 //----------------------------------------

 while(1)
  {
  
  if (UsartRam.port1[1] == 0) {    //Daten im Array?
  
  }else{

    for (i=0;i<200;i++) {    Daten aus array auslesen
         a = pgm_read_float (&arrayimflash[i]); // entspr. "a = arrayimflash[i];"
      PORTB = a;    //hjPort ansteuern
       }
  }
 }
}
 
 
ISR(USART_RXC_vect)
{
 
   unsigned char byte;
   byte = UDR;    //daten auslesen und an byte übergeben
 
   if (pos ==201){    // 200 mal 8bit Daten
 
    pos = 0;
 
   }else{
 
     UsartRam.port1[pos++] = byte;  //erstmal nur port1 auslesen (routine schreiben um Port zu wechseln!) 
 
   }
 
  const uint8_t *arrayimflash PROGMEM = {UsartRam.port1};  //datenarray in flash speichern mit zeiger "arrayimflash"

}

Es ist recht schwierig! Muss mir die Infos zusammensuchen. Bis jetzt 
haben meine C (grund)kenntnisse ausgereicht aber bei diesem Projekt 
nicht mehr....

MfG Michael

[Karl H. (kbuchegg)]

Michael Ammann schrieb:

> ISR(USART_RXC_vect)
> {
>
>    unsigned char byte;
>    byte = UDR;    //daten auslesen und an byte übergeben
>
>    if (pos ==201){    // 200 mal 8bit Daten
>

Das sieht nicht richtig aus.
Dein Array ist 200 Bytes gross. D.h. die Indizes laufen von 0 bis 199. 
Wenn pos den Wert 200 hat, darfst du schon nichts mehr in UsartRam.port1 
speichern, weil UsartRam.port1[200] schon nicht existiert.

>     pos = 0;
>
>    }else{
>
>      UsartRam.port1[pos++] = byte;  //erstmal nur port1 auslesen
> (routine schreiben um Port zu wechseln!)
>
>    }

Ausserdem: warum wirfst du das empfangene Byte weg, wenn du pos auf 0 
setzen musstest?

>
>   const uint8_t *arrayimflash PROGMEM = {UsartRam.port1};  //datenarray
> in flash speichern mit zeiger "arrayimflash"

Das wird so nichts.
Daten im Flash ablegen ist nicht so simpel, dein normaler Programmcode 
kann das gar nicht, sondern mann muss den Umweg über Programmcode in der 
Bootloader-Sektion gehen. Du suchst dir hier eine Problemstellung aus, 
die (zumindest momentan) mit an Sicherheit grenzender Wahrscheinlichkeit 
zum Scheitern verurteilt ist.
>
> Es ist recht schwierig! Muss mir die Infos zusammensuchen. Bis jetzt
> haben meine C (grund)kenntnisse ausgereicht aber bei diesem Projekt
> nicht mehr....

Mach Vorübungen auf dem PC!
Dort kannst du besser Debuggen.
Du UART ersetzt du durch ein char-Array aus dem du Byte für Byte Werte 
holst und verarbeitest. Du kannst auf dem PC die ganze Verarbeitung, mit 
all den Buffern und dergl. wunderbar entwickeln und durchspielen.

> Bis jetzt
> haben meine C (grund)kenntnisse ausgereicht

Mit Verlaub, bei allem nötigen Respekt und ohne dich kränken zu wollen: 
Aber das was ich da sehe, sind noch nicht einmal Grundkenntnisse.

[Michael A. (ammannm)]

Vielen Dank für die erlichen Worte.
Somit ist mein Projekt wirklich gescheitert.

Nun werde ich wie vorgeschlagen hinter die Bücher gehen und Lernen.

Fertige Programmcodes findet man ja nur schwer.

Danke für die Hilfe.

MfG Michael

[Michael A. (ammannm)]

Es lässt mir keine Ruhe!

Habe nochmals nach Beispielen im internet gesucht. Auf folgender Seite 
sieht es so einfach aus.

Nur mal das auslesen des USART angeschaut, nichts von ins Flash 
speichern und so!

Warum siehts hier so einfach aus?

http://www.rn-wissen.de/index.php/Sourcevergleich

#include <avr/io.h> 

#define F_CPU       8000000 
#define USART_BAUD_RATE   9600 
#define USART_BAUD_SELECT   (F_CPU/(USART_BAUD_RATE*16L)-1) 

//-----------------------------------------------------
int main(void)
{
  char bZeichen;
  
  UCSRB = (1 << RXEN) | (1 << TXEN); 
  UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0); 
  UBRRL = (unsigned char) USART_BAUD_SELECT; 
  
  while (1) 
  { 
    while ( !(UCSRA & (1 << RXC)) ) 
    {}
    bZeichen = UDR; 
  }
}

Bin noch eine Antwort schuldig: Es sollte eine Anzeige werden welche 35 
LED in einer Reihe hat. Diese werden nach einem bestimmten Muster 
angesteuert. Davon wird ein Foto gemacht, danach kommt ein anderes 
Muster und wieder ein Foto, dies immer weiter und am Schluss werden die 
Fotos aneinander gefügt und es entsteht ein Schriftzug. Der Schriftzug 
oder auch ein Bild wird via usb einprogrammiert (EEPROM oder Flash wobei 
eher EEPROM). Die zu sendenden Daten sind lauter einsen und nullen 35 
pro Zeile und 200 Zeilen lang.

mfg

[Karl H. (kbuchegg)]

Michael Ammann schrieb:

> Warum siehts hier so einfach aus?

Weil das kein praxistaugliches Programm ist, sondern nur die 
prinzipielle Funktionsweise der Registerzugriffe im AVR zeigt.

Im Grunde ist es wie der Unterschied zwischen einer halben Stunde 
Fahrpraxis eines Autofahr-Anfängers auf dem nächstgelegenen 
Kaufhausparkplatz und dem Fahren um 5 in der Rushhour einer Grossstadt. 
Fahren auf einem leeren Parkplatz ist einfach im Vergleich zum Fahren in 
der Stosszeit. Und doch ist beides nur Autofahren.

[Karl H. (kbuchegg)]

Michael Ammann schrieb:

> Bin noch eine Antwort schuldig: Es sollte eine Anzeige werden welche 35
> LED in einer Reihe hat. Diese werden nach einem bestimmten Muster
> angesteuert. Davon wird ein Foto gemacht, danach kommt ein anderes
> Muster und wieder ein Foto, dies immer weiter und am Schluss werden die
> Fotos aneinander gefügt und es entsteht ein Schriftzug. Der Schriftzug
> oder auch ein Bild wird via usb einprogrammiert (EEPROM oder Flash wobei
> eher EEPROM). Die zu sendenden Daten sind lauter einsen und nullen 35
> pro Zeile und 200 Zeilen lang.

Dann ist eine Speicherung in einem Array[35][200] aber sehr 
speicherintensiv!

Das kann man im µC auch bitweise speichern. Dann benötigt man 5*200 = 
1000 Bytes.

Wie auch immer:
Der Ansatz mit der Interrupt Routine war ja im Grunde schon in Ordnung. 
Aber die Aufgabenstellung als Ganzes ist noch zu schwer für dich. 
Vergiss fürs erste deine LED. Fang nochmal an und lass deinen AVR einen 
Text empfangen, den du ihm von einem Terminalprogramm aus schickst. Der 
AVR soll den Text zwischenspeichern und wenn eine Zeiele vollständig 
ist, den Text zurückschicken. Aber nicht in der ISR zurückschicken! Das 
muss die Hauptschleife erledigen können. Die ISR soll einfach nur das 
empfangene abspeichern und mitteilen (in einer Variablen) wann eine 
Zeile vollständig ist. Nicht mehr!

[Michael A. (ammannm)]

Gute Idee! Werde ich versuchen!

Karl heinz Buchegger schrieb:

> Dann ist eine Speicherung in einem Array[35][200] aber sehr
> speicherintensiv!

Von dieser Seite habe ich es noch nicht betrachtet! Habe mich noch 
umgesehen wegen dem abspeichern der Daten. Zwei dinge habe ich gefunden: 
speichern in EEPROM, gibt es fertige Bibliotheken. Oder die Lösung mit 
einer SD-Karte. Die SD-Karte wäre auch nicht schlecht, da grössere 
Datenmengen gepeichert werden können und sogar mehrere Dateien 
aufgerufen werden könnten(?!).

Welches würde wohl besser zu meinem Projekt passen?

Aber erstmal eins nach dem anderen! Zuerst UART lesen und auswerten 
danach antworten!

[Michael A. (ammannm)]

Guten Morgen!

Nach etwas längerem grübeln habe ich mir nun volgendes überlegt:
Da es für mich noch schwierig ist ein Programm zu schreiben welches die 
ankommenden Signale (ein aus zustände der LED) ZUSAMMENZUHÄNGEN (bit 1 + 
bit 2...) mache ich es mir leichter.

Wenn ich ein zeichen wie den Buchstaben (ascii) ä  sende, sieht ein byte 
so aus 11100100. Dieses kann ich nun in einem Array ablegen und das 
nächste byte empfangen und wieder alblegen usw. Nun kann ich den PORT's 
direckt das array zuweisen ohne irgendetwas umzurechnen sprich PORTA = 
array[1].

Das Problem dabei ist, einige Binärcodes wie 10001111 sind Leerzeichen 
und wenn ich mehrere davon habe weiss der mC nicht was ich damit meine!?

wie funktionirt das Hypertherminal?
Wenn ich bei einem Hypertherminal ein Zeichen sende wird das in Binär 
umgewandelt und gesendet? Buchstabe für Buchstabe?

Kann ich da auch Hex code senden sprich C3 und der mC empfängt im UDR 
Register 11000011 ?


Das Problem mit dem empfangen von Daten habe ich gelöst. Sie kommen an.


Hoffe ihr könnt meinem Gedankengang verstehen und mir helfen.

MfG Ammann Michael

PS: Habe ein Programm geschrieben welches mir Binärdaten in verschiedene 
andere umschreibt (Hex, Dez, ASCII)