Minimal UART für Attiny gesucht

[eric (Gast)]

Hallo,

ich hab hier einen Attiny85 den ich für Debuggingzwecke um einen 
minimalen UART erweitern möchte.

-Es reicht völlig wenn er nur senden kann, Empfang wird nicht benötigt.
-Beide Timer sind schon in Benutzung, Timer 1 läuft mit CTC und entweder 
OCR1A oder OCR1B wäre noch frei. Notfalls hätte der Teiler auch noch 
etwas Spiel.

Ich möchte natürlich, dass es den Rest des Programms möglichst wenig 
behindert.
Meine erste Idee war es mit der freien Leitung vom Timer das USI zu 
takten. Da mein Problem ja eigentlich nicht sonderlich selten ist, hat 
es mich überrascht, dass dazu kaum etwas zu finden war. Das meiste mit 
Senden und Empfangen und gleich ne Nummer größer als ich gehofft hab...

Sofern das mit dem USI überhaupt sinnvoll machbar ist, sollte das Timing 
softwareseitig kein Problem sein. Das wäre bei einem reinen software 
UART ja nicht unbedingt gegeben.

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

Wenn deine Timer schon einen OF Interrupt auslösen, kannst du einen 
davon 'huckepack' als seriellen Ausgang mitnutzen. Dazu brauchst du 
eigentlich nur einen 1-byte Buffer, indem dein zu sendendes Zeichen 
steht, einen Bitzähler und evtl. 2 Flags für 'neues Zeichen im Buffer' 
und 'Senden aktiv'.

[Jörg E. (jackfritt)]

Per Bitbanging gehts evtl bis 9600.
Kommt auf dein restliches programm an.

[Peter D. (peda)]

void sputchar( uint8_t c )
{
  c = ~c;
  STX_PORT &= ~(1<<STX_BIT);            // start bit
  for( uint8_t i = 10; i; i-- ){        // 10 bits
    _delay_us( 1e6 / BAUD );            // bit duration
    if( c & 1 )
      STX_PORT &= ~(1<<STX_BIT);        // data bit 0
    else
      STX_PORT |= 1<<STX_BIT;           // data bit 1 or stop bit
    c >>= 1;
  }
}

[Jörg E. (jackfritt)]

Peters Code nutze ich auch ztw.
Danke dir nochmals ;)

Manchmal muss ich das Bit invertieren wenn MAX232 dranhängt.
Ich habe mit dem atiny85 mal ein paar Test mit internen 8Mhz gemacht.
eventuell klappts bei dir ja auch.
Hoffe es ist kein Fehler bei C&C passiert...

#include <util/delay.h>
#define TX_PORT PORTB
#define TX_PIN PB0
#define     TX_INVERT    // without MAX232
#define BAUD    9600UL
//Bitbanging
#define  BB            

// Das geht mit BB bei 8 Mhz
//#define BAUD    200UL
//#define BAUD    300UL
//#define BAUD    1200UL
#define BAUD    9600UL
//#define BAUD    4800UL
//#define BAUD    9600UL
//#define BAUD    19200UL
//#define BAUD    28800UL
//#define BAUD    38400UL
//#define BAUD    57600UL

// Ab hier nur mit Timer bei 8Mhz
//#define BAUD    76800UL
//#define BAUD    115200UL

// Ab hier nur mit externem Quartz
//#define BAUD    230400UL
//#define BAUD     256000UL
//#define BAUD    921600UL //C³ BT Modul


