AVR32 UC3 Beispielscode

Sebastian B. schrieb:
> Sers,
> ich hatte das Selbe Problem. Deshalb habe ich mein erarbeitet Wissen in
> einem Tutorial zusammengefasst :)
> http://www.mikrocontroller.net/articles/AVR32-Tutorial


Besten Dank schon einmal dafür!
Ich werde mich heute damit befassen.

Danke & Gruss
Manuel

Nochmals Hallo Basti

Ich habe kurz dein tolles Tutorial angeschaut.
Viele Infos waren mir nützlich, allerdings würde mich gerne 
interessieren wie du dein uC initialisiert hast. Welcher Clock-Eingang 
(Quarz etc.) hast du verwendet und welche #includes sind notwendig?
Hast du eine Vorlage dazu fürs Atmel Studio 6? Ich scheitere schon an 
der Erstellung eines entsprechenden Projekts.

Ich wäre dir sehr dankbar
Gruss Manuel

Nachtrag zur Register Repräsentation. Ich habe zwar statt des uc3 damals 
den ap7000 im Fokus gehabt, aber das sollte nichts ändern. Ich fand 
deine Beschreibung der Registerzugriffe etwas zu "handwerklich". 
Natürlich kannst du auch anders auf die Register zugreifen. Wenn du die 
Adresse weißt (sei es durch eigenes Ausrechnen oder sonstwoher)

Das Beispiel des Timers. Die Basisadresse von z.B. Timer0 steht im (ok 
jetzt falschen) ap7001.h: Da kannst du wenn du lustig bist schon mit 
auskommen.

1

#define AVR32_TC0_ADDRESS                  0xFFF00C00

2

#define AVR32_TC0                          (*((volatile avr32_tc_t*)AVR32_TC0_ADDRESS))

Um es leichter zu machen gibt es dann in den Perepherieheadern noch mal 
exaktere Strukturen zur Hardware. Für den Timer z.B. in tc_221.h:

1

typedef struct avr32_tc_t {

2

  avr32_tc_channel_t channel[3];//0x0

3

  union {

4

          unsigned long                  bcr       ;//0x00c0

5

          avr32_tc_bcr_t                 BCR       ;

6

  };

7

  union {

8

          unsigned long                  bmr       ;//0x00c4

9

          avr32_tc_bmr_t                 BMR       ;

10

  };

11

          unsigned int                   :32       ;//0x00c8

12

          unsigned int                   :32       ;//0x00cc

13

          unsigned int                   :32       ;//0x00d0

14

          unsigned int                   :32       ;//0x00d4

15

          unsigned int                   :32       ;//0x00d8

16

          unsigned int                   :32       ;//0x00dc

17

          unsigned int                   :32       ;//0x00e0

18

          unsigned int                   :32       ;//0x00e4

19

          unsigned int                   :32       ;//0x00e8

20

          unsigned int                   :32       ;//0x00ec

21

          unsigned int                   :32       ;//0x00f0

22

          unsigned int                   :32       ;//0x00f4

23

          unsigned int                   :32       ;//0x00f8

24

  union {

25

    const unsigned long                  version   ;//0x00fc

26

    const avr32_tc_version_t             VERSION   ;

27

  };

28

} avr32_tc_t;

Da siehst du dann direkt woher die Schreibweise kommt. das halte ich für 
besser als das als Kochrezept anzugeben.
Interessant/hilfreich/wichtig finde ich auf jeden Fall hinzuweisen, das 
in der Struktur avr32_tc_t ein Register in den Unions einmal groß- und 
einmal klein geschrieben auftaucht. Zu merken wäre, dass KLEINES 
Register dem 32 register entspricht und das Register in GROSS ein 
Bitfeld repräsentiert, wo die bits ausgeschrieben angeschprochen werden 
können.

also AVR32_TC0.chanel[1].ccr = 1<<8;
gegen AVR32_TC0.chanel[1].CCR.clken = 1;


