Weiterleitung von Daten

[Sabine F. (Gast)]

Hallo,

habe eine Hardware - UART Schnittstelle und möchte nun die Empfangen 
Daten dieser Schnittstelle über die Software - UART Schnittstelle 
weiterleiten (sprich senden).

Ich kann Daten empfangen und senden, aber alles nur getrennt. Wie muss 
ich vorgehen, damit ich die empfangenen Daten weiter senden kann?

[Tom M. (Gast)]

Sabine F. schrieb:
> Ich kann Daten empfangen und senden, aber alles nur getrennt.

Was meinst du mit "getrennt"?

> Wie muss
> ich vorgehen, damit ich die empfangenen Daten weiter senden kann?

Ich würde am ehesten:

- eine Timer gesteuerte Senderoutine verwenden für die SW UART, die 
einfach Daten aus einem Sendepuffer rausschiebt
- den "UART RX Complete Interrupt" (sofern vorhanden) nutzen, um Daten 
in den Sendepuffer zu übergeben

Oder wenn's einfach werden soll:

- eine andere MCU derselben Familie nehmen, die 2 Hardware UARTs besitzt 
:D

[Sabine F. (Gast)]

Tom M. schrieb:
> Was meinst du mit "getrennt"?

Ich kann sowohl Zeichen empfangen, welche ich über den Terminal an den 
Mikrocontroller sende, als wie auch Zeichen an den Terminal senden.

Daten werden im Terminal eingegeben und werden an den µC gesendet, 
dieser sollte sie danach weiterschicken an einen anderen Terminal.

Das Emfangen geschieht ohne Interrupts über die Hardware - UART, das 
Senden über die Software - UART mit Interrupt.
Funktioniert die Kombination von mit und ohne Interrupt?

[Noname (Gast)]

Hi Sabiner,

das sollte eigentlich ohne Probleme gehen. Der Teufel wird wie immer im 
Detail stecken. Etwa unterschiedliche Baudraten ohne Puffer etc.
Beschreibe mal ausführlich was Du geschrieben hast und poste den 
Quellcode.

[Tom M. (Gast)]

Sabine F. schrieb:
> Das Emfangen geschieht ohne Interrupts über die Hardware - UART,
> das Senden über die Software - UART mit Interrupt.

Klingt gut, sollte funzen. Wo hakt's noch?

[Sabine F. (Gast)]

#include <avr/io.h>
#include "main.h"
#include "suart.h"
#include <avr/power.h>

int i;
char satz[2000];

int main( void ) {
  uart_init();
  uartRx();
  clock_prescale_set(clock_div_1);
  suart_init();
  DDRB = 0x02;
  PORTB = 0x02;
 
  sei();
  for(i=0; satz[i] != 0; i++) {
    sputs(satz[i]);    
    }
    for (;;) {        // main loop
      sputchar( '-' );
      while (! kbhit());      // wait until byte received
      sputchar (sgetchar () + 1);    // sent byte + 1
    }
}

void uart_init(void) {
    UBRR0H = 0x00;
  UBRR0L = 0x17;    

 
    UCSR0B = (1<<TXEN0) | (1<<RXEN0);  // UART TX und RX einschalten
    UCSR0C = (1<<USBS0)|(1<<UCSZ01)|(1<<UCSZ00);  // Asynchron 8N2 
}

void uartRx() {
  satz[0] = 1;
  for(i=0; satz[i] != 0; i++) {
      while(!(UCSR0A & (1<<RXC0))) {
    }
    satz[i] = UDR0;                   
  }
}

Hier wird die Software UART initalisiert.

#include "main.h"
#include "suart.h"



#define BIT_TIME  (u8)((XTAL / BAUD) / PRESCALE)


volatile u8 stx_count;
u8 stx_data;

volatile u8 srx_done;
u8 srx_data;
u8 srx_mask;
u8 srx_tmp;


void suart_init( void )
{
  SBIT(PORTD,STX) = 1;
  // OCR0A = TCNT0 + 1;    // force first compare
  // TCCR0A = 0;        // Default: Normal port operation
  TCCR0B = 1 << CS01 | 1<<CS00;  // clk/64
  // TIFR0 = 1<<ICF1;      // clear pending interrupt
  TIMSK0 = 1 << OCIE0A;    // enable output compare interrupt

  EICRA = 1 << ISC01;      // falling edge
  EIMSK = 1 << INT0;      // enable edge interrupt

  stx_count = 0;        // nothing to sent
  srx_done = 0;            // nothing received
  STXDDR |= 1 << STX;      // TX output
}


u8 sgetchar (void)      // get byte
{
  while (!srx_done);      // wait until byte received
  srx_done = 0;
  return srx_data;
}


ISR (INT0_vect)    // rx start
{
  OCR0B = TCNT0 + (u8)((BIT_TIME * 3) / 2);// scan 1.5 bits after start

  srx_tmp = 0;        // clear bit storage
  srx_mask = 1;        // bit mask
  if( !(SRXPIN & 1<<SRX))  {  // still low
    EIMSK &= ~(1 << INT0);      // disable edge interrupt
    TIMSK0 = 1<<OCIE0A^1<<OCIE0B;  // wait for first bit
}
  TIFR0 = 1<<OCF0B;      // clear pending interrupt ? why does that output compare int occur?
EIFR |= (1 << INTF0);    // clear any pending edge interrupt
}


