aTeVaL 2.0 – das Universalwerkzeug

Über den Beitrag

In diesem Beitrag möchte ich euch das aTeVaL 2.0 Board vorstellen, auf das ich vor ein paar Wochen gestoßen bin und das ich für eine ziemlich geniale Erfindung halte. Insbesondere empfehle ich es denjenigen, die mal über den Arduino Tellerrand hinaus- und in die C-Programmierung verschiedener Microcontroller hineinschauen wollen, zum Beispiel per Atmel Studio (deswegen übrigens der Marienkäfer im Beitragsbild – ein Marienkäfer ist das Logo des Programms).

Um die „nackten“ Microcontroller per Atmel Studio zu programmieren, müsst ihr spezielle und teilweise teure Programmer verwenden. Hinzu kommt einige Verkabelungsarbeit, wenn ihr zwischen der Arduino und der Atmel Studio Welt hin- und herwechseln wollt. Und hier kommt das aTeVaL 2.0 Board ins Spiel. Mit dem Board könnt ihr (unter anderem):

  • einen Arduino UNO simulieren und mit der Arduino IDE programmieren
  • verschiedene andere AVR Microcontroller mit der Arduino IDE programmieren
  • alle AVR Microcontroller direkt mit Atmel Studio programmieren
  • zwischen der Arduino IDE und Atmel Studio ohne große „Umstöpselei“ hin- und herwechseln
  • Sketche mit den auf dem Board integrierten Tastern, LEDs, Potis und dem Buzzer testen
  • problemlos zwischen 5.0 und 3.3 Volt Ausgangsspannung wechseln
Das zusammengebaute aTeVaL 2.0 Board
Das zusammengebaute aTeVaL 2.0 Board

Ich habe übrigens keinerlei wirtschaftliche Vorteile davon, das aTeVaL 2.0 Board zu empfehlen. Ich bin einfach nur ganz begeistert von dem guten Stück!

Vorbereitungen

Wo ihr das Board herbekommt

Der aTeVaL 2.0 (steht wohl für Atmel Evaluation) wird von der Firma eHaJo in Bayern hergestellt. „Made with love and brain in bavaria“ ist auf der Rückseite des Boards zu lesen. Es gibt ihn nur als Bausatz, aber sofern ihr einen Lötkolben und keine zwei linken Hände habt, ist das Board problemlos in 30 Minuten zusammengebaut. Alle SMD Bauteile sind vorgelötet. Das gute Stück kostet 29,90 Euro plus Versand (Stand April 2020). Ich habe zwei davon bestellt und beide kamen gut verpackt innerhalb weniger Tage bei mir an. 

Microcontroller werden nicht mitgeliefert, die müsst ihr separat bestellen. Es gibt eine Auswahl auch bei eHaJo – das spart Versandkosten. Auf jeden Fall empfehle ich euch die Anschaffung eines ATmega328P oder gleich mehrerer. Wichtig ist, dass es die „P“ Variante ist, wenn ihr den aTeVaL per Arduino IDE programmieren wollt. Ihr könnt aber auch einfach erstmal den ATmega328P aus eurem Arduino UNO verwenden, falls ihr einen habt. 

Der Zusammenbau

Die Platine des aTeVal 2.0 .....
Die Platine des aTeVal 2.0 …..
.... und hier die Teile zum Auflöten bzw. Aufstecken für den aTeVaL 2.0
…. und hier die Teile zum Auflöten bzw. Aufstecken

Zum Zusammenbau gibt es vom Hersteller ein schönes Video hier auf YouTube. Dort werden auch ein paar ganz hilfreiche Tipps zum Löten gegeben. Wie schon erwähnt, alles einfach, aber macht es in Ruhe und überprüft nach der jeweils ersten Lötverbindung lieber doppelt, ob alles richtig herum eingesteckt ist. Einen Lötpunkt kann man wieder lösen, aber wenn ihr z.B. den 40-Pin Wannenstecker vollständig und falsch herum eingelötet habt, dann ist das schwer zu korrigieren. 

