UART empfängt nur 2 zeichen

[Dennis (Gast)]

Hallo
ich sende mit einem mega328 über uart ein string

char* test = "TEST";
rs485_puts(test,sizeof(test));

void rs485_putc(unsigned char c){
  while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
  {
  }

  UDR0 = c;                      /* sende Zeichen */
  //return 0;
}

void rs485_puts(char *s, unsigned int len){
  while (*s)
  {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
    rs485_putc(*s);
    s++;
  }
}

Empfangen tue ich mit einem zweiten mega328

if((UCSR0A & (1<<RXC0))){
      uart_gets(uart_string, sizeof(uart_string));
      //uart_readline(uart_string);
      
    }
    if(uart_str_complete == 1){
      lcd_gotoxy(0,0);
      if(uart_string[0] == 0x42){
        UCSR0A &= ~(1<<MPCM0);
        PORTD |= (1<<PORTD2);
        _delay_ms(20);
        PORTD &= ~(1<<PORTD2);
        _delay_ms(20);
        uart_string[0] = 0xFF;
        uart_str_complete = 0;
      }else{
        UCSR0A |= (1<<MPCM0);
        PORTD |= (1<<PORTD4);
        _delay_ms(20);
        PORTD &= ~(1<<PORTD4);
        //uart_string[0]= 0xFF;
        uart_str_complete = 0;
        lcd_puts(uart_string);
      }  
      
    }

uint8_t uart_getc(void)
{
   //while (!(UCSR0A & (1<<RXC0)))   // warten bis Zeichen verfuegbar
   //;
  return UDR0;                   // Zeichen aus UDR an Aufrufer zurueckgeben
}

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
  uart_str_complete = 1;
  *Buffer = '\0';
}

Empfange tue ich aber statt TEST nur TETEEEEEEEE
..

aber wenn ich mich parallel mit Putty drauf hänge sehe ich TEST....

wodran kann es liegen, bin schon am verzweifeln

--

Quelltext in [ c ] [ /c ] -Tags einschließen, dann wird er (etwas) 
lesbarer.

-rufus

[Rufus Τ. F. (rufus)]

Dennis schrieb:
> uint8_t uart_getc(void)
> {
>    //while (!(UCSR0A & (1<<RXC0)))   // warten bis Zeichen verfuegbar
>    //;
>   return UDR0;                   // Zeichen aus UDR an Aufrufer
> zurueckgeben
> }

Warum hast Du hier etwas auskommentiert?

[Dennis (Gast)]

Rufus Τ. F. schrieb:
> auskommentiert

weil der dann garnichts mehr macht empfängt wenn das drin ist.... wieso 
auch immer

[Dennis (Gast)]

Also habe es jetzt mit der while schleife hinbekommen...
allerdings bekomme ich dennoch nur die ersten beiden Zeichen


uint8_t uart_getc(void)
{
   while (!(UCSR0A & (1<<RXC0)))   // warten bis Zeichen verfuegbar
   ;
  return UDR0;                   // Zeichen aus UDR an Aufrufer 
zurueckgeben
}

[Dennis (Gast)]

sorry... mir ist noch was aufgefallen...
ich schicke folgenden String
char* test = "123456";

Empfangen tue ich 126B
wenn ich nun aber den String schicke

char* test = "1234567";

dannn empfange ich 127B...

der verschluckt irgendwie alles dazwischen!?

[S. Landolt (Gast)]

Liegt es vielleicht an der Umschaltung des "Multi-processor 
Communication Mode"? Was passiert denn, wenn man die weglässt?

[Dennis (Gast)]

S. Landolt schrieb:
> Liegt es vielleicht an der Umschaltung des "Multi-processor
> Communication Mode"? Was passiert denn, wenn man die weglässt?

.... dann läuft es!... danke...
aber warum? Das würde ich gerne drin lassen....

[Rufus Τ. F. (rufus)]

Dennis schrieb:
> Das würde ich gerne drin lassen....

Weißt Du, wozu das gut ist, und welchen technischen Hintergrund das hat?

[Dennis (Gast)]

Rufus Τ. F. schrieb:
> Dennis schrieb:
>> Das würde ich gerne drin lassen....
>
> Weißt Du, wozu das gut ist, und welchen technischen Hintergrund das hat?

