AVR32 online video

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

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?tool_id=4118
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?

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
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):

http://www.mikrocontroller.net/topic/69544


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/NGW100_First_Steps

and here....
http://www.avrfreaks.net/wiki/index.php/Documentation:NGW/FirstSteps

> 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

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

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

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

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