Hi Forum,
ein neuer Podcast ist online auf www.avrtv.com.
Gezeigt wird diesmal kurz das neue AVR32 Studio.

Have fun

Cool danke.
Weiß jemand ob (und wenn ja wo) (und wenn nicht wann) man einen AVR32
bereits "nackt" bekommt also ohne das Board?

Digikey

Aber nur die AT32AP im Bastler unfreundlichen BGA Gehäuse...
Die AT32UC mit internem Flash sollten irgendwann dieses Jahr vermutlich
auch noch kommen. Für 5-8€ bei großen Stückzahlen, also ähnlich wie die
ARM controller

Die AT32AP7000 kosten um die 20€ Netto bei Abnahme einer VPE mit 90
Stück. Zumindest war das der letzte Preis den ich bekommen hab. Bissel
arg teuer. Und BGA... wer's kann.

Der AT32AP7001 is ja im TQFP, aber leider abgespeckt (ich glaub kein
Ethernet)

Gibt es denn schon eine GCC-Portierung für den AVR32 oder einen anderen
funktionierenden C++ Compiler?

Ja gibt es:
http://www.atmel.com/dyn/products/tools_card.asp?t...
Allerdings ohne C++ Standard Library. :( Da bleib ich lieber bei ARM.

> Allerdings ohne C++ Standard Library. :( Da bleib ich lieber bei ARM.

Wo steht das?

Stekker wrote:
> Allerdings ohne C++ Standard Library. :( Da bleib ich lieber bei ARM.

Hmmmmm?

Ich zitiere aus deinem Link:

> C-libraries for development of C/C++ programs


PS: Ich glaub son STK1000 werde ich mir mal holen. Einer von den
"Homies" hier hat sich doch bereits so eins zugelegt, oder? Ich glaube
Benedikt wars. Kann man mit dem Ding eigentlich auch debuggen? Sieht auf
dem Video irgendwie danach aus...

Simon Küppers wrote:
> Kann man mit dem Ding eigentlich auch debuggen? Sieht auf
> dem Video irgendwie danach aus...

Okay habs schon gesehen, der hat da ein JTAGICE mkII dran :-)

Nein, ich habe leider noch keines, der Preis hat mich bisher davon
abgehalten. Sobald es die kleine Version mit Flash gibt, werde ich mir
aber ein paar von den AVR32 holen.

Ah, hm dann war das wohl wer anders. Hab mich grad mal nach den Dingern
etwas schlau gemacht. Das ATSTK1000 kostet 500 (!!!) Dollar. Auha!
Nenenene..

Aber ich überlege mir grad ernsthaft mir ein ATEVK1100 zuzulegen. Das
ist mit 150€ noch gut beschaffbar. Und das Dingen kann echt ne Menge. Am
meisten reizt mich das SDRAM Interface(bis 128MB!), das Onboard MAC
(Ethernet) Interface und der USB (Host-fähig!) Gedönsel. Außerdem sind
da echt ne Menge GPIOs dran, die zudem auch noch 5V tollerant sind.

Ich guck grad aber noch. So wie es scheint hat das ATEVK1100 keinen
Programmierer drauf, und wenn ich das richtig sehe lässt sich der
AVR32UC3A nur per JTAG programmieren. Und son JTAGICE ist auch nicht
gerade das billigste :(

Edit: Grad gelesen: Das/Die eingebaute(n) UART(s) haben die Möglichkeit
die Daten manchester kodiert auszugeben, auch ne tolle Sache! Außerdem
noch IrDA moduliert.

Auszug vom OnBoard Ethernet-Controller:

> • Automatic pad and CRC generation on transmitted frames
> • Address checking logic to recognize four 48-bit addresses

PadBytes einzufügen ist auch etwas neues. Das kann so'n popeliger
bastelfreundlicher Realtek8019 soweit ich weiß nicht. Und dass man sich
4 MAC-Adressen einstellen kann (versteh ich doch richtig so, oder?) habe
ich auch bisher noch nicht gesehen.

Um meine Frage zur Programmierung zu beantworten:

Es gibt da anscheinend eine Software womit man über USB und RS232 den
Flash beschreiben kann.
http://www.atmel.com/dyn/products/tools_card.asp?t...
Aber braucht man dafür nicht ne Art Bootloader? Oder irgendein kleiner
anderer Mikrocontroller der dann die Daten annimmt und sie in den AVR32
flasht? *grübel

Ansonsten bliebe nur noch das Programmieren über JTAG. Und ein JTAGICE
mkII kostet satte 350€!

PS: Hier etwas stuff dazu von avrfreaks.net:
http://avrfreaks.net/index.php?name=PNphpBB2&f...

Das EVK1100 versuch ich schon seit Wochen zu kriegen. Nix zu machen. Die
UC3A gibts mit viel Glück Ende des Jahres.

Ich hab mir erstmal ein NGW100 geholt. Auch ein geiles Teil
http://shop.embedit.de/product__590.php

Clifford wrote:
> Das EVK1100 versuch ich schon seit Wochen zu kriegen. Nix zu machen. Die
> UC3A gibts mit viel Glück Ende des Jahres.
>
> Ich hab mir erstmal ein NGW100 geholt. Auch ein geiles Teil
> http://shop.embedit.de/product__590.php

Ich hab mir grad mal das NGW100 angeschaut. Das ding ist irgendwie etwas
oversized für mich. Das hat ja echt nichts mehr mit dem klassischen AVR
am Hut (Soll es aber auch nicht). Das kommt ja quasi mit Linux
ausgeliefert... Nene, da kann ich ja direkt Anwendungen für meinen
Core2Duo 1,8Ghz hier schreiben.

Ich wollte schon noch was mit Flash, wo man den Chip selber noch
konfigurieren kann und die Register selbst beschreibt...

Schade, werde ich wohl auch warten müssen.

PS: Wo hast du denn überall versucht das EVK1100 zu bekommen, und wann
war das?

@Clifford
Schaut sehr gut aus; wie wird es programmiert?
Also aus dem AVR32 Studio mit JTAG? Funktioniert auch ein billig
programmer oder nur JTAGICE ?

Ich bastele hier lustig mit dem NGW100. Den kannst Du auch mit dem
AVR32STUDIO 'nackt' programmieren, d.h. ohne Linux. Außerdem gab es
irgendwo einen Deal bzgl. dem JTAGICE mkII. Das war im Bundle mit dem
STK500 (leider nachdem ich schon teures Geld dafür ausgegeben hatte):

Beitrag "Angebot bei Spoerle !!!"


Hier

Beitrag "AT32AP7000 - USB Controller"

habe ich schon einmal ein wenig Quelltext veröffentlicht, der ohne Linux
auf dem NGW100 auskommt.

> PS: Ich glaub son STK1000 werde ich mir mal holen.

Hm, du wolltest dir das STK1000 holen und findest das NGW100 oversized?
Da komm ich jetzt nicht hinterher

> Schaut sehr gut aus; wie wird es programmiert?

Gnu Toolchain und am besten auch das AVR32 Studio installieren (am PC).
Ganz normal, wie unter Linux, ein Programm schreiben. Fertiges Programm
per FTP hochladen.

Das NGW100 hat auch einen Bootloader namens U-Boot. Damit kann man sogar
ohne Linux das Flash löschen und via FTP neue Programme ins Flash
schreiben.

Den JTAGICE mkII braucht man nur zum Debuggen oder wenn man das Flash
komplett geschossen hat

Hier ein kleines Tutorial was man mit dem so machen kann
http://www.wiki.elektronik-projekt.de/w/index.php/...

and here....
http://www.avrfreaks.net/wiki/index.php/Documentat...

Clifford wrote:
>> PS: Ich glaub son STK1000 werde ich mir mal holen.
>
> Hm, du wolltest dir das STK1000 holen und findest das NGW100 oversized?
> Da komm ich jetzt nicht hinterher


Nö, ich wollte mir das EVK1100 holen, wie ich im Nachhinein festgestellt
habe. Die AVR32AP7 Serie ist mir etwas zu High-End ;)

Deswegen wollte ich auch wissen, wo du probiert hast dein EVK1100 zu
kaufen. Ich hab zwei oder drei Distributoren gefunden, die das im Shop
haben. Was das heißen mag - keine Ahnung.

> Nö, ich wollte mir das EVK1100 holen,

Das mußte dann aber auch sagen ;)


ich hab bei 4 Distributoren angerufen. Sind bestellt, aber noch nicht
lieferbar. KW32 soll was kommen

Die SW gibt's komplett bei http://www.atmel.no/beta_ware/
Aber 256MB sind reichlich, also Downloadzeit mitbringen! :)

