AtTiny85 - Software UART die Zweite

[Max M. (maxmicr)]

Guten Abend,

ich bin bei meinem Versuch, einen Software UART (zu erstmal TX) auf 
einem Attiny85 zu implementieren, erneut an eine Grenze gestoßen. Und 
zwar möchte ich das Ganze softwareseitig so aufbauen, dass man es 
ähnlich bedient wie einen normalen UART. Dafür hatte ich erst die Idee, 
das so zu machen (Pseudocode):

volatile char printChar;
volatile enablePrinting = 0;
ISR{
 if(enablePrinting == 1)
  print "printChar"...
 enablePrinting = 0; //aufhören nachdem der Char geprintet wurde
}
void setPrintChar(char c){
 enablePrinting = 1;
 printChar = c;
}
int main(void){
 while(1)
  setPrintChar('C');
  setPrintChar('B');
}

Das führte aber dazu, dass nicht ein C nach einem B folgte, sondern 
mehrere Cs und dann mehrere Bs kamen (ich denke, das liegt daran, dass 
die Funktion bereits wieder aufgerufen wird, obwohl der alte Char noch 
gar nicht übertragen wurde). Daher hab ich mir überlegt, dass mit einer 
Queue zu machen. Das sieht aktuell so aus:

#define F_CPU 1000000UL

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>

volatile uint8_t enablePrinting = 0;
volatile char* queue;
volatile uint8_t queueLength = 0;

volatile int8_t position = -1;
volatile uint8_t pauseBits = 13;
volatile uint8_t needPause = 0;

ISR(TIMER1_COMPA_vect){
  if(enablePrinting == 1){
    if(needPause == 1 && pauseBits > 0){
      pauseBits--;
      if(pauseBits == 0){
        pauseBits = 13;
        needPause = 0;
      }
    } else {
      if(position == -1){ //start of transmission
        PORTB &=~(1<<PINB3); //Start Bit
        position++;
      } else {
        if(position == 8){ //end of transmission
          queue[queueLength-1] = (char)0;
          queueLength--;
          if(queueLength == 0)
            enablePrinting = 0;
          position = -1;
          PORTB |= (1<<PINB3); //Stop Bit HIGH
          needPause = 1;
        } else{
          if((queue[queueLength-1] >> position) & 0x01){
            PORTB |= (1<<PINB3);
          } else {
            PORTB &=~(1<<PINB3);
          }
          position++;
        }
      }
    }
  }
}

void initTimer(){
  TCCR1 |= (1<<CTC1); //Enable CTC
  TCCR1 |= (0b0010<<CS10); //CK/2
  OCR1A = 1;
  TIMSK |= (1<<OCIE1A); //enable compare interrupt
  queue = (char*)malloc(sizeof(char));
  sei(); //Enable Interrupts
}

void printChar(char c){
  queue[queueLength] = c;
  queueLength++;
  enablePrinting = 1;
}

int main(void)
{
  DDRB |= (1<<PINB3); //PINB1 as output
  PORTB |= (1<<PINB3); //PINB3 HIGH
  initTimer();
  while(1){
    printChar('C');
    printChar('B');
  }
}