Es gibt ein paar Lötjumper auf dem Board, zum Beispiel für die LEDs oder den Bootloader. Ich empfehle sie alle zu verbinden. 

„Füße“ werden nicht mitgeliefert. Wie ihr weiter oben seht, habe ich Abstandshalter dafür verwendet. Es gibt auch kein Gehäuse, aber das würde aus meiner Sicht auch gar keinen Sinn machen, da fast die gesamte Oberfläche zugänglich sein muss.

Treiberinstallation

Treiber sind oft ein Quell reichhaltiger Probleme – hier aber nicht! Auf den Dokuwiki Seiten des Herstellers findet ihr sowohl eine Anleitung für die Installation wie auch die Treiber selbst. Je nachdem, ob ihr den Jumper „ISP“ neben dem ATmega32U2 (der IC mit den 32 Beinchen) setzt, verhält sich der aTeVaL wie ein ISP Programmer oder wie eine serielle Schnittstelle. Für beide Einstellungen ist ein Treiber notwendig. Folgt einfach den Anweisungen. Das muss ich hier ja nicht noch einmal beschreiben, da es schon sehr gut beschrieben ist.

ISP Jumper auf dem aTeVal 2.0 Board
ISP Jumper auf dem aTeVaL 2.0 Board

Einsetzen eines Microcontrollers

Den Microcontroller eurer Wahl setzt ihr in die passende Fassung ein. Es darf immer nur ein Microcontroller eingesetzt werden, unter anderem weil die ISP-Leitungen mit allen IC-Fassungen verbunden sind. Ihr könnt also nicht „umschalten“. Das Einsetzen der ICs sollte nie mit Gewalt erfolgen. Bei frischen Microcontrollern müsst ihr die Beinchen vorab ein wenig zusammendrücken. Auch das Herausnehmen ist so eine Sache – dafür empfehle ich eine IC-Zange

aTeVaL 2.0 Board in die Arduino IDE integrieren

Der aTeVaL 2.0 versetzt euch in die Lage, verschiedene AVR Microcontroller mit der Arduino IDE programmieren zu können, also nicht nur den ATmega328P. Das müsst ihr der Arduino IDE aber erst einmal beibringen. Dazu müsst ihr lediglich in den Voreinstellungen bei den Boardverwalter URLs die Zeile „https://www.ehajo.de/dokuwiki/_media/package_ehajo_index.json“ hinzufügen und im Boardverwalter die eHaJo Boards installieren. Dort einfach nach „ehajo“ suchen. Wenn ihr das schon mal gemacht habt, sollten diese Informationen ausreichen. Falls nicht, findet ihr eine detaillierte Anleitung hier bei eHaJo. Wenn ihr erfolgreich wart, dann solltet ihr die Boards nach Neustart der Arduino IDE in den Werkzeugen sehen.

aTeVaL Boardauswahl in der Arduino IDE
aTeVaL Boardauswahl in der Arduino IDE

Schnellstart

Der aTeVaL 2.0 als Arduino UNO

Das Board ist zusammengelötet, die Treiber sind installiert, die Boards in der Arduino IDE installiert – nun kann es losgehen. Als Erstes möchte ich euch zeigen, wie der aTeVaL 2.0 als Arduino eingesetzt werden kann.

Den Arduino UNO Bootloader brennen

Wenn ihr nicht wisst, was ein Bootloader ist und wozu man ihn braucht, dann empfehle ich euch dieses YouTube Video von eHaJo. Ich habe noch nirgendwo eine so klare, auch für Anfänger verständliche Erklärung gefunden – sehenswert. 

