ATSAMD21G18 und Atmel Studio 7

[nixblicker (Gast)]

Guten Tag,

ich hab mir ein adafruit Feather M0 zugelegt und versucht mehrere 
Ausgänge mit PWM zu nutzen.
Dazu gibt es die Funktion analogWrite(), die aber nicht mit allen Pins 
funktioniert!
Deswegen wollte ich den µC mit Atmel Studio 7 nutzen und muss aber 
feststellen dass ich da vor einer arg steilen Lernkurve stehe...

Ich scheitre bereits daran den USART korrekt zu konfigurieren.
Die ganzen ASF-Sachen kommen mir arg unübersichtlich und verzweigt vor.
Kurzum ich blicke nicht durch und brauche "Starthilfe"

Gibt es eine leicht verständliche Doku oder Tutoarials?

Viele Grüße,
Bob

[Marco H. (damarco)]

Das liegt am Pinmux siehe Referenz. Nicht alle Pins können per MUX mit 
den Timer PWM ausgeben.

Die erste Hürde wird sein das linker Script zu besorgen. Denn die SAMs 
haben keinen ROM Bootloader mehr. Der liegt im Flash und damit muss das 
Programm oberhalb gespeichert werden. Hinzu kommt das Problem mit dem 
NVM Ram wenn du den Flash blank machst.

Sagen wir es mal so wenn du dich der Herausforderung nicht stellen 
willst, lass es. Hat das Teil überhaupt SWD Anschlüsse ?


Mit Atmel Studio bist du bis auf das Debuggen nicht weiter. Denn die SAM 
Libs sind auch im Arduino nutzbar und sogar enthalten. Es hindert dich 
nichts dran diese auch im Sketch zu benutzen.

Somit kann weniger schief gehen ;)

[nixblicker (Gast)]

Guten Morgen und Danke für die Antwort!

Marco H. schrieb:
> Die erste Hürde wird sein das linker Script zu besorgen. ... Hinzu kommt
> das Problem mit dem NVM Ram wenn du den Flash blank machst.

Zugegeben, so tief bin ich noch nie in die µC-Geschichten eingestiegen.
Wäre sicherlich von Vorteil um besser zu verstehen was man da eigentlich 
macht, aber bisher ist das immer im Hintergrund abgelaufen und ich 
konnte in z.Bsp. AVR32Studio die Projekte mit den mitgelieferten 
Bibliotheken ganz gut bewältigen.

Marco H. schrieb:
> Sagen wir es mal so wenn du dich der Herausforderung nicht stellen
> willst, lass es. Hat das Teil überhaupt SWD Anschlüsse ?


Eigentlich wollte ich die Herausforderung annehmen, deswegen auch meine 
Frage hier ;-)
Ja, die SWD-Pins sind rausgeführt, zwar nur als Lötpads, aber 
immerhin...
Ich kann das Teil auch mit dem Atmel ICE programmieren und debuggen.

Konkret scheitere ich daran die ASF-Bibliotheken für USART so anzupassen 
dass sie mit meinem "user board" laufen.
Die Doku ist keine wirkliche Hilfe, das liest sich alles zwar schön, 
aber mehr wissen tut man nachher auch nicht.

Ich werde mir mal das Beispiel für das Atmel-Xplained board genauer 
anschauen, vielleicht kommt dadurch ja ein gewisser Erkenntnisgewinn.

Marco H. schrieb:
> Denn die SAM Libs sind auch im Arduino nutzbar und sogar enthalten. Es
> hindert dich nichts dran diese auch im Sketch zu benutzen.

Heißt das ich kann mit der Arduino IDE auch die HW-Timer selber 
konfigurieren und an die Pins schicken die ich möchte (falls nöglich)?

[chris_ (Gast)]

Man kann was mit Atmel-Start probieren:
Beitrag "Arduino Zero mit ArduinoStart Konfigurieren"