void tx(uint8_t c)
{
#ifdef BB
  c = ~c;
#ifndef TX_INVERT
  TX_PORT &= ~(1<<TX_PIN);            // start bit
#else
  TX_PORT |= (1<<TX_PIN);
#endif
  for( uint8_t i = 10; i; i-- ){        // 10 bits
    _delay_us( 1e6 / BAUD );
#ifndef TX_INVERT
    if( c & 1 )
      TX_PORT &= ~(1<<TX_PIN);        // data bit 0
    else
      TX_PORT |= (1<<TX_PIN);           // data bit 1 or stop bit
#else
    if( c & 1 )
      TX_PORT |= (1<<TX_PIN);        // data bit 0
    else
      TX_PORT &= ~(1<<TX_PIN);           // data bit 1 or stop bit
    c >>= 1;
#endif
  }
#else
    uint8_t i = tx_in;

    ROLLOVER( i, TX0_SIZE );
    tx_buff[tx_in] = ~c;      // complement for stop bit after data
    while( i == (*(volatile uint8_t*)&(tx_out)));    // until at least one byte free
    // tx_out modified by interrupt !
    tx_in = i;
#endif
  }

[c-hater (Gast)]

eric schrieb:

> -Es reicht völlig wenn er nur senden kann, Empfang wird nicht benötigt.
> -Beide Timer sind schon in Benutzung, Timer 1 läuft mit CTC und entweder
> OCR1A oder OCR1B wäre noch frei. Notfalls hätte der Teiler auch noch
> etwas Spiel.
>
> Ich möchte natürlich, dass es den Rest des Programms möglichst wenig
> behindert.
> Meine erste Idee war es mit der freien Leitung vom Timer das USI zu
> takten.

Was für eine "freie Leitung" brauchst du denn? Das USI kann doch direkt 
von Timer0 getaktet werden. Nur völlig idiotische Timer-Nutzungsarten, 
die einen manuellen Reload des Zählregister beinhalten, können das 
verhindern...

> Sofern das mit dem USI überhaupt sinnvoll machbar ist, sollte das Timing
> softwareseitig kein Problem sein. Das wäre bei einem reinen software
> UART ja nicht unbedingt gegeben.

Wenn dein Timer0 mit einer "brauchbaren" Zyklusfrequenz läuft und du 
dich obendrein für die Debugausgaben auf einen 64 Zeichen großen 
Zeichensatz beschränkst (sinnvollerweise: ASCII32..96), dann hast du die 
optimale, minimalinvasive Debugausgabe.
Format 6N1. Die Ausgabe eines Zeichens (inklusive Prüfung, ob 
Schieberegister frei) kostet nur 8 MCU-Takte. Und die eigentliche 
Ausgabe läuft dann komplett mittels Hardware, ohne weitere Eingriffe 
durch die Software zu erfordern.

Besser geht's auf einem Tiny nicht (außer auf einem mit echter USART 
natürlich...)

[eric (Gast)]

Peter: Als reine Verständnisfrage: der Code erzeugt 2 stop bits, oder?

c-hater schrieb:
> Was für eine "freie Leitung" brauchst du denn? Das USI kann doch direkt
> von Timer0 getaktet werden. Nur völlig idiotische Timer-Nutzungsarten,
> die einen manuellen Reload des Zählregister beinhalten, können das
> verhindern...

Damit meinte ich Timer/Counter0 Compare Match, oder geht das noch 
'direkter'?


c-hater schrieb:
> Format 6N1. Die Ausgabe eines Zeichens (inklusive Prüfung, ob
> Schieberegister frei) kostet nur 8 MCU-Takte. Und die eigentliche
> Ausgabe läuft dann komplett mittels Hardware, ohne weitere Eingriffe
> durch die Software zu erfordern.
>
> Besser geht's auf einem Tiny nicht (außer auf einem mit echter USART
> natürlich...)

Das klingt schon mal gut, mal gucken was mein Terminalprogramm bei 6N1 
ausspuckt.
Es sollte doch eigentlich auch möglich sein das mit dem Counter Overflow 
Interrupt auf 8 bit zu verlängern, aber 6 bit reichen.

[c-hater (Gast)]

eric schrieb:

> Das klingt schon mal gut, mal gucken was mein Terminalprogramm bei 6N1
> ausspuckt.

Sichtbar? Nur Müll natürlich. Man muß zu jedem empfangenen Zeichen 32 
addieren, um wieder auf darstellbare ASCII-Zeichen zu kommen.