Aber echt Daumen hoch fürs anpacken!!! Die avr32 sind wirklich etwas 
schlecht präsent für Ein- und Umsteiger. Halte ich für eine sehr gute 
Idee die auch im Wiki einzupflegen. Ich werde mit dem Framework von 
Atmel allerdings nicht so schrecklich warm (das mag an meiner 
Begriffsstutzigkeit liegen oder an der Art der Dokumentation und 
Erklärung oder an sonstwas - ist ja auch egal) und daher benutze ich sie 
gar nicht mehr.

Die Offsetadressen sind in Headern erfreulicherweise angegeben. Das kann 
man direkt mit den Angaben im User Interface vergleichen.

Bei einiger Hardware war die Beschreibung im Datenblatt was Kanäle und 
Adressen geht echt mäßig. Der Timer ist sehr gut zum Einstieg.

Holger Krähenbühl schrieb:
> Ausserdem erwartest du mal wieder von der Community, dass diese dir
> alles auf einem Silbertablett serviert! "Vorlage für Studio 6"...

Hallo Krähe Holger

Ich kenne mich mit den 8bit Controllern von Atmel mittel bis gut aus, 
jedoch habe ich nirgends geschrieben das ich eine Lösung ERWARTE.

Schon nur eine LED zu blinken, wie du vorschlägst, wäre mir extrem 
nützlich. Aber Atmel muss dafür ja zirka 100 .c & .h sowie diverse 
#includes verwenden, die einen Einstieg in die 32Bit Welt extrem 
erschweren.

Erst überlegen dann reklamieren!

So und als letztes: doch noch etwas vom uc3 gefunden :-) Ich hatte mir 
einmal so ein kleines Breakout Board von Alvidi gekauft. Aus o.g. 
Gründen ist das aber verstaubt.

Ich teile schon die Ansichten, dass man nicht alles aus dem Nichts 
können wollen kann. Aber ich weiß auch wie beschissen es ist wenn man 
hängt und Starthilfe braucht. Der Code benutzt aber das api. Also z.B. 
hinter configure_clocks stecjt eine ganze Menge.
Vielleicht kannst du mit dem Testprogramm was anfangen. Ich habe es 
nicht mehr durchgesehen. Aber besser als nichts.

1

#include <avr32/io.h>

2

#include "compiler.h"

3

#include "stdio.h"

4

#include "gpio.h"

5

#include "pm.h"

6

#include "flashc.h"

7

#include "intc.h"

8

#include "rtc.h"

9

10

#include "math.h"

11

12

volatile unsigned int ms_count;

13

14

__attribute__((__interrupt__))

15

static void rtc_int()

16

{

17

  volatile struct avr32_rtc_t* timer = &AVR32_RTC;

18

19

  ms_count++;

20

  timer->ICR.topi = 1;

21

}

22

23

void wait_ms(unsigned int time)

24

{

25

  unsigned int bla = ms_count + time;

26

27

  while(ms_count < bla){;}

28

}

29

30

void setup_ms_counter(void) //naja pseudo ms-Counter

31

{

32

  volatile struct avr32_rtc_t* timer = &AVR32_RTC;

33

34

  //Ich versuche mal die api Funktionen.

35

  rtc_init(timer, RTC_OSC_32KHZ,  0);

36

  rtc_set_top_value(timer, 16);

37

  rtc_enable(timer);

38

39

  Disable_global_interrupt();

40

  INTC_register_interrupt(&rtc_int, AVR32_RTC_IRQ, AVR32_INTC_INT3); //Prioritäten nachgucken

41

  Enable_global_interrupt();

42

43

  rtc_enable_interrupt(timer);

44

}

45

//_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

46

47

void init(void)

48

{

49

//clocks

50

  pm_freq_param_t par = {

51

      .cpu_f = 60,

52

      .pba_f = 30,

53

      .osc0_f = 12,

54

      .osc0_startup = 128,

55

  };

56

  flashc_set_wait_state(1);

57

  pm_configure_clocks(&par);

58

59

  INTC_init_interrupts();

60

61

//timer for ms_tick

62

  setup_ms_counter();

63

}

