Daten Senden Empfangen Pc -> Ic -> Pc

[knoddelpusch (Gast)]

Hallo zusammen,

ich habe mir ein VB.Net Programm geschrieben wo ich an einen Ic 
(Atmega16) warte Zeiten ändern. Die Übertragung von VB zum Ic soll in 
Ascii code passieren. Die Umwandlung in VB funktioniert
super, lasse es mir in einer Textbox anzeigen.
Wenn ich im Ic die Variable x (als Char oder uint8_t) umwandle und damit 
z.B. eine warte Zeit einstellen möchte geht das nicht.
Ich habe mir auch schon die Variable x als Ascii wider an den Pc 
geschickt da kommen immer unterschiedliche Werte an. Selbst wenn ich 
direkt ein Ascii Variable schicke.

#include <avr/io.h>
#include <stdlib.h>
#include <inttypes.h>
#include <util/delay.h>

#define F_CPU 1000000 /* evtl. bereits via Compilerparameter definiert */
#define BAUD 9600UL // Baudrate

// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*/(BAUD*16)-1) // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1))) // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.


static void Rot (void)
{
PORTB = (~(1<<PIN0) & ~(0<<PIN1) & ~(0<<PIN2) & ~(0<<PIN2) & ~(1<<PIN3) & ~(0<<PIN4) & ~(0<<PIN5) & ~(0<<PIN5) & ~(1<<PIN6) & ~(0<<PIN7));
}

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

// UART konfig

void uart_init (void)
{
UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;

UCSRB |= (1<<TXEN) | (1<<RXEN); //UART TX und RX einschalten
UCSRC = (1<<URSEL) |(1<<UCSZ1) | (1<<UCSZ0); //Asynchron 8N1
}

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

//Senden
int uart_putc(uint8_t z)
{
while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */
{
}
UDR = z; /* sende Zeichen */
return 0;
}

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

//Empfanen
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC)))
;
return UDR;
}

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

int main (void)
{


uint8_t x;

uint8_t c; //Ascii kommen

uint8_t z; //Ascii gehen

uint8_t t; //Variable für Zeitwert

//Ausgangs Port Festgelegt
DDRB = 0xFF;
PORTB = 0xFF;

uart_init(); //UART deklarit

while (1)
{

c = uart_getc(); //Variable c mpfange
x = atoi (c); //Ascii variable c in variable x umwandeln

itoa (65, z, 10); //65 in Ascii umwandeln entspricht A zum Testen

uart_putc(z); //variable z (65, A) an Pc senden

t = x * 100; //Auf sekungen umwandeln

PORTB = Rot; //Port B schalten
_delay_ms(t); //WarteZeit t
PORTB =0xFF; //Port B ausschalten
_delay_ms(t); //WarteZeit t
PORTB = Rot; //Port B schalten
_delay_ms(t); //WarteZeit t
PORTB =0xFF; //Port B ausschalten
}

return 0; // never reached

}

[Karl H. (kbuchegg)]

knoddelpusch schrieb:

> c = uart_getc(); //Variable c mpfange
> x = atoi (c); //Ascii variable c in variable x umwandeln

Äh. Nein.
An dieser Stelle müsste dein Compiler schon Zeter und Mordio schreien.

> itoa (65, z, 10); //65 in Ascii umwandeln entspricht A zum Testen

und hier gleich noch einmal.

Dir scheint der Unterschied zwischen einem einzelnen Character und einem 
String komplett und völlig egal zu sein.

https://www.mikrocontroller.net/articles/String-Verarbeitung_in_C

Kauf dir ein C Buch und arbeite es zumindest bis zur Hälfte durch. Da 
gibt es noch viele Dinge, die du wissen und können musst, ehe du 
sinnvoll ein reales Programm schreiben kannst.

[knoddelpusch (Gast)]

Hallo,
ich habe jezt mal im internet und auf dem link noch mehr informiert und 
hoffe das ich das jetzt etwas mehr verstanden habe.

Jetzt müsste ich doch wenn ich einen Wert x an den Controller sende der 
Wert in der Variable Line gespeicher sein oder?

Und mit dem "itoa (Line, Buffer, 10);" wandle ich den Wert x in ein 
Ascii zeichen um?

oder hab ich da nochmal was falsch verstanden

#include <avr/io.h>
#include <stdlib.h>
#include <inttypes.h>
#include <util/delay.h>
#include <string.h>


