SAM4S Xplained Pro UART1

[M. W. (rallini94)]

Hallo Leute,

ich beginne gerade mich in ARM Controller einzuarbeiten und habe mir 
dafür ein SAM4S Xplained Pro Board gekauft.
Dieses kann laut User Manual über den UART 1 und den EBDG einen 
virtuellen COM Port aufbauen und mit dem PC kommunizieren. Dies habe ich 
nun versucht zu realisieren, scheitere aber leider.
Ich konnte leider kaum Beispiele finden und wenn dann nur welche, die 
mit dem ASF von Atmel arbeiten, was ich nicht möchte (ich möchte es 
gerne auf Register Ebene verstehen).

Unten mein Code:

#include "sam.h"

void init_vCOM();
void vCOM_sendByte(char c);


void init_vCOM()
{
  
//  PMC->PMC_PCER0 |= (1<<ID_PIOB);                // Power für Port B
//  PIOB->PIO_PER |= PIO_PB2 | PIO_PB3;              // Pins Enablen
//  PIOB->PIO_OER |= PIO_PB3;                  // PB3 aus Output

  // Pins auf Peripherie A stellen
  PIOB->PIO_ABCDSR[0] &= ~(PIO_PB2A_URXD1 | PIO_PB3A_UTXD1);
  PIOB->PIO_ABCDSR[1] &= ~(PIO_PB2A_URXD1 | PIO_PB3A_UTXD1);

  PMC->PMC_PCER0 |= (1<<ID_UART1);              // Power für UART1 aktivieren

  UART1->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS;    // erstmal alles aus un resetten
  UART1->UART_BRGR = 781;                    // Baud auf 9.600
  UART1->UART_MR = UART_MR_CHMODE_NORMAL | UART_MR_PAR_NO;  // Normaler Modus, keine Parity  
  UART1->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;    // kein DMA
  UART1->UART_CR = UART_CR_TXEN | UART_CR_RXEN;        // Transmitter und Reciever enabeln
      
  
  // Fertig?
}

void vCOM_sendByte(char c)
{
  while (!(UART1->UART_SR & UART_SR_TXRDY))    // Bereit?
  {
  }
  UART1->UART_THR = c;              // Daten in den Transmitter laden- Begintt automatisch zu senden
  while (!(UART1->UART_SR & UART_SR_TXEMPTY))    // Solange noch nicht fertig gesendet, warten
  {
  }
}

Wie gesagt ich bin neue in der ARM Architektur. Habe ich irgendwas 
vergessen zu aktivieren/mit einem Takt zu versehen? Wie man sieht habe 
ich schon versucht noch mit dem PIOB zu arbeiten (Kommentare), hat aber 
auch nichts geholfen. Ist bestimmt nur ein kleiner Fehler bzw. eine 
Kleinigkeit die fehlt.

Wäre schön, wenn mir die Profis weiterhelfen würden.

Danekschön ;)

[Jim M. (turboj)]

M. W. schrieb:
> Habe ich irgendwas
> vergessen zu aktivieren/mit einem Takt zu versehen?

Woher sollen wir das wissen? Meine Glaskugel ist in Reparatur.

Die Wahrscheinlichkeit ist aber nahezu 1, denn UART braucht i.d.R. den 
Quarz.

[M. W. (rallini94)]

Jim M. schrieb:
> M. W. schrieb:
>> Habe ich irgendwas
>> vergessen zu aktivieren/mit einem Takt zu versehen?
>
> Woher sollen wir das wissen? Meine Glaskugel ist in Reparatur.
>
> Die Wahrscheinlichkeit ist aber nahezu 1, denn UART braucht i.d.R. den
> Quarz.

Nun, ich ging davon aus, dass die Zeile

  PMC->PMC_PCER0 |= (1<<ID_UART1);              // Power für UART1 aktivieren

den Takt für den UART generell freischaltet und dieser dann vom 
Buadratengenerator heruntergeteilt wird. Die Frage war mehr, ob es noch 
einen weiteren Takt benötigt. Wie gesagt, ich bin neu in der ARM 
Programmierung

[Jim M. (turboj)]