Zunächst muss also der Arduino Bootloader auf den ATmega328P gebrannt werden, wenn ihr das Board als Arduino benutzen wollt. Das geht nur im ISP Modus. Folgt diesen Schritten:

  • setzt einen ATmega328P in die 28-Pin IC-Fassung
  • der ISP Jumper muss gesetzt werden, damit das Board als Programmer eingesetzt werden kann
  • setzt die Serial USART Jumper (neben dem Buzzer)
  • setzt den 16 MHz Oszillator in den Halter neben C4 und C18
  • schließt das Board per USB an den PC 
    • ihr seht keinen Port in den Werkzeugen (der Eintrag ist hellgrau) – das ist kein Wunder, da das Board als ISP Programmer keine serielle Schnittstelle ist
  • wählt in der Arduino IDE als Board den Arduino UNO aus
  • als Programmer wählt ihr den „AVRISP mkII“
  • geht auf Werkzeuge –> Bootloader brennen; nach wenigen Sekunden sollte die Erfolgsmeldung kommen

 

Einen Arduino Sketch hochladen und das Board testen

Nun verlasst ihr den ISP Modus, indem ihr den aTeVaL vom PC trennt, den ISP Jumper zieht und das Board wieder an den PC anschließt. Wenn ihr jetzt in Werkzeuge geht, sollte „Port“ nicht mehr ausgegraut sein. Setzt einen Haken dahinter. Als Board sollte immer noch „Arduino UNO“ eingestellt sein und als Programmer „AVRISP mkII“. Nun könnt ihr Sketche auf ganz normalem Wege hochladen. 

Sofern ihr alle Löt-Jumper verbunden und die Poti-Jumper gesetzt habt, verhält sich das Board dem folgenden Fritzing Schema entsprechend:

Ersatzschaltbild für den aTeVal 2.0 als Arduino UNO
Ersatzschaltbild für den aTeVal 2.0 als Arduino UNO

Der folgende Sketch testet die auf dem aTeVaL Board integrierten Taster, LEDs, Potis und den Buzzer. Ich glaube der Sketch braucht keine großen Erläuterungen, außer vielleicht die Zeile 40: if((millis()%1000)==0). Die Bedingung wird einmal pro Sekunde für eine Millisekunde wahr, d.h. einmal pro Sekunde werden die Potiwerte ausgegeben. Eine schöne Alternative zu delay Konstruktionen, denn die würden die Abfrage der Taster stören. 

const int poti1Pin = A1;
const int poti2Pin = A0;
const int ledGruenPin = 8;
const int ledGelbPin = 5;
const int ledRotPin = 6; 
const int buzzerPin = 7;
const int taster1 = 2;
const int taster2 = 3;
const int taster3 = 4;
float poti1Voltage, poti2Voltage = 0; 