64

65

int main(void)

66

{

67

  volatile avr32_gpio_port_t *gpio_port = &AVR32_GPIO.port[1];

68

  U32 bla=0x7, hin = 0x01;

69

70

  init();

71

72

  gpio_port->gpers = 0xffffffff;   //periph controller ist chef

73

  gpio_port->oders = 0xffffffff;   //init an

74

  gpio_port->ovrs  = bla;     //output driver 

75

76

  while(1){

77

    //for(i=0; i<CLK_CNT; i++);

78

    wait_ms(10);

79

    if(hin)

80

    {

81

      bla = bla << 1;

82

      if(bla >= 0x800000)

83

        hin=0;

84

    }

85

    else

86

    {

87

      bla = bla >> 1;

88

      if(bla <= 0x7)

89

        hin=1;

90

    }

91

    gpio_port->ovr = bla;

92

  }

93

}

Vielleicht etabliert sich der avr32 ja hier im Forum wie die 8 bitter. 
Vielleicht werde ich ja zu Kreuze kriechen und meinen Ausstieg von den 
Prozessoeren revidieren :-)

lerner schrieb:
> So und als letztes: doch noch etwas vom uc3 gefunden :-) Ich hatte mir
> einmal so ein kleines Breakout Board von Alvidi gekauft. Aus o.g.
> Gründen ist das aber verstaubt.

Dankeschön! Schaue mir dies an
Gruss Manuel

@lerner

Die Include files welche du verwendest

lerner schrieb:
> #include "gpio.h"
> #include "pm.h"

Sind die aus den Atmel app notes?

Ahm,
ich schlage mich auch schon seit Monaten mit den AVR32UC3 rum. Hab hier 
ein ein EVK1100-Board von Atmel.

Wenn man das AtmelSoftwareFramework verwendet ist es ein wenig leichter, 
weil man in den AppNotes für alles Beispiele findet.

Prinzipiell funktioniert alles wie auf einem 8Bit-µc, es ist nur alles 
ein "wenig" komplexer. Man hat seine Register, beschreibt die und wenn 
man alles richtig gemacht hat funktioniert es. (Vielleicht)

Hab mal ein Projekt angehängt, welches nur LEDs steuert und Tasten 
abfragt. (Ja, die Tastenabfrage ist noch ohne Entprellung.)


@Sebastian:
Tolles Tutorial! Hätte mir ein Haufen Zeit gespart, wenn ich es gekannt 
hätte. Vor allem der rot umrahmte Hinweis bei Hardwarefunktionen den 
Gper-Pin zu deaktivieren. Ich war am verzweifeln, bis endlich die 
SPI-Schnittstelle lief.
Arbeitest du noch weiter an dem Tutorial?

Die header sind die, die damals in dem Framework enthalten waren.

Und uc3a. Also wenn sich der thread um exklusive Hardware der Neueren 
dreht, natürlich irgendwie weniger hilfreich... Hoffe ich habe jetzt 
nicht noch Verwirrung gestiftet.

Sebastian B. schrieb:
> Damit du die Clock erst einmal initialisieren kann must du Verstehen,
> wie die Register aufgebaut sind. dann musst du dich mit dem Teils
> Schlecht dokumentieren Datenblatt herumschlagen.
> hier der Code für den RC Oscillator:

Danke!

Tom74 schrieb:
> Hab mal ein Projekt angehängt, welches nur LEDs steuert und Tasten
> abfragt. (Ja, die Tastenabfrage ist noch ohne Entprellung.)

Vielen Dank dafür!



Hallo Zusammen

Ich habe es nun tatsächlich unter anderem dank Tom74's Code geschafft 
eine LED zum leuchten zu bringen.

Ich danke euch sehr für all eure Tipps & Tricks.
Nun sollte ich selbst zu schlag kommen mit den weiteren Pins (TWI etc.).

Gruss Manuel