> Es sollte doch eigentlich auch möglich sein das mit dem Counter Overflow
> Interrupt auf 8 bit zu verlängern

Häh? Das Problem ist einfach, daß das verfügbare Schiebereister der 
Hardware einfach mal nur 8 Bit breit ist. Da man für einen UART-Betrieb 
Start- und Stopbit braucht, bleiben nur 6 Bit im Register für den 
Payload.

Die üblichen UART-Implementierungen für USI machen das anders, die 
erzeugen das Startbit i.d.R. komplett mittels Software und für das 
Stopbit nutzen sie entweder eine Eigenart des USI, die erstens nicht 
dokumentiert ist und die zweitens z.B. bei invertierter Ausgabe direkt 
für eine PC-UART auch nicht in dieser Form nutzbar ist oder sie erzeugen 
auch das Stopbit in Software. Damit ergeben sich in beiden Fällen 
Probleme beim Timing, die zwar natürlich lösbar sind, aber dem Ziel 
einer möglichst unabhängigen Debug-Ausgabe zuwieder laufen.

[Sebastian W. (wangnick)]

eric schrieb:
> ich hab hier einen Attiny85 den ich für Debuggingzwecke um einen
> minimalen UART erweitern möchte.

Such mal nach tinydebugserial.

LG, Sebastian

[eric (Gast)]

c-hater schrieb:
> Häh? Das Problem ist einfach, daß das verfügbare Schiebereister der
> Hardware einfach mal nur 8 Bit breit ist. Da man für einen UART-Betrieb
> Start- und Stopbit braucht, bleiben nur 6 Bit im Register für den
> Payload.

Er löst ja (wenn aktiviert) alle 8 bit einen Interrupt aus. Ob das 
reicht um die restlichen bits nahtlos anzufügen ist natürlich die andere 
frage.

Aber 6N1 reicht mir wie gesagt in dem fall, Und da ich sowieso fast 
ausschließlich Zahlen ausgebe, ist das mit dem Zeichensatz auch kein 
Ding.

[Petr Tomášek (Gast)]

Hallo,

hier ist so ein UART, das ich mal gebastelt habe. Es läuft über den 
timer (war, glaube ich, für AT90USB647 geschrieben, aber könnte beim 
Anpassen auch bei ATtinys funktionieren)...

MfG
Petr

/*
 * (c) 2013 Petr Tomasek <[e-mail]>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>

#include "utils.h"

volatile unsigned char dbg_serial_buffer[256];
volatile unsigned char dbg_serial_start; // interrupt reads from here...
volatile unsigned char dbg_serial_end;   // user writes here...
volatile unsigned char dbg_serial_bit;


/* --------------- interrupt ------------------- */

ISR(TIMER1_COMPA_vect) {
 if (!dbg_serial_bit)
 {
   if (dbg_serial_end!=dbg_serial_start) // TODO: CTS !!!
   {
     // Start bit
     io_clear(DBG_SERIAL_TX); 
     dbg_serial_bit++;
   }
 }
 else if (dbg_serial_bit<=8)
 {
   // one bit
   if (dbg_serial_buffer[dbg_serial_start]&1)
     io_set(DBG_SERIAL_TX); 
   else
     io_clear(DBG_SERIAL_TX); 

   dbg_serial_buffer[dbg_serial_start]/=2;
   dbg_serial_bit++;
 }
 else
 {
   // Stop bit
   io_set(DBG_SERIAL_TX); 
   dbg_serial_start++;
   dbg_serial_bit=0;
 }
}


/* --------------------- init ------------------- */

void dbg_serial_init (void) {
  TCCR1A = 0x00;                    // NO OC* pins + WGM11:01<=00 => CTC mode
  TCCR1B = (1<<WGM12) | (1<<CS10);  //  WGM13:02<=01  => CTC mode,  CS12:10<= 001 == Fclk

  OCR1A = (unsigned int)(F_CPU/DBG_SERIAL_BAUD_RATE+0.5);

#ifdef DBG_SERIAL_CTS
  ddr_set_in(DBG_SERIAL_TX); 
#endif
  ddr_set_out(DBG_SERIAL_TX); 
  io_set(DBG_SERIAL_TX); 

  // interrupt
  TIMSK1 = (1<<OCIE1A);
  sei();

}


