aTeVaL 2.0 – das Universalwerkzeug

Über den Beitrag

Hinweis: Leider schließt der Hersteller des aTeVaL 2.0, eHaJo, seinen Online-Shop Ende 2023. Der aTeVal 2.0 ist leider jetzt schon nicht mehr verfügbar. Schade!

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. 

 

20 thoughts on “aTeVaL 2.0 – das Universalwerkzeug

  1. Hallo! Ich habe noch eine kurze (Anfänger-)Frage:
    Es steht, dass debugWire Programmierung nicht möglich ist. Heißt das, dass man gar nicht debuggen kann wie mit einem AVR Dragon z.B.?
    Danke schon mal!
    Viele Grüße
    Andreas

  2. Hallo Wolle!
    Ich schreibe mal eine e-Mail damit ich einige Screenshoot liefern kann.
    Das Problem ist nicht gelöst 🙁

    Grüße
    Franz-Bernd

    1. Hallo Franz-Bernd, ich hatte ja schon per e-mail geantwortet, hier nun auch für andere Leser: Die Treiber sind anscheinend korrekt installiert. Trotzdem funktioniert der Upload nicht. Am Setzen des ISP Jumpers liegt es auch nicht. Ich weiß nicht woran es noch liegen könnte. Frage an alle Leser: Ist irgendjemand auf so ein Problem gestoßen? VG, Wolfgang

  3. Ok Wolle, Danke für deine Antwort. Ich habe nun die gleiche Konstellation nochmal aufgebaut. Die Arduino Version ist allerdings 1.8.15. Ob das einen Unterschied macht ? Ich glaube nicht…
    Das Ergebnis:
    ————————
    avrdude: Version 6.3-20190619
    Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
    Copyright (c) 2007-2014 Joerg Wunsch

    System wide configuration file is „C:\Users\FBS\AppData\Local\Arduino15\packages\arduino\tools\avrdude\6.3.0-arduino17/etc/avrdude.conf“

    Using Port : usb
    Using Programmer : stk500v2
    avrdude: usbdev_open(): did not find any USB device „usb“ (0x03eb:0x2104)

    avrdude done. Thank you.

    Beim Hochladen des Sketches ist ein Fehler aufgetreten
    ————————————————-
    Also wie gesagt, es wird kein Programmer gefunden..? Ich hatte zuvor mit dem ATmega328P gearbeitet, denn da heißt es ja, dass das Board dann bei nicht gestecktem ISP Jumper wie ein UNO oder als Gescheiduino ansprechbar ist. Aber nichts dergleichen 🙁
    Der 328 läuft in einem original UNO V3 einwandfrei.
    Alles Gute, Franz-Bernd

    1. Diese Fehlermeldung bekomme ich nur, wenn der ISP Jumper nicht gesteckt ist und ich Hochladen mit Programmer wähle. Das verträgt sich nicht. Gesteckter Jumper = er verhält sich wie ein Programmer, nicht gesteckter Jumper = er verhält sich wie ein USB zu Seriell Adapter (wie Arduino). Letzteres funktioniert allerdings nicht mit einem ATtiny85.
      Wenn du die Lust noch nicht total verloren hast, dann schaue mal, ob du das Board bei gestecktem ISP Jumper im Gerätemanager von Windows findest. Wenn das nicht der Fall ist, dann ist der Treiber nicht richtig installiert. Es müssen zwei Treiber installiert werden, so wie auf den Dokuwiki Seiten bei Treiberinstallation beschrieben:
      https://www.ehajo.de/dokuwiki/bausaetze:ateval:anleitung
      Einer für die serielle Verbindung und einer für die Funktion als mkII Programmer.
      Ich kann nur sagen, dass es bei mir problemlos funktioniert.

  4. Moin Wolle!
    Sehr guter Beitrag, mittels deiner Einleitung zum Atmel-Studio habe ich ein Attiny85 programmieren können. Bislang habe ich andere diverse Programmadapter benutzt. Auch gut, aber dieses aTeVal interessierte mich einfach. Leider vielen die ersten Test mit der Arduino-1.8.15 negativ aus. Da es mit dem Atmel-Studio nun funktioniert kann ich einen Fehler meinerseits und der Hardware ausschließen! Folgende Fehlermeldung bekomme ich beim Arduino:
    ——————–
    C:\Users\FBS\AppData\Local\Arduino15\packages\arduino\tools\avrdude\6.3.0-arduino17/bin/avrdude -CC:\Users\FBS\AppData\Local\Arduino15\packages\arduino\tools\avrdude\6.3.0-arduino17/etc/avrdude.conf -v -pattiny85 -cavrispmkii -PCOM6 -b{upload.speed} -D -Uflash:w:C:\Users\FBS\AppData\Local\Temp\arduino_build_597379/BinkTest.ino.ino.hex:i
    avrdude: invalid baud rate specified ‚{upload.speed}‘
    Beim Hochladen des Sketches ist ein Fehler aufgetreten
    ——————–
    Es scheint ihm die Variable {upload.speed} zu fehlen. Nur wo kann ich sie eintragen bzw welcher Wert muss dort definiert werden.
    Beim Atmel ist dieses ja wohl mit dem Reiter (ISP Clock), der auf 145kHz steht, bestimmt.
    Viele Grüße aus Vechta-Langförden
    Franz-Bernd

    1. Hi Franz-Bernd,

      merkwürdig! Ich kann nur sagen, dass ich keine Probleme oder Fehler hatte. Vielleicht wendest du dich mal direkt an ehajo. Zu anderen Fragen habe ich dort schnell eine Antwort bekommen.

      VG, Wolfgang

      1. Dank für deine schnelle Antwort!
        Dem Herrn Jochriem habe ich schon geschrieben. Dort ist man allerdings die nächsten 14Tage im Urlaub:-)
        Sollte ich das Problem in irgend einer Art gelöst haben, werde ich es hier melden…
        Grüße
        FB

        1. Ja, würde mich interessieren, was dabei heraus kommt. Besonders wenn andere vielleicht ähnliche Probleme habe.

          1. Moin,
            Herr Jochriem hat am 23.Aug geantwortet:
            —————————————————————————————-
            es gibt aktuell eine neue Version der Bibliothek für Arduino, die ist
            jetzt wieder auf Github umgezogen, der Link im Dokuwiki wurde gerade
            aktualisiert:
            https://www.ehajo.de/dokuwiki/artikel:arduino-boardmanager

            Theoretisch sollte das Hochladen dann mit dem Menüpunkt „Upload with
            programmer“ funktionieren!
            —————————————————————————————
            Das ist leider nicht der Fall 🙁 Die Fehlermeldung ist nun eine Andere: er kann den Programmer nicht finden….?
            Schönes Board, ich kann es aber leider unter „Arduino“ nicht verwenden. Wie zuvor schon gemeldet, mittels „Microchip Studio“ ist die Verwendung kein Problem :-!
            Weitere Info habe ich leider noch nicht bekommen.. Habe aber auch keine Zeit mich damit weiter zu beschäftigen. In meinem Besitz befinden sich genügend Systeme die problemlos arbeiten. Da bleibt mehr Zeit für’s zielorientierte Programmieren 🙂
            Grüße Franz-Bernd

            1. Hallo,

              ich habe das noch einmal ausprobiert, weil es mir keine Ruhe gelassen hat. Ich kann den upload.speed Fehler reproduzieren, wenn ich anstelle „Hochladen mit Programmer“ nur „Hochladen“ bzw. Pfeilsymbol wähle.

              Bei mir funktioniert der Upload auf den ATtiny85 problemlos mit:
              * Arduino IDE Version 1.8.13
              * gesetztem ISP Jumper (Port ist ausgegraut)
              * Board: „aTeVaL IC1 (ATtiny85,..)“
              * Prozessor: ATtiny85
              * Takt: „8MHz (intern)
              * und besagtem „Hochladen per Programmer“

              1. Ok Wolle, Danke für deine Antwort. Ich habe nun die gleiche Konstellation nochmal aufgebaut. Die Arduino Version ist allerdings 1.8.15. Ob das einen Unterschied macht ? Ich glaube nicht…
                Das Ergebnis:
                ————————
                avrdude: Version 6.3-20190619
                Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
                Copyright (c) 2007-2014 Joerg Wunsch

                System wide configuration file is „C:\Users\FBS\AppData\Local\Arduino15\packages\arduino\tools\avrdude\6.3.0-arduino17/etc/avrdude.conf“

                Using Port : usb
                Using Programmer : stk500v2
                avrdude: usbdev_open(): did not find any USB device „usb“ (0x03eb:0x2104)

                avrdude done. Thank you.

                Beim Hochladen des Sketches ist ein Fehler aufgetreten
                ————————————————-
                Also wie gesagt, es wird kein Programmer gefunden..? Ich hatte zuvor mit dem ATmega328P gearbeitet, denn da heißt es ja, dass das Board dann bei nicht gestecktem ISP Jumper wie ein UNO oder als Gescheiduino ansprechbar ist. Aber nichts dergleichen 🙁
                Der 328 läuft in einem original UNO V3 einwandfrei.
                Alles Gute, Franz-Bernd

  5. Ich habe das Teil heute aufgebaut – allerdings laut Platinenaufdruck Version 2.0.1 statt 2.0 – und bemerke folgende Probleme:

    1. Die grüne „POWER“-LED ist extrem hell und sehr unangenehm, wenn man länger als ein paar Sekunden drauf sieht.

    2. Die drei 5mm-Test-LEDs sind viel zu dunkel und eingeschaltet bei Tageslicht kaum zu erkennen.

    Ist das bei dem von Dir begutachteten Exemplar auch so? Ich habe eHajo dazu auch schon angeschrieben und bin gespannt auf die Antwort. An sich funktioniert das Ding auch problemlos sowohl mit Atmel Studio (jetzt ja „Microchip Studio“) als AVRISP mkII wie auch mit der Arduino IDE und Bootloader – aber mit den LEDs muss ich mir etwas einfallen lassen, wenn das der offiziell vorgesehene Aufbau ist.

    1. Bei mir ist die rote LED auch dunkler als die grüne und gelbe. Es wirkt, als hätte er bei den rote LEDs einen anderen Typ verbaut. Ich habe zwei aTeVaL Boards und es ist bei beiden so. Allerdings sind roten LEDs bei mir so hell, dass ich sie auch bei Tageslicht gut erkennen kann. Gestört hat mich das deswegen bisher nicht. Dass die Power LED unangenehm wäre, ist mir nicht aufgefallen. Du kannst ja mal teilen, was ehajo antwortet.

    1. Nein, habe ich nicht – vielleicht mal beim Erfinder und Hersteller (ehajo) nachfragen. Ich habe da auf meine Fragen schnelle und gute Antworten bekommen.

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