Simple software UART, sieht jemand den Fehler?

[C. H. (hedie)]

Hallo zusammen

Folgendes Szenario:
Ich habe ein GPS Modul, welches theoretisch SPI können müsste.
Leider ist der Hersteller (Maestro GPS) nicht kompetent genug um mir bei 
der Fehlerbehebung der eigenen Module behilflich zu sein.

Deshalb habe ich das Modul auf UART umgestellt.
Dieses hängt nun am hardware SPI Port des Atmega324p

Deshalb dachte ich mir, ich bastle mir schnell eine soft-uart.
Leider klappt diese noch nicht so wie sie sollte.

Vielleicht hat mir ja noch jemand tipps.
Kurz zur konfiguration:
Baudrate 4800
Parity: none
Stoppbit: 1

Meine Idee:

Es gibt einen Pin-Change interrupt für den RX Pin sowie einen Timer0.

Zuerst soll synchronisiert werden. Dazu setze ich den Timer0 auf
die halbe bit-breite. Nun prüfe ich 40mal hintereinander ob RX High ist.
Somit erhoffe ich mir, die Pause zwischen den Sendezeiten des Moduls zu 
erwischen.

Wenn dies erfolgreich war, setzte ich ein Flag in der Variable ucStatus
und aktiviere den PinChange Interrupt.

Wenn nun eine negative flanke eintritt, weiss ich dass dies das Startbit 
sein muss.

Nun möchte ich den Timer Starten, jedoch mit nur der halben bit-zeit, 
damit ich, wenn ich später auf die volle-bitzeit wechsle immer in der 
mitte des bits lande.

Zudem setze ich ein flag dass das startbit erkant wurde.

Nun bin ich das erste mal im timer interrupt, hier setze ich den 
timerwert auf die volle bitzeit und verlasse den interrupt wieder.

Die nächsten male sammle ich die bits ein und beginne mit dem flag 
wieder erneut.



Ich wäre auch bereit ein Struktogram zu machen, sollte dies zu 
unübersichtlich sein.


Hier nun mein code:

#include <avr/io.h>
#include <avr/interrupt.h>
#include "soft_uart.h"
#include "ports.h"

#define RX_PIN ( PINB & (1<<PINB6) )

#define BAUDRATE_0  4800
#define TIMER_PRESC  256
#define CPU_CLOCK  10000000
#define TIMER_VALUE (((CPU_CLOCK/TIMER_PRESC)/BAUDRATE_0)-1)

volatile unsigned char ucBitCount = 0;
volatile unsigned char ucStatus = 0;
volatile unsigned char ucBuffer [8];
volatile unsigned char ucNewChar;
volatile unsigned char ucTempByte = 0;
volatile unsigned char ucBufferCounter = 0;
volatile unsigned char ucSynchroCount = 0;
volatile unsigned char ucSynchro = 0;

ISR(PCINT1_vect)
{
  if(RX_PIN == 0) //Negative Flanke
  {
    if((ucStatus & 0x01))        //0x01 ist gesetzt, dies bedeutet wir haben vorhin eine längere high-phase erkannt.
    {
      PCICR  &= ~(1<<PCIE1);      //Interrupt deaktivieren für den PinChange

      TIMSK0 |= (1<<OCIE0A);      //Timer Interrupt aktivieren
      TCNT0 = 0;             //Timer Counter auf 0
      OCR0A   = (TIMER_VALUE / 2)  ;   //Timing auf ein Halbes bit setzen

      ucStatus &= ~(1<<0x01);     //Startbit erkennung deaktivieren, bzw. wurde erkannt
    }
  }
}