/* --------------------- user ------------------- */

void dbg_serial_printchar (char ch) {

  while (dbg_serial_start==dbg_serial_end+1)
  {
    sleep_cpu(); 
  }
  dbg_serial_buffer[dbg_serial_end++]=ch;
}

signed char dbg_serial_printchar_nonblock (char ch) {

  if (dbg_serial_start==dbg_serial_end+1) return -1;
  dbg_serial_buffer[dbg_serial_start++];
  return 0;
}

void dbg_serial_print_p (const char * s) {
unsigned char ch;
while ((ch=pgm_read_byte(s))) {
 dbg_serial_printchar(ch);
 s++;
 }
}

// TODO: atomic: either fail or print everything!
signed char dbg_serial_print_p_nonblock (const char * s) {
unsigned char ch;
while ((ch=pgm_read_byte(s))) {
 if (dbg_serial_printchar_nonblock(ch)) return -1;
 s++;
 }
 return 0;
}

#define dbg_serial_print_P(__s)  dbg_serial_print_p(PSTR(__s))
#define dbg_serial_print_P_nonblock(__s)  dbg_serial_print_p_nonblock(PSTR(__s))

void dbg_serial_print_maxlen (char * s, unsigned int maxl) {
unsigned char ch;
//unsigned int ii;
//while ((ch=*s) && (ii<maxl)) {
while ((ch=*s)) {
 dbg_serial_printchar(ch);
 s++; //ii++;
 }
}

void dbg_serial_printciff (unsigned char cf) {
 if (cf>9) dbg_serial_printchar (cf+'a'-10);
 else dbg_serial_printchar (cf+'0');
 return;
}

void dbg_serial_printx (unsigned char x) {
 dbg_serial_printciff(x/16);
 dbg_serial_printciff(x%16);
 return;
}

void dbg_serial_print010 (unsigned char c) {
 unsigned char cc;
 dbg_serial_printciff(c/100);
 cc=c%100;
 dbg_serial_printciff(cc/10);
 dbg_serial_printciff(cc%10);
 return;
}

void dbg_serial_print10 (unsigned char c) {
 unsigned char cc;
 if (c>99) dbg_serial_printciff(c/100);
 cc=c%100;
 if (c>9) dbg_serial_printciff(cc/10);
 dbg_serial_printciff(cc%10);
 return;
}

[eric (Gast)]

Ich hab mich mal an dem USI versucht, leider ohne wirklichen Erfolg.
Die Dokumentation zum USI ist stellenweise leider ungenau oder 
unvollständig, sodass einiges nur durch Rumprobieren rauszufinden war.

Mit dem angefügten Code klappt es immerhin schon mal, den Pin konstant 
auf High zu halten...

Sobald ich versuche etwas anderes zu senden, kommt zwar etwas an, aber 
er scheint Probleme zu haben Anfang und Ende richtig zu erkennen. Das 
delay in der ISR sollte jetzt sicherstellen, dass auch für das Stopbit 
das Timing eingehalten wird, hat aber nicht den gewünschten Erfolg und 
ist hässlich.

F_CPU ist 1MHz und der Code von Peter funktioniert soweit. Ein 
Oszilloskop um mir das Signal mal genauer anzugucken hab ich leider 
nicht...
USI ist jedenfalls ein ziemlicher Krampf, da bin ich vermutlich besser 
dran im Timer Interrupt selber am Pin zu wackeln...

#include <avr/interrupt.h>
#include <avr/io.h> 
#include <util/delay.h>
#include <stdint.h>

#define BAUD 1200UL

