SAM3X8E (Arduino DUE) - USART Inbetriebnahme ohne Arduino

[mr. mo (Gast)]

Hallo zusammen,

ich habe vor kurzem angefangen einen Arduino DUE ohne Arduino im Atmel 
Studio 7 mit einem Atmel ICE in C/C++ zu programmieren. Den vorhandenen 
UART konnte ich bereits mit PDC in Betrieb nehmen und läuft einwandfrei.

Heute wollte ich mich mit dem USART beschäftigen und versuchen ein 
ASCII-Zeichen zu versenden. Nur leider scheint meine Initialisierung der 
Register fehlerhaft zu sein.

Aus der Schnittstelle kommt nichts raus, getestet habe ich mit meinem 
Logic-Analyzer (PIN_PA11(TX) + GND).

Hier ist mein Quelltext zur Initialisierung:

  // Enable USART clock
  PMC->PMC_PCER0 = (1 << ID_USART0);

  // Reset USART
  USART0->US_IDR = 0xFFFFFFFF;
  USART0->US_CR = US_CR_RSTRX | US_CR_RSTTX | US_CR_RXDIS | US_CR_TXDIS;
  USART0->US_PTCR |= US_PTCR_RXTDIS | US_PTCR_TXTDIS;

  // Disable write protection
  USART0->US_WPMR = 0x555341;

  // Configure
  //uint32_t baudrate = 115200;
  //USART0->US_BRGR = (CHIP_FREQ_CPU_MAX / baudrate) / 16;

  USART0->US_BRGR = 45;
  USART0->US_MR = US_MR_PAR_NO | US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT;

  // Enable write protection
  USART0->US_WPMR = 0x555341 | US_WPMR_WPEN;

  // Enable receiver and transmitter
  USART0->US_CR = US_CR_RXEN | US_CR_TXEN;

Vermutlich handelt es sich um einen einfachen Fehler, evtl. hat jemand 
eine Idee.

Gruß,
mr. mo

[mr. mo (Gast)]

Komisch ist, dass ich mit der Arduino IDE sofort einen String über alle 
USARTs senden kann.

Benutze ich z.B. folgende Bilbiothek (welche die USARTs unterstützt):
http://www.infidigm.net/projects/sam_printf/

Kommt auch nichts aus der Schnittstelle?! Stelle ich die Bibliothek auf 
UART dann funktioniert es ...

Irgendwie habe ich da nun ein Brett vorm Kopf. Keiner einen USART beim 
SAM in Betrieb genommen? :(

[Kaj G. (Firma: RUB) (bloody)]

Hier mal meine Routine dafuer.

//  Werte fuer die Baudraten des U(S)ART      --> BR = BaudRate   MCK = MasterClocK   CD = ClockDivisor
#define   BAUD_115k2     46   //  Wert fuer   115.200Baud ( BR = MCK / (16 * CD) --> CD = MCK / (16 * BR) --> CD = 84.000.000 / (16 *   115.200) =  46)

#define   USART0_PMC_ENABLE           0x00020000    //  P_ID  17
#define   USART0_PIN_CONTROL_TO_PERI  0x00000C00    //  Pin 10 und 11
#define   USART0_TX_OUTPUT            0x00000800    //  Pin 11
#define   USART0_PINS_TO_PERI_A      ~0x00000C00    //  Pin 10 und 11
#define   ENABLE_RX                   0x00000010    //
#define   USART_MODE_REG              0x000008C0    //  normal mode - 1-8-N-1
#define   RXRDY_IRQ_ENABLE            0x00000001    //
#define   TXEMPTY_IRQ_ENABLE          0x00000200    //



void init_usart0(void)
{
  PMC->PMC_PCER0  |= USART0_PMC_ENABLE;
  PIOA->PIO_PDR   |= USART0_PIN_CONTROL_TO_PERI;
  PIOA->PIO_OER   |= USART0_TX_OUTPUT;
  PIOA->PIO_ABSR  &= USART0_PINS_TO_PERI_A;

  USART0->US_CR    = ENABLE_RX;
  USART0->US_MR    = USART_MODE_REG;
  USART0->US_BRGR  = BAUD_115k2;
  USART0->US_IER   = RXRDY_IRQ_ENABLE | TXEMPTY_IRQ_ENABLE;
} //  init_usart0

Gruesse

[Maxx (Gast)]

mr. mo schrieb:
> Nur leider scheint meine Initialisierung der
> Register fehlerhaft zu sein.

Sind die PINs auch der USART Peripherie zugeordnet?
Also prüfen:
- PIO Clock
- Peripheriral ABCD Select Register 1 und 2
- PIO Disable für die Pins

[mr. mo (Gast)]

Guten morgen,

Kaj G. schrieb:
> Hier mal meine Routine dafuer...

Ich habe deine Initialisierung bei mir eingebaut und konnte immer noch 
nichts versenden ... :(

Maxx schrieb:
> Sind die PINs auch der USART Peripherie zugeordnet?
> Also prüfen:
> - PIO Clock
> - Peripheriral ABCD Select Register 1 und 2
> - PIO Disable für die Pins

Jap. Ich habe meine "alte" Initialisierung der Pins mal mit in das 
folgende Minimalbeispiel reinkopiert. Die Initialisierung ist vom Kaj G. 
mit enthalten.

Mir scheint es so als hätte ich irgendwas Grundsätzliches vergessen. 
Irgendwie hatte ich den Einstieg in die STM32-Familie einfacher in 
Erinnerung.

Für die ersten Gehversuche sollte der USART0 einfach das Zeichen 'x' 
einmal pro Sekunde versenden:

#include "sam.h"

int main(void)
{
    SystemInit();

  // Alte Initialisierung der pins
  //PIOA->PIO_OER |= PIO_PA11A_TXD0;
  //PIOA->PIO_PDR |= PIO_PA10A_RXD0 | PIO_PA11A_TXD0;
  //PIOA->PIO_ABSR &= ~(PIO_PA10A_RXD0 | PIO_PA11A_TXD0);
  
  PMC->PMC_PCER0  |= 0x00020000; // Init von Kaj
  PIOA->PIO_PDR   |= 0x00000C00;
  PIOA->PIO_OER   |= 0x00000800;
  PIOA->PIO_ABSR  &= ~0x00000C00;

  USART0->US_CR    = 0x00000010;
  USART0->US_MR    = 0x000008C0;
  USART0->US_BRGR  = 46;
    
    while (true) 
    {  
    while(!(USART0->US_CSR & US_CSR_TXRDY));
    USART0->US_THR = 'x';

    //while(!(USART0->US_CSR & US_CSR_TXEMPTY));

    delay(10000000);  // ca. 1s warten
    }
}

[Peter Hacke (Gast)]

Gibt's für dir SAM kein Programmers Manual oder fertige Bibliotheken die 
du als Referenz nutzen kannst?

Wieso überhaupt SAM? Die STM32 sind spott billig und es gibt viel 
Support. Nein keinen Glaubenskrieg anfangen bitte.

[Kaj G. (Firma: RUB) (bloody)]

Peter Hacke schrieb:
> Die STM32 sind spott billig und es gibt viel
> Support.
[Meine Meinung]
Dafür sind die Datenblätter bei STM grütze, und das sich 2, völlig 
verschiedene, Interrupts eine ISR teilen find ich auch daneben.
Mit Atmel Studio hat man unter Windows eine hochwertige IDE die a) 
nichts kostet und b) keine limitierungen hat, wie z.B. die Trial 
Versionen von Keil/IAR.

