EA eDIPTFT43-ATP per RS-232 an Atmega32

[shibbyx (Gast)]

Hallo ich habe ein EA eDIPTFT43-ATP Display der Firma Electronic 
Assambly
Ich möchte jetzt daten über RS-232 zu einem ATMEGA32 senden bzw. 
empfangen
gibt es vll ein Tutorial oder ähnliches dafür ?

[spess53 (Gast)]

Hi

>gibt es vll ein Tutorial oder ähnliches dafür ?

Datenblatt. An deiner Stelle würde ich erst mal einen RS232-Wandler 
(DAtenblatt S.23) dranhängen und die ersten Versuche vom PC aus machen.

MfG Spess

[Ralf (Gast)]

Geht ohne probleme direkt am µC.
Einfach TX -> RX und RX -> TX verbinden und Befehle mit der Uart senden.

Wichtig gleiche Bautrate einstellen.

[spess53 (Gast)]

Hi

>Geht ohne probleme direkt am µC.
>Einfach TX -> RX und RX -> TX verbinden und Befehle mit der Uart senden.

Das weiss ich. Ich schrieb aber PC . Mir ging es darum, das er die 
ersten Ansteuerversuche mit dem PC macht. Und wenn er es verstanden hat 
mit dem ATMega weiter macht.

MfG Spess

[Adrian B. (Firma: FHL) (shibbyx)]

für den PC hab ich das USB-Board.
Im Datenblatt steht als sende Beispiel:

voidSendData (unsingned char *buf, unsigned char len)
{
 unsigned char i, bcc;

 Sendbyte(0x11);                      //Send DC1
 bcc = 0x11;

 SendByte(len);                     // Send data length
 bcc = bcc + len;

 for(i=0; i < len; i++)             //Send buf
 { SendByte (buf[i]);
   bcc= bcc + buf[i];
  }

 Sendbyte (bcc);                  //Send checksum
}

Das hilft mir irgendwie nich ganz

len = ist die Datenlänge ?
bcc = ist die Prüfsumme?

was ist DC1?
Wo sind die eigentlichen Datenbytes?

[Adrian B. (Firma: FHL) (shibbyx)]

kann mir keiner weiterhelfen?

[juppi (Gast)]

Hallo
Nimm ein beliebiges Terminalprogramm und sende im ASCii Format,ohne 
Small Protokoll.

MfG

[shibbyx (Gast)]

hmmm ich möchte vom atmega ja keine ascii zeichen haben sondern bytes, 
denn die oberfläche soll auf dem controller vom tft laufen. vom atmega 
möchte ich nur infos bzw infos zum atmega senden

[juppi (Gast)]

natürlich , aber es kann damit alles einfach erst einmal getestet 
werden!

[Juppi J. (juppiii)]

vielleicht hilft das ,hatte mal einen primitiven Simulator gemacht.
Ist schon länger her,aber über die Grundversuche nicht herausgekommen.

Gruß

[shibbyx (Gast)]

juppi schrieb:
> natürlich , aber es kann damit alles einfach erst einmal getestet
> werden!

da hast du natürlich recht vll. wird mir dann einiges klarer

[shibbyx (Gast)]

ist es überhaupt möglich ein programm über usb zu schreiben und
zusätlich daten über die rs-232 schnittstelle zu empfangen?

[Juppi J. (juppiii)]

Hallo
Ich spreche das Teil über COM oder USB to Seriell Adapter an.
Mit meinem Primitivprogramm kann ich Strichgrafiken zeichnen und Buttons
Positionieren.
Befehle testen und senden.
Kleine Versuche speichern.
Für meine Zwecke reicht es.
Ich glaube nicht das du USB Ansteuerung und RS232 gleichzeitig nutzen 
kannst.
USB  ist in diesem Falle auch nur ein USB to seriell Adapter,..oder
MfG

[shibbyx (Gast)]

naja ich will es ja nur über usb programmieren und dann über rs232 daten 
empfangen. also wenn das programm einmal auf das ding geladen ist soll 
nur noch die rs232 angebunden sein

[Juppi J. (juppiii)]

Beim Testen nutze ich einen TxD/RxD  Umschalter.
Willst du den Controller mit dem TFT direkt Verbinden,ohne Max232?

[spess53 (Gast)]

Hi

>Willst du den Controller mit dem TFT direkt Verbinden,ohne Max232?

Wie sonst?

Datenblatt:

'Die Leitungen RxD und TxD führen 5V CMOS-Pegel zur direkten Anbindung 
an
z.B. einen Mikrokontoller.'

MfG Spess

[Juppi J. (juppiii)]

spess53 schrieb:
>>Willst du den Controller mit dem TFT direkt Verbinden,ohne Max232?
>
>
>
> Wie sonst?

Bei mir ist das zu steuernte Gerät einige Meter entfernt.
..ob dann noch der 5V Pegel sicher ist?

MfG

[shibbyx (Gast)]

Ich komme einfach nicht weiter, es passiert nix hier mal code:

#include <avr/io.h>           
#include <stdint.h>     
#include <stdio.h> 
#include <util/delay.h> 
      
 
void USART_init(void)    // Manual S. 148
  {
  

#ifndef F_CPU

#define F_CPU 4000000UL  // Systemtakt in Hz - Definition als unsigned long beachten 
                         // Ohne ergeben sich unten Fehler in der Berechnung
#endif
 
#define BAUD 115200UL      // Baudrate
 
// Berechnungen
#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))
  
#endif 
 
void uart_init(void)
{
  UCSRB = (1<<RXEN) | (1<<TXEN);  // UART TX einschalten
  UCSRC |= (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1 
 
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
}
  /* enable Receiver und Transmitter:  */
  UCSRB = (1<<RXEN) | (1<<TXEN);
  // set frame format: 8 Dat - 2 Stopbits  
  UCSRC = (1<<URSEL) | (1<<USBS) | (1<<UCSZ1) | (1<<UCSZ0); 
  }


void USART_transmit (unsigned char data ) // Senden 
  {
  /* warte auf leeren Transmit-Puffer */
  while (! (UCSRA & (1<<UDRE)))        // wartet ewig?
  ;
  /* put date in the buffer, send the data */
  UDR = data;
  return;
  }

  
int main(void)
  {
  unsigned char data = 0x11;
   USART_init();
  USART_transmit(data);

  data = 0x01;
  USART_transmit(data);
  
  data = 'a';
  USART_transmit(data);
  

  return 0; 
  }

[spess53 (Gast)]

Hi

>#define F_CPU 4000000UL
>#define BAUD 115200UL

Gibt einen Baudrate-Fehler von über 8% !

MfG Spess

[shibbyx (Gast)]

jetzt mit 9600 baud

#include <avr/io.h>           
#include <stdint.h>     
#include <stdio.h> 
#include <util/delay.h> 
      
 
void USART_init(void)    // Manual S. 148
  {

#ifndef F_CPU
/* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann
   F_CPU im Makefile definiert werden, eine nochmalige Definition
   hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch
   #ifndef/#endif 
 
   Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio 
   verwendet wird und dort eine andere, nicht zur Hardware passende 
   Taktrate eingestellt ist: Dann wird die folgende Definition 
   nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?) 
   von AVRStudio - daher Ausgabe einer Warnung falls F_CPU
   noch nicht definiert: */
#warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 8000000"
#define F_CPU 4000000UL  // Systemtakt in Hz - Definition als unsigned long beachten 
                         // Ohne ergeben sich unten Fehler in der Berechnung
#endif
 
#define BAUD 9600UL      // Baudrate
 
// Berechnungen
#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))
  
#endif 




/* UART-Init Bsp. ATmega16 */
 
void uart_init(void)
{
  UCSRB = (1<<RXEN) | (1<<TXEN);  // UART TX einschalten
  UCSRC |= (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1 
 
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
}
  /* enable Receiver und Transmitter:  */
  UCSRB = (1<<RXEN) | (1<<TXEN);
  // set frame format: 8 Dat - 2 Stopbits  (wie N u. nur 1 Stopbit?
  UCSRC = (1<<URSEL) | (1<<USBS) | (1<<UCSZ1) | (1<<UCSZ0); 
  }


void USART_transmit (unsigned char data ) // Senden (Manual S. 149)
  {
  /* warte auf leeren Transmit-Puffer */
  while (! (UCSRA & (1<<UDRE)))        // wartet ewig?
  ;
  /* put date in the buffer, send the data */
  UDR = data;
  return;
  }

  
int main(unsigned char *buf, unsigned char len)
  {
   unsigned char data, i, bcc;
  data= 0x11;
  bcc= 0x11;
  USART_init();
  USART_transmit(data);

  data = 0x04;
  bcc=bcc+data;
  USART_transmit(data);
  
  data = '#';
  USART_transmit(data);
  
  
  data = 'Z';
  USART_transmit(data);
  

  data = 'T';
  USART_transmit(data);
  
  data = 'a';
  USART_transmit(data);

  for(i=0; i < len; i++) // Send buf
{ data=(buf[i]);
  USART_transmit(data);

bcc= bcc + buf[i];

}
  
data = bcc;
USART_transmit(data);
  
  return 0; 
  }

[spess53 (Gast)]

Hi

Und was soll das bewirken? Die #-Befehle werden übrigens ohne das 
DC-Gedödel gesendet.

MfG Spess

[shibbyx (Gast)]

momentan möchte ich einfach nur ne zeichenkette aufm terminal ausgeben 
das wäre schomal etwas

[Info (Gast)]

Schick dir erst an den PC, um deine AVR Routinen zu testen.
Schick vom PC an das EDIP
Als letztes dann AVR-EDIP..

[Daniel B. (dbuergin)]

Hallo

Ich weiss nicht genau, wo die Unterschiede zu meinem eDIPTFT43-A liegen,
aber Du kannst es sonst mal mit meinem Code versuchen.

ACHTUNG: Die Library ist für einen Luminary Cortex-M3 und benutzt deren 
Library. Du musst alle UART... Befehle und die Include Statements auf 
den ATmega anpassen. Mein Display läuft am UART1 des Cortex-M3 mit 
115200 Baud.

Nun hast zu zwei Varianten, entweder Du arbeitest im sog. Terminalmode
d.h. Du schreibst deinen Output einfach mit ediptft43_puts() an das
Display. Oder Du verwendest die Grafikbefehle und plazierst deinen
Text irgendwo auf dem Display.

main():

.... UART initialisieren....
ediptft43_puts("Entering Main-Loop....\r\n");
ediptft43_puts("Initializing UDP-get....\r\n");
....

oder über die Grafikbefehle:

.... UART initialisieren....
ediptft43_fontsel(4);
ediptft43_fontzoom(2,2);
ediptft43_fontcolor(6,0);
ediptft43_printxy(240,1,'C', "Text1");
ediptft43_fontcolor(8,0);
ediptft43_printxy(1,50,'L', "Text2:      Text3");
.....

Die Library ist noch sehr jung und unausgetestet. Sporadisch ändert sich 
der Font oder die Grösse, aber das liegt ev. am Rest meines Programs und 
nicht der Library ;-)

Daniel

[juppi (Gast)]

Beitrag "Re: EA eDIPTFT43-ATP per RS-232 an Atmega32"

Mache das!

[shibbyx (Gast)]

irgendwie bringt mich das auch nicht weiter....

[shibbyx (Gast)]

Hier nochmal der Code
das Display befindet sich im Terminal Mode mit einer Baudrate von 115200 
und das small Protokoll ist deaktiviert.
Ich möchte nur ein a Ausgeben.

#include <avr/io.h>           
#include <stdint.h>     
#include <stdio.h> 
#include <util/delay.h> 
      
 
void USART_init(void)   
  {
  

#ifndef F_CPU
/* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann
   F_CPU im Makefile definiert werden, eine nochmalige Definition
   hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch
   #ifndef/#endif 
 
   Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio 
   verwendet wird und dort eine andere, nicht zur Hardware passende 
   Taktrate eingestellt ist: Dann wird die folgende Definition 
   nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?) 
   von AVRStudio - daher Ausgabe einer Warnung falls F_CPU
   noch nicht definiert: */

#define F_CPU 4000000UL  // Systemtakt in Hz - Definition als unsigned long beachten 
                         // Ohne ergeben sich unten Fehler in der Berechnung
#endif
 
#define BAUD 115200L      // Baudrate
 
// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate




/* UART-Init Bsp. ATmega16 */
 
void uart_init(void)
{
  UCSRB = (1<<RXEN) | (1<<TXEN);  // UART TX einschalten
  UCSRC |= (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1 
 
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
}
  /* enable Receiver und Transmitter:  */
  UCSRB = (1<<RXEN) | (1<<TXEN);
  // set frame format: 8 Dat - 2 Stopbits  (wie N u. nur 1 Stopbit?
  UCSRC = (1<<URSEL) | (1<<USBS) | (1<<UCSZ1) | (1<<UCSZ0); 
  }


  
int main(unsigned char *buf, unsigned char len)
  {
   unsigned char data, i, bcc;

  USART_init();
  data = '#';
  USART_transmit(data);
  
  
  data = 'Z';
  USART_transmit(data);
  

  data = 'T';
  USART_transmit(data);
  
  data = 'a';
  USART_transmit(data);


}

void USART_transmit (unsigned char data ) // Senden (Manual S. 149)
  {
  /* warte auf leeren Transmit-Puffer */
//  while (! (UCSRA & (1<<UDRE)))       // wartet ewig?
  ;
  /* put date in the buffer, send the data */
  UDR = data;
  return;
  }

[Daniel B. (dbuergin)]

Du scheinst ziemlich renitent gegenüber jedwelchen Vorschlägen zu sein.

Hast Du Deine Schaltung (wie sieht die eigentlich aus ?) über einen 
Pegelwandler (max232 o.ä) auf die serielle Schnittstelle gehängt, und 
über ein Terminalprogram kontrolliert, ob der Code läuft ?

Beim Code bin ich auch nicht so sicher. Verschachtelte Funktionen 
( uart_init() innerhalb von USAR_init() ) finde ich nicht sehr 
übersichtlich. Bin nicht der C-Crack, aber mir ist das suspekt.

Habe mal mein Display an einen ATMega128 gehängt.
Einen ATMega32 habe ich nicht. Die Ports 17 und 8 am Display auf GND. 
Damit läuft das Ding mit 9600 Baud und ohne SmallProtocol. Mit 115200 
ist es auch bei mir nicht gelaufen, mein 16Mhz erzeugt dabei wohl zuviel 
Abweichung.

Für die UART Schnittstelle gibts die Library von Peter Fleury. Wenn das 
Ding mal läuft, kannst Du dir die Schnittstellenkonfiguration immer noch
rauspullen, und ohne die Library arbeiten.

Nach dem flashen erscheint bei mir auf dem Display:

EA eDIPTFT43-A V1.1 Rev.E TP+
a

Habe Dir die main.c und das Makefile für einen ATMega32 angepasst. 
Sollte so laufen.

// Includes 

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

#define F_CPU 16000000L
#include <util/delay.h>

#include "uart.h" 

// Serielle Schnittstelle

#define UART1_BAUD 9600

int main(void)
{
  // Init UART1 with 9600 for Input 

  uart_init( UART_BAUD_SELECT(UART1_BAUD, F_CPU));

  // enable interrupts 

  sei();
  _delay_ms(1000);

  // Den Versionstring ausgeben
  uart_putc('#');
  uart_putc('T');
  uart_putc('V');

  // Linefeed und Carriagereturn
  uart_putc(0xa);
  uart_putc(0xd);

  // Den Buchstaben a
  uart_putc('#');
  uart_putc('Z');
  uart_putc('T');
  uart_putc('a');

  while(1)
  {
  }
}

Daniel

[Daniel B. (dbuergin)]

Und hier noch der code.....

[Daniel B. (dbuergin)]

F_CPU musst Du natürlich auch noch anpassen im main.c

[shibbyx (Gast)]

Danke!

ich habe das problem mit das ich garnix versende habe dein programm mit 
baud 9600 jetzt so übernommen und das stk500 board an die com 
schnitstelle gehängt um per hyperterminal zu gucken ob ich was versende 
doch leider bekomme ich nix.

mach ich da schonwieder etwas falsch?

das sende vom hyperterminal zum display funktioniert aber schonmal.

[shibbyx (Gast)]

Also Ich hab ja einen Atmega8 mit 4Mhz
Die Baudrate ist auf 9600
Dann ist am RS232 Spare vom Stk500 ein RS232 auf USB adapter dran und 
über Hyperterminal ruf ich den (com3) auf.

nun sollte er mir das doch eigentlich auf dem Bildschirm auswerfen oder 
nicht?

// Includes 



#include <avr/io.h>

#include <avr/interrupt.h>



#define F_CPU 4000000L

#include <util/delay.h>



#include "uart.h" 



// Serielle Schnittstelle



#define UART1_BAUD 9600



int main(void)

{

  // Init UART1 with 9600 for Input 



  uart_init( UART_BAUD_SELECT(UART1_BAUD, F_CPU));



  // enable interrupts 



 sei();

  _delay_ms(1000);



  // Den Versionstring ausgeben

  uart_putc('#');

  uart_putc('T');

  uart_putc('V');



  // Linefeed und Carriagereturn

  uart_putc(0xa);

  uart_putc(0xd);



  // Den Buchstaben a

  uart_putc('#');

  uart_putc('Z');

  uart_putc('T');

  
  uart_putc('b');



  while(1)

  {

  }

}

[spess53 (Gast)]

Hi

>Also Ich hab ja einen Atmega8 mit 4Mhz

Hoffentlich mit einem Quarz.

>Dann ist am RS232 Spare vom Stk500 ein RS232 auf USB adapter dran und
>über Hyperterminal ruf ich den (com3) auf.

Und Spare auch am Controller (PD0/PD1) angeschlossen?

MfG Spess

[shibbyx (Gast)]

oder benötige ich einen MAX232?

[shibbyx (Gast)]

spess53 schrieb:
> Hi
>
>>Also Ich hab ja einen Atmega8 mit 4Mhz
>
> Hoffentlich mit einem Quarz.
>
ja


>>Dann ist am RS232 Spare vom Stk500 ein RS232 auf USB adapter dran und
>>über Hyperterminal ruf ich den (com3) auf.
>
> Und Spare auch am Controller (PD0/PD1) angeschlossen?
>
ja

[Daniel B. (dbuergin)]

Meiner Meinung nach solltest Du auf STK500 alles haben was Du brauchst.

Siehe:

http://www.mikrocontroller.net/attachment/42741/STK500-HW-Beschreibung.pdf

Seite 13. So solltest Du die Verbindung von deinem Processor auf die
RS232 Schnittstelle auf dem STK500 aufsetzen.

[shibbyx (Gast)]

So da bin ich wieder...
es funktioniert die Verbindung von STK500 zu PC (Hyperterminal)

und es funktioniert die verbindung von PC (Hyperterminal) zum Display

ich bekomme auf dem hyperterminal momentan #TV (Linefeed und 
Carriagereturn) a angezeit

und wenn ich das so vom pc zum display sende zeigt er mir das die 
displayversion (Linefeed und Carriagereturn) und ein a an.

nur wenn ich das display an den RS232 Spare vom STK500 hänge bekomme ich 
irgendwelche kryptischen zeichen.

es funzt sowohl der code von Daniel B. (danke nochmal) als auch der 
hier:

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

#ifndef F_CPU
/* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann
   F_CPU im Makefile definiert werden, eine nochmalige Definition
   hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch
   #ifndef/#endif 
 
   Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio 
   verwendet wird und dort eine andere, nicht zur Hardware passende 
   Taktrate eingestellt ist: Dann wird die folgende Definition 
   nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?) 
   von AVRStudio - daher Ausgabe einer Warnung falls F_CPU
   noch nicht definiert: */
#warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 8000000"
#define F_CPU 4000000UL  // Systemtakt in Hz - Definition als unsigned long beachten 
                         // Ohne ergeben sich unten Fehler in der Berechnung
#endif
 
#define BAUD 2400UL      // Baudrate
 
// Berechnungen
#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))
  
#endif 

void uart_init(void);
void USART_transmit (unsigned char data );

/* UART-Init Bsp. ATmega16 */
 
void uart_init(void)
{
  UCSRB = (1<<RXEN) | (1<<TXEN);  // UART TX einschalten
  UCSRC |= (1<<URSEL)|(1<<USBS) | (1<<UCSZ1) | (1<<UCSZ0);  // Asynchron 8N1 
 
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
}
  /* enable Receiver und Transmitter:  */
 // UCSRB = (1<<RXEN) | (1<<TXEN);
  // set frame format: 8 Dat - 2 Stopbits  (wie N u. nur 1 Stopbit?
  //UCSRC = (1<<URSEL) | (1<<USBS) | (1<<UCSZ1) | (1<<UCSZ0); 
 // }
  
int main(void)
{
  unsigned char data;
  int i=0;

  if(i<5)
  {
    //  data= 0x11;
    //  bcc= 0x11;
    uart_init();
    //  USART_transmit(data);

    //  data = 0x04;
    //  bcc=bcc+data;
    //  USART_transmit(data);


     data = '#';
    USART_transmit(data);

    data = 'T';
    USART_transmit(data);


    data = 'V';
    USART_transmit(data);

  
    data = 0xa;
    USART_transmit(data);

    data = 0xa;
    USART_transmit(data);  

    data = 'a';
    USART_transmit(data);

    i++;
  }
  //  for(i=0; i < len; i++) // Send buf
  //  { data=(buf[i]);
  //  USART_transmit(data);

  //  bcc= bcc + buf[i];

}

//  data = bcc;
//  USART_transmit(data);

//  return 0; 
//  }


void USART_transmit (unsigned char data ) // Senden (Manual S. 149)
  {
  /* warte auf leeren Transmit-Puffer */
     while (! (UCSRA & (1<<UDRE)));    // wartet ewig?
  
  /* put date in the buffer, send the data */
  UDR = data;
  return;
  }

[spess53 (Gast)]

Hi

>nur wenn ich das display an den RS232 Spare vom STK500 hänge bekomme ich
>irgendwelche kryptischen zeichen.

Das Display will TTL-Pegel keine RS232-Pegel!

MfG Spess

[shibbyx (Gast)]

aber wenn ich von pc über rs232 sende geht es ja.
liefert der denn nen TTL pegel?

ich habe das display auch direkt an rxd txd vom atmega angeschlossen, 
das ging auch nicht.

[Juppi J. (juppiii)]

shibbyx schrieb:
> aber wenn ich von pc über rs232 sende geht es ja.
>
> liefert der denn nen TTL pegel?

Hast du einen usb to ser. Wandler am PC.
Viele liefern 0/5 V.

>ich habe das display auch direkt an rxd txd vom atmega angeschlossen,
>das ging auch nicht.

Das sollte aber gehen,wenn du Rx nicht auf Rx und Tx nicht auf Tx 
geschaltet hast.(5V Pegel)

[shibbyx (Gast)]

Juppi J. schrieb:
> shibbyx schrieb:
>> aber wenn ich von pc über rs232 sende geht es ja.
>>
>> liefert der denn nen TTL pegel?
>
> Hast du einen usb to ser. Wandler am PC.
> Viele liefern 0/5 V.

ja ich hab nen usb zu rs232 wandler dran


>>ich habe das display auch direkt an rxd txd vom atmega angeschlossen,
>>das ging auch nicht.
>
> Das sollte aber gehen,wenn du Rx nicht auf Rx und Tx nicht auf Tx
> geschaltet hast.(5V Pegel)

ne rx is auf tx und tx auf rx

[Daniel B. (dbuergin)]

Und die Addressleitungen am Display hast Du entsprechend der Baudrate
auf GND gezogen ?

Für 2400 wären das dann Pin 7 und 8 auf GND, Pin 6 frei lassen, hat ja 
internen Pullup und ist damit High.

[shibbyx (Gast)]

ja

pin 1 GND
pin 2 5V
pin 7 GND
pin 8 GND
pin 10 an TXD
pin 11 an RXD
pin 17 GND

wenn ichs mit hyperterminal anspreche gehts ja komischerweise auch

[Juppi J. (juppiii)]

also...

PC--Usb to seriell--->>>> rs232/seriell->EA-dip

PC/Terminal-->Usb to seriell------------->>>>rs232/seriell-> Ea-dip
ist das so?


Arbeite doch erst einmal ohne Small-Protokoll!

[shibbyx (Gast)]

genau so

ich hab doch pin 17 auf null dezogen also ist das small protokoll aus

[Juppi J. (juppiii)]

shibbyx schrieb:
> und es funktioniert die verbindung von PC (Hyperterminal) zum Display

sende mal Text ohne  #

vor dem Display ist doch der Max232?

[shibbyx (Gast)]

ja das hyperterminal-> display funzt!
wenn ich da einfach nur ein T eingebe zeigt er mir auch ein T an

Wenn ich vom STK500->Hyperterminal das T sende geht es auch

nur Wenn ich von STK500-> Display T sende bekomme ich mal ne 5 oder ein 
S (unregelmäßig)

[shibbyx (Gast)]

Baudraten die ich ausprobiert habe sind 2400, 4800 und 9600 bei allen 
das selbe problem

[shibbyx (Gast)]

hat keiner mehr eine idee was ich versuchen könnte bzw. wo der fehler 
steckt ?

ich verzweifel langsam !

[shibbyx (Gast)]

liefert der mikrocontroller über rxd txd eigentlich einen cmos pegel 
oder einen ttl pegel?

[Thomas (Gast)]

Hi
Der Mikrocontroller liefert über rxd txd TTL Pegel !!

Gruß Thomas