void initTimer(void) {
  TCCR0A =
    (1 << WGM01) | // CTC
    (0 << WGM00);

  TCCR0B =
    (0 << WGM02) |
    (0 << CS02)  | // clk/8
    (1 << CS01)  |
    (0 << CS00);

  OCR0A = (unsigned int)(F_CPU/(BAUD*8UL)+0.5);
}

void initUSI(void) {
  USIDR = 0xFF;

  USICR =
    (1<<USIOIE) |
    (0<<USIWM1) | // 3 wire mode
    (1<<USIWM0) |
    (0<<USICS1) | // Timer/Counter0 Compare Match
    (1<<USICS0);
}

ISR(USI_OVF_vect) {
  //_delay_us(1e6 / BAUD);
  USIDR=0xFF;

  TCNT0=0;
  USISR = (1<<USICNT3) | (1<<USICNT0); // USICNT = 9
  USISR |= (1<<USIOIF);
}

int main(void) {
  initTimer();
  initUSI();

  DDRB |= (1<<DDB1); // UART

  sei();

  for(;;);

  return 0;
}

[Peter D. (peda)]

eric schrieb:
> USI ist jedenfalls ein ziemlicher Krampf

Ja, was sich Atmel dabei gedacht hat, ist mir ein Rätsel. Es ist 
wirklich zu nichts nütze.

[eric (Gast)]

Mit dem Timer Interrupt hat es jetzt ~10 Minuten gedauert und es kommt 
sogar auf Anhieb das an was ankommen soll... autsch...

[Verwirrter Anfänger (Gast)]

Ich häng hier einfach mal meine kleine bit banging Variante dran. Das 
ist im Grunde das Gleiche wie von Peter oben, nur etwas mehr als Library 
aufgemacht.


header:

#define __UART_H
#include <stdint.h>
#include <avr/io.h>
 
// Baud rate
#define UART_BPS 9800
#define UART_TX_DDR  DDRB
#define UART_TX_PORT PORTB
#define UART_TX_PIN  PB0
 
extern uint8_t uart_setup(void);
extern void uart_putc(char c);
extern void uart_puts(char* s);
 
#endif

code:

#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>
#include "uart.h"
 
#define UART_SET_BIT(port,bit)   (port |=  (1 << bit))
#define UART_CLEAR_BIT(port,bit) (port &= ~(1 << bit))
 
#define UART_BIT_WAIT()  _delay_us(1000000.0 / (float) UART_BPS)
#define UART_SEND_HIGH() {UART_CLEAR_BIT(UART_TX_PORT, UART_TX_PIN); UART_BIT_WAIT();}
#define UART_SEND_LOW()  {UART_SET_BIT(UART_TX_PORT, UART_TX_PIN); UART_BIT_WAIT();}
 
uint8_t uart_setup(void){
  UART_SET_BIT(UART_TX_DDR, UART_TX_PIN);
  UART_SET_BIT(UART_TX_PORT, UART_TX_PIN);
  return 0;
}
 
void uart_putc(char c){
  uint8_t i = 8;
  // start bit
  UART_SEND_HIGH();
  while(i){
    if(c & 1){
      UART_SEND_LOW();
    } else {
      UART_SEND_HIGH();
    }
    c = c >> 1;
    i--;
  }
  // stop bits
  UART_SEND_LOW();
}
 
void uart_puts(char* s){
  while (*s) {
    uart_putc(*s);
    s++;
  }
}

[c-hater (Gast)]

Peter Dannegger schrieb:

> eric schrieb:
>> USI ist jedenfalls ein ziemlicher Krampf

Das ja.

> Ja, was sich Atmel dabei gedacht hat, ist mir ein Rätsel. Es ist
> wirklich zu nichts nütze.

Das ist allerdings Unsinn. Ja klar, ein Stück Hardware, was wirklich das 
Akronym "USI" verdient, hätte schon gern ein ganzes Stück universeller 
sein dürfen als das USI tatsächlich ist, soweit stimme ich dir da 
vollkommen zu.

