AVR32UC3A Einstieg

Ja, das wird Richtung 32 Bit immer übler mit der Komplexität von 
Prozessor und Programmierung, und das wo es für die geplante Anwendung 
oft gar nicht notwendig wäre. Kostet dann nur zusätzlich Zeit und 
Nerven. Ich würde mir genau überlegen ob der Einarbeitungsaufwand lohnt. 
Nach meinem Eindruck wurde AVR32 ziemlich schnell von den ARMs überholt. 
Das hat auch Atmel eingesehen und seitdem fristet AVR32 ein 
Schattendasein in der MCU Produktpalette- eingeklemmt zwischen den 
erfolgreichen 8Bittern und ARM.

Die UC3 Reihe waere eine Tolle Hardware Maschine, mit Featurs, die 
andere CPUs eigntlich nicht bieten. Aber der Support ist etwas mager.

@Troll:
Seh ich auch so. Ich wollt eigentlich mal schaun, ob hier der ein oder 
andere unterwegs ist der mit den Teilen arbeitet. Ich hab so viele 
Ideen, nur weiß ich nicht ob sie so umsetzbar sind, z.B. : Modbus RTU 
Frames und Errors  komplett von der Hardware erfassen/kennen zu lassen. 
Denke da an USART empfängt und Leiter per DNA weiter und parallel liegt 
das Signal auch am TC an und misst die charzeiten... Probier ich morgen 
mal aus.

Auch halt nur Kontakt zum Austausch ...

MfG Hans

Schau mal ins asf.
Da ist einiges an Bleistiften vorhanden.
Ich kann mir auch nicht erklären, warum Atmel die Serie, wie eine heiße 
Kartoffel, hat fallen lassen.

scheint nicht danach aus als ob atmel den 32bit avr fallen laesst
http://www.ifixit.com/Teardown/Microsoft+Surface+Teardown/11275/2

http://ir.atmel.com/releasedetail.cfm?ReleaseID=723073

Wenn sowohl microsoft als auch samsung den uc3l verwenden obwohl es 
sowohl von atmel einen sam4l gibt als auch entsprechende low power 
cortexe von andren herstellern dann wuerd ich das nicht so nennen. 
Offensichtlich hat er mehr verbreitung als man denkt

Habt ihr im asf die example projekte schon gecheckt?

Ich nutze zwar den UC3C, aber die meisten Sachen funktionieren da 
ähnlich...

