Hyperterminal lääst LED's springen

[Anfänger (Gast)]

Guten Tag,

ich möchte gern vom HyperTerminal aus meine LED's am PORTC durch 
Eingaben wie "0b11101100" ansteuern. Jedoch werden die eingegebenen 
Muster nicht korrekt übertragen und schon allein durch Tippen der 
Leertaste springen die LED's wie wild herum. Das man solche Sachen 
irgendwie Filtern muss ist mir bewusst, nur worum es hier eigentlich 
geht ist, dass die Muster nich korrekt wiedergegeben werden.

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

#define F_CPU 16000000UL  // Systemtakt in Hz - Definition als unsigned long beachten
#define BAUD 9600UL      // Baudrate
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
#include "util/delay.h"

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

int uart_putc(unsigned char c)
{
  while(!(UCSR0A & (1<<UDRE0)))
  {
    
  }
  _delay_ms(100);
  UDR0= c;
}

void uart_puts (char *s)
{
  while (*s)
  {   
    
    uart_putc(*s);
    s++;
  }
}
  

int main(void)
{
  UBRR0H = UBRR_VAL >> 8;
  UBRR0L = UBRR_VAL & 0xFF;

  UCSR0C=(0<<UMSEL0)|(1<<UCSZ00)|(1<<UCSZ01); //Asynchroner Mode, 8-bit
  UCSR0B= (1<<TXEN0)|(1<<RXEN0);              //Transmitter einschalten
  
  uart_puts("Bereit zum Empfangen von Daten""\n");

  while(1)
  {
    
  

        if ( (UCSR0A & (1<<RXC0)) )
        {
          uint8_t c;
          c = uart_getc();
          DDRC = 0xFF; 
          PORTC = c;
      _delay_ms(200);
        }
        else
        {

        }

  }
}

Meine Einstellungen im HyperTerminal: BAUD 9600, 8-bit, keine Parität, 1 
Stoppbit, keine Flusssteuerung. Mein Prozessor ist ein ATmega8 und das 
Senden von Daten an den PC funktioniert einwandfrei.

Vielen Dank schonmal!

[Rufus Τ. F. (rufus)]

Naja, Du wertest diese Nummer, die Du Dir da vorstellst, auch in keiner 
Weise aus, sondern Du gibst jedes empfangene Zeichen direkt an Deinen 
Port C aus:

          c = uart_getc();
          DDRC = 0xFF; 
          PORTC = c;

Das Muster, das Du dann mit Deinen LEDs angezeigt bekommst, entspricht 
dem von Dir getippten Zeichen.

Wenn Du die Leertaste drückst, ist das 0x20, bzw. 0010 0000
Bei einer 0 ist das 0x30, bzw. 0011 0000

Und bei einem 'b' ist das 0x62, bzw. 0110 0010

Übrigens ist es nicht nötig, für jedes empfangene Zeichen DDRC erneut zu 
setzen, das genügt genau einmal am Anfang.

[Karl H. (kbuchegg)]

Anfänger schrieb:
> Guten Tag,
>
> ich möchte gern vom HyperTerminal aus meine LED's am PORTC durch
> Eingaben wie "0b11101100" ansteuern.

?

Willst du tatsächlich 0b11101100 eingeben. Also
Die Taste '0' drücken.
Die Taste 'b' drücken.
Die Taste '1' drücken.
etc. etc.


Wenn ja, dann erzeugst du auf die Art erst mal einen String. Eine 
Abfolge der Zeichen '0', 'b', '1', '1' ....

Die musst du natürlich auch so auf dem AVR empfangen, wieder zu einer 
Zahl zusammensetzen und erst dann kannst du damit auf den Port gehen.

> Jedoch werden die eingegebenen
> Muster nicht korrekt übertragen

Wenn deine UART funktioniert, werden die schon korrekt übertragen. Das 
Problem ist nur, dass dir nicht wirklich klar ist, was da eigentlich 
übertragen wird.

> und schon allein durch Tippen der
> Leertaste springen die LED's wie wild herum.

Logisch. Die Leertaste hat den ASCII Code 0x20. In Binärer SChreibweise 
ist das 0b00100000

Jedes Zeichen hat einen bestimmten ASCII Code. Wenn du das empfangene 
Byte einfach auf den Port gibst

          c = uart_getc();
          PORTC = c;

dann zeigen dir die LED genau diesen Code des gerade empfangenen 
Zeichens an.

Siehe ASCII Tabelle

Auf einer UART werden komplette Bytes übertragen. Keine einzelnen 
Bits(*). Jedes Zeichen, jede Taste, hat einen bestimmten Bytewert je 
nach Code-Tabelle, die heutzutage meistens die ASCII Tabelle ist.


Edit:
(*) Natürlich werden da einzelne Bits übertragen. Schliesslich besteht 1 
Byte ja aus 8 Bits. Gemeint ist, dass du beim Sender nicht einfach nur 1 
Bit auf den Weg schickst, sondern dass da immer 1 Byte rausgeht.