- MultiPlus Wechselrichter Insel und Nulleinspeisung Conrad         
Seite 2 von 3 ErsteErste 123 LetzteLetzte
Ergebnis 11 bis 20 von 25

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

  1. #11
    Erfahrener Benutzer Robotik Visionär Avatar von 021aet04
    Registriert seit
    17.01.2005
    Ort
    Niklasdorf
    Alter
    37
    Beiträge
    5.082
    Anzeige

    Praxistest und DIY Projekte
    Wenn du schon nichts Fixes übertragen kannst, liegt es an der Einstellung (unterschiedliche Einstellungen PC-uC) oder einer nicht funktionierenden Verbindung (defekte Lötstelle, RX/TX falsch angeschlossen, ...).

    Es gibt noch weitere mögliche Fehler, aber das würde ich als erstes kontrollieren.

    MfG Hannes

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


    mhh defekte Lötstellen kann ich mal kontrollieren, kann ich mir jetzt weniger vorstellen.
    Ich benutzt zur Programmierung das STK500 Board.
    RX/TX kann ich auch ausschliessen denn wenn ich die zwei Pins drehe kommt nichts mehr an.

    Was für einstellung kann es denn noch geben. StopBits = 1, Buad = 9600, Datenbits = 8

    Wenn ich jetzt eine feste Variable übertragen will z.B. "j" bekomme ich auf meinem Hyperterminal ein ö angezeigt

    @ sternst
    ich habe die Variable a zu Testzwecken durch die Line variable ausgetauscht. Aber das hat auch nicht funktioniert. Da steht jetzt wieder a.
    Geändert von knoddelpusch (25.10.2015 um 13:58 Uhr)

  3. #13
    Erfahrener Benutzer Roboter-Spezialist Avatar von sast
    Registriert seit
    30.11.2004
    Alter
    54
    Beiträge
    502
    Wenn ich jetzt eine feste Variable übertragen will z.B. "j" bekomme ich auf meinem Hyperterminal ein ö angezeigt
    Sieht nach Baudrate aus.

    Am Anfang hast du 1MHz als F_CPU dann zwischendurch mal 12MHz. Was stimmt denn nun? Denn das ist nicht ganz unwichtig für die korrekte Baudrateneinstellung. Was steht denn im makefile und da 12MHz sicher extern in den Controller gehen, sind die Fuses richtig eingestellt? Wenn das alles stimmt, sollte auch das richtige Zeichen kommen bzw immer das gleiche verkehrte Zeichen.

    Wenn mit
    Code:
    // Warteschleife
    void delay_ms(unsigned int ms)
    {
        unsigned int zaehler;   
        while (ms) {
            zaehler = F_CPU / 5000;       
            while (zaehler) {
                __asm volatile("nop");
                zaehler--;
            }
            ms--;
        }
    }
    
    //und in der main 
    
    delay_ms(1000);
    LED an;
    delay_ms(1000);
    LED aus;
    die LED ungefähr im Sekundentakt an und dann wieder aus geht, dann stimmt dein F_CPU mit deiner Theorie überein. Sonst musst du da noch einmal drüber schauen.

    sast

    雅思特史特芬
    开发及研究

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

    ich habe die F_CPU auf 12MHz stehen und die LED's blinken im Sekundentakt

    Hier die Fuses einstellungen
    Klicke auf die Grafik für eine größere Ansicht