Über mageren Support kann ich nicht klagen. Eine Frage bezüglich des 
(differentiellen) ADCs im UC3C wurde prompt beantwortet. Die 
Dokumentation von µC und Software finde ich im Vergleich zu µCs anderer 
Hersteller außerordentlich gut. Für jede Peripherie ist 
(funktionierender) Beispielcode vorhanden und auch recht gut 
dokumentiert.
Lediglich die Bugs im Atmel Studio, die ich Ende letzten Jahres gemeldet 
habe, sind immernoch da - obwohl ich die Fixes (zumindest für meinen 
UC3C164C) gleich mitgeliefert habe :(

Ich habe den Einstieg über das ASF gefunden. Erstmal wurde einfach der 
Beispielcode übernommen und angepasst.
Teilweise verwende ich diese Bibliotheksfunktionen immernoch, trotz 
ihres Overheads (z.B. Überprüfungen von Parametern auf ihre 
Wertebereiche/Gültigkeit).
In meinem Projekt habe ich jedoch einen 10µs-Interrupt (also alle 640 
Prozessortakte), der diverse Eingänge auswertet, ein bisschen rumrechnet 
(mit der FPU) und beide SPIs bedient (einmal direkt nur 2 Bytes und 
einmal per DMA). Mit den ASF-Funktionen wäre das zeitlich etwas knapp 
geworden, also habe ich den Code daraus genommen und abgespeckt...

Für den Pin-Zugriff beispielsweise nehme ich ein paar Makros:

1

#define getPin(pin)    ((AVR32_GPIO.port[pin >> 5].pvr & (1 << (pin & 0x1F))) != 0)

2

#define setPin(pin)    {AVR32_GPIO.port[pin >> 5].ovrs = (1 << (pin & 0x1F));}

3

#define clearPin(pin)  {AVR32_GPIO.port[pin >> 5].ovrc = (1 << (pin & 0x1F));}

4

#define togglePin(pin) {AVR32_GPIO.port[pin >> 5].ovrt = (1 << (pin & 0x1F));}

Da die Pins in der Regel konstant sind, hat der Compiler da auch noch 
ganz schön Spielraum zum optimieren. Im Prinzip bleibt eine einfache 
Zuweisung einer Konstante auf ein Register übrig.
Dass mehrere Register für einen Port zuständig ist empfinde ich als 
Vorteil und nicht als Nachteil. Somit wird ein Pin einfach durch eine 
Zuweisung gesetzt und nicht wie beim AVR per auslesen, maskieren und 
schreiben - das bringt durchaus ein paar Taktzyklen, vor allem da bei 
den meisten 32-bittern Zugriffe auf Peripherieregister mit Waitstates 
behaftet sind.

Beim PDCA (Peripheral DMA) muss man auch nicht jedes Mal alle Register 
beschreiben, wie es das ASF macht. Einfach im Debugger schauen, welche 
Werte geblieben sind und auch bleiben dürfen, dann die restlichen im 
Code setzen und schon hat man wieder gespart...

Martin schrieb:
> und nicht wie beim AVR per auslesen, maskieren und
> schreiben

Beim Xmega gehts ganz einfach und in jedem Fall einzeln via sbi/cbi wenn 
der betreffende Port einem der vorhandenen virtuellen zugeordnet wird.

... und auch bei anderen AVRs gehts direkt mit sbi/cbi, wenn auch nicht 
mit allen Ports.

So langsam geht's voran:
Clock läuft, nur weiß ich noch nicht ob mit der von mir gedachten freq 
;)
Pll sieht auch gut aus nur scheint der mul ein anderer zu sein, für mich 
sind 12 MHz mal 7 84Mhz für'n premompiler 13 :(
Die Port/Pin Geschichte geht auch
Timer läuft, nur Krieg ich die pwm nicht an tc0b2 raus :(
Jetzt Versuch ich mal die Interruptsache an zu schalten und dann werd 
ich auch den genauen Click ermitteln können...
Dann kommt der USART dran, dann DMA und USB heb ich mir für'n  Winter 
2014 auf ;)
Zu den hinweisen, das im asf viele Beispiele gibt: WO denn ? Find nur 
die Beschreibung der einzelnen Treiber/Services aber nix zu Beispielen, 
an denen man ablesen könnte, wie die Funktionen ihre Übergaben haben 
wollen ... Wie oben geschrieben: C war bis jetzt immer nur ein mittel um 
nicht in ASM die Register zu manipulieren damit HardwareX läuft. Also um 
mit richtig C anzufangen is das asf nix ;)

Ich hält euch auf dem Laufenden ...
Hans

Öffne Atmel Studio 6, File - new - example project...
Und als Device Family AVR UC3 auswählen, bekommst ca. 700Projekte, da 
kann man sich viel selbst abgucken

So allzu glücklich bin ich mit den Beispielen nicht geworden.

Man kann zwar recht einfach das gute, alte Blinkbeispiel finden, aber 
wenn man, ohne den Source-Code durchzuhecheln feststellen will ob:
- Die for-Schleife,
- die delay-Funktion,
- der System-Timer oder
- eine eigene Interruptroutine
zur Anwendung kommt...

Funktionieren bzw. blinken tun sie wohl alle.

So da bin ich wieder :-D

Ich versuch mich jetzt seit ner Woche mit dem External Interrupt 
Controler:
Nachfolgender Codeausschnitt will aber nicht so richtig. Wenn ich direkt 
nach dem DebugStart den INT0 Pin Toggle springt er mir in den 
int_handler_1 oder 2 statt 0 :-S um dann in der exception.S bei 0x014 
Instruction Address hängen zu bleiben.

hat wer ne Idee, was ich vergessen hab?

MfG Hans

1

eic_options_t eic_options[4];

2

3

  eic_options[0].eic_line  = 0;      

4

  eic_options[0].eic_mode  =  EIC_MODE_EDGE_TRIGGERED  ;