Oder besser, richtig "bare metal" programmieren:
Beitrag "ATMEL ARM SAMD ohne Framework programmieren"

[Marco H. (damarco)]

Ja na klar. Du kannst auch im Sketch z.bsp diesen Code ausführen.

/* Uart Modul*/
struct usart_module usart_instance;

void configure_usart(void)
{
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = 256000;
config_usart.generator_source=GCLK_GENERATOR_3;
config_usart.pinmux_pad0 = PINMUX_UNUSED;
config_usart.pinmux_pad1 = PINMUX_PA09C_SERCOM0_PAD1;
config_usart.pinmux_pad2 = PINMUX_PA10C_SERCOM0_PAD2;
config_usart.pinmux_pad3 = PINMUX_UNUSED;
while (usart_init(&usart_instance,SERCOM0, &config_usart) != STATUS_OK) {}
usart_enable(&usart_instance);
}

uint8_t string[] = "Hallo\n";

usart_write_buffer_wait(&usart_instance,string, sizeof(string));

[chris_ (Gast)]

Hier noch der direkte Link auf die Uart:
Beitrag "Re: ATMEL ARM SAMD ohne Framework programmieren"

[Marco H. (damarco)]

#include <usart.h>
#include <usart_interrupt.h>

muss natürlich eingebunden werden ;)

[nixblicker (Gast)]

Marco H. schrieb:
> Ja na klar. Du kannst auch im Sketch z.bsp diesen Code ausführen.

Hmm... das hab ich im AS7 aber ganz ähnlich:

#include <usart.h>
#include <usart_interrupt.h>
#include <stdio.h>

void configure_usart(void);
struct usart_module usart_instance;

void configure_usart(void)
{
  struct usart_config config_usart;
  usart_get_config_defaults(&config_usart);
  
  config_usart.baudrate      = 115200;
  config_usart.generator_source  = GCLK_GENERATOR_3;
  config_usart.pinmux_pad0    = PINMUX_UNUSED;
  config_usart.pinmux_pad0    = PINMUX_UNUSED;
  config_usart.pinmux_pad2    = PINMUX_PB22D_SERCOM5_PAD2;
  config_usart.pinmux_pad3    = PINMUX_PB23D_SERCOM5_PAD3;
  
  while (usart_init(&usart_instance, SERCOM5, &config_usart) != STATUS_OK) {}
  usart_enable(&usart_instance);
}

int main(void)
{
  system_init();

  configure_usart();
  system_interrupt_enable_global();

  uint8_t string[] = "Hello World\r\n";
  usart_write_buffer_wait(&usart_instance, string, sizeof(string));
}

...trotzdem funktioniert es nicht. Keine Ausgabe an der seriellen 
Schnittstelle :(
Hardwaremässig ist aber alles ok, mit dem Arduino sketch kann ich an den 
Pins senden und empfangen...

Ich würde das schon gerne richtig lernen, auch wenn sketch einfacher 
ist.
Obwohl, deinen code krieg ich da auch nicht zum laufen. Scheitert schon 
an dem einbinden der .h Dateien :/

@chris: Danke für die Links, bin schon am Lesen :)

[chris_ (Gast)]

>@chris: Danke für die Links, bin schon am Lesen :)

Gerne geschehen. Mein Leidensweg war:

1. Atmel ASF
2. Atmel Start
3. schließlich und endlich alles zu Fuß "Bare Metal"

Für das Verständnis ist "3" sicherlich der beste Weg, allerdings 
natürlich auch etwas mühsam. Dafür kann man sich aber sicher sein, dass 
sich alles damit machen lässt und man nicht durch die Eigenschaften der 
verwendeten Lib beschränkt wird.

Schöne wäre es, wenn es noch mehr "Bare Metal" Beispiele gibt. Mit 
größerer Code-Basis wird alles einfacher.

[nixblicker (Gast)]

kommt mir bekannt vor!

weder mit ASF noch mit Start habe ich ein funktionierendes Beispiel für 
USART hinbekommen...

