Krabbelversuche am ATmega4809

[Micha W. (blackxiiv)]

Moin!

Bin schon paar Tage am Üben mit den AVR8 MCUs und habe auch schon ein 
Projekt gemacht - siehe 
Beitrag "Re: Zeigt her eure Kunstwerke (2021)" .

Jetzt habe ich die neueren megaAVR® 0-series Dingers gesehen und habe 
mir auch gleich ein ATmega4809 Curiosity Nano bestellt - hat sich gut 
gelesen.
Beim Blick ins Datenblatt ist mir aufgefallen, dass es keine 
Code-Examples mehr gibt - nur Beschreibungen wie man über 23 Wege mit 
diversen Sytemen/Methoden nen Port-Pin ein- oder ausschalten kann. Dazu 
kommt dieses AtmelStart gelöt mit dem man seinen Chip konfigurieren 
kann. Vllt ist das gar nicht schlecht?! - Die werden sich ja was dabei 
gedacht haben.

Gibt es schon irgendwo leicht verständliche Code-Beispiele, wie ich 
meinen neuen AVR einfach in AtmelStudio programmieren kann? Ich habe 
bisher immer nur AtmelStudio aufgemacht, ein neues C/C++ Projekt 
aufgemacht, den Controller gewählt, die Fuses eingestellt und dann ging 
es mit Bits, Bytes und Registern straight forward ans Programmieren. 
Halt sehr Alt-Schul und ich weiß Weiterbildung ist nie verkehrt.

Aber muss ich mich jetzt ernsthaft in das AtmelStart einarbeiten?!