Warum fahren die Leute Audi, BMW und Co. wo es doch einen Dacia 
praktisch geschenkt gibt? :)
Warum nutzen Leute Apple/Microsoft-Produkte, wo Linux/BSD doch nichts 
kostet? Und der Support ist auch Bombe.
Selbe Aussage, andere Beispiele.
So, genug davon!
[/Meine Meinung]


So, zurück zum Problem:
mr. mo schrieb:
> Ich habe deine Initialisierung bei mir eingebaut und konnte immer noch
> nichts versenden ... :(
Ich hab nie versucht, nicht interruptgesteuert zu senden...
Du müsstest den Sender erst noch einschalten.
Meine Initialisierung ist darauf ausgelegt, per Interrupt zu 
senden/empfangen, und ich sende nur, nachdem ich etwas empfangen habe. 
Deswegen ist TX in meiner Initialisierung noch deaktiviert.

Es sollte dann so aussehen:

USART0->US_CR    = 0x00000050;  // Datenblatt, Seite 836: Bit 6: TXEN, Bit 4: RXEN

Vielleicht war's das schon, was dir fehlte.

Weitere Hinweise:
Du musst den Watchdog abschalten! Mit dem Arduinozeug macht das halt das 
Arduinozeug im Hintergrund für dich, so musst du das selber machen.
Watchdog: Datenblatt Seite 272/273 WDT_MR, Bit 15 (WDDIS) auf 1 setzen.

Weiter ist die Stackgröße in den Linkerscripten definiert, zu begin 
steht diese auf 1k (wenn ich mich recht erinnere).
Wird dein Stack größer, so läuft der Controller in den Hard-Fault 
Interrupt. vielleicht musst du die Stackgröße an deine Bedürfnisse 
anpassen, vielleicht nicht jetzt, aber später mal. :)

[mr. mo (Gast)]

Hallo Kaj,

danke für deine ausführliche Antwort! Ich habe mich heute nochmal an den 
DUE gemacht und weiterhin versucht den USART zum Senden zu bewegen.

Kaj G. schrieb:
> Weitere Hinweise:
> Du musst den Watchdog abschalten! Mit dem Arduinozeug macht das halt das
> Arduinozeug im Hintergrund für dich, so musst du das selber machen.
> Watchdog: Datenblatt Seite 272/273 WDT_MR, Bit 15 (WDDIS) auf 1 setzen.

Dieser Tipp war sehr hilfreich! Die Zeile hat tatsächlich dazu geführt 
das der USART ohne Interrupts funktioniert und das Zeichen 'x' versendet 
wird.

// Disable watchdog
WDT->WDT_MR = WDT_MR_WDDIS;

Danke vielmals!

Gruß,
mr. mo

[W.S. (Gast)]

Kaj G. schrieb:
> Mit Atmel Studio hat man unter Windows eine hochwertige IDE die a)
> nichts kostet und b) keine limitierungen hat, wie z.B. die Trial
> Versionen von Keil/IAR.

Denk nochmal nach.

Wovon schreibst du eigentlich?
Von einer IDE oder von den eigentlichen Tools?

Wenn dieses Atmel-Studio kostenlos ist und keine Limitierung kennt, dann 
vermute ich doch sehr stark, daß die eigentliche Arbeit bei diesem 
Studio von irgendeiner GCC-Distribution gemacht wird. Das ist ein 
anderer Compiler als der von ARM, der normalerweise beim Keil dabei ist 
- und auch ein anderer als IAR.

Wenn du schon eine Einschätzung der IDE's schreiben willst, dann 
solltest du bedenken, daß man die uVision von Keil auch mit dem GCC 
betreiben kann - wenn man will. Dann gibt es dort auch keine 
Begrenzungen bei der Codegröße - allenfalls beim Simulator, da der ja 
von ARM kommt.

Klaro?

W.S.