void setup(){
  Serial.begin(9600);
  pinMode(ledGruenPin, OUTPUT);
  pinMode(ledGelbPin, OUTPUT);
  pinMode(ledRotPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  digitalWrite(taster1, HIGH);
  digitalWrite(taster2, HIGH);
  digitalWrite(taster3, HIGH);
  ledAndBuzzerTest();
}

void loop(){
  if(!digitalRead(taster1)){
    digitalWrite(ledRotPin, HIGH);
    delay(1000);
    digitalWrite(ledRotPin, LOW);
  }
  if(!digitalRead(taster2)){
    digitalWrite(ledGelbPin, HIGH);
    delay(1000);
    digitalWrite(ledGelbPin, LOW);
  }
  if(!digitalRead(taster3)){
    digitalWrite(ledGruenPin, HIGH);
    delay(1000);
    digitalWrite(ledGruenPin, LOW);
  }
  if((millis()%1000)==0){
    poti1Voltage = analogRead(poti1Pin)/1023.0 * 5.0;
    Serial.print("Poti 1 [V]: ");
    Serial.print(poti1Voltage);
    poti2Voltage = analogRead(poti2Pin)/1023.0 * 5.0;
    Serial.print("  /  Poti 2 [V]: ");
    Serial.println(poti2Voltage);
  }
}

void ledAndBuzzerTest(){
  digitalWrite(ledGruenPin, HIGH);
  delay(500);
  digitalWrite(ledGelbPin, HIGH);
  delay(500);
  digitalWrite(ledRotPin, HIGH);
  tone(buzzerPin, 1000);
  delay(2000);
  digitalWrite(ledGruenPin, LOW);
  digitalWrite(ledGelbPin, LOW);
  digitalWrite(ledRotPin, LOW);
  noTone(buzzerPin);
}

 

Weitere Pins verbinden

Alle I/O-Pins des ATmega328P sind auch auf dem 40-poligen Wannenstecker ausgeführt. Wo sich welcher Pin dort genau versteckt, seht ihr auf dem folgenden Schema:

Pinout des ATmega328P auf dem 40-poligen Wannenstecker (mit freundlicher Genehmigung von eHajo)
Pinout des ATmega328P auf dem 40-poligen Wannenstecker (mit freundlicher Genehmigung von eHajo)

Setzt ihr „Achtbeiner“ wie den ATtiny85, „Zwanzigbeiner“ wie den ATtiny2313 oder „Vierzigbeiner“ wie den ATmega16 auf das Board, gelten entsprechende andere Schemata, die ihr hier findet. 

Zurechtfinden mit dem Breadboardadapter

Wenn ihr die Pins des Wannensteckers per Steckbrückenkabel mit einem Breadboard verbindet, dann könnt ihr euch dabei leicht vertun. Am besten bestellt ihr mit dem aTeVaL gleich einen Breadboardadapter mit passendem Flachbandkabel. Beides findet ihr hier für 4,80 Euro plus Versand (Stand April 2020) – es lohnt sich. 

Breadboardadapter für den aTeVaL
Breadboardadapter für den aTeVaL

Atmel Studio mit dem aTeVaL 2.0

Atmel Studio ist eine kostenlose IDE (Entwicklungsumgebung)  der Fa. Microchip, also dem Hersteller der AVR Microcontroller. Ihr könnt das Programm hier herunterladen. Atmel Studio ist erheblich komplexer als die Arduino IDE, aber dafür auch wesentlich mächtiger. Eine Einführung von mir findet ihr hier. In diesem Beitrag kann ich nur in groben Zügen skizzieren, was ihr tun müsst. Alles andere würde den Rahmen sprengen.

Wenn ihr den Treiber für den aTeVaL als ISP Programmer installiert habt, sollte Atmel Studio ihn ohne Probleme erkennen, bei mir hat es jedenfalls auf Anhieb geklappt. Natürlich müsst ihr dazu den ISP Jumper gesetzt haben. 

aTeVaL als AVRISP mkII Programmer in Atmel Studio
aTeVaL als AVRISP mkII Programmer in Atmel Studio

Eine Einschränkung gegenüber teuren Programmern wie dem Atmel-ICE oder dem AVR Dragon gibt es dann aber doch. Eine debugWire Programmierung ist nicht möglich.

Einstellung der Fuse Bits

Ein frischer Microcontroller hat gewisse Voreinstellungen, wie z.B. die Taktfrequenz, die Taktquelle oder den Taktteiler (Clock Divider). Diese Voreinstellungen könnt ihr im Bereich „Device Programming“ ändern (Strg + Umschalt + P). Bei der Wahl der Einstellungen ist allerdings ein wenig Vorsicht geboten. Bei falschen Einstellungen kann man sich durchaus regelrecht aussperren und kommt dann nur mit speziellen Programmern wie dem AVR Dragon wieder rein. 

Als Beispiel bereite ich den ATmega328P für 16 MHz mit externem Oszillator vor. In diesem Fall muss ich den Haken beim Clock Divider (LOW.CKDIV8) entfernen, falls er denn gesetzt war, und die richtige Einstellung für den Oszillator wählen:

Einstellungen für den ATmega328P in Atmel Studio
Einstellungen für den ATmega328P in Atmel Studio (7)

Ein Testprogramm für den ATmega328P

Auch für Atmel Studio habe ich ein kleines Programm geschrieben, mit dem ihr die auf dem Board integrierten Taster, LEDs, usw. testen könnt. Es funktioniert etwas anders als der Arduino Testsketch, da kein serieller Monitor zur Verfügung steht, mit dem ihr die Poti-Werte ausgeben könntet. Stattdessen wird hier die Buzzerfrequenz über die Poti-Werte eingestellt. Probiert es einfach mal aus. Die Steuerung erfolgt über den Timer1 – vielleicht hat der eine oder andere ja meinen Beitrag zu diesem Thema gelesen. 

Auf die weiteren Details des Programmcodes möchte ich hier aber nicht näher eingehen. Stattdessen verweise ich euch auf die gut kommentierten C-Programmbeispiele bei eHaJo.

Wer noch keine Erfahrung in C-Programmierung hat, der mag das ziemlich abschreckend finden. Aber es ist weniger schwer als man denkt, es sieht nur ein wenig kryptisch aus. Im Grunde arbeitet man wie mit einer großen Schalttafel und muss lediglich die einzelnen Schalter kennen und in der richtigen Reihenfolge „drücken“. Einsteigern empfehle ich dieses Buch oder vielleicht zunächst meinen Beitrag über Binärlogik und Portmanipulation

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define F_CPU		16000000UL
#define LED_GRUEN	(1<<PB0)
#define LED_GELB	(1<<PD5)
#define LED_ROT		(1<<PD6)
#define TASTER1		(1<<PD2)
#define TASTER2		(1<<PD3)
#define TASTER3		(1<<PD4)
#define BUZZER		(1<<PD7)


int main(void)
{
  uint16_t poti1Wert, poti2Wert;
  
  DDRB |= LED_GRUEN;
  DDRD |= BUZZER | LED_ROT | LED_GELB;
  PORTD |= TASTER3 | TASTER2 | TASTER1;
  TIMSK1 |= (1<<OCIE1A);
  ADCSRA |= (1<<ADEN);
  ADMUX |= (1<<REFS0);
  ADCSRA |= (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0) ;
  ADCSRA |= (1<<ADSC);
  
  while (ADCSRA & (1<<ADSC))
  {}
  poti1Wert = ADCW;
  
  sei();
  
    while (1) 
    {
    ADMUX &= ~(1<<MUX0);
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC))
    {}
    poti2Wert = ADCW;
    
    ADMUX |= (1<<MUX0);
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC))
    {}
    poti1Wert = ADCW;
    
    if(!(PIND & TASTER1))
    {
      PORTB |= LED_GRUEN;
      OCR1A = 5000 + poti1Wert*16;
      TCCR1B |= (1<<CS10) | (1<<WGM12);
    }
        
    else if(!(PIND & TASTER2))
    {
      PORTD |= LED_GELB;
      OCR1A = 5000 + poti2Wert*16;
      TCCR1B |= (1<<CS10) | (1<<WGM12);
    }
    
    else if(!(PIND & TASTER3))
    {
      PORTD |= LED_ROT;
    }
    
    else if(PIND & (TASTER1 | TASTER2 | TASTER3))
    {
      PORTB &= ~LED_GRUEN;
      PORTD &= ~LED_GELB;
      PORTD &= ~LED_ROT;
      TCCR1B = 0;
      
    }
    }
}