Die Clock-Trees moderner ARM µCs sind so komplex, das sie i.d.R. ein 
eigenes Kapitel im Handbuch/Reference Manual haben. Das sollte man mal 
lesen.


Und nein, ich lese das nur gegen monetäre Unterstützung.

[M. W. (rallini94)]

Jim M. schrieb:
> Die Clock-Trees moderner ARM µCs sind so komplex, das sie i.d.R. ein
> eigenes Kapitel im Handbuch/Reference Manual haben. Das sollte man mal
> lesen.

Nach eben diesem Kapitel muss man meines Erachtens nach nur den Clock 
per

  PMC->PMC_PCER0 |= (1<<ID_UART1);              // Power für UART1 aktivieren

aktivieren.

Ansonsten kann ich kein Fehler erkennen. Ich hab mir auch die Beispiele, 
die man mit Atmels ASF findet angeguckt. Wenn man dann deren Code auf 
die Register Beschreibungen reduziert, komme ich auf meinen Code. Bin 
echt ratlos :|

[M. W. (rallini94)]

Ich habs jetzt mal mit dem Code aus folgendem Beitrag versucht:

Beitrag "SAM4S Xplained UART"

aber auch das funktioniert leider nicht.

Ist hier keiner unterwegs, der sich mit den SAM Controllern auskennt und 
einem Einsteiger weiterhelfen könnte?

[M. W. (rallini94)]

Ich hab's jetzt doch endlich selbst geschafft! Wuhu!!!

Ich hatte wohl zwei Probleme:

1. Der EBDG auf dem SAM4S Xplained Pro Board muss erstmal mit einem über 
die zugehörige COM Schnittstelle gesendeten DTR Signal in den Modus 
versetzt werden, dass die Daten, die er vom SAM4S über den UART 1 
bekommt, auch an den PC weitergeleitet werden.
Das macht mein TerminalProgramm (Hterm) nicht automatisch. Das 
Terminal-Extension von Atmel Studio zum Beispiel schon

2. Aber die Wohl entscheidene Zeile istfolgende

  // PIO disablen für PB2 und PB3
  PIOB->PIO_PDR |= PIO_PB2 | PIO_PB3;

Ich dachte, dass der Grundzustand derjenige wäre, dass die PIOs die 
Signale der Peripherie (ohne weitere Wahl die Peripherie A) an die Pins 
weiterleiten. Ich dachte nicht, dass man noch extra die PIOs für den Pin 
disablen muss.


Achso hier nochmal mein endgültiger Code, um mit dem UART1 des SAM4s ein 
einzelnes Zeichen zu senden. Eventuell braucht es ja später nochmal wer:

void init_vCOM();
void vCOM_sendByte(char c);


void init_vCOM()
{
  // PIO disablen für PB2 und PB3
  PIOB->PIO_PDR |= PIO_PB2 | PIO_PB3;
  
  // Peripherie A einstellen
  PIOB->PIO_ABCDSR[0] &= ~(PIO_PB2A_URXD1 | PIO_PB3A_UTXD1);
  PIOB->PIO_ABCDSR[1] &= ~(PIO_PB2A_URXD1 | PIO_PB3A_UTXD1);
  
  // UART1 Clock aktivieren
  PMC->PMC_PCER0 |= (1<<ID_UART1);              // Power für UART1 aktivieren
  
  // UART1 configurieren
  UART1->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS;    // erstmal alles aus und resetten
  UART1->UART_BRGR = 781;                    // Baud auf 9.600
  UART1->UART_MR = UART_MR_CHMODE_NORMAL | UART_MR_PAR_NO;  // Normaler Modus, keine Parity  
  UART1->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;    // kein DMA
  UART1->UART_CR = UART_CR_TXEN | UART_CR_RXEN;        // Transmitter und Reciever enabeln
      
}

void vCOM_sendByte(char c)
{
  while (!(UART1->UART_SR & UART_SR_TXRDY))    // Bereit?
  {
  }
  UART1->UART_THR = c;              // Daten in den Transmitter laden- Begintt automatisch zu senden
  while (!(UART1->UART_SR & UART_SR_TXEMPTY))    // Solange noch nicht fertig gesendet, warten
  {
  }
}