//#include "uart.h"

#define F_CPU 1200000   /* evtl. bereits via Compilerparameter definiert */
#define BAUD 9600UL      // Baudrate
 
// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD)     // Fehler in Promille, 1000 = kein Fehler.
 
#include <util/setbaud.h>

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

// UART konfig

void uart_init (void)
{
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
  
  UCSRB |= (1<<TXEN) | (1<<RXEN);    //UART TX und RX einschalten
  UCSRC = (1<<URSEL) |(1<<UCSZ1) | (1<<UCSZ0); // Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}

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

//Zeichen Senden
int uart_putc(unsigned char c)
{
  while (!(UCSRA & (1<<UDRE)))
  {
  }
  UDR = c;
  return 0;
}

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

void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
        uart_putc(*s);
        s++;
    }
}


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

//Zeichen Empfanen 
uint8_t uart_getc(void)
{
  while (!(UCSRA & (1<<RXC)))  //warten bis Zeichen verfügbar 
  ;
  return UDR;    //Zeichen aus UDR an Aufrufer zurückgeben
}

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


void uart_gets( char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;
 
  NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen
 
                                  // Sammle solange Zeichen, bis:
                                  // * entweder das String Ende Zeichen kam
                                  // * oder das aufnehmende Array voll ist
  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }
 
                                  // Noch ein '\0' anhängen um einen Standard
                                  // C-String daraus zu machen
  *Buffer = '\0';
}


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

int main (void) 
{
  
  DDRB = 0xFF;
  PORTB = 0xFF;

int Line [8];      //Array vom Typ int

char Buffer[9];      //String mit maximal 8 zeichen

uart_init();      // UART einstellen
  
    while (1)
     {


  if ( (UCSRA & (1<<RXC)))      //überprüfen ob neue Zeichen vorhanden sind
  {                  //Zeichen wurden empfangen, jetzt abholen
    uart_gets (Line, sizeof(Line));

    itoa (Line, Buffer, 10);
    uart_puts(Buffer);
  }
  else
  {
  

    PORTB = 0b00000000;    //Port B schalten
    _delay_ms(1000);  //WarteZeit t
    PORTB =0b11111111;    //Port B ausschalten
    _delay_ms(1000);    //WarteZeit t
    PORTB = 0b00000000;    //Port B schalten
    _delay_ms(1000);    //WarteZeit t
    PORTB =0b11111111;    //Port B ausschalten
  }
   }
 
   return 0; // never reached 

 
}

[Karl H. (kbuchegg)]

knoddelpusch schrieb:

> Jetzt müsste ich doch wenn ich einen Wert x an den Controller sende der
> Wert in der Variable Line gespeicher sein oder?

Du sendest keinen 'Wert'.
Du sendest einen String! EInen Text.
An dieser Stelle gibt es noch keinen Unterschied, ob dieser Text "123" 
oder "Hugo" beinhaltet. Text ist erst mal Text.

(UNd die Empfangsroutine erwartet, dass der Text mit einem Carriage 
Return abgeschlossen ist. Denn woher soll diese Routine denn sonst 
wissen, dass du nach "Hugo" nicht noch ein weiteres Zeichen senden 
willst?)

Wenn du weisst, das dein Text eben nicht "Hugo" lautet, sondern "123", 
dann kannst du die Funktion atoi benutzen, um aus diesem Text eine Zahl 
mit dem Zahlenwert von 123 machen zu lassen. Erst dann hast du einen 
Wert mit dem du zb auch rechnen kannst oder was auch immer du damit 
machen willst.


Die umgekehrte Übertragungsrichtung lautet dann so:
du hast eine Zahl, die in einer int Variablen vorliegt. Da du sie 
textuell (also in Form von ASCII Zeichen) übertragen willst, musst du 
erst mal aus dieser Zahl einen entsprechenden String generieren lassen. 
Das erledigt itoa. Es erzeugt aus der Zahl 123 den String "123". Wieder: 
dieser String könnte prinizpiell auch "Hugo" oder "Anna" sein, das wäre 
der String Sende Funktion völlig gleichgültig. Nur ist den String eben 
nicht "Hugo", sondern "123". Ein Text wie jeder andere auch.

> Und mit dem "itoa (Line, Buffer, 10);" wandle ich den Wert x in ein
> Ascii zeichen um?