Leider funktioniert das immer noch nicht. Jetzt kommt CCBBCCBB. 
Außerdem verbraucht mein Program nun statt 300Byte über 1KByte (liegt 
wahrscheinlich am malloc) :(

Wie würdet ihr das Problem lösen?

[Sebastian S. (amateur)]

Ich mag einfach kein delay(), aber in diesem Falle ist es eine einfache 
Möglichkeit, festzustellen, ob Du Deine eigene Queue durcheinander 
bringst.

Du schriebst:
>void printChar(char c){
>  queue[queueLength] = c;
>  queueLength++;
>  enablePrinting = 1;
>}
Das heißt Du schreibst, ohne Rücksicht auf den Zustand der Queue, 
einfach einen neuen Wert in den Puffer.

Jeder Anfänger aber weiß das:
>  while(1){
>    printChar('C');
>    printChar('B');
>  }
Nicht nur schneller wie eine serielle Schnittstelle übergibt, sondern 
VIEL schneller.

Unabhängig davon, ob der Rest des Programmes funktioniert, solltest Du 
beim Einfügen neuer Zeichen, den Zustand kontrollieren.
Was Du bei einer vollen Queue machen sollst hängt aber vom gesamten, 
späteren Programm ab. Also abweisen oder warten.

Test Möglicherweise:
  while(1){
    printChar('C');
    delay ( 1000 );
    printChar('B');
    delay ( 1000 );
  }

[Sebastian S. (amateur)]

Ich vergaß:

>queue = (char*)malloc(sizeof(char));

Ist natürlich Unsinn.
Immer eine feste Portion Speicher reservieren, widerspricht dem Konzept 
der dynamischen Speicherverwaltung.
In diesem Falle ist es sinnvoller einen fixen Speicherbereich (char 
xxx[cc]) zu reservieren.

Soweit mir bekannt reservierst Du einen Puffer mit der Länge 1!

Noch was:
Die/eine sinnvolle Verzögerung (1000) hängt natürlich von der zu 
erwartenden Übertragungsrate ab.

[Max M. (maxmicr)]

Sebastian S. schrieb:
> Test Möglicherweise:

Wenn ich ein delay zwischendurch einfüge, klappt es wunderbar. Hätte es 
aber wahrscheinlich auch, wenn ich einfach eine Variable mit einem 
Char-Wert definiere und diesen Char dann einmal schreibe und in der 
Funktion jedes mal wieder ändere anstatt das über eine queue zu machen 
(wie im ersten Post erklärt).

Ich hab mal versucht, eine "String"-Funktion zu implementieren, die 
funktioniert auch. Nur das der eingegebene String rückwärts ausgegeben 
wird. Macht auch Sinn, jetzt brauch ich nur wieder eine Variable um von 
Oben nach Unten zu zählen. Nur, wo setzt man diese Variable auf das 
letzte Element? Wenn ein neues Element gerade hinzugefügt wird, kann ich 
die nicht setzen, weil sonst die Elemente ganz vorne nie ausgegebene 
werden.

void printString(char* str){
  while(*str){
    printChar(*str);
    str++;
  }
}

int main(void)
{
  DDRB |= (1<<PINB3); //PINB1 as output
  PORTB |= (1<<PINB3); //PINB3 HIGH
  initTimer();
  while(1){
    printString("\nolleH");
    _delay_ms(7500);
  }
}

Kann man das noch optimieren? 1.1Kbyte ist mir etwas viel nur für den TX 
vom UART.

[Karl M. (Gast)]

Hallo,

ich frage mich warum du noch immer mit diesem Ansatz herum machst und 
nicht weiter kommst.

Es gibt die Implementation von Peter Dannegger für einen Software Uart 
mit FIFO, diese kann man verwenden und auch auf andere AVR µC anpassen.

[Max M. (maxmicr)]

Karl M. schrieb:
> Es gibt die Implementation von Peter Dannegger für einen Software Uart
> mit FIFO, diese kann man verwenden und auch auf andere AVR µC anpassen.

Meinst du diese hier: Beitrag "AVR-GCC: UART mit FIFO"
So wie ich das sehe, benutzt er da Hardware-Peripherie die in einem 
ATtiny85 gar nicht vorhanden sind (z.B. ein USART_UDRE_vect)? Oder 
übersehe ich da was?

[Sebastian S. (amateur)]

Damit es nicht so langweilig wird, ändern sich die Namen, die Atmel 
verwendet schon mal.

Davon sind sogar die Registerbelegung und die Namen der Unterbrechungen 
betroffen.

Also nix mit Copy & Paste.

Es besteht aber Hoffnung: ...suchet so werdet Ihr finden...

[Karl M. (Gast)]

Max M. schrieb:
> Meinst du diese hier: Beitrag "AVR-GCC: UART mit FIFO"
> So wie ich das sehe, benutzt er da Hardware-Peripherie die in einem
> ATtiny85 gar nicht vorhanden sind (z.B. ein USART_UDRE_vect)? Oder
> übersehe ich da was?
Nein natürlich nicht.
Wenn man mit dem Schlagwort in die Mikrocontroller.net Suche geht, 
erhält man als ersten Link:
Beitrag "Software UART mit FIFO"

Den hatte hatte ich Dir in einem anderen Thread schon mal verlinkt.

[Jörg E. (jackfritt)]

Ich benutze die Routinen von Peter schon länger auf meinen Tiny85 und 
habe bei langsamen Baudraten ohne Quartz keine Probleme, und das schöne 
ist man kann fast jeden Pin als TX nutzen.

[Sebastian S. (amateur)]

@Max M³

Ob Du einzelne Zeichen in den Puffer schreibst oder einen ganzen String 
bleibt sich gleich.

So lange Du blind in den Puffer (und das auch noch bei einer Länge von 1 
Byte) schreibst, wird das nichts;-)
Vor allem, wenn Du ihn schneller füllst, wie die serielle Schnittstelle 
ihn leert.
Das sollte sich auch explizit, durch dem Test mit der langen 
Verzögerung, ergeben...