ISR(TIMER1_COMPA_vect)
{
  PORTD ^= BUZZER;
}

 

Andere Microcontroller in der Arduino IDE verwenden

Einer der Vorzüge des aTeVaL 2.0 ist, dass ihr außer dem ATmega328P noch weitere Microcontroller direkt in der Arduino IDE programmieren könnt. Ihr findet die Auswahl unter Werkzeuge –> Board: … –> eHaJo Boards –> aTeVaL Boards. Neben dem ATmega328P habe ich den ATtiny85 und den ATtiny2313 ausprobiert und es funktionierte wunderbar.

Beim ATmega16 mit seinen 40 Pins hatte ich leider Probleme. Beim Kompilieren gab es eine Fehlermeldung (unabhängig vom Sketch):

Fehlermeldung mit dem ATmega16

Beispiel: ATtiny85 auf dem aTeVaL 2.0

Zunächst müsst ihr den ATtiny85 (richtig herum) in die Fassung für die 8-Pin Microcontroller einsetzen. Die Programmierung erfolgt über ISP, ihr setzt also den Jumper. In der Arduino IDE wählt ihr den ATtiny85:

Auswahl ATtiny85
Auswahl ATtiny85

Als Programmer nehmt ihr wieder den AVRISP mkII. Als Takt habe ich „8 MHz (intern)“ gewählt. Zum Ausprobieren nehmt z.B. einen einfachen Blink Sketch wie diesen hier:

void setup() {
// 4 = PB4 = Pin Nr. 3 auf ATtiny85 = Pin Nr. 12 auf dem 40 pol. Wannenstecker
  pinMode(4, OUTPUT); 
}

void loop() {
  digitalWrite(4, HIGH);   
  delay(1000);                       
  digitalWrite(4, LOW);   
  delay(1000); 
}

 

Bei Verwendung eines 8-Pin Microcontrollers ist dieser leider mit keiner der internen LEDs verbunden. Ihr müsst also eine extern anschließen und dabei das entsprechende Ausgangsschema verwenden:

Pinout der 8-Pin Microcontroller auf dem 40-poligen Wannenstecker (mit freundlicher Genehmigung von eHajo)
Pinout der 8-Pin Microcontroller auf dem 40-poligen Wannenstecker (mit freundlicher Genehmigung von eHajo)

Dann ladet ihr den Sketch über „Hochladen mit Programmer“ bzw. Strg + Umschalt + U hoch. Und siehe da: wenn ihr einen frischen ATtiny85 verwendet, wird die LED mit großer Wahrscheinlichkeit nicht mit 1 Hz, sondern mit 1/8 Hz blinken. Wählt ihr anstelle der 8 MHz Taktfrequenz 1 MHz, ist die Welt in Ordnung. In der Arduino IDE wählt ihr also die im Microcontroller eingestellte Taktfrequenz, ihr verändert sie aber nicht. 

Wie ändere ich dann die Taktfrequenz?

Den Takt könnt ihr ganz leicht mit Atmel Studio ändern, auch wenn ihr euch mit dem Programm noch nicht auskennt: Programm starten –> Strg + Umsch + p –> Tool auswählen –> Device auswählen –> Apply –> Fuses –> Haken bei Clock Divider rausnehmen –> auf „Program“ klicken. Und schon blinkt die LED in der richtigen Frequenz.

ATtiny85: Änderung der Taktfrequenz
ATtiny85: Änderung der Taktfrequenz in Atmel Studio

Zurück in der Arduino IDE könnt ihr ja jetzt mal 1 MHz als Takt wählen und schauen was passiert. 

Danksagung

Ich habe mal wieder einige Bilder von Pixabay als Grundlage für mein Beitragsbild verwendet:

Der Firma eHaJo danke ich für die Entwicklung dieses schönen Boards, die prompte Beantwortung technischer Fragen und die Erlaubnis, einige Schemata benutzen zu dürfen. 

 

3 thoughts on “aTeVaL 2.0 – das Universalwerkzeug

  1. Hallo Wolle,

    interessant ist jedoch die Tatsache, wenn man auf den Attiny85 einen Sketch mit Arduino drauf lädt und im Vergleich das gleiche Programm (über Atmen Studio geschrieben) auf den Chip hoch schiebt.
    Die Arduino IDE spart nicht gerade Speicherplatz 🙂

    1. Hi Frank, vielen Dank nochmal für deinen Tipp. Und ja, die Arduino IDE ist wirklich nicht sparsam – aber für Einsteiger leichter zugänglich. Deswegen finde ich den aTeVaL auch so gut – ideal für Leute die gerne über den Arduino Tellerrand hinausschauen wollen. VG, Wolle

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.