Damit ich bei mehreren uC die ich per rs485 anspreche nicht alle 
gleichzeitig belaste wenn ich eine Info an nur ein ziel Sende... kurz 
gesagt.. Adressierung...

[S. Landolt (Gast)]

Ohne mich in ein fremdes Programm einarbeiten zu wollen, von dem ich 
ohnehin nur die Hälfte sehe, frage ich mich, welchem Zweck diese 
Umschaltung dient; da muss doch u.a. auch der Rahmen von 8 auf 9 bit 
umgeschaltet werden, das sehe ich nirgendwo. Und ganz naiv hätte ich 
gesagt, entweder immer aus oder immer ein.

[Dennis (Gast)]

S. Landolt schrieb:
> Ohne mich in ein fremdes Programm einarbeiten zu wollen, von dem
> ich
> ohnehin nur die Hälfte sehe, frage ich mich, welchem Zweck diese
> Umschaltung dient; da muss doch u.a. auch der Rahmen von 8 auf 9 bit
> umgeschaltet werden, das sehe ich nirgendwo. Und ganz naiv hätte ich
> gesagt, entweder immer aus oder immer ein.

so habe ich es mir irgendwo durchgelesen...
erst TXB80 an... und wenn die adresse passt dann wieder aus...

aber naja... ich versuche es nun mit 8 bit!

[Dennis (Gast)]

also... ich empfange nun meine "1234567"
ABER..... wenn ich auf sende.. dann ist mein uart_string[0] '1'
beim erneuten senden ist er dann '1'
beim 3ten senden '2'

in Putty sehe ich aber dass er immer alle sendet!

uart_str_count ist immer 0 nachdem uart_str_complete = 1 wird


ISR(USART_RX_vect){

  unsigned char nextChar;

  // Daten aus dem Puffer lesen
  nextChar = UDR0;


  //lcd_putc(UDR0);
  if( uart_str_complete == 0 ) {  // wenn uart_string gerade in 
Verwendung, neues Zeichen verwerfen

    // Daten werden erst in uart_string geschrieben, wenn nicht 
String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( nextChar != '\n' &&
    nextChar != '\r' &&
    nextChar != '\0' &&
    uart_str_count < UART_MAXSTRLEN ) {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
      lcd_putc(nextChar);
      lcd_putc(' ');
    }
  }
}

[S. Landolt (Gast)]

Vorab: Sie hatten Recht, das MPCM0 muss im adressierten Slave 
tatsächlich umgeschaltet werden, da habe ich Sie leider auf eine falsche 
Fährte gelockt.
  Der Fehler muss also anderswo gesteckt haben, und vielleicht hängt das 
jetzige Problem damit zusammen. Das kann aber ein Außenstehender kaum 
beurteilen, da immer nur Teile des Programms gezeigt werden. Zuletzt zum 
Beispiel ist das Rücksetzen von uart_str_complete nicht zu sehen, was 
aber wichtig wäre, denn:
> if( uart_str_complete == 0 ) {  // wenn uart_string
> gerade in Verwendung, neues Zeichen verwerfen

[Marc V. (Firma: Vescomp) (logarithmus)]

Dennis schrieb:

 Auch wenn es (wahrscheinlich) nicht die Ursache ist:

ISR(USART_RX_vect){
...
...
     lcd_putc(nextChar);
      lcd_putc(' ');
    }
  }

 LCD Ausgabe macht man nicht aus der ISR...

[Dennis (Gast)]

Marc V. schrieb:
> Dennis schrieb:
>
>  Auch wenn es (wahrscheinlich) nicht die Ursache ist:ISR(USART_RX_vect){
> ...
> ...
>      lcd_putc(nextChar);
>       lcd_putc(' ');
>     }
>   }
>
>  LCD Ausgabe macht man nicht aus der ISR...

das war nur zum debugen:)

hier nun mein kompletter Sende Code...

/*
 * 1WallSwitch_RS485.c
 *
 * Created: 27.02.2017 08:15:42
 * Author : Mitch
 */ 

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/power.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>
#include <stdint.h>
#include <string.h>
#include "EEPROM.h"