ISR(TIMER0_COMPA_vect)
{
  //LED_1;

  if(ucSynchro == 0)  //Kein Synchronisationsmodus
  {
    if((ucStatus & 0x02) == 0)  //0x02 ist nicht gesetzt, wir sind das erstemal nach der Startbiterkennung hier
    {
      TCNT0 = 0;          //Timerzähler auf 0 setzen
      OCR0A   = TIMER_VALUE;   //Timing auf ein ganzes bit setzen
      ucStatus |= 0x02;
    }
    else //wir sind nicht das erste mal hier, somit befinden wir uns im Datenbyte oder den Steuerbits (parity oder stopbit)
    {
      //if(ucBitCount == 0)
      //{
      //  OCR0A   = TIMER_VALUE;   //Timing auf ein ganzes bit setzen
      //}
      if(ucBitCount < 8)  //Wir lesen nun die Bits ein
      {
        if(RX_PIN)
        {
          ucTempByte |= 0x80;
        }

        if(ucBitCount != 7)
        {
          ucTempByte = ucTempByte >> 1;
        }

      }
      ucBitCount++;

      if(ucBitCount == 9)  //Hier befindet sich das Stoppbit
      {
        LED_1;
        if(RX_PIN) //Stoppbit erkannt
        {
          ucBuffer[ucBufferCounter] = ucTempByte;
          ucBufferCounter++;
          if(ucBufferCounter == 8) ucBufferCounter = 0;
          ucNewChar = 1;

          ucStatus = 0x01;    //Bereit für nächstes Startbit
          PCICR  |= (1<<PCIE1);  //Interrupt aktivieren für den PinChange
          TIMSK0 &= ~(1<<OCIE0A); //Interrupt deaktivieren
          LED_0;
        }
        else //kein Stoppbit erkannt
        {
          ucSynchro = 1; //Synchronisieren
          //Interrupt für den Timer nicht deaktivieren.
        }

        ucBitCount = 0;
      }

    }




  }
  else // Synchronisationsmodus
  {
    //LED_1
    if(RX_PIN)  //Prüfen ob RX high ist
    {
      ucSynchroCount++;
    }
    else
    {
      ucSynchroCount = 0;    //Sobald RX einmal low war, wieder auf 0 setzen
    }

    if(ucSynchroCount == 40)  //Es wurde 20bitzeiten lang high erkannt, somit muss nun das startbit folgen
    {              //auflösung ist ein halsbes bit
      ucSynchroCount = 0;
      TIMSK0 &= ~(1<<OCIE0A); //TIMER Interrupt deaktivieren und somit auf startbit warten
      ucSynchro = 0;      //Synchrobit löschen
      PCICR  |= (1<<PCIE1);  //PinChange Interrupt aktivieren
      ucStatus = 0x01;    //Startbit aktivieren
    }

  }
  //LED_0;
}


void init_soft_uart(void)
{

  //PCINT14 ist der Interrupt des RX-Pins
  PCMSK1 |= (1<<PCINT14); //Interruptgruppe 1

  ucSynchro = 1;        //Synchronisation aktiveren

  OCR0A   = TIMER_VALUE;    //Timer auf eine ganze bitlänge setzen
  TCCR0A |= (1<<WGM01);     //CTC MODE
  TCCR0B |= (1<<CS02);    //256 Prescaler
  TIMSK0 |= (1<<OCIE0A);    //Interrupt aktivieren

}

Das Problem:

mit folgendem Code teil funktioniert es nicht:

if((ucStatus & 0x02) == 0)  //0x02 ist nicht gesetzt, wir sind das erstemal nach der Startbiterkennung hier
    {
      TCNT0 = 0;          //Timerzähler auf 0 setzen
      OCR0A   = TIMER_VALUE;   //Timing auf ein ganzes bit setzen
      ucStatus |= 0x02;
    }

Meine gwünschte Verögerung nach dem Startbit muss ich merkwürdigerweise 
im obigen Codeblock setzen mit: OCR0A = TIMER_VALUE * 2;

Dann muss ich auch folgenden Code einsetzen:

if(ucBitCount == 0)
      {
        OCR0A   = TIMER_VALUE;   //Timing auf ein ganzes bit setzen
      }

Doch ich verstehe nicht, weshalb mein zuerst geposteter code so wie er 
ist nicht läuft.


Wenn ich ihn entsprechend anpasse, klappt es mit maximal 2 zeichen 
hintereinander. Dann verschluckt er sich.


Ich hoffe jemand kann mir ein paar tipps geben.

Danke

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Claudio Hediger schrieb:
> Nun möchte ich den Timer Starten, jedoch mit nur der halben bit-zeit,
> damit ich, wenn ich später auf die volle-bitzeit wechsle immer in der
> mitte des bits lande.

Ohne jetzt deinen ganzen Code durchzugehen, aber warum nimmst du da 
nicht die 1 1/2-fache Bitlänge? Das Startbit brauchst du ja nicht und 
kannst dann gleich anfangen, bits in den RX-Buffer zu schieben.

[C. H. (hedie)]

So ich habe noch ein kleines Diagram erstellt.

Die roten Striche entsprechen den Interrupts des Timers.

[Stefan E. (sternst)]

Ein schwerwiegendes Problem (und möglicherweise auch die Ursache für 
deine Beobachtungen) ist, dass du die Interrupt-Flags nie zurücksetzt. 
Während des Daten-Einlesens ist der Pin-Change-Interrupt zwar 
deaktiviert, aber es wird ja trotzdem bei jeder Flanke das entsprechende 
Flag gesetzt. Wenn du dann den Interrupt wieder freigibst, löst er wegen 
des bereits gesetzten Flags sofort aus, und nicht erst bei der nächsten 
Flanke. Und für das Compare-Flag gilt das gleiche.