5

  eic_options[0].eic_edge  =  EIC_EDGE_RISING_EDGE  ;

6

  eic_options[0].eic_level  =  EIC_LEVEL_LOW_LEVEL;

7

  eic_options[0].eic_filter  =  EIC_FILTER_DISABLED;

8

  eic_options[0].eic_async  =  EIC_SYNCH_MODE  ;

9

10

  eic_options[1].eic_line  = 1;

11

  eic_options[1].eic_mode  =  EIC_MODE_EDGE_TRIGGERED  ;

12

  eic_options[1].eic_edge  =  EIC_EDGE_RISING_EDGE  ;

13

  eic_options[1].eic_level  =  EIC_LEVEL_LOW_LEVEL;

14

  eic_options[1].eic_filter  =  EIC_FILTER_DISABLED;

15

  eic_options[1].eic_async  =  EIC_SYNCH_MODE  ;

16

17

  eic_options[2].eic_line  = 2;

18

  eic_options[2].eic_mode  =  EIC_MODE_EDGE_TRIGGERED  ;

19

  eic_options[2].eic_edge  =  EIC_EDGE_RISING_EDGE  ;

20

  eic_options[2].eic_level  =  EIC_LEVEL_LOW_LEVEL;

21

  eic_options[2].eic_filter  =  EIC_FILTER_DISABLED;

22

  eic_options[2].eic_async  =  EIC_SYNCH_MODE  ;

23

24

  eic_options[3].eic_line  = 3;

25

  eic_options[3].eic_mode  =  EIC_MODE_EDGE_TRIGGERED  ;

26

  eic_options[3].eic_edge  =  EIC_EDGE_RISING_EDGE  ;

27

  eic_options[3].eic_level  =  EIC_LEVEL_LOW_LEVEL;

28

  eic_options[3].eic_filter  =  EIC_FILTER_DISABLED;

29

  eic_options[3].eic_async  =  EIC_SYNCH_MODE  ;

30

31

32

  gpio_enable_module_pin(AVR32_EIC_EXTINT_0_PIN,AVR32_EIC_EXTINT_0_FUNCTION);

33

  gpio_enable_module_pin(AVR32_EIC_EXTINT_1_PIN,AVR32_EIC_EXTINT_1_FUNCTION);

34

  gpio_enable_module_pin(AVR32_EIC_EXTINT_2_PIN,AVR32_EIC_EXTINT_2_FUNCTION);

35

  gpio_enable_module_pin(AVR32_EIC_EXTINT_3_PIN,AVR32_EIC_EXTINT_3_FUNCTION);

36

37

38

39

  Disable_global_interrupt();

40

  INTC_init_interrupts();

41

  INTC_register_interrupt(&timer1_chan2_irq,  AVR32_TC1_IRQ2,    1);

42

  INTC_register_interrupt(&usart_1_rx_irq,  AVR32_USART1_IRQ,    1);

43

  INTC_register_interrupt(&eic_int_handler0,  EXT_INT0,  1);  

44

  INTC_register_interrupt(&eic_int_handler1,  EXT_INT1,  1);  

45

  INTC_register_interrupt(&eic_int_handler2,  EXT_INT2,  1);  

46

  INTC_register_interrupt(&eic_int_handler3,  EXT_INT3,  1);  

47

48

49

  eic_init(&AVR32_EIC,eic_options,4);

50

  eic_enable_line(&AVR32_EIC,eic_options[0].eic_line);

51

  eic_enable_line(&AVR32_EIC,eic_options[1].eic_line);

52

  eic_enable_line(&AVR32_EIC,eic_options[2].eic_line);

53

  eic_enable_line(&AVR32_EIC,eic_options[3].eic_line);

54

55

56

  eic_enable_interrupt_line(&AVR32_EIC,eic_options[0].eic_line);

57

  eic_enable_interrupt_line(&AVR32_EIC,eic_options[1].eic_line);

58

  eic_enable_interrupt_line(&AVR32_EIC,eic_options[2].eic_line);

59

  eic_enable_interrupt_line(&AVR32_EIC,eic_options[3].eic_line);

60

61

  Enable_global_interrupt();