Nein. Nicht in 1 ASCII Zeichen.
1 ASCII Zeichen ist 1 Buchstabe. Wobei unter Buchstaben auch Dinge wie 
'=' oder '0' oder '7' oder ',' fallen. Den Begriff Buchstaben da jetzt 
nicht zu wörtlich nehmen. Wichtig ist: es wäre genau 1ner.

Das kannst du aber nicht brauchen. Denn der String "Hugo" besteht aus 4 
Buchstaben! Oder der String "123" - der besteht aus 3 Buchstaben- Oder 
"65320", der besteht aus 5 Buchstaben.

Ein String ist also eine Abfolge von meheren Einzelbuchstaben. Um einen 
String zu übertragen muss man daher Buchstabe für Buchstabe einzeln 
übertragen. genau das macht die uart_puts.

Disclaimer: In C sind Strings immer um genau 1 Zeichen länger als sie 
lesbare Buchstaben haben. Denn ganz zum Schluss kommt immer ein 
Buchstabe mit dem ASCII Codewert von 0. Der String "Hugo" hat also in C 
nicht 4 Buchstaben, sondern deren 5.

[knoddelpusch (Gast)]

Das heist ich muss wenn ich vom Pc auf Ic "123" senden will danach noch 
ein "\n" dranhängen?
Auch wenn mein Array gößer ist, ist dann die "Empfangsroutine" 
abgeschlossen und mein Array ist dann halt nicht ganz gefüllt?

Mit "a=atoi(Line)"
weiße ich meiner variable a den Wert 123 zu.
Geht das auch wenn ich schon mit einem Ascii zeichen z.B. "A" rüberkomme 
das ich die Zahl 65 bekomme?
Habe das irgendwo mal gelesen das ich mit der Funktion "atoi" einen 
Ascii Zeichen wider in einen Wert umwandeln kann.
Oder ist die atoi funktion nicht direkt auf die Ascii-Tabelle bezogen.

Und mit "itoa (a, Buffer, 10)" erstelle ich mir wider einen String 
(Buffer) der den Text "123" bzw das was in der Variable a steht.
Mit dem itoa bekomme ich ja dann schon einen Null-Terminierten string 
zurück?

// UART konfig

void uart_init (void)
{
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
  
  UCSRB |= (1<<TXEN) | (1<<RXEN);    //UART TX und RX einschalten
  UCSRC = (1<<URSEL) |(1<<UCSZ1) | (1<<UCSZ0); // Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}

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

//Zeichen Senden
int uart_putc(unsigned char c)
{
  while (!(UCSRA & (1<<UDRE)))
  {
  }
  UDR = c;
  return 0;
}

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

void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
        uart_putc(*s);
        s++;
    }
}


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

//Zeichen Empfanen 
uint8_t uart_getc(void)
{
  while (!(UCSRA & (1<<RXC)))  //warten bis Zeichen verfügbar 
  ;
  return UDR;    //Zeichen aus UDR an Aufrufer zurückgeben
}

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


void uart_gets( char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;
 
  NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen
 
                                  // Sammle solange Zeichen, bis:
                                  // * entweder das String Ende Zeichen kam
                                  // * oder das aufnehmende Array voll ist
  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }
 
                                  // Noch ein '\0' anhängen um einen Standard
                                  // C-String daraus zu machen
  *Buffer = '\0';
}


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

int main (void) 
{
  
  DDRB = 0xFF;
  PORTB = 0xFF;

int Line [8];      //Array vom Typ int

char Buffer[9];      //String mit maximal 8 zeichen

int a;

uart_init();      // UART einstellen
  
    while (1)
     {


  if ( (UCSRA & (1<<RXC)))      //überprüfen ob neue Zeichen vorhanden sind
  {                  //Zeichen wurden empfangen, jetzt abholen
    uart_gets (Line, sizeof(Line));

    a=atoi(Line);          //aus Text eine Zahl machen
  
    itoa (a, Buffer, 10);      // Aus der Variablen a ein Text erstellen

    uart_puts(Buffer);      //Senden Text aus Buffer

  }
  else
  {
  ...

[Axel S. (a-za-z0-9)]

knoddelpusch schrieb:
> ich habe ein Programm geschrieben wo ich an einen Ic warte Zeiten ändern.

Welche Sprache ist das? Deutsch wohl nicht.