grüüßee (:

[Veit D. (devil-elec)]

Hallo,

https://www.microchip.com/wwwproducts/en/ATMEGA4809

Liegt alles unter Dokumente, hättest du eigentlich sehen müssen.

[Steffen H. (avrsteffen)]

Also ich denke mit da kannst du eigentlich fast so weiter machen. Das 
Atmel Start benötigt man im Normalfall nicht. Vielleicht am Anfang, um 
zu sehen was da gemacht wird.

In C/C++ kann ich dir da leider nicht weiter helfen da ich zwar 
vorhandene C/C++ Projekte ein wenig - in Grenzen - ergänzen/abändern 
kann, aber nicht erstellen. Da fehlt mir noch das drum herum wie man da 
genau anfängt. (Deklarationen, Includes,.. u.s.w.)

Ich programmiere hauptsächlich in Assembler. Und daher kann ich dir 
sagen, man sollte am Anfang auf alle Fälle erst einmal den System 
CLK/Takt einstellen.

Die I/O's mit dessen zahlreichen Registern ist näher betrachtet schon 
eine feine Sache. Ich denke mal, das hilft dem C-Compiler auch ungemein 
effizient arbeiten zu können.

Steffen

[Thomas R. (r3tr0)]

Joa, hier machst du halt keine Bitmanipulation mehr, da alles definiert 
ist.

z.B.

PORTD_OUTCLR = PIN1_bm; //Clear PORTD PIN1
PORTD_OUTSET = PIN2_bm; //Set PORTD PIN2

Ansonsten ist es fast genau so wie bei den älteren AVRs. Zudem hilft 
Atmel Studio auch noch mit dem ausfüllen des Codes, wenn du z.B. 
PORTD_OU schreibst.

PWM initialisierst du nun über Structs anstatt direkt über die Register:

void pwm_init(void)
{
  PORTMUX.TCBROUTEA = PORTMUX_TCB0_bm;
  TCB0.CTRLA = TCB_ENABLE_bm | TCB_CLKSEL_CLKDIV1_gc;
  TCB0.CTRLB = TCB_CCMPEN_bm | TCB_CNTMODE_PWM8_gc;
  TCB0.CCMP = 0x00FF;
}*/

Finde das Ganze sogar noch viel lesbarer.

[Steffen H. (avrsteffen)]

Thomas R. schrieb:
> PWM initialisierst du nun über Structs anstatt direkt über die Register:

Das finde ich auch super und übersichtlicher.

@Thomas R.
Um dies mit den Structs nutzen zu können muss man diese aber vorher 
anlegen/deklarieren? Oder übernimmt das schon der Compiler/Atmel Studio?

[Thomas R. (r3tr0)]

Steffen H. schrieb:
> Um dies mit den Structs nutzen zu können muss man diese aber vorher
> anlegen/deklarieren? Oder übernimmt das schon der Compiler/Atmel Studio?

Macht Atmel Studio direkt. Musst nur in der Projekteinstellung den 
entsprechenden Prozessor auswählen.

Als Include brauchst du dann nur noch:

#include <avr/io.h> und was du halt sonst noch so benötigst.

Jedoch bin ich der Meinung (schon etwas länger her), dass man bei der 
AVR-0 Series den Systemtakt initialisieren muss.
Hab gerade einmal das aus einem Codeschnipsel von mir geholt.

void sys_clock_init(void)
{
  CPU_CCP = CCP_IOREG_gc;
  CLKCTRL.MCLKCTRLA = CLKCTRL_CLKSEL_OSC20M_gc;
  CPU_CCP = CCP_IOREG_gc;
  CLKCTRL.MCLKCTRLB = CLKCTRL_PEN_bm | CLKCTRL_PDIV_2X_gc;
}

Damit taktet der 4809 mit 20MHz (achtung, Taktfrequenz ist abhängig von 
Betriebsspannung beim µC.) Bei 3.3V kannst du glaube nicht mehr mit 
20MHz takten.

[B. Lötmann (Gast)]

Moin,

Veit D. schrieb:
> Hallo,
>
> https://www.microchip.com/wwwproducts/en/ATMEGA4809
>
> Liegt alles unter Dokumente, hättest du eigentlich sehen müssen.

Ich alter Blindfisch habe tatsächliche die ganzen Application Notes 
übersehen -.-
Damit komme ich in jedem Fall weiter!

Danke und Gruß, Micha (:

[Johann L. (gjlayde)]

Thomas R. schrieb:
>   TCB0.CTRLA = TCB_ENABLE_bm | TCB_CLKSEL_CLKDIV1_gc;

Wofür stehen eigentlich "_bm" und "_gc"?

[Thomas R. (r3tr0)]

Johann L. schrieb:
> Wofür stehen eigentlich "_bm" und "_gc"?

_bm steht für Bitmask.
_gc steht für Group Configuration.

[Veit D. (devil-elec)]

Hallo,

man muss in seinem Code nicht mehr Bits schubsen, man verodert Z.Bsp. 
nur noch die Bitmasken-Namen. Da wurde seit megaAVR0 viel mehr 
vordefiniert bzw. anders definiert. Im Headerfile zwar nicht konsequent 
durchgezogen, oft ist Bit schubsen definiert, selten stehen gleich 
fertige Werte dahinter, aber das wird ja zur Compilezeit erledigt. Wer 
weiterhin in seinem Code Bits schubsen möchte nimmt _bp, muss dann 
längere Bit-Namen in Kauf nehmen.

Ich vermute die haben irgendeine Software die das generiert. Von Hand 
würde niemand (0x00<<0) oder (0x00<<6) schreiben.   :-)

Davon abgesehen, ich finde die Definitionen auch alle sehr angenehm.

[Micha W. (blackxiiv)]

Moin,

long time no see...

Ich habe mich jetzt bissl mit dem Teil (megaAVR0) auseinandergesetzt.
Das AtmelStart ist tatsächlich cool. Man kann alles schön 
vorkonfigurieren und nach dem Import in der IDE lustig "draufloshacken".
Als <ja-lacht-halt> Apfel-Jünger </ja-lacht-halt> musste ich früher auch 
Win10 auf dem Alu-Kasten laufen lassen um AtmelStudio7 zu nutzen (für 
meine AVR8 Projekte). Mit dem MPLAB X funktioniert jetzt auch das 
wunderbar.

Allerdings ein negativ-Beispiel aus der Praxis anhand vom TWI:
Für mich als Hobbyisten sind die Examples von microchip viel zu 
überladen. Da wird mit Pointern und Error-Handlern gearbeitet bis die 
Wolken wieder lila sind. Bis ich endlich eine Lib gefunden habe, die 
nicht gemacht hat was ich wollte, aber nah dran war, musste ich schon 
die 2. Google-Page aufmachen (Luxus-Problem ;) )und habe mir dann das 
aus dem Code geschnappt, was ich brauche. Es geht um die "tiny-mega-i2c" 
lib.
https://github.com/technoblogy/tiny-mega-i2c

