UART läuft unter FreePascal nicht (Kein OutPut)

[Vam L. (vam_l)]

Hallo liebe Gemeinschaft,

ich habe hier ein Älteres Programm, welches ich seit Jahren unter 
Code::Blocks verwende versucht in Lazarus umzuschreiben.

Soweit auch alles Klar, und wird auch alles ohne Fehler Compiliert.
hier mal das einfachste aller Programme UART-Programme inkl. 
selbstgeschriebender Header.

#ifndef SCHNITTSTELLEN_H
#define SCHNITTSTELLEN_H


#include <avr/io.h>
#include <stdbool.h>
#include <util/delay.h>


//#define TAKT            F_CPU                           // 8MHz Systemtakt
#define TAKT            8000000ul                       // 8MHz Systemtakt
#define UART_NO_DATA    0x0100
unsigned long UBAUD;

void uart(bool fast)                                    // doppelte Bautrate
{
//  UBAUD =  19200UL;                                       // Akuelle Übertragungsrate
  UBAUD =   9600UL;
  unsigned char x = 0x00;
  if (fast) {
    UBRRL = (TAKT / (8 * UBAUD)) - 1;                 // Baudrate mit TAKt und BAUD
    UBRRH = 0;
    UCSRA |= (1 << U2X);                                // U2X Doppelte Bautrate * 8
    }
  else {
    UBRRL = (TAKT / (16 * UBAUD)) - 1;                // Baudrate mit TAKt und BAUD
    UBRRH = 0;
    UCSRA |= (0 << U2X);                                // U2X eindache Bautrate * 16
    }
  UCSRB |= (1 << TXEN) | (1 << RXEN);                   // Sender und Empfänger ein
  UCSRC |= (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);  // async 8bit
  x = UDR;                                              // Empfänger leeren
  }

void putch(unsigned char x)                       // warten und Zeichen sende
{
  while (! (UCSRA & (1 << UDRE)));               // warten solange Sender besetzt
  UDR = x;                                       // Zeichen nach Sender
  }

unsigned char getch(bool echo)                   // zeichen vom USART holen
{
  while (!(UCSRA & (1 << RXC)));                 // Warten bis Zeichen da
  if (!echo)                                   // Zeichen mit oder Ohne echo holen
  {
    return UDR;                                  // Zeichen abholen
    }
  else
  {
    int x;                                       // Hilfsvariable
    x = UDR;                                     // abholen und sichern
    while (!(UCSRA & (1 << UDRE)));              // warte bis Sender frei
    UDR = x;                                     // Zeichen als echo zurück
    return x;                                    // Zeichen zurückgeben
    }
  }

unsigned char kbhit(void)
{
  if (UCSRA & (1 << RXC)) return UDR; else return 0;
}

void putstring(unsigned char *zeiger)             // SRAM_String ausgeben
{
    while (*zeiger)
      putch(*zeiger++);
}

unsigned char getstring(unsigned char *zeiger, unsigned SLAENG)
{
  unsigned anz = 0;
  while (1)
  {
    *zeiger = getch(false);
    if (*zeiger >= 0x20 && anz < SLAENG)
    {
      putch(*zeiger); anz++; zeiger++;           // Echo Zähler Zeiger erhöhen
    }                                            // Ende if
    else
    {
      if (*zeiger != '\b' || anz >= SLAENG)      // Ende der Eingabe
      {
        anz = *zeiger; *zeiger = 0; return anz;  // Abbruchszeichen
      }                                          // Ende if
      else
      if (*zeiger == '\b' && anz != 0)           // Korrektur mit Rücktaste
      {
        zeiger--; putch('\b'); putch(' '); putch('\b'); anz--;
      }                                          // Ende If
    }                                            // Ende else
  }                                              // Ende while
}                                                // Ende Funktion

#endif // SCHNITTSTELLEN_H  
---------------------------------------------------------------------------

int main(void)
{
    uart(false);
    _delay_ms(100);

    while(1)
      if (getch(true) == WakeUp)
      {
        putstring("Hallo Welt!");
        putch(0x13);
        putch(0x10);
      }
    return 0;
}

unter C läuft es alles OHNE Probleme, jedoch nach dem Umbau in Lazarus 
scheint der OutPut nicht richtig zu laufen.

unit uart;

{$mode objFPC}

interface

const
//  CPU_Clock   = 16000000; // µC Takt = 16MHz
  CPU_Clock   =  8000000; // µC Takt =  8MHz
  Baud        =     9600; // Baudrate

procedure UARTInit;                            // Inizialisieren
function  UARTReadChar: char;                  // Zeichen Empfangen
procedure UARTSendChar(value: char);           // Zeichen Senden
procedure UARTSendString(Value: shortString);  // String Senden;