Simon Küppers wrote:
> Ich zitiere aus deinem Link:
> > C-libraries for development of C/C++ programs

C-Libraries != C++ Libraries!

Entweder es gibt tatsächlich keine C++ Standard Libary in diesen
Compiler oder die haben sich verschrieben. Hat mal jemand nachgeschaut?

Das ist doch der gcc, den die verwenden. Da kannst Du Dir im Fall, dass
es das tatsächlich nicht gibt, den Kram einfach selbst kompilieren...

So einfach ist das bei inoffiziellen Portierungen leider nicht. Beim
MSPGCC kann ich auch nicht einfach die STL bauen. Da werde ich mit
Tausenden von Fehlermeldungen bombardiert.

Hey, es gibt jetzt ein online Tutorial zum NGW auf avrtv.com!

Have fun

Argh, der interessante Teil kommt wohl erst im nächsten Part. Menno!
Sieht aber interessant aus.

Sou, gestern ist mein EVK1100 angekommen. Wollte das ganze erstmal ohne
JTAGICE mkII probieren. Manche Quellen sagen, dass es per USB-Bootloader
gehen soll (DFU Class von Atmel). Aber ich krieg im AVR32 UC3 nicht den
Bootloader gestartet. Die Docs vom Kit sagen, man soll den Joystick beim
Reset gedrückt halten - geht nicht. Ich werd mal schauen ob ich irgendwo
einen JTAGICE mkII auftreiben kann.