ISR (TIMER0_COMPB_vect)
{
  u8 in = SRXPIN;      // scan rx line
  // PORTB = 0x00;
  if (srx_mask) {
      if (in & 1 << SRX)
      srx_tmp |= srx_mask;
    srx_mask <<= 1;
    OCR0B += BIT_TIME;      // next bit slice
  } else {
    srx_done = 1;      // mark rx data valid
    srx_data = srx_tmp;      // store rx data
    // TIFR0 = 1<<ICF1;      // clear pending interrupt
    TIMSK0 = 1<<OCIE0A;        // enable tx and wait for start
    EIFR |= (1 << INTF0);    // clear any pending edge interrupt: This hinders the in0-vect from beeing triggerd again just now which may occur by falling edges in the serial data bits
    EIMSK = 1 << INT0;  // reenable edge interrupt
  }
    // PORTB = 0x02;
}


void sputchar (u8 val)      // send byte
{
  while (stx_count);      // until last byte finished
  stx_data = ~val;      // invert data for Stop bit generation
  stx_count = 10;      // 10 bits: Start + data + Stop
}


void sputs (u8 *txt)      // send string
{
  while (*txt)
    sputchar (*txt++);
}


ISR (TIMER0_COMPA_vect)    // tx bit
{
  u8 dout;
  u8 count;

  OCR0A += BIT_TIME;      // next bit slice
  count = stx_count;

  if (count) {
    stx_count = --count;    // count down
    // ??? dout = 1<<COM0A1;      // set low on next compare
    dout = 0;
    if (count != 9) {      // no start bit
      if (!(stx_data & 1))    // test inverted data
        //??? dout = 1<<COM0A1^1<<COM0A0;  // set high on next compare
        dout = 1;
          stx_data >>= 1;      // shift zero in from left
    }
    // TCCR0A = dout;
    // STX = (dout == 0) ? 1 : 0;
    SBIT(PORTD,STX) = dout;
  }
}

[Karl H. (kbuchegg)]

Am einfachsten ist es, wenn du das ganze Gedöns mit dem 'satz' wieder 
vergisst.
Kommt ein Zeichen an der Hardware UART an, schickst du es gleich wieder 
auf der Software UART weiter.

Dazu brauchst du dann eine Funktion, die auf 1 Zeichen an der Hardware 
UART wartet

uint8_t uartRx()
{
  while(!(UCSR0A & (1<<RXC0)))
  {
  }

  return UDR0;                   
}

eine Funktion, die ein einzelnes Zeichen auf der Software UART 
rausschickt hast du ja schon. Und in der Hauptschleife in main() ist der 
verbindende 'Kitt'

int main()
{
  ....


  for(;;) {        // main loop
    Zeichen = uartRxChar();
    sputchar( Zeichen );
  }
}

dann überlegst du noch, was von dem Zeugs, das jetzt überflüssig ist, du 
nicht brauchst, schmeisst es raus und bist fertig.

[Sabine F. (Gast)]

Tom M. schrieb:
> Klingt gut, sollte funzen. Wo hakt's noch?

Bei der Übertragung wird nur ein -o- übertragen, anstatt des textes.

[Noname (Gast)]

Sag mal was über die Baudraten, bitte.

[Tom M. (Gast)]

Sabine F. schrieb:
> Bei der Übertragung wird nur ein -o- übertragen, anstatt des textes.

Jo, was anderes tust du ja nicht in deiner main():

Sabine F. schrieb:

>     for(i=0; satz[i] != 0; i++) {
>       sputs(satz[i]);
>     }
>     for (;;) {        // main loop
>       sputchar( '-' );
>       while (! kbhit());      // wait until byte received
>       sputchar (sgetchar () + 1);    // sent byte + 1
>     }

[Max1989 (Gast)]

Danke für eure bisherigen Antworten!!

Kann noch immer keine Zeichenkette versenden :(, hat jemand eine Idee?

#include "main.h"
#include "suart.h"
#include <avr/power.h>

char satz[2000];
int i = 0;

int main( void ) {
  clock_prescale_set(clock_div_1);
  suart_init();

  sei();
  while(1) {
  uartRxChar();
  sputs(satz[i]);  
  }
  for (;;) {        // main loop
    sputchar( '-' );
    while (! kbhit());      // wait until byte received
    sputchar (sgetchar () + 1);    // sent byte + 1
  }
}

void uartRxChar() {
      satz[0] = 1;
  for(i=0; satz[i] != 0; i++) {
      while(!(UCSR0A & (1<<RXC0))) {
    }
    return satz[i] = UDR0;                   
  }
}

[Karl H. (kbuchegg)]

Max1989 schrieb:
> Danke für eure bisherigen Antworten!!
>
> Kann noch immer keine Zeichenkette versenden :(, hat jemand eine Idee?

Die Programmiersprache lernen.
Mit zusammenkopiertem unverstandenem Code hat noch keiner bei 0 
beginnend programmieren gelernt.

[Sabine F. (Gast)]

Warum funktioniert es nicht, wenn ich das empfangene Zeichen in ein Char 
- Array an Stelle i speichere und dann die Stelle i wieder ausgib?

[UART (Gast)]

Sabine,
Das wird so nichts.
Programmiere Dir erst mal eine UART library (oder nimm die eine vom 
Netz), bei der die empfangenen bzw. die zu sendenden Daten mittels 
Interrupt in eine Queue gespeichert werden.  Dann können die Daten aus 
der RxQueue bequem abgeholt, bearbeitet, und in die TxQueue geschoben 
werden.  Die Vermischung von UART Funktionalität und Bearbeitung in der 
Main loop führt ins Chaos.