#define F_CPU 8000000UL
#include <util/delay.h>

#define DEVICE 1

#define BAUDRATE 19200UL
#define USAR_BAUD_CALC 25 //8000000 / (16*19200)

#define LOW(x) ((x) & 0xFF) //LOWBYTE
#define HIGH(x) (((x) >> 8) & 0xFF) //HIGHBYTE

//RF24 radio(8,7);

volatile uint8_t fourBtn = 0, initBtn  =0;
volatile uint8_t WDT_count    = 0;
volatile uint64_t Zeitstempel  = 0;
volatile uint8_t id        = 0;
volatile uint8_t timer_1s    = 0;
volatile uint8_t timer_3s    = 0;

//Für Spannungsüberwachung
volatile uint8_t adc_low, adc_high; //Zwischenspeicher für die Ergebnisse des ADC
volatile uint64_t adc_result, vcc; //adc_result Gesamtergebnis der Messung des ADC //VCC Versorgungsspannung

const uint64_t addresses[2] = {0xF0F0F0F002LL,0xE101000000LL};

char *sendByte[20];
volatile char recByte[10];

void rs485_putc(unsigned char c){
  while (!(UCSR0A & (1<<UDRE0)))  /* warten bis Senden moeglich */
  {
  }

  UDR0 = c;                      /* sende Zeichen */
  //return 0;
}

void rs485_puts(char *s, unsigned int len){
  while (*s)
  {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
    rs485_putc(*s);
    s++;
    //_delay_ms(200);
  }
}

void rs485_putAddr(uint8_t data){
  UCSR0B |= (1<<TXB80);
//  _delay_ms(10);
  rs485_putc(data);
  //rs485_putc('\n');
//  _delay_ms(10);
  UCSR0B &= ~(1<<TXB80);
}

void config_timer(){
  //16Bit Timer1
  OCR1A = 31250;
  TCCR1B = (1<<CS12) | (1<<WGM12);
  TIMSK1 = (1<<OCIE1A);
}

void config_interrupt(){
  //PinChange Interrupt
  PCMSK1  |= (1<<PCINT11)|(1<<PCINT10)|(1<<PCINT9)|(1<<PCINT8); //4 Taster PC0,PC1,PC2,PC3
  PCICR  |= (1<<PCIE1);

  //PinChange Interrupt PD4 (InitTaster)
  PCMSK2  |= (1<<PCINT20);
  PCICR  |= (1<<PCIE2);
}

void config_rs485(){
  UBRR0H = HIGH(USAR_BAUD_CALC);
  UBRR0L = LOW(USAR_BAUD_CALC);

  //Bei Slave mit Adresse
  //  UCSR0A = (1<<MPCM0); //Adressüberprüfung... dann 9Bit Modus

  //Character
  UCSR0B = (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0); //RX Enable, TX Enable, Empfangsinterrupts erlauben , UCSZ02 und UCSZ01 und 2aus UCSR0C = 9n1 ...(1<<RXCIE0)
  UCSR0C = (1<<UCSZ00) | (1<<UCSZ01); //8n1
}

ISR(PCINT1_vect){ //4Taster
  fourBtn = 1;
}

ISR(PCINT2_vect){ //InitTaster
  initBtn = 1;
}

ISR(TIMER1_COMPA_vect){
  timer_1s = 1;
  timer_3s++;
}