Nunja, ansonsten macht das Board aber einen sehr guten Eindruck. Das
"Control Panel", was standardmäßig auf den Chip geflasht ist, macht auch
nen tollen Eindruck ;) So konnte man wenigstens schon ein bisschen mit
der Peripherie spielen.

ISP und IIC/I²C/TWI ist per 100mil (2,54mm RM) unbestückter Steckleiste
herausgeführt. Die kompletten Ports aber als 50mil (1,27mm RM) ebenfalls
unbestückter Steckleiste.

Nunja, ich hab mal Atmel eine E-Mail geschickt. Vielleicht wissen die
ja, was vor sich geht.

Wo hast du das Board bestellt? Bei Digikey?

Von der Elmicro "filiale" in Detmold:
http://elmicro.com/de/atevk1100.html

Auf www.avrtv.com ist jetzt der interessante Teil des NGW100 online.
Sieht ganz interessant aus.

Hat jemand Infos darüber, wie viel Strom das Board (NGW) aufnimmt?

Habe im Forum einen Beitrag gefunden, in dem ca. 110 mA genannt wurden.
Leider stand nichts dabei, unter welchen Bedingungen. Ich habe vor, das
Board als Web-Interface für meine Rollosteuerung zu betreiben, d. h.
eine Netzwerkschnittstelle muss dauernd in Betrieb sein.

Weiß jemand vielleicht, ob die Versorgungsspannung sich unter 9V
reduzieren lässt? Laut Schaltbild
http://www.avrfreaks.net/wiki/index.php/Documentat...
müsste es eigentlich reichen ca. 5 V über J16 einzuspeisen.

Hi Simon,

wie sieht es denn mit C++ Code bei deinem Board aus? Kannst du in der
Software C-Programmer schreiben, die die STL benutzen (z.B. die vector
Klasse)?