[nixblicker (Gast)]

habe eben versucht den USART-Code aus

Beitrag "Re: ATMEL ARM SAMD ohne Framework programmieren"

bei mir zu verwenden, leider erfolglos :(

Das Debuggen will mir auch irgendwie nicht wirklich gelingen.
Sehr oft steht nur "could not evaluate" oder "optimized out" da. Was 
natürlich wenig Erkenntnisse bringt.

So langsam zweifele ich echt an mir selber...

[chris_ (Gast)]

>Beitrag "Re: ATMEL ARM SAMD ohne Framework programmieren"

Das Beispiel dort ist für einen SAMD20. Du hast einen SAMD21. 
Wahrscheinlich muss man da noch was anpassen.

>Das Debuggen will mir auch irgendwie nicht wirklich gelingen.
>Sehr oft steht nur "could not evaluate" oder "optimized out"

Dort könntest Du die Compileroptionen auf -O0 stellen und eventuell die 
Variablen "static" deklarieren, die Du beobachten willst.

Kannst Du eine LED "bare metal" blinken lassen?

[Werner P. (Gast)]

Probier mal das hier:

void configure_usart(void)
{
  
  struct usart_config config_usart;
  usart_get_config_defaults(&config_usart);

  config_usart.baudrate    = 115200;
  config_usart.mux_setting = USART_RX_3_TX_2_XCK_3;
  config_usart.pinmux_pad0 = PINMUX_UNUSED;
  config_usart.pinmux_pad1 = PINMUX_UNUSED;
  config_usart.pinmux_pad2 = PINMUX_PA10C_SERCOM0_PAD2;
  config_usart.pinmux_pad3 = PINMUX_PA11C_SERCOM0_PAD3;
  config_usart.generator_source = GCLK_GENERATOR_0;
  
  while (usart_init(&usart_instance,SERCOM0, &config_usart) != STATUS_OK) {
  }

  usart_enable(&usart_instance);
}

[nixblicker (Gast)]

chris_ schrieb:
> Das Beispiel dort ist für einen SAMD20. Du hast einen SAMD21.
> Wahrscheinlich muss man da noch was anpassen.

oh, etwas weiter oben stand:

> Ich habe den Code für
> das senden mittels TX  für einen SAMD21 zusammengebaut.

deswegen dachte ich das sollte passen.
Die Pinbelegung passt ja auch...

chris_ schrieb:
> Kannst Du eine LED "bare metal" blinken lassen?

Ja, das funktioniert bereits

Werner P. schrieb:
> config_usart.pinmux_pad2 = PINMUX_PA10C_SERCOM0_PAD2;
>   config_usart.pinmux_pad3 = PINMUX_PA11C_SERCOM0_PAD3;

Ich glaub ich spinn, das geht!
Meine Güte, hab ich doch tatsächlich die ganze Zeit die Signale an die 
falschen Pins gesendet!
Ich geh mich mal kurz schämen :/

...
...

so, jetzt gehts wieder ;-)
Zu meiner Verteidigung, im adafruit Schaltplan sind PB22 und PB23 mit 
TXD und RXD bezeichnet, rausgeführt sind aber PA10 und PA11. Aber die 
sind D1 und D0 benannt.
auf der Platine sind die PIns aber mit TxD und RxD beschriftet.

Tausend Dank, Werner!

[chris_ (Gast)]

>oh, etwas weiter oben stand:

>> Ich habe den Code für
>> das senden mittels TX  für einen SAMD21 zusammengebaut.

Äh, tschuldigung, Du hast recht. Die Version war doch für den SAMD21 ( 
steht ja auch im Filenamen ( 
http://www.mikrocontroller.net/attachment/286995/SAMD21_bareMetalUartTx.c 
)

Ich habe zwei verschieden Systeme: einen vom Boot-Fuses modifizierten 
Arduino Zero mit SAMD21 und ein anders mit SAMD20.