int main(void){
  DDRC  |= (1<<DDC4)|(1<<DDC5); //PC4 & PC5 als Ausgang für LEDs(Tasterleds)
  DDRD  |= (1<<DDD2)|(1<<DDD3)|(1<<DDD5); //PD2 & PD3 als Ausgang für LEDs(Tasterleds), PD5 StatusLed
  DDRB  |= (1<<DDB2);//PB1 als Ausgang Ansteuerung für RS485

  config_timer();
    config_interrupt();
  config_rs485();
  sei();

  //ADC abschalten, verbraucht dann noch weniger
  ADCSRA = 0;

  //Für Batterieüberwachung
  ADMUX |= (1<<REFS0); //VCC als Referenzspannung f?r den AD-Wandler
  ADMUX |= (1<<MUX3) | (1<<MUX2) | (1<<MUX1);  //1.1V Referenzspannung als Eingang f?r ADC
  
  _delay_ms(10);  //warten bis sich die Referenzspannung eingestellt hat

  sendByte[0] = 1;//DEVICE; //Modus
  sendByte[1] = 2;//EEPROM_read(0);  ; //lese ID aus EEPROM
  sendByte[2] = 5;//EEPROM_read(1);
  sendByte[3] = 6;//EEPROM_read(2);
  sendByte[4] = 7;//EEPROM_read(3);
  sendByte[5] = 8; //CRC
  sendByte[6] = 9; //BAT
  sendByte[7] = 10; //STATUS
  sendByte[8] = 11; //STATUS
  sendByte[19] = 0; //STATUS
  for(uint8_t i=9; i<19; i++){
    sendByte[i] = 0xF1; //DATA i
    }
  
  while(1){    
    if(fourBtn == 1){ //wenn einer der 4Taster gedrückt
      if(PINC & (1<<PINC0)){ //Btn 1 gedrückt
        _delay_ms(60);
        PORTC |= (1<<PORTC4);
        _delay_ms(60);
        PORTC &= ~(1<<PORTC4);
        
        sendByte[8] = 0x01;
        char *test = "1234567";

      //  rs485_putAddr(0x42);
        rs485_puts(test,sizeof(test));
        //uart_putstring("\r\n");
        //uart_putstring(test);
        //_delay_ms(100);
      }
      if(PINC & (1<<PINC1)){ //Btn 2 gedrückt
        PORTC |= (1<<PORTC5);
        _delay_ms(100);
        PORTC &= ~(1<<PORTC5);

      //  sendByte[8] = 0x02;

        rs485_putAddr(0x42);
        rs485_puts(sendByte,sizeof(sendByte));

        //_delay_ms(100);
      }
      if(PINC & (1<<PINC2)){ //Btn 3 gedrückt
        PORTD |= (1<<PORTD2);
        _delay_ms(100);
        PORTD &= ~(1<<PORTD2);

      //  sendByte[8] = 0x03;

        rs485_putAddr(0x42);
        rs485_puts(sendByte,sizeof(sendByte));

        //_delay_ms(100);
      }
      if(PINC & (1<<PINC3)){ //Btn 4 gedrückt
        PORTD |= (1<<PORTD3);
        _delay_ms(100);
        PORTD &= ~(1<<PORTD3);

        //sendByte[8] = 0x04;

        rs485_putAddr(0x42);
        rs485_puts(sendByte,sizeof(sendByte));

        //_delay_ms(100);
      }
      fourBtn = 0;
      //sendByte[8] = 0x00;

      //rs485_putAddr(0x42);
      //rs485_puts(sendByte);
    }
    //Initialisierung
    if(initBtn == 1){
      timer_3s = 0; 
      while(PIND & (1<<PIND4)){ //InitBtn gedrückt
        PORTD |= (1<<PORTD5);
        if(timer_3s == 3){  //3sekunden gedrückt
          for(int i=0; i<5; i++){
            PORTD &= ~(1<<PORTD5);
            _delay_ms(100);
            PORTD |= (1<<PORTD5);
            _delay_ms(100);
          }
          
        }
      }
      PORTD &= ~(1<<PORTD5);
      initBtn = 0;
    }
  }
}

und mein Receive Code

/*
 * RS485_Test1_Slave.c
 *
 * Created: 18.02.2017 21:19:24
 *  Author: Mitch
 */ 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <string.h>
#include "lcd.h"

#define F_CPU 8000000UL
#include <util/delay.h>
#define BAUDRATE 19200UL
#define USAR_BAUD_CALC 25 //8000000 / (16*19200)

#define LOW(x) ((x) & 0xFF) //LOWBYTE
#define HIGH(x) (((x) >> 8) & 0xFF) //HIGHBYTE

#define UART_MAXSTRLEN 20

volatile uint8_t uart_str_complete = 0;     // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN] = "";

uint8_t uart_getc(void)
{
    while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
     
     }   
  return UDR0;                   // Zeichen aus UDR an Aufrufer zurueckgeben
}

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' &&  NextChar != '\0' &&StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }

  // Noch ein '\0' anhängen um einen Standard
  // C-String daraus zu machen
  uart_str_complete = 1;
  *Buffer = '\0';
}