Außerdem würde es mich interessieren, ob man überhaupt sinnvoll (im
Bezug auf die Code Größe eigener Klassen) C++ Programme dort schreiben
kann. Ich hatte vor ein paar Monaten mal mit einem AVR Compiler (weiß
gerade nicht mehr ob es ICC oder AVRGCC war) versucht ein
objektorientiertes Programm mit 2 sehr einfach gestrickten Klassen
(jeweils nur eine integer Variable) zu kompilieren. Das ging auch und
hat sogar korrekt funktioniert - allerdings hatte eine nahezu leere
Klasse schon 2kB an Code gehabt (wahrscheinlich wegen Default/Copy
Konstruktoren, Destruktor usw.). Damit hatte sich dann die Frage nach
objektorientierter Programmierung beim AVR für mich erledigt. Ich würde
gern wissen, wie das mit den AVR32 Prozessoren aussieht, da ich aufgrund
der Wartbarkeit größerer Programmer lieber objektorientiert arbeite.

Danke schonmal,
Thomas

Ich versteh nicht so ganz wo dein Problem liegt. Klassen aus der STL
lassen sich wunderbar kompilieren.

Folgender simpler Code beispielsweise kompiliert ohne Probleme:

#include <string>
#include <iostream>

int main()
{
  std::string Test("Teststring");
  
  std::cout << Test;
  
  return 0;
}

Ich guck aber gerade noch, wo ich die Größe des eigentlichen Binaries,
das im Nachhinein auf den Prozessor geflasht wird, finde.

Hi,

es ist eigentlich weniger ein Problem als mehr meine Neugier :)
Insbesondere der Teil mit der Code Größe würde mich interessieren, da ja
offenbar eine Implementierung der STL beiliegt.

Gruß,
Thomas

Ah, wusste garnicht, dass es ein avr32-size Tool gibt. Warum wird das
nicht ins managed Makefile aufgenommen? :-(

D:\_Projekte\_avr32\cpptest\Debug>avr32-size -x main.o
   text    data     bss     dec     hex filename
   0x88    0x78     0x1     257     101 main.o

Das ist obiger Code kompiliert. Ist also nicht wirklich groß ;)

Hi Simon,

wie sieht denn ein Vergleich folgender Möglichkeiten aus? Ich denke,
dass das etwas aussagekräftiger ist, als ein einfaches ausgeben per
cout.

----------Version in C++ mit Klasse----------

#include <iostream>
#include <vector>

class Test
{
  unsigned char value;
  Test() : value(0)
  {}

  Test(unsigned int value_) : value(value_)
  {}

  void print(void)
  {
    std::cout << value << ' ';
  }
};

int main()
{
  std::vector<Test> bla(50, Test(1));

  //Alternativ mit for Schleife
  /*
  std::vector<unsigned char> bla;
  for (unsigned int i=0; i<50; ++i)
  {
    bla.push_back(Test(1));
  }
  */

  for (unsigned int i=0; i<50; ++i)
  {
    bla[i].print();
  }
  std::cout << endl;

  return 0;
}

----------Version in C++----------

#include <iostream>
#include <vector>
#include <algorithm>

void print (int val)
{
  std::cout << val << ' ';
}

int main()
{
  std::vector<unsigned char> bla(50, 1);

  //Alternativ mit for Schleife
  /*
  std::vector<unsigned char> bla;
  for (unsigned int i=0; i<50; ++i)
  {
    bla.push_back(1);
  }
  */

  std::for_each (bla.begin(), bla.end(), print);
  std::cout << endl;

  return 0;
}

----------C-ähnliche Version in C++----------

#include <iostream>
#include <vector>

int main()
{
  unsigned char bla[50];
  for (unsigned int i=0; i<50; ++i)
  {
    bla[i] = 1;
  }

  for (unsigned int i=0; i<50; ++i)
  {
    std::cout << bla[i] << ' ';
  }
  std::cout << endl;
  return 0;
}


----------Version in C----------

#include <stdio.h>

int main()
{
  unsigned char bla[50];
  unsigned int i = 0;
  for (; i<50; ++i)
  {
    bla[i] = 1;
  }

  for (i=0; i<50; ++i)
  {
    printf("%d ", bla[i]);
  }
  printf("\n");
  return 0;
}