Name:	Fuses.png
Hits:	3
Größe:	39,6 KB
ID:	30824

    Habe auch schon probiert wenn ich nur den Sende Pin aktiviert ist. Da habe ich dann die uart_puts() zeile in die else schleife geschrieben, kam aber auch nur irgendwelche Buchstaben oder Zeichen an.
    Habe es auch mal mit einem anderen PC und uC probiert.

    Hier nochmal das Programm
    Code:
    #include <avr/io.h>
    #include <util/delay.h>
    #include <stdlib.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>
    
    //------------------------------------------------------------------------------------------
    
    //USART initialisieren
    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
    
    }
    
    //------------------------------------------------------------------------------------------
    
    //Warteschleife
    void delay_ms(unsigned int ms)
    {
        unsigned int zaehler;   
        while (ms) {
            zaehler = F_CPU / 5000;       
            while (zaehler) {
                __asm volatile("nop");
                zaehler--;
            }
            ms--;
        }
    }
    
    //------------------------------------------------------------------------------------------
    
    // Zeichen senden
    int uart_putc(unsigned char c)
    {
    	while (!(UCSRA & (1<<UDRE)))
    	{
    	}
    	UDR = c;
    	return 0;
    }
    //------------------------------------------------------------------------------------------
    
    //String senden
    void uart_puts(char *s)
    {
    	while (*s)
        {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
            uart_putc(*s);
            s++;
        }
    }
    //------------------------------------------------------------------------------------------
    
    //Zeichen empfangen
    uint8_t uart_getc(void)
    {
    	while (!(UCSRA & (1<<RXC)))	//warten bis Zeichen verfügbar 
    	;
    	return UDR;					//Zeichen aus UDR an Aufrufer zurückgeben
    
    }
    //------------------------------------------------------------------------------------------
    
    //Sting empfangen
    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';
    
    }
    //------------------------------------------------------------------------------------------
    
    //Hauptprogramm
    int main(void)
    {
    	int Line[5];			//Array vom Typ int
    	char Buffer[9];			//String mit maximal 8 zeichen
    	int a;
    	
    	DDRB = 0xFF;
    	PORTB = 0xFF;
    
    	uart_init();			// UART einstellen
    
    	while (1)
    	{
    		if ((UCSRA & (1<<RXC)))					//überprüfen ob neue Zeichen vorhanden sind
    		{
    			uart_gets(Line, sizeof(Line));		//Zeichen wurden empfangen, jetzt abholen
    			
    			a=atoi (Line);						//aus Text eine Zahl machen
    
    			itoa (Line, Buffer, 10);			// Aus der Variablen a ein Text erstellen
    
    			uart_puts("j");						//Senden festen Buchstaben j
    		else
    		{
    			uart_puts("a");						//Senden festen Buchstaben a
                            
                            PORTB = 0b00000000;
    			delay_ms(1000);
    			PORTB = 0b00001111;
    			delay_ms(1000);
    			PORTB = 0b11110000;
    			delay_ms(1000);
    			PORTB = 0b11111111;
    			delay_ms(1000);
    		}
    
    	}
    
    }
    Wenn ich die Daten-oder die Stoppbits verstelle, bekomme ich gar nichts mehr angezeigt.
    Also müsten diese ja auch stimmen.
    Geändert von knoddelpusch (26.10.2015 um 16:06 Uhr)

  5. #15
    Erfahrener Benutzer Roboter-Spezialist Avatar von sast
    Registriert seit
    30.11.2004
    Alter
    54
    Beiträge
    502
    Deine Fuses stehen auf 1MHz interner Takt und wenn du wirklich 12 MHz dran hast, fehlt bei F_CPU auch noch eine 0. Durch deine F_CPU von 1,2MHz wirkt das natürlich dann wie 1s.
    Hatte mich nämlich vorhin um diese eine 0 vertan.

    sast

    雅思特史特芬
    开发及研究

  6. #16
    Neuer Benutzer Öfters hier
    Registriert seit
    22.10.2015
    Beiträge
    11
    Ich habe meinen internen Takt auf 8MHz 6CK + 64ms gestellt. Die LED's blinken im Sekunden

    Wenn ich jetzt auf meinem Realterm den Ansi Code einstelle bekomme ich gar nichts mehr angezeigt.
    wenn ich ihn aber auf Ascii einstelle bekomme ich wider irgendwelche zeichen und Buchstaben angezeigt.
    takt.

    Habe jetzt auch probleme auf mein STK500 zu kommen.

  7. #17
    Erfahrener Benutzer Fleißiges Mitglied Avatar von drew
    Registriert seit
    06.04.2005
    Beiträge
    161
    Hallo,
    Da gibt es doch den alten Trick bei der RS232, dass man RX und TX verbindet. Dann wird das auf dem Terminal empfangen, was man gerade gesendet hat.
    Auf die Weise kann man testen, wie weit die Übertragung noch gut gegangen ist. (Vor dem Pegelwandler, direkt auf der Platine, ...)

    Man kann aber nicht erkennen, ob die eingestellte Baudrate auf dem Controller zu der auf dem PC passt. (Komisches Zeug auf der RS232 hört sich irgendwie nach falscher Baudrate an.)


  8. #18
    Neuer Benutzer Öfters hier
    Registriert seit
    22.10.2015
    Beiträge
    11
    Hallo,
    danke für den Tipp, hätte man ja auch selbst drauf können.
    Habe das auch gleich mal getestet.
    Habe die Brücke auch nach dem Pegelwandler gemacht und es funktioniert super, es kommen immer die Buchstaben bzw. Zahlen an wo ich los schicke.
    Habe auch schon unterschiedliche Baudrate (auf PC und uC) ausprobiert es kommt aber immer was anderes an.

  9. #19
    Erfahrener Benutzer Robotik Visionär Avatar von 021aet04
    Registriert seit
    17.01.2005
    Ort
    Niklasdorf
    Alter
    37
    Beiträge
    5.082
    Hast du schon versucht statt der Berechnung der Baudrate es fix einzustellen? Im DB steht für einige übliche Frequenzen die Baudraten mit den Einstellungen.

    MfG Hannes

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

    habe jezt auch mal die Baudrate fix eingestellt dies hat aber auch nichts gebracht. Immer der selbe "Müll".
    Habe meinen externen Quarz mal weggenommen und habe intern den RCOsc. mal auf 8MHz; 6CK+64ms gestellt, und habe meine F_CPU auf 8000000 gestellt
    Meine LED's blinken alle noch im sekundentakt.
    Wenn ich mir einen festen Wert oder Buchstabe übertragen lassen will, kommt in ANSI nichts mehr an und in Ascii nur noch komische Symbole, ich sehe aber an meinen RXD das irgendwelche daten ankommen.

    Hier nochmal mein Programm
    Code:
    #include <avr/io.h>
    #include <util/delay.h>
    #include <stdlib.h>
    			  
    #define F_CPU 8000000// 12000000	 /* evtl. bereits via Compilerparameter definiert */
    #define BAUD 300      // 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>
    
    //------------------------------------------------------------------------------------------
    
    //USART initialisieren
    void uart_init(void)
    {
    	//Set Baudrate
    	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
    }
    
    //------------------------------------------------------------------------------------------
    
    //Warteschleife
    void delay_ms(unsigned int ms)
    {
        unsigned int zaehler;   
        while (ms) {
            zaehler = F_CPU / 5000;       
            while (zaehler) {
                __asm volatile("nop");
                zaehler--;
            }
            ms--;
        }
    }
    
    //------------------------------------------------------------------------------------------
    
    // Zeichen senden
    int uart_putc(unsigned char c)
    {
    	while (!(UCSRA & (1<<UDRE)))
    	{
    	}
    	UDR = c;
    	return 0;
    }
    //------------------------------------------------------------------------------------------
    
    //String senden
    void uart_puts(char *s)
    {
    	while (*s)
        {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
            uart_putc(*s);
            s++;
        }
    }
    //------------------------------------------------------------------------------------------
    
    //Zeichen empfangen
    uint8_t uart_getc(void)
    {
    	while (!(UCSRA & (1<<RXC)))	//warten bis Zeichen verfügbar 
    	;
    	return UDR;					//Zeichen aus UDR an Aufrufer zurückgeben
    
    }
    //------------------------------------------------------------------------------------------
    
    //Sting empfangen
    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';
    
    }
    //------------------------------------------------------------------------------------------
    
    //Hauptprogramm
    int main(void)
    {
    	int Line[2];			//Array vom Typ int
    	char Buffer[3];			//String mit maximal 8 zeichen
    	int a;
    	
    	DDRB = 0xFF;
    	PORTB = 0xFF;
    a=12;
    	uart_init();			// UART einstellen
    
    	while (1)
    	{
    		if ((UCSRA & (1<<RXC)))			//überprüfen ob neue Zeichen vorhanden sind
    		{
    			uart_gets(Line, sizeof(Line));		//Zeichen wurden empfangen, jetzt abholen
    			
    			a=atoi (Line);				//aus Text eine Zahl machen
    
    			itoa (Line, Buffer, 10);			// Aus der Variablen a ein Text erstellen
    
    			uart_puts("j");				//Senden festen Buchstaben j
    		}
    		else
    		{
    		uart_puts(a);      //Variable a senden Testzwecke
    			PORTB = 0b00000000;
    		uart_puts(a);      //Variable a senden Testzwecke
    			delay_ms(1000);
    		uart_puts(a);     //Variable a senden Testzwecke
    			PORTB = 0b00001111;
    		uart_puts(a);     //Variable a senden Testzwecke
    			delay_ms(1000);
    			PORTB = 0b11110000;
    			delay_ms(1000);
    			PORTB = 0b11111111;
    			delay_ms(1000);
    		}
    
    	}
    
    }
    Kann das wirklich nur an der CPU-Frequenz liegen?

    Habe eben mal noch Versucht eine feste Variable zu Übertragen das heißt ich habe
    Code:
    uart_puts("12")
    geschrieben und es kommt auch die 12 an auch wenn ich buchstaben übertrage funktioniert das.

    Wenn ich jetzt aber eine Variabel deklariere zum Beispiel
    Code:
    char a;
    a = 65;
    Aber hier kommt dann nur wirres zeug an.
    Geändert von knoddelpusch (28.10.2015 um 22:50 Uhr)

Seite 2 von 3 ErsteErste 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
  •  

LiFePO4 Speicher Test