ISR(USART_RX_vect){
  
  unsigned char nextChar;

  // Daten aus dem Puffer lesen
  nextChar = UDR0;
  
  
  //lcd_putc(UDR0);
  if( uart_str_complete == 0 ) {  // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen

    // Daten werden erst in uart_string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( nextChar != '\n' &&
    nextChar != '\r' &&
    nextChar != '\0' &&
    uart_str_count < UART_MAXSTRLEN ) {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
      //lcd_putc(nextChar);
      //lcd_putc(' ');
    }
  }
}


int main(void){
  UBRR0H = HIGH(USAR_BAUD_CALC);
  UBRR0L = LOW(USAR_BAUD_CALC);

  //Bei Slave mit Adresse
  //UCSR0A = (1<<MPCM0); //Adressüberprüfung... dann 9Bit Modus

  //Character 
  UCSR0B = (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0); //RX Enable, TX Enable, Empfangsinterrupts erlauben , UCSZ02 und UCSZ01 und 2aus UCSR0C = 9n1 ...(1<<RXCIE0)
  UCSR0C = (1<<UCSZ00) | (1<<UCSZ01); //8n1

  DDRD |= (1<<DDD5)|(1<<DDD6)|(1<<DDD7);   //DDRA für LCD Datenleitung als Ausgang
  DDRB |= (1<<DDB0)|(1<<DDB1)|(1<<DDB2)|(1<<DDB3);

  DDRD = (1<<DDD4)|(1<<DDD2); //Ausgang
  DDRC = (1<<DDC4); //Ausgang
  //Interrupts global aktivieren
  sei();
  
  lcd_init(12);
  lcd_clrscr();

  lcd_puts("A");
//  lcd_puts(uart_string);

    while(1){
  //  if((UCSR0A & (1<<RXC0))){
      //  uart_gets(uart_string, sizeof(uart_string));
    //  }
    
    if(uart_str_complete == 1){
      //  if(uart_string[0] == '1'){
          //uart_str_count = 0;
          lcd_gotoxy(0,0);
          uart_str_complete = 0;
          lcd_puts(uart_string);
          
      //  }  
    }


    }
}

und hier ist kein Unterschied ob ich jetzt mit ISR arbeite oder die 
uart_gets() Funktion abfrage.

Meine Ausgabe sieht wie folgt aus..

1.Senden > Ausgabe: 1234567
2.Senden > Ausgabe: 2345671
3.Senden > Ausgabe: 3456712
usw.

--
Nochmal zum Mitmeisseln für Dich


Quelltext in [ c ] [ /c ] -Tags einschließen, dann wird er (etwas) 
lesbarer.

-rufus

[Rufus Τ. F. (rufus)]

Warum hast Du auf der Empfänger-Seite eine ISR für den RX-Vektor, wenn 
Du doch in uart_getc pollst?

Das ist kaputt.

[Dennis (Gast)]

Rufus Τ. F. schrieb:
> kaputt

wie gesagt, ich habe es mit ISR und mit der uart_gets() probiert.
das (1<<RXCIE0) Bit ist natürlich abgeschaltet, so springt der in die 
ISR garnicht rein.

[Martin B. (Gast)]

Eine einfache Erklärung wäre ja die:
Bei jedem Durchlauf geht ein Zeichen verloren  Und zwar in der ISR. So 
lange uart_str_complete == 1 gilt, macht die ISR ja fast nichts, aber 
sie holt  Zeichen ab.

Was passiert denn bei:
uart_str_complete = 0;
lcd_gotoxy(0,0);  ?
Die beiden Zeilen also vertauschen.

[S. Landolt (Gast)]

Ist vielleicht das lcd_gotoxy zu langsam? Was passiert, wenn in

          lcd_gotoxy(0,0);
          uart_str_complete = 0;

die beiden Befehle vertauscht werden?

[S. Landolt (Gast)]

Oder besser:

          uart_string_dup = uart_string;
          uart_str_complete = 0;
          lcd_gotoxy(0,0);
          lcd_puts(uart_string_dup);

[Martin B. (Gast)]

oder einfach einen Ringpuffer programmieren  ...