Ich hoffe mal, dass ich mich jetzt nicht vertippt habe :)
Es wäre sehr interessant, wenn du das mal ausprobieren könntest.

Danke schonmal im voraus,
Thomas

Etwas korrigiert (std::endl statt endl), folgende Ergebnisse (Debug
Compilat)

#include <iostream>
#include <vector>

class Test
{
public:
  
  unsigned char value;
  Test() : value(0)
  {}

  Test(unsigned int value_) : value(value_)
  {}

  void print(void)
  {
    std::cout << value << ' ';
  }
};

int main()
{
  std::vector<Test> bla(50, Test(1));

  for (unsigned int i=0; i<50; ++i)
  {
    bla[i].print();
  }
  std::cout << std::endl;

  return 0;
}

D:\_Projekte\_avr32\cpptest\Debug>avr32-size main.o
   text    data     bss     dec     hex filename
   2288     366       1    2655     a5f main.o

#include <iostream>
#include <vector>
#include <algorithm>

void print (int val)
{
  std::cout << val << ' ';
}

int main()
{
  std::vector<unsigned char> bla(50, 1);

  std::for_each (bla.begin(), bla.end(), print);
  std::cout << std::endl;

  return 0;
}

D:\_Projekte\_avr32\cpptest\Debug>avr32-size main.o
   text    data     bss     dec     hex filename
   2296     403       1    2700     a8c main.o

#include <iostream>
#include <vector>

int main()
{
  unsigned char bla[50];
  for (unsigned int i=0; i<50; ++i)
  {
    bla[i] = 1;
  }

  for (unsigned int i=0; i<50; ++i)
  {
    std::cout << bla[i] << ' ';
  }
  std::cout << std::endl;
  return 0;
}

D:\_Projekte\_avr32\cpptest\Debug>avr32-size main.o
   text    data     bss     dec     hex filename
    276     148       1     425     1a9 main.o

#include <stdio.h>

int main()
{
  unsigned char bla[50];
  unsigned int i = 0;
  for (; i<50; ++i)
  {
    bla[i] = 1;
  }

  for (i=0; i<50; ++i)
  {
    printf("%d ", bla[i]);
  }
  printf("\n");
  return 0;
}

D:\_Projekte\_avr32\cpptest\Debug>avr32-size main.o
   text    data     bss     dec     hex filename
    136      64       0     200      c8 main.o

Hier nochmal im Überblick die 4 Varianten:

D:\_Projekte\_avr32\cpptest\Debug>avr32-size main.o
   text    data     bss     dec     hex filename
   2288     366       1    2655     a5f main.o

D:\_Projekte\_avr32\cpptest\Debug>avr32-size main.o
   text    data     bss     dec     hex filename
   2296     403       1    2700     a8c main.o

D:\_Projekte\_avr32\cpptest\Debug>avr32-size main.o
   text    data     bss     dec     hex filename
    276     148       1     425     1a9 main.o

D:\_Projekte\_avr32\cpptest\Debug>avr32-size main.o
   text    data     bss     dec     hex filename
    136      64       0     200      c8 main.o

Hi,

das ist ja sehr interessant. Offenbar macht ihm der Vector doch deutlich
zu schaffen. Möglicherweise kommt es daher, dass er ja dynamisch den
Speicher erweitern muss.

Was mich überrascht ist, dass die Version mit der eigenen C-Klasse nicht
viel größer ist als die Version ohne.

Könntest du da nochmal folgendes gegen Checken?:

#include <iostream>
#include <vector>

class Test
{
public:

  unsigned char value;
  Test() : value(0)
  {}

  Test(unsigned int value_) : value(value_)
  {}

  void print(void)
  {
    std::cout << value << ' ';
  }
};

int main()
{
  Test bla[50];

  for (unsigned int i=0; i<50; ++i)
  {
    bla[i].value = 1;
  }

  for (unsigned int i=0; i<50; ++i)
  {
    bla[i].print();
  }
  std::cout << std::endl;

  return 0;
}

Vielen Dank übrigens für Deine Mühen.

Gruß,
Thomas