[C. H. (hedie)]

Matthias Sch. schrieb:
> Ohne jetzt deinen ganzen Code durchzugehen, aber warum nimmst du da
> nicht die 1 1/2-fache Bitlänge? Das Startbit brauchst du ja nicht und
> kannst dann gleich anfangen, bits in den RX-Buffer zu schieben.

Gut da hast du recht, dies ergibt sinn.

Das problem ist jedoch, dass aus irgendeinem mir unbekannten Grund,
der Timer diese Zeit nicht "übernimmt"

Damit meine ich, dass direkt nach diesem Code:

ISR(PCINT1_vect)
{
  if(RX_PIN == 0) //Negative Flanke
  {
    if((ucStatus & 0x01))        //0x01 ist gesetzt, dies bedeutet wir haben vorhin eine längere high-phase erkannt.
    {
      PCICR  &= ~(1<<PCIE1);      //Interrupt deaktivieren für den PinChange

      TIMSK0 |= (1<<OCIE0A);      //Timer Interrupt aktivieren
      TCNT0 = 0;             //Timer Counter auf 0
      OCR0A   = (TIMER_VALUE / 2)  ;   //Timing auf ein Halbes bit setzen

      ucStatus &= ~(1<<0x01);     //Startbit erkennung deaktivieren, bzw. wurde erkannt
    }
  }
}

der Timerinterrupt ausgelöst wird

Die gewünschte Verzögerung tritt somit nicht ein

[C. H. (hedie)]

Stefan Ernst schrieb:
> Ein schwerwiegendes Problem (und möglicherweise auch die Ursache für
> deine Beobachtungen) ist, dass du die Interrupt-Flags nie zurücksetzt.

Ahhhhh :)

Das wird wohl wirklich der Grund sein!

Werde ich nach dem Essen gleich mal versuchen...


Damit diese Thread jedoch nicht gleich endet noch eine Frage
Ist meine Realisierung bzw. mein Konzept so überhaupt sinnvoll
oder gibt es da besseres?

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Noch ein Tipp: Du kannst Flags einfacher behandeln (ohne die ganze 
fehlerträchtige Maskiererei), indem du dir ein kleines Struct 
zusammenbastelst:

typedef struct serialflags
{
  uint8_t bufferEmpty: 1;   // no data yet
  uint8_t startbitReceived : 1; // we have a startbit - sample the da.
  uint8_t rxBusy : 1;    // if the receiver is in the middle of a byte.
} serialflags_t;
// nun kannst du damit eine Variable bauen:
volatile serialflags_t rxFlags;

// und im Code dann
rxFlags.startbitReceived = FALSE;
rxFlags.bufferEmpty = TRUE;

 if (rxFlags.startbitReceived) {
 // 
 }

usw. Das ist doch viel übersichtlicher und man kommt nicht so schnell 
mit den bits durcheinander.

[C. H. (hedie)]

Matthias Sch. schrieb:
> Diesen Beitrag bewerten:
>   ▲ lesenswert
>
>   ▼ nicht lesenswert
>
>
>
>       Noch ein Tipp: Du kannst Flags einfacher behandeln (ohne die ganze
> fehlerträchtige Maskiererei), indem du dir ein kleines Struct
> zusammenbastelst:

Vielen Dank!

Das ist wirklich ein genialer Tipp!

Ich habe mir nämlich wirklich die Variable ucSynchro aufgesetzt,
da ich mit dem Bit Maskieren ein durcheinander hatte :)

Wird sogleich implementiert!

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Ich habe nochmal gesucht, da ich einen recht zuverlässigen Code für 
einen Empfänger (aufm Tiny45/85) habe, den ich mal für ein Tablet-USB 
Adapter gebaut habe. Der kommt mit den Datenströmen des Tabletts recht 
gut klar:

// Konstanten
/* software serial port */
/* timer periods for 9600 baud, 16mhz and a prescaler of 32 */
/* resolution is 2 uSec per timer tick          */ 
#define period 256-52      /* time from bit to bit = 104 uSecs*/
#define startperiod 256-74     /* time from start of start bit to middle of LSB */ 
// Variablen
/* softserial IRQ values */
volatile uint8_t  offset;    /* bit shifter */
volatile uint8_t  val;    /* receive value */
/* buffer properties */
static   uint8_t   rxbuf[16];
static   uint8_t   rxpos;

Hier ist der Startbit Detektor:

/* Let us once more implement the serial receiver routine in interrupt, this time in C.
PCINT0 is fired by the startbit of incoming serial and then prepares variables and starts the timer 
- after that it blocks itself . It is freed again by the completion of the timer routine. 
never touch the global irq flag 'cause the USB routines need it */
ISR(PCINT0_vect,ISR_NOBLOCK)
{
  if (bit_is_clear(PINB,BIT_RXD))    /* only a falling edge will trigger */
    {
      /* Start timer 1 with a prescaler of 32 */
      TCNT1 = startperiod;
      TCCR1 |= _BV(CS12) | _BV(CS11);  /* start with prescaler / 32  */
    GIMSK &= ~(_BV(PCIE));  /* block myself */
     GIFR |= _BV(PCIF);     /* clr pendings on me */
    TIFR  |= _BV(TOV1);    /* clr pending on timer */
    TIMSK |= _BV(TOIE1);    /* enable Timer 1 irq */
    offset = 0;        /* shifter init */
    val = 0;          /* value init */
    }
  return;
};

Und hier der Timerinterrupt. Die sind beide auf ISR_NOBLOCK, weil da im 
Hintergrund V-USB läuft, was immer der Chef ist.

/* the timer routine takes care of incoming bits from software serial 
 * it is initialized by the PC_INT0 Routine . the timer IRQ now sets the timer to the 
 * real bit rate and samples the incoming data line in the middle of the bit 
 * keep in mind that RS232 sends the LSB first in contrary to e.g. I2C. 
 * 
 * the assembled value is in 'val' 
 */
ISR(TIM1_OVF_vect,ISR_NOBLOCK)
{
   TCNT1 = period ;    /* restart timer in any case to maintain best timing */
  if ( offset > 7 ) {      /* swallow stop bit */
      TIMSK &= ~(_BV(TOIE1));  /* block myself */
     GIFR |= _BV(PCIF);     /* clr pendings on PC_INT*/
     PCMSK |= _BV(BIT_RXD);   /* prepare pinchange irq */  
      TCCR1 = 0;        /* stop timer */
    GIMSK |= _BV(PCIE);    /* enable PC INT0 we don't expect a Pinchange between stop bit and idle */
    offset += 1;      /* at the end of a completed byte we should have offset == 9 */
    return;          /* out of here */
  }
  val >>= 1;           /*shift one bit to the right - LSB comes first */ 
  if (bit_is_set(PINB,BIT_RXD)) {
    val |= 0x80 ; /* set the highest data bit */
  }
  offset += 1;    /* outerloop counter */
  return;  
};

Vllt. kannst du da ja noch was rausziehen. Meine Strategie ist 
geringfügig anders, da ich den Timer vorbesetze und dann auf einen 
Überlauf warte. Das ist aber recht wurscht, wie man das macht.

[C. H. (hedie)]

Vielen Dank für deinen Code

Ich werde ihn mir mal genauer ansehen.
Aber bevor ich hier meinen Code komplett umstelle, würde es mich schon 
noch interessieren, ob jemand eine Idee hat, weshalb ich etwas falsches 
empfange.

Ich sende zweimal hintereinander 01010101 01010101 und erhalte 01101010 
01010101 zurück

Die Fehler sind sporadisch. Manchmal kommen 3 Zeichen hintereinander 
korrekt an, manchmal zweimal der selbe fehler und dann ein richtiges 
(wenn 3 aufeinanderfolgend gesendet werden)

Anbei ein Bild vom Oszi für das obige Beispiel

die gelben Spikes ist die LED
Diese wird vor dem if(RX_PIN) aktiviert und nach dem schieben der 
Variable ucTempByte wieder deaktiviert.

Man sieht somit, dass der uC zur richtigen Zeit prüft, jedoch liest er 
einen falschen Pin-Zustand ein.

Hat jemand eine Idee?

[C. H. (hedie)]

------- PROBLEM GELÖST!!!! ---------

So ich konnte das Problem lösen.

Es hatte mit dem Speicherzugriff zu tun.

Folgendes war geschehen:

Ich habe in diesem Codeblock:

if(ucBitCount < 8)  //Wir lesen nun die Bits ein
      {
        if(RX_PIN)
        {
          ucTempByte |= 0x80;
        }

        if(ucBitCount != 7)
        {
          ucTempByte = ucTempByte >> 1;
        }

      }

Immer wieder auf eine Volatile Variable zugegriffen.
Volatile sagt dem compiler, dass er den Speicher, sobald Änderungen 
auftauchen aktualisieren muss!

So nun habe ich an diesen stellen, anstelle der volatile eine in der ISR 
aufgesetzte

static unsigned char ucLocalTemp;

Static variable verändert und beim erkennen des Stoppbits den Inhalt 
dieser in die Globale, volatile kopiert.

Nun funktioniert alles wunderbar!

Ich würde mich freuen, falls sich jemand noch ein bisschen genauer damit 
auskennt, wenn dies jemand noch etwas detailierter ausführen würde.


Danke an euch!