-         

Seite 1 von 3 123 LetzteLetzte
Ergebnis 1 bis 10 von 25

Thema: Daten Senden Empfangen Ic -> Pc -> Ic

  1. #1
    Neuer Benutzer Öfters hier
    Registriert seit
    22.10.2015
    Beiträge
    11

    Daten Senden Empfangen Ic -> Pc -> Ic

    Anzeige

    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.
    [CODE]
    #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

    }
    [/CO

  2. #2
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    27.06.2008
    Beiträge
    183
    Hallo knoddelpusch,

    sehr konfus das Ganze, aber ich probiere es.

    Zuerst zur Namenskonvention: IC heißt Integrated Circuit -> meist ist der IC ein (dummer) Baustein in einer Schaltung.
    Was Du meinst ist ein Mikrokontroller (auch MCU oder µC genannt). Bleiben wir in deinem Fall beim ATmega16.

    Also:
    Ich gehe jetzt stark davon aus, daß Du keine Ahnung von der internen Verarbeitung von Daten hast.
    Ein Computer kann nur binäre Zahlen verarbeiten. Das heisst 0 oder 1. 0 = aus 1 = ein.

    Da aber der Mensch mit binären Zahlen nicht sehr viel anfangen kann hat man die hexadezimale Darstellung eingeführt.
    Damit aber alle den gleichen binären Wert für jedes Zeichen verwenden wurde (zumindest auf PC und µC) der ASCII Code eingeführt
    (es gibt da auch noch den EBCDIC Code).

    Also wenn Du ein Zeichen "A" an den Atmega16 schickst dann sendet der PC 10000001 an den µC.
    binär 10000001 = hex 41 dezimal 65 = A (der PC malt dir dann ein A auf den Schirm).

    Warum willst Du das dann noch einmal in ASCII konvertieren?

    Zum programmieren: ich kenne weder VB noch irgendeine C** Sprache (und werde es auch nicht lernen).

    Ich habe mir dein Programm angesehen. was mir fehlt ist die genaue Einstellung der
    Übertragungsrate (BAUD) auf beiden Seiten (PC UND Atmega16).

    Ich hoffe, ich konnte dich verwirren.

    P.S. welche Werte willst Du an den µC senden?
    MfG
    Hans

  3. #3
    Neuer Benutzer Öfters hier
    Registriert seit
    22.10.2015
    Beiträge
    11
    Hallo,

    Ich will Zeitwerte an meine uC senden, wo ich warte Zeiten ändern kann.
    Dachte das es in ASCII konvertieren einfacher geht. Ich gebe eine Zahl auf dem PC ein, wandele die dann in den ASCII-Code um
    Auf dem uC wieder zurück und nehme die Zahl mal x das ich auf meine Wartezeit komme.
    Die Übertragungsrate habe ich auf PC auf 9600 und auf dem uC auch (unter der CPU Definition).

    Habe mich jetzt im Internet noch etwas recherchierte habe auch ein paar Fehler gefunden, aber es funktioniert immer noch nicht, ich bin am Verzweifeln.
    Hier ist noch mal mein Programm.
    Code:
    #include <avr/io.h>
    #include <stdlib.h>
    #include <inttypes.h>
    #include <util/delay.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
    
    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 (Line, Buffer, 10);		// Aus der Variablen a ein Text erstellen
    
    		uart_puts(Buffer);				//Senden Text aus 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 
    
     
    }

  4. #4
    Unregistriert
    Gast
    Hallo,

    Wenn Du Zeichen an den Atmega sendest, was kommt dort an?
    Bist Du sicher, das Du den richtigen COM-Port eingestellt hast?

    Versuche einfach nur Zeichen zu senden z.B. "AAAA". Über die Zahlen sprechen wir später.

    Übrigens ist mir im ersten Post ein Fehler unterlaufen: ein "A" hat den Binäwert 01000001 und NICHT 10000001!
    Da hat der Calculator eine Null verschluckt und ich habe es auch noch falsch abgeschrieben.

    M.f.G.
    Hans

  5. #5
    Neuer Benutzer Öfters hier
    Registriert seit
    22.10.2015
    Beiträge
    11
    Hallo,

    Mit dem Com-Port bin ich mir sicher, habe nur den einen zur Auswahl und ich bekomme ja schon komisches Zeug zurück.
    Ja was kommt dor an, das ist eine gute Frage, wo ich mir definitiv sicher bin ist das bei mir auch der Buchstabe raus geht wo ich will.
    Habe zwei Pc's mit einem Nullmodem Kabel verbunde, und habe Buchstaben und Zahlen hin und her geschickt und sind immer die angekommen
    wo ich los geschickt habe.
    Habe auch schon das HyperTerminal von Win XP benutzt, ist aber immer das selbe, kommt immer unterschiedliche Buchstaben oder Zahlen an.
    Habe da auch Porbleme mit dem Auswerten von dem Endzeichen eines Srings (\n) das funktioniert auch nicht.

  6. #6
    Erfahrener Benutzer Robotik Einstein Avatar von 021aet04
    Registriert seit
    17.01.2005
    Ort
    Niklasdorf
    Alter
    29
    Beiträge
    4.544
    Versuche einmal vom uC etwas fixes zu übertragen. Also z.b. A, B, C, 1, 2, 3,...
    Somit kannst du herausfinden ob es an der Wandlung (int»ascii oder ascii»int) liegt oder der Übertragung.

    MfG Hannes

  7. #7
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.551
    Code:
      #define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)    // clever runden
    Wer hat denn diese Formel erfunden - genauer den offset BAUD*8 ? Bisher dachte ich immer (und bei mir läufts) dass die richtige Formel, z.B. auf Datenblatt mega16A 8154B–AVR–07/09 - Seite 150 Tabelle 19-1 steht.

    Zitat Zitat von hans99 Beitrag anzeigen
    .. wenn Du ein Zeichen "A" an den Atmega16 schickst dann sendet der PC 10000001 an den µC ..
    ASCII ist im Ursprung siebenbittig. Daher ist in ASCII ein 'A' (0)100 0001. Die (meisten?) C-Konventionen erlauben aber stattdessen die Syntax 'A' - Buchstabe mit Strichelchen. Wie es Hans schon als Gastredner dargestellt hat.
    Geändert von oberallgeier (25.10.2015 um 09:32 Uhr) Grund: Die Sache mit dem ASCII 'A'
    Ciao sagt der JoeamBerg

  8. #8
    Erfahrener Benutzer Roboter Experte Avatar von sternst
    Registriert seit
    07.07.2008
    Beiträge
    672
    Zitat Zitat von oberallgeier Beitrag anzeigen
    Wer hat denn diese Formel erfunden - genauer den offset BAUD*8 ?
    Das ist das, was im Kommentar steht. Es sorgt dafür, dass bei der Integer-Division eine Rundung stattfindet. Aus X/Y wird (X+Y/2)/Y gemacht, so wird das Ergebnis von (z.B.) 9/5 zu 2 statt 1.

    - - - Aktualisiert - - -

    Code:
            itoa (Line, Buffer, 10);        // Aus der Variablen a ein Text erstellen
    Diese Zeile ist Unsinn.
    MfG
    Stefan

  9. #9
    Neuer Benutzer Öfters hier
    Registriert seit
    22.10.2015
    Beiträge
    11
    Hallo

    Ich habe es mal mit den festen Variablen probiert, aber da kommt alles nur nicht das an wo ich los geschickt habe. Habe das HyperTerminal von Win XP benutzt.
    Also kann es an der Umwandlung nicht liegen oder?
    Habe auch mal den uC getauscht hätte ja sein könne das der ein defekt hat, hat sich aber nichts geändert.

    Warum ist diese Zeile Unsinn?
    Code:
    itoa (Line, Buffer, 10);        // Aus der Variablen a ein Text erstellen
    Ich muss doch meine Variable in einen Text umwandeln damit ich diesen übertragen kann oder nicht?

  10. #10
    Erfahrener Benutzer Roboter Experte Avatar von sternst
    Registriert seit
    07.07.2008
    Beiträge
    672
    Zitat Zitat von knoddelpusch Beitrag anzeigen
    Ich muss doch meine Variable in einen Text umwandeln damit ich diesen übertragen kann oder nicht?
    Und dir kommt es nicht irgendwie merkwürdig vor, dass der Kommentar sagt, dass etwas mit der Variable a getan werden soll, diese aber gar nicht in der Code-Zeile vorkommt?
    MfG
    Stefan

Seite 1 von 3 123 LetzteLetzte

Ähnliche Themen

  1. Daten senden und empfangen mit IR
    Von GerdM im Forum Robby RP6
    Antworten: 3
    Letzter Beitrag: 21.06.2009, 13:40
  2. RS232 daten empfangen, senden und auswerten
    Von Crischan im Forum Software, Algorithmen und KI
    Antworten: 62
    Letzter Beitrag: 20.03.2009, 17:10
  3. USART Senden und Empfangen von Daten.
    Von Ferdinand im Forum C - Programmierung (GCC u.a.)
    Antworten: 5
    Letzter Beitrag: 05.02.2009, 23:13
  4. Daten senden/empfangen
    Von FSTII im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 15
    Letzter Beitrag: 29.12.2006, 17:25
  5. Antworten: 1
    Letzter Beitrag: 22.09.2006, 17:33

Berechtigungen

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