Forum: Mikrocontroller und Digitale Elektronik AVR32UC3A Einstieg


von Hans M. (Gast)


Lesenswert?

Hallo zusammen,

also bis letzte Woche war ich noch ein glücklicher Hardwerker, der 
"progrmmieren" nur brauchte um rudimentäre Funtionalitäten zu testen. 
Also quasi den MC auf unterster Ebene ansprechen und schaun, ob alles 
geht. Jetzt liegt aber n AT32UC3A3256 xplained auf meinem Tisch und ich 
fühl mich voll überfordert. ich will ja nix schlimmes von ihm: Clock auf 
MaxSpeed, USART mit 19200 für ModBusRTU also iwie das FrameEnde 
erkennen, Frames verarbeiten und per USB an Windows schicken. Nur 
zweifel ich grad an mir n bissl, denn ich find kaum Tuts oder HowTos im 
Netz. Die ASF Beschreibungen find ich leicht verwirrend ja , den Tip " 
Nimm nen STM32" kenn ich schon!! Nur bin ich der meinung Monokulturen 
waren nie von langer Dauer und der AVR32 hat echt Potential, nur warum 
wird er von Atmel so wenig unterstützt? Das Framework ist wirklich 
umfangreich aber warscheinlich in anbetracht der unterstützen Vielfalt 
verwirrend.
Hat wer n Einsteigertip? ich hab kein Probelem mit Datenblatt lesen und 
bits schubsen, aber mal ehrlich 4 Register um n PortPin um zu schalten?! 
PLL auf 84MHZ und Takt aufn Pin geben geht mittlerweile schon, aber 
vermiss schon n bissl den Zusammenhang der einzelnen Komponenten, wie 
sie beim 8Bitter vermittelt wurden. Nich falsch verstehen, will nix vor 
gekaut bekommen, aber welcher GCCTRLx is für welchen Port lässt sich nur 
durch Trial&Error mitn ICE mkII ermitteln

finds echt schade,das der MC so untergeht... Hör immer nur, das kann der 
M3 auch, aber keiner sieht zu welcher Zeit welcher MC das konnte und 
zeigt mir n Cortex der HighSpeed USB direkt in Speicher in Hardware kann 
und nebenbei  noch den Rest macht !!

MfG Hans

Ps. das AVR32-Wiki is momentan nicht erreichbar

von Moby (Gast)


Lesenswert?

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.

von Der Troll (Gast)


Lesenswert?

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

von Hans M. (Gast)


Lesenswert?

@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

von Amateur (Gast)


Lesenswert?

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.

von Mike (Gast)


Lesenswert?

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?

von Martin (Gast)


Lesenswert?

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...

von Pittiplatsch (Gast)


Lesenswert?

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.

von Pittiplatsch (Gast)


Lesenswert?

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

von Hans M. (Gast)


Lesenswert?

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

von Mike (Gast)


Lesenswert?

Ö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

von amateur (Gast)


Lesenswert?

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.

von Hans M. (Gast)


Lesenswert?

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();

von Frank M. (frank_41)


Lesenswert?

Moin,
also ich finde die Beispiele im ASF genial.
Da findet man eigentlich alles, was man braucht. Man muss mit dem
ASF Wizzard halt die passenden Teile zusammenklicken.
Nimm doch ein gpio - Beispiel und arbeite das ab ?
Für USB gibts auch Beispiele. Das Problem ist nur, die ganzen Teile
zusammenzubringen. Eine typische Main - Routine sieht bei mir
z.B. so aus :
int main (void)
{
  volatile avr32_tc_t *tc = EXAMPLE_TC;
  volatile spi_status_t spi_stat;
  uint32_t timer = 0;
  int mycnt;
  char buffer[80];
  int ret;
  volatile uint32_t sysclk;



  board_init(); // ist leer
  sysclk_init();
  sysclk = sysclk_get_cpu_hz();
  delay_init(sysclk_get_cpu_hz());
  // Enable the clock to the selected example Timer/counter peripheral 
module.
  sysclk_enable_peripheral_clock(EXAMPLE_TC);

  #if defined (CONF_BOARD_RFM01_SDI)
  static const gpio_map_t RFM01_SPI_GPIO_MAP = {
    {RFM01_SPI_SCK_PIN,  RFM01_SPI_SCK_FUNCTION },
    {RFM01_SPI_MISO_PIN, RFM01_SPI_MISO_FUNCTION},
    {RFM01_SPI_MOSI_PIN, RFM01_SPI_MOSI_FUNCTION},
    {RFM01_SPI_NPCS0_PIN, RFM01_SPI_NPCS0_FUNCTION},
    {RFM02_SPI_NPCS1_PIN, RFM02_SPI_NPCS1_FUNCTION}
  };

  // Enable the local bus interface for GPIO.
  gpio_local_init();
  gpio_local_enable_pin_output_driver(RFM02_FSK_PIN);
  gpio_configure_pin(RFM02_nIRQ_PIN, GPIO_DIR_INPUT);
  gpio_configure_pin(RFM01_nIRQ_PIN, GPIO_DIR_INPUT);
  gpio_local_clr_gpio_pin(RFM02_FSK_PIN);

....

Wichtig ist, dass man in conf_clock.h den richtigen Oscillator
auswählt :

#define CONFIG_SYSCLK_SOURCE        SYSCLK_SRC_OSC0
/* Fbus = Fsys / (2 ^ BUS_div) */
#define CONFIG_SYSCLK_CPU_DIV         0
#define CONFIG_SYSCLK_PBA_DIV         0
#define CONFIG_SYSCLK_PBB_DIV         0
#define CONFIG_SYSCLK_PBC_DIV         0
#define   CONFIG_USBCLK_SOURCE        USBCLK_SRC_PLL0
/* Fusb = Fsys / USB_div */
#define CONFIG_USBCLK_DIV             1

#define CONFIG_PLL0_SOURCE            PLL_SRC_OSC0
/
....

Also bei mir klappt gpio, timer, usb wunderbar.
Ich habe auch keine neuen Makros "erfunden", sondern die Beispiele
von ASF einfach verwendet.
Gruss
Frank

von Chris W. (chw)


Lesenswert?

Hi Hans M.

probiere mal

// Enable the EIC lines.
eic_enable_lines(&AVR32_EIC, (1<<eic_options[0].eic_line));
eic_enable_lines(&AVR32_EIC, (1<<eic_options[1].eic_line));
eic_enable_lines(&AVR32_EIC, (1<<eic_options[2].eic_line));
eic_enable_lines(&AVR32_EIC, (1<<eic_options[3].eic_line));

// Enable the interrupt for each EIC line.
eic_enable_interrupt_lines(&AVR32_EIC, (1<<eic_options[0].eic_line));
eic_enable_interrupt_lines(&AVR32_EIC, (1<<eic_options[1].eic_line));
eic_enable_interrupt_lines(&AVR32_EIC, (1<<eic_options[2].eic_line));
eic_enable_interrupt_lines(&AVR32_EIC, (1<<eic_options[3].eic_line));

Gruss

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.