Hätte mircochip nicht einfach ins datasheet schreiben können:

//I2C0_Master init:
  uint32_t baud = ((F_CPU/100000) - (((F_CPU*300)/1000)/1000)/1000 - 10)/2;
  TWI0.MBAUD = (uint8_t)baud;
  TWI0.MCTRLA = TWI_ENABLE_bm;                                        // Enable as master, no interrupts
  TWI0.MSTATUS = TWI_BUSSTATE_IDLE_gc;

und dann fütter ich meinen Bus mit Daten, wie in diesem Bsp:

void Set_RTC()
  {
    TWI0.MADDR = 0xD0;                        // Send START condition with R/W bit
    while (!(TWI0.MSTATUS & (TWI_WIF_bm | TWI_RIF_bm)));      // Wait for write or read interrupt flag
    TWI0.MDATA = 0x01;                        // Set Register to start reading/writing
    while (!(TWI0.MSTATUS & (TWI_WIF_bm | TWI_RIF_bm)));      // Wait for write or read interrupt flag
    TWI0.MDATA = (Convert_to_BCD(RTCsec));              // Set Register to start reading/writing
    while (!(TWI0.MSTATUS & (TWI_WIF_bm | TWI_RIF_bm)));      // Wait for write or read interrupt flag
    TWI0.MDATA = (Convert_to_BCD(RTCmin));              // Set Register to start reading/writing
    while (!(TWI0.MSTATUS & (TWI_WIF_bm | TWI_RIF_bm)));      // Wait for write or read interrupt flag
    TWI0.MDATA = (Convert_to_BCD(RTCh));              // Set Register to start reading/writing
    while (!(TWI0.MSTATUS & (TWI_WIF_bm | TWI_RIF_bm)));      // Wait for write or read interrupt flag
    TWI0.MCTRLB = TWI_ACKACT_bm | TWI_MCMD_STOP_gc;                 // Send STOP
  }

Einfach mal 3 Byte via TWI/I2C hart geschrieben.
Ich weiß, dass ist Fire-and-Forget und man hat keine 
Debug-Möglichkeiten. Aber wenn ich meine Slave-Chips kenne, dann will 
ich doch auch nicht mehr, oder?

Wie gesagt - ich betrachte das aus der Sicht eines (mehr oder weniger) 
engagiertem Laien.
Ich verstehe natürlich, dass microchip/atmel möglichst viele Features 
einbaut und das dass viel Utility(?) bringt, wenn man die Produkte 
gezielt, geplant und performant einsetzen will. Warum aber gibt es dann 
diese Evaluation-Kits so billig?
Will man das Produkt an Hobbyisten verkaufen, wie ich einer bin (Habe 2 
davon)? Ein Arduino Uno (kein Clone) kostet 25% mehr.
Soll sich die Industrie damit auseinandersetzen?
Sollen die megaAVR series0/1 eine Alternative zum ARM (STM32) sein?

Grüße (:

[Peter D. (peda)]

Micha W. schrieb:
> TWI0.MDATA = (Convert_to_BCD(RTCsec));              // Set Register to
> start reading/writing
>     while (!(TWI0.MSTATUS & (TWI_WIF_bm | TWI_RIF_bm)));      // Wait
> for write or read interrupt flag
>     TWI0.MDATA = (Convert_to_BCD(RTCmin));              // Set Register
> to start reading/writing
>     while (!(TWI0.MSTATUS & (TWI_WIF_bm | TWI_RIF_bm)));      // Wait
> for write or read interrupt flag

Man kann natürlich Copy&Pasten, bis der Arzt kommt. Der Profi schreibt 
sich ne Unterfunktion, sobald eine Codesequenz zweimal oder öfter 
benötigt wird.
Das erhöht die Übersichtlichkeit und verringert die Fehlergefahr.

[dada (Gast)]

OT: Warum microchip/Atmel immer noch ICs mit so wenig Sram fabriziert, 
ist mir ein Rätsel.