Das heißt aber andererseits nun auch ganz sicher nicht, daß das USI 
wirklich zu garnix nützlichem zu gebrauchen wäre. Das ist Quatsch. 
Insbesondere ist es Quatsch im Bezug auf das konkrete Thema dieses 
Threads.

Man kann damit eine "minimalinvasive" Debugausgabe realisieren, die 
praktisch unabhängig von jeglichem Timing der eigentlichen Anwendung ist 
(und auch umgekehrt die Anwendung nur minimal tangiert). Das kostet USI 
und leider auch zumindest Restriktionen für die Benutzung von Timer0 
durch die Anwendung. Aber das war ja von vornherein klar.

Ergänzend: Ich war in meinen Postings in diesem Thread bisher davon 
ausgegangen, daß die Timing-Unabhängigkeit der Ausgabe nur mit 6N1 
möglich wäre.
Inzwischen habe ich mir die Sache nochmal genauer angeschaut und 
festgestellt, daß auch 7N1 rein in Hardware geht. Das macht die 
Debug-Ausgabe auf diesem Weg praktisch vollwertig (weil dann mit jedem 
normalen Terminalprogramm nutzbar). Ein weiterer Vorteil bei der 
7N1-Betriebsart ist, daß die eigentliche Debug-Ausgabe hier nicht 8, 
sondern nur 6 MCU-Takte kostet, der Einfluß der Debug-ausgabe auf die 
Anwendung als noch geringer ist.

Der Nachteil: zusätzlich zu dem naturgemäß immer benutzten DO fällt dann 
auch noch der mit DI verknispelte µC-Pin für die Benutzung durch die 
eigentliche Anwendung aus, was insbesondere bei den Tinys mit ganz 
wenigen Pins durchaus eine herbe Einschränkung sein kann.

Naja, und ganz zuletzt ist mir auch noch aufgefallen, daß auch 8N1 rein 
in Hardware möglich wäre, das allerdings nur, wenn Timer0 wirklich 
exklusiv für die Debugausgabe genutzt wird (6N1 und 7N1 lassen vielfach 
eine Mitnutzung durch die Anwendung zu, die wäre zwar auch bei 8N1 nicht 
völlig ausgeschlossen, würde aber das Timing der Anwendung beeinflussen, 
weil an TCNT geschraubt werden muß, um das Startbit jederzeit passend 
generieren zu können)

[Armin J. (arminj)]

Für einen 1 Mhz Attiny hatte ich auch mal das Problem mit der 
Debuggausgabe und hab dann Peters Idee aufgegriffen und bin erfolgreich 
bis 38400 Baud gekommen.
Der komplette Code ist auf Github 
https://github.com/ArminJo/AttinySendSerial_1Mhz_38400Bd

/*
 * Only multiple of 4 cycles are possible. Last loop is only 3 cycles.
 * 3 -> 11 cycles
 * 4 -> 15 cycles
 */
inline void delay4MicrosecondsInlineExact(uint16_t a4Microseconds) {
    // the following loop takes 4 cycles (4 microseconds  at 1MHz) per iteration
    __asm__ __volatile__ (
            "1: sbiw %0,1" "\n\t"    // 2 cycles
            "brne .-4" : "=w" (a4Microseconds) : "0" (a4Microseconds)// 2 cycles
    );
}

/*
 * 26 cycles per bit, 260 per byte for 38400 baud
 * 24 cycles between each cbi or sbi command
 */
void write1Start8Data1StopNoParity(uint8_t aChar) {
    // start bit
    PORTB &= ~(1 << TX_PIN);
    _NOP();
    delay4MicrosecondsInlineExact(4);

    // 8 data bits
    uint8_t i = 8;
    do {
        if (aChar & 0x01) {
            // bit=1
            // to compensate for jump at data=0
            _NOP();
            PORTB |= 1 << TX_PIN;
        } else {
            // bit=0
            PORTB &= ~(1 << TX_PIN);
            // compensate for different cycles of sbrs
            _NOP();
            _NOP();
        }
        aChar = aChar >> 1;
        // 3 cycles padding
        _NOP();
        _NOP();
        _NOP();
        delay4MicrosecondsInlineExact(3);
        --i;
    } while (i > 0);

    // to compensate for missing loop cycles at last bit
    _NOP();
    _NOP();
    _NOP();
    _NOP();

    // Stop bit
    PORTB |= 1 << TX_PIN;
    // -8 cycles to compensate for fastest repeated call (1 ret + 1 load + 1 call)
    delay4MicrosecondsInlineExact(4); // gives minimum 25 cycles for stop bit :-)
}

[Stefan F. (Gast)]

>> USI ist jedenfalls ein ziemlicher Krampf
> Ja, was sich Atmel dabei gedacht hat, ist mir ein Rätsel. Es ist
> wirklich zu nichts nütze.

Ich habe damit mal eine I2C Slave implementiert und dabei soviel Frust, 
dass ich beinahe auf eine reine Softwarelösung umgestiegen wäre.

[Stefan F. (Gast)]

Ich habe auch noch eine Variante, um die bereits üppige Sammlung zu 
erweitern :-)

// Required setting, usually in the Makefile:
// #define F_CPU 1200000

#define SOFTSERIAL_BITRATE    2400
#define SOFTSERIAL_TXD_INIT   { DDRB  |= (1<<PB3);  }
#define SOFTSERIAL_TXD_HIGH   { PORTB |= (1<<PB3);  }
#define SOFTSERIAL_TXD_LOW    { PORTB &= ~(1<<PB3); }

// Files for input and output through serial port.
static int serial_write(char, FILE *);
static FILE serialPort = FDEV_SETUP_STREAM(serial_write, 0, _FDEV_SETUP_WRITE);

// Calculate the time per bit minus 5 CPU cycles
#define US_PER_BIT 1000000/SOFTSERIAL_BITRATE-5/F_CPU

#if F_CPU/SOFTSERIAL_BITRATE<100
    #warning SOFTSERIAL_BITRATE is to high for this CPU clock frequency
#endif

// Initialize the serial port
void initSerialConsole(void) 
{
    SOFTSERIAL_TXD_INIT;
    SOFTSERIAL_TXD_HIGH;
    // Bind stdout to the serial port
    stdout = &serialPort;
}


// Write a character to the serial port
static int serial_write(char c, FILE *f) 
{
    cli();
    // Send start bit
    SOFTSERIAL_TXD_LOW;
    _delay_us(US_PER_BIT);
    // Send 8 data bits
    for (uint8_t i=0; i<8; i++) 
    {
        if (c & 1)
        {
            SOFTSERIAL_TXD_HIGH;
        }
        else
        {
            SOFTSERIAL_TXD_LOW;
        }
        _delay_us(US_PER_BIT);
        c=c>>1;
    }
    SOFTSERIAL_TXD_HIGH;  
    sei();
    _delay_us(2*US_PER_BIT);
    return 0;
}

Du musst zuerst initSerialConsole() aufrufen. Danach kannst du mit den 
Funktionen der Standard C Library Texte senden, zum Beispiel puts() und 
printf().

[Stefan F. (Gast)]

@Verwirrter Anfänger:

  UART_SEND_HIGH();
  while(i){
    if(c & 1){
      UART_SEND_LOW();
    } else {
      UART_SEND_HIGH();
    }

Kann es sein, das du High/Low vertauscht hast?

[Stefan F. (Gast)]

> Per Bitbanging gehts evtl bis 9600.

Da geht locker flockig noch viel mehr. Senden ist einfach.

[Jörg E. (jackfritt)]

@Stefan
Sieht man ja im Code danach in meinen Kommentaren.
Hatte ich mal mit rumprobiert.
Aber jeder Tiny ohne Quarz war halt ab 57600 anders bzw. "fehlerhafter"

Is halt die Frage ob ich für Debugging so schnell sein muss, wenns mal 
nen Variable is.