implementation

procedure UARTInit;
begin
  UBRRH       := ((CPU_Clock div (16 * Baud)) - 1) shr 8;
  UBRRL       := byte((CPU_Clock div (16 * Baud)) - 1);
  UCSRA       := (0 shl U2X);
  UCSRB       := (1 shl TXEN) or (1 shl RXEN);
  UCSRC       := (1 shl URSEL) or (%011 shl UCSZ);
end;

function  UARTReadChar: char;
begin
  while UCSRA and (1 shl RXC) = 0 do begin     // Warte, bis Zeichen ankommt
  end;
  Result      := char(UDR);
end;

procedure UARTSendChar(value: char);
begin
  while UCSRA and (1 shl UDRE) = 0 do begin
  end;
  UDR         := byte(c);
end;

procedure UARTSendString(value: ShortString);
var
  i: Integer;
begin
  for i := 1 to length(value) do begin
    UARTSendChar(value[i]);
  end;
end;

end.

-------------------------------------------------------------------------------
program SerTest;

uses uart;

begin
  UARTInit;
  repeat
    if UARTReadChar = #32 then begin
      UARTSendString('Hello World!'#13#10);
      UARTSendString('Ich bin ein Test deiner UART'#13#10);
      end;
    until 1 = 2;
end.

Der C Code wurde erstell mit Code::Blocks IDE 17.12, der Pascal Code 
unter Lazarusfpcupdeluxe 2.0.10 und fpc 3.0.4. (Beides läuft auf einem 
Laptop mit RPI Desktop, bei dem µC handelt es sich um einen ATmega16 mit 
8MHz.)

Über einen Wink mit einem Ziegel, so der Fehler liegen könnte wäre ich 
durchaus dankbar.

Wünsche euch allen ein Entspanntes Weihnachtsfest.

[Stefan F. (Gast)]

Die Parameter zur Baudrate lässt man normalerweise von der avr libc 
berechnen. Auf die kann man sich verlassen.

Siehe 
https://www.nongnu.org/avr-libc/user-manual/group__util__setbaud.html

Der Titel verwirrt zusammen mit dem Text:
> UART läuft unter FreePascal sauber
> unter C läuft es alles OHNE Probleme,
> jedoch nach dem Umbau in Lazarus scheint der OutPut nicht richtig zu laufen.

Was heißt denn "scheint"?

Sende mal einfach wiederholt den gleichen Buchstaben (ohne zu empfangen) 
und zeige mal, was dabei am Tx Pin heraus kommt. Dazu wirst du einen 
Logic Analyzer besorgen müssen, falls du keinen hast. Bei Amazon Prime 
gibt es welche innerhalb von 24 Stunden für nur 10 Euro.

[Vam L. (vam_l)]

Stefan ⛄ F. schrieb:
> Der Titel verwirrt zusammen mit dem Text:
>> UART läuft unter FreePascal sauber
>> unter C läuft es alles OHNE Probleme,
>> jedoch nach dem Umbau in Lazarus scheint der OutPut nicht richtig zu laufen.

Danke für den Hinweiß, gleich mal geändert

> Was heißt denn "scheint"?
>
> Sende mal einfach wiederholt den gleichen Buchstaben (ohne zu empfangen)
> und zeige mal, was dabei am Tx Pin heraus kommt. Dazu wirst du einen
> Logic Analyzer besorgen müssen, falls du keinen hast. Bei Amazon Prime
> gibt es welche innerhalb von 24 Stunden für nur 10 Euro.

also mit Zeigen wird es dann auf die schnelle def. nix, weil KEIN Amazon 
habe.
Ja sowas soll es auch noch geben.

Ungeachtet dessen, gehe ich eher von einer Code-Unstimmigkeit aus, da 
die C erstellte HEX ihren Text ausgibt, die Lazarus-erstellte Hex 
allerdings nicht.

Ergo liegt wohl ein Softwareproblem vor, welches ich gerade nicht sehe.

[Stefan F. (Gast)]

Kommt denn überhaupt etwas am Tx Pin heraus, wenn du nur eine 
forlaufende Ausgabe (ohne Eingabe) machst?

Stelle zum Test die Baudrate auf einen niedrigen Wert und schließe eine 
LED an. Die müsste man flackern sehen.

[Vam L. (vam_l)]

Stefan ⛄ F. schrieb:
> Kommt denn überhaupt etwas am Tx Pin heraus, wenn du nur eine
> forlaufende Ausgabe (ohne Eingabe) machst?
>
> Stelle zum Test die Baudrate auf einen niedrigen Wert und schließe eine
> LED an. Die müsste man flackern sehen.

OutPut unter PicoCom mit dem C-Code = Hallo Welt
OutPut unter PicoCom mit dem Lazarus erstelltenn Code = ''

[Carl D. (jcw2)]

Vam L. schrieb:
> Ergo liegt wohl ein Softwareproblem vor, welches ich gerade nicht sehe.

Ich würde zuerst mal 1:1 übersetzen und erst danach bei der 
Initialisierung der UART "Verbesserungen" einzuführen.

Ps: Ich persönlich würde würde mich bei dem Quelltext an die 80er 
erinnern, als ich noch jung war und den funktionierenden Code einfach 
weiter benutzen.

[S. Landolt (Gast)]

Nur aus Interesse gefragt, ich kenne die Programmiersprache nicht - 
woher weiß der Compiler eigentlich an dieser Stelle, was c ist?

procedure UARTSendChar(value: char);
begin
  while UCSRA and (1 shl UDRE) = 0 do begin
  end;
  UDR         := byte(c);
end;

[Stefan F. (Gast)]

Ich glaube kaum, dass deine LED "Hallo Welt" ausgegeben hat. Jetzt mal 
im Ernst, mach das mal wie beschrieben. Die Frage ist, ob der Serielle 
Port überhaupt irgend etwas ausgibt.

Falsche Konfiguration der Baudrate, Parity, Bits und Stopbits kann 
nämlich auch dazu führen, dass dein PC nichts anzeigt obwohl etwas 
gesendet wird.

Ich möchte jetzt erstmal wissen, ob überhaupt etwas gesendet wird, um 
die Fehlerbeschreibung zu komplettieren. Vorher gucke ich mir deinen 
Quelltext gar nicht an.

Teste mit diesem Code:

baud = 300;
...
begin
  UARTInit;
  repeat
    UARTSendString('Hello World!'#13#10);
  until 1 = 2;
end.

[Georg G. (df2au)]

Vam L. schrieb:
> while UCSRA and (1 shl RXC) = 0

ich kenne Lazarus nicht. Aber solche Konstrukte schreibt nur der 
absolute Könner. Praktiker setzen ein paar Klammern für die Dummerchen, 
die nicht sofort wissen, welcher Operator zuerst kommt.

while ((UCSRA and (1 shl RXC)) = 0) ist imho lesbarer.

[Vam L. (vam_l)]

S. Landolt schrieb:
> Nur aus Interesse gefragt, ich kenne die Programmiersprache nicht -
> woher weiß der Compiler eigentlich an dieser Stelle, was c ist?
>
>

> procedure UARTSendChar(value: char);
> begin
>   while UCSRA and (1 shl UDRE) = 0 do begin
>   end;
>   UDR         := byte(c);
> end;
>

genau das war der Treffer, welchen ich nicht gesehen habe...

   UDR         := byte(value);

schaut auch sinnvoller aus.

[S. Landolt (Gast)]

Wie jetzt - und da bringt der Compiler keine Fehlermeldung?

[GeraldB (Gast)]

Kann das überhaupt funktionieren?

UDR         := byte(value);

Wird die byte-Funktion nicht schon beim Compilieren ausgewertet und der 
zufällige Wert von value fest im Code hinterlegt?

Korrekt müßte es doch so sein:

UDR         := ord(value);

[c-hater (Gast)]

GeraldB schrieb:
> Kann das überhaupt funktionieren?
>

UDR         := byte(value);

> Wird die byte-Funktion nicht schon beim Compilieren ausgewertet

Das ist keine Funktion, sondern ein Typecast.

Entspricht c'isch:

>

UDR         = (byte)(value);

[Maxe (Gast)]

Georg G. schrieb:
> Vam L. schrieb:
>> while UCSRA and (1 shl RXC) = 0
>
> ich kenne Lazarus nicht. Aber solche Konstrukte schreibt nur der
> absolute Könner. Praktiker setzen ein paar Klammern für die Dummerchen,
> die nicht sofort wissen, welcher Operator zuerst kommt.
In Pascal ist das unproblematisch, da while einen Boolean-Wert erwartet. 
Waere die Reihenfolge falsch, dann gaebe es eine Fehlermeldung, da die 
Typen nicht mehr stimmen/zusammenpassen.

[W.S. (Gast)]

Vam L. schrieb:
> UCSRC       := (1 shl URSEL) or (%011 shl UCSZ);

Erstens: könntest du mal erklären, was du mit %011 meinst? Ist mir 
nämlich nicht geläufig. Stattdessen wäre mir $11 nicht unbekannt.

Zweitens: Du beziehst dich massiv auf irgendwelche Konstanten, die aber 
nicht sichtbar sind, da sie irgendwo in anderen Quellen definiert sind. 
Sowas macht mich immer mißtrauisch. Könnte ja sein, daß es da 
Diskrepanzen gibt zwischen dem Zeugs in C und dem Zeugs in Pascal.

W.S.

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

S. Landolt schrieb:
> Wie jetzt - und da bringt der Compiler keine Fehlermeldung?

Das wundert mich auch. Gerade in Pascal ist es nicht üblich, aus dem 
Nichts eine Variable zu erzeugen, was bei manchen Sprachen ja geht. 
Mögl. ist Lazarus da anders als die anderen Pascal Varianten, die ich so 
kenne.

[Einer K. (Gast)]

Matthias S. schrieb:
> Gerade in Pascal ist es nicht üblich, aus dem
> Nichts eine Variable zu erzeugen,

Das ist so sicher wie das Amen in der Kirche!
Der Kompiler haut dir den Kram um die Ohren.
Es sei denn, es dümpelt noch ein c in den übergeordneten 
Geltungsbereichen rum.
Dann nimmt er dieses.

[Zeno (Gast)]

S. Landolt schrieb:
> Nur aus Interesse gefragt, ich kenne die Programmiersprache nicht -
> woher weiß der Compiler eigentlich an dieser Stelle, was c ist?

So wie der Quellcode gepostet wurde müßte da eigentlich ein Fehler 
kommen, weil c an keiner Stelle deklariert wurde.

[Zeno (Gast)]

Georg G. schrieb:
> ch kenne Lazarus nicht. Aber solche Konstrukte schreibt nur der
> absolute Könner. Praktiker setzen ein paar Klammern für die Dummerchen,
> die nicht sofort wissen, welcher Operator zuerst kommt.

Das hat nichts mit Könner zu tun, das ist ganz normale Pascalquelltext. 
Du kennst offensichtlich auch Pascal nicht.

Allerdings wäre es schon hilfreich, wenn er in seinem Codeschnipsel die 
Variablendeklarationen korrekt geschrieben hätte.
Was ist denn USRC?

Georg G. schrieb:
> while ((UCSRA and (1 shl RXC)) = 0) ist imho lesbarer.
Deine vielen Klammern sind völlig unnötig und erhöhen die Lesbarkeit an 
dieser Stelle nicht, im Gegenteil es wird unübersichtlicher. In dem 
Konstrukt soll UCSRA (was vermutlich vom Datentype Byte ist) auf die 
Bitmaske (1 shl RXC) abgeprüft werden.

W.S. schrieb:
> Erstens: könntest du mal erklären, was du mit %011 meinst? Ist mir
> nämlich nicht geläufig. Stattdessen wäre mir $11 nicht unbekannt.
Naja % ist ja eigentlich die Kennzeichnung von Binärzahlen, aber da 
schreibt man das dann eigentlich so: %00000011 für ein Byte.
Ich bvin aber über die gleiche Stelle gestolpert. Der ganze Quelltext 
ist irgendwie nur hingerotzt , das geht schon mit den unvollständigen 
Variablendeklationen los. Man kann nur erahnen welche Datentypen er 
meint. Wenn das ganze Programm in dem Stil wie der gepostete Quelltext 
geschrieben wurde, braucht er sich nicht zu wundern wenn es nicht 
funktioniert.

[Vam L. (vam_l)]

W.S. schrieb:
> Vam L. schrieb:
>> UCSRC       := (1 shl URSEL) or (%011 shl UCSZ);
>
> Erstens: könntest du mal erklären, was du mit %011 meinst? Ist mir
> nämlich nicht geläufig. Stattdessen wäre mir $11 nicht unbekannt.
>
> Zweitens: Du beziehst dich massiv auf irgendwelche Konstanten, die aber
> nicht sichtbar sind, da sie irgendwo in anderen Quellen definiert sind.
> Sowas macht mich immer mißtrauisch. Könnte ja sein, daß es da
> Diskrepanzen gibt zwischen dem Zeugs in C und dem Zeugs in Pascal.
>
> W.S.

Ich trenne sehr wohl meine c Programme von Pascal
C ist meine Spielwiese Pascal meine Arbeitsumgebung ändert aber an den 
verwendeten Registern eines ATmega16 an Ende Null, Null.

Zeno schrieb:
> Naja % ist ja eigentlich die Kennzeichnung von Binärzahlen, aber da
> schreibt man das dann eigentlich so: %00000011 für ein Byte.

Funktioniert sowohl als auch die kurze Variante.
Leidlich der Lesbarkeit ist %00000011 von Vorteil.

Wobei

(%011 shl UCSZ)

 sich explizit auf das Register-Paar UCSZ (UCSZ0 - 2) bezieht.