TinyMega

Der TinyMega (häufig auch „Jockiboard“) ist ein Breakout-Board für den ATmega32U4-Mikrocontroller von Atmel, welches komplett in SMD gefertigt und durch seine geringe Größe Breadboard-tauglich ist. Das Board enthält ausser dem Mikrocontroller alle notwendigen Bauteile, die zum einfachen Betrieb des Controllers nötig sind, zwei Taster sowie zwei LEDs.

Mit ein bisschen Löterfahrung ist der TinyMega trotz der SMD-Bauteile leicht zu löten – wir bieten in unregelmäßigen Abständen einen SMD-Workshop an, in dem genau dieses Board unter Anleitung gelötet werden kann.

Features

  • ATmega32U4-Controller
    • 32 KiB Flash
    • 2,5 KiB SRAM
    • 1 KiB EEPROM
    • Integrierter USB-Controller (Low Speed, Full Speed, Host oder Device)
  • USB-Bootloader vorprogrammiert – bequem flashen per USB!
  • 16 MHz-Quarz
  • Taster für Reset und Bootloader
  • 2 LEDs (grün für Power, rot an GPIO-Pin)
  • Alle Signale des uC und Power bequem auf zwei Pinreihen im 2,54mm-Raster – ideal für Breadboards
  • Stromversorgung per USB oder extern (5V stabilisiert)
    • (nur v2) Optionaler Spannungsregler von 5V aus USB auf beliebige andere Spannung, z.B. 3,3V
    • (nur v2) Eingebaute Sicherung, um auch die USB-Ports billiger Notebooks vor Zerstörung zu schützen ;)
  • (nur v2) Großer Massekontakt für bequemen Masseabgriff mit Tastköpfen u.ä.

Aufbau

CAD-Dateien

hier: https://github.com/dop3j0e/eagle/tree/master/Atmega32U4-Breakout/v3

Top LayerBottom Layershackspace.de_gallery_var_thumbs_projekte_atmega32u4-board_dsc_5667.jpg

Schaltplan

                         Pinout >Jockiboard<
                              Atmega32u4
                               ___USB___
              ADC0	F0	o	o	GND
              ADC1	F1	o	o	VCC 5V
       TCK	ADC4	F4	o	o	Aref
       TMS	ADC5	F5	o	o	E6    	NT.6 AIN0 & Demo LED 
       TDO	ADC6	F6	o	o	B0	SS PCINT0
       TDI	ADC7	F7	o	o	B1	PCINT1 SCLK
             (HWB)	E2	o	o	B2	PDI    MOSI PCINT2
   ICP3 CLK0 OC4A	C7	o	o	B3	PDO    MISO PCINT3
      OC3A  (OC4A)	C6	o	o	B7	PCINT7 OC0A OC1C (RTS)
PCINT6  OC1B OC4B ADC13|B6	o	o	Reset
PCINT5 (OC1A)OC4B ADC12|B5	o	o	D0	OC0B SCL INT0
         PCINT4 ADC11	B4	o  B R  o	D1	SDA  INT1
       T0  OC4D ADC10	D7	o  O S	o	D2 	RXD1 INT2
      T1 (OC4D) ADC9	D6	o  O T	o	D3	TXD1 INT3
            CP1 ADC8   	D5	o__T____o	D4	XCK1 CTS

Teileliste

Anzahl Beschreibung Wert Digikey-Teilenummer
1 Atmega32U4 TQFP44 ATMEGA32U4-AU-ND
1 SMD LED 0805 Grün 754-1131-1-ND
1 SMD LED 0805 Rot, hell 754-1132-1-ND
1 SMD-Kerko 0805 4.7uF
1 SMD-Kerko 0603 1uF
2 SMD-Kerko 0603 18pF
5 SMD-Kerko 0603 100nF
2 SMD-Widerstand 0603 22R
1 SMD-Widerstand 0603 150R
1 SMD-Widerstand 0603 180R
2 SMD-Widerstand 0603 10k
2 SMD-Drucktaster KMR221NG LFS oder
KMR421G LFS (*)
CKN10244CT-ND bzw.
CKN10249CT-ND
1 USB-Buchse Hirose UX60-MB-5ST H2959CT-ND
1 Quarz Abracom ABM7 16MHz 535-9840-1-ND

(*) Alle Taster aus der KMR2- oder KMR4-Serie von C&K können verwendet werden. Die KMR4-Serie hat höhere Tastkappen und ist vermutlich einfacher zu betätigen.

Die beiden angegebenen Bauteile waren zum Zeitpunkt des Schreibens die jeweils billigsten der KMR2- bzw. KMR4-Serie bei Digi-Key.

Die KMRxxxG-Taster haben im Gegensatz zu den KMRxxxNG-Tastern einen Gehäusepin. Auf der Platine ist dafür kein Lötpad vorgesehen, weil nicht notwendig, aber überall, wo ein Gehäusepin sein könnte, ist nur Massefläche, so dass keine Leiterbahn versehentlich kurzgeschlossen werden kann. Beide Varianten können daher verwendet werden.

siehe auch: https://github.com/dop3j0e/eagle/blob/master/Atmega32U4-Breakout/v3/bom.ods?raw=true

Bauanleitung

Dokumentation

Spannungsversorgung

Der TinyMega v1 ist auf 5V aus dem USB festgelegt. Betrieb mit eigener Spannungsversorgung unabhängig vom USB ist natürlich möglich, aber gefährlich, wenn der TinyMega ausserdem an den USB angeschlossen werden soll, denn es besteht keinerlei Trennung zwischen VUSB und VDD.

Beim TinyMega v2 ist Platz für einen Spannungsregler vorgesehen, mit dem die USB-Versorgungsspannung von 5V auf jede beliebige kleinere Spannung geregelt werden kann, z.b. wenn man einen Haufen 3,3V-Logik steuern will und keine Lust auf Pegelwandler überall hat. Die gesampte Platine und auch ihr VDD-Pin hängen am Ausgang des Spannungswandlers. Beim 3,3V-Betrieb muss darauf geachtet werden, dass der ATmega dann nur bis 8MHz verträgt, also den Taktteiler besser nicht auf 1 setzen ;)

Wird die normale USB-Versorgungsspannung von 5V benötigt, kann der Spannungsregler weggelassen werden und die Lötbrücke „VDD=VUSB“ muss geschlossen werden. Das geht auch bei eingebautem Spannungsregler; der verträgt es ohne Probleme, überbrückt zu werden.

Ausserdem sind durch diese Bauweise VUSB und VDD nicht mehr fest verbunden, es kann also ein USB-Gerät gebaut werden, das zwar mit dem USB redet, aber die Versorgungsspannung (fast) nicht nutzt. Dazu muss die Lötbrücke „VDD=VUSB“ offen gelassen werden und der Spannungsregler darf nicht eingebaut sein (oder man lötet seinen linken oberen Pin ab und biegt ihn hoch).

Inbetriebnahme

Der Controller ist mit einem USB-Bootloader vorprogrammiert, der das DFU-Prokotoll (Device Firmware Update) spricht. Der übliche avrdude unterstützt dieses Protokoll leider nicht, aber für Windows gibt es FLIP von Atmel und für Linux dfu-programmer (s.u.), die sind beide auch batchtauglich. Programmierung über SPI ist für gewöhnlich nicht nötig, ausser man will den Bootloader ersetzen oder Fuses ändern.

Beim ersten Anschliessen ist noch keine Anwendungssoftware auf dem Controller, daher startet er direkt in den Bootloader. Sobald eine Anwendung programmiert wurde, startet der Controller beim Reset die Anwendung; mit dem BOOT-Taster (s.u.) kann stattdessen wieder der Bootloader gestartet werden. Protip: Die Anwendung kann natürlich auch in den Bootloader springen – z.B. kann man ein Kommando vorsehen, das dies tut.

WICHTIG: Die Fuses des Controllers sind so programmiert, dass der interne Taktteiler beim Einschalten auf einen Teiler von 8 konfiguriert ist (CLKDIV8-Fuse) – der Controller läuft also bei dem 16MHz-Quarz des Boards zunächst nur mit 2MHz! Der Taktteiler kann im laufenden Betrieb umkonfiguriert werden; folgender Code schaltet auf die vollen 16MHz um:

  #include <avr/power.h>
  
  /* in main() dann... */
  clock_prescale_set(clock_div_1);

Bedienelemente

RESET- und BOOT-Taster

shackspace.de_gallery_var_thumbs_projekte_atmega32u4-board_dsc_5689.jpg

Der RESET-Taster ist wohl selbsterklärend ;)

Der BOOT-Taster zwingt den Atmega in den USB-Bootloader: Wird der BOOT-Taster gehalten, während RESET betätigt wird, startet der Controller in den Bootloader statt in die Anwendung. Der Taster hängt zusammen mit einem Pullup-Widerstand an Pin E2 des Controllers (!HWB im Datenblatt). Falls der Pin als GPIO benutzt werden soll und der Pullup stört, kann die Lötbrücke BOOT_EN aufgelötet werden, um Taster und Pullup abzuklemmen. Beim TinyMega v2 ist die Lötbrücke mit „E2=BOOT“ beschriftet.

Im laufenden Betrieb kann Pin E2 ganz normal als Input konfiguriert werden (ohne Pullup, ist ja schon einer da), so dass der BOOT-Taster als General-Purpose-Taster dienen kann.

LEDs

shackspace.de_gallery_var_thumbs_projekte_atmega32u4-board_dsc_5690.jpg

Die grüne LED ist die Power-LED und ist immer an, wenn das Board mit 5V versorgt wird.

Die rote (v1) bzw. blaue (v2) LED ist über eine Lötbrücke an Pin E6 angeschlossen und kann darüber gesteuert werden. Wenn die LED-Last an E6 nicht erwünscht ist, einfach die Lötbrücke öffnen (heissmachen, Entlötsaugpumpe, fertig). Beim TinyMega v2 ist die Lötbrücke auf der Unterseite und mit „E6=LED“ beschriftet.

Software

Windows: Eclipse & WinAVR

  • Eclipse –> „Eclipse IDE for C/C++ Developers“
  • Damit Windows den Bootloader erkennt, muss ein libusb-basierter Treiber installiert werden:
    • Wer fremden ZIPs nicht vertraut, kann sich den Treiber auch selbst erstellen:
      1. Neueste libusb-win32 runterladen und auspacken
      2. TinyMega anschliessen und bin/inf-wizard.exe starten
      3. Den Anweisungen folgen, dabei das Gerät „ATm32U4DFU“ auswählen
      4. Der INF-Wizard schreibt eine .inf-Datei, die als Treiber verwendet werden kann
  • Zum Flashen wird FLIP benutzt

FLIP

Screenshot

  1. Mit USB verbinden (alternativ: Strg-U / Ctrl-U), im sich öffnenden Fenster „Open“ wählen. Falls das nicht klappt, ist der Treiber nicht installiert, der Controller nicht angeschlossen oder nicht im Bootloader.
  2. HEX-Datei öffnen. FLIP merkt sich die zuletzt verwendete HEX-Datei; falls die gleiche Datei verwendet werden soll, kann dieser Schritt entfallen.
  3. „Run“ klicken – FLIP führt die darüber ausgewählten Schritte durch. WICHTIG: Der Bootloader ist im Auslieferungszustand im sicheren Modus und akzeptiert alle weiteren Kommandos erst nach einem Erase.
  4. Board manuell resetten, um die Anwendung zu starten, oder über diesen Knopf. WICHTIG: Wenn „Reset“ ausgewählt ist, wird der Controller per Watchdog resettet – falls die Anwendung den Watchdog nicht direkt abschaltet oder umprogrammiert, resettet der Watchdog immer wieder. Daher ist „Reset“ meistens abzuschalten.

Windows: AVR Studio

  • AVR Studio 4 kann von sich aus mit dem DFU-Bootloader auf dem Chip sprechen, evtl. muss der Treiber wie oben installiert werden.
  • AVR Studio 5 wurde dahingehend erweitert, dass es das nicht mehr beherrscht *grml*.

Windows: AVR Studio 5,6

Man kann sich AVR_studio so einrichten, dass man Flip nicht manuell bedienen muss

1. Befehl Anlegen

  Extras => Externe Tools => Hinzufügen
  Titel: Flip
  Befehl: C:\Program Files (x86)\Atmel\Flip 3.4.5\bin\batchisp.exe   (pfad zu batchisp.exe , die im Flip ordner ist)
  Argumente: -device atmega32u4 -hardware usb -operation ERASE F LOADBUFFER "$(TargetDir)$(TargetName).hex" PROGRAM VERIFY START noreset 0
  =>übernehmen
  

2. Hotkey/in die Menüleiste

  Extras => Anpassen => Neu ->"Flip"
  dann reiter "Befehle" => Symbolleiten => Flip 
  Befehl Hinzufügen => Extras => Externer Befehl 1 
  
  Für hotkey: 
  Im selben Menü: Tastatur-> Pop-up => in "Befehl mit folgendem inhalt anzeigen" nach "Extras.ExternerBefehl1" suchen
  Gewünschte Tastenkobi zuweisen (F5 empfielt sich da sich der deugger mit dem tiny mega eh nicht nutzen lässt)

Linux: avr-gcc

  # sudo dfu-programmer atmega32u4 erase                  # Löscht den Flash und schaltet das Programmieren frei
  # sudo dfu-programmer atmega32u4 flash filename.hex     # Programmiert filename.hex in den Controller
  # sudo dfu-programmer atmega32u4 start                  # Startet die Anwendung

Hello World für den TinyMega

Es werden die Programme avr-gcc und dfu-programmer und die Bibliothek avr-libc benötigt.

Der folgenden Quelletext muss als helloworld.c gespeichert werden:

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

int main() {
    // internen clock teiler deaktivieren
    cli();	// clear interrupts
    clock_prescale_set(clock_div_1);
    MCUCR = (1 << JTD);			//jtag ausschalten
    MCUCR = (1 << JTD);			//this need to be executed twice 
    sei();	// set interrupts

    DDRE |= (1 << PE6);             // pin 6 von port E als output schalten 

    while(1) {                      // endlosschleife fürs blinken
        PORTE |= (1 << PE6);        // pin 6 von port E auf high schalten
        _delay_ms(500);             // warte 500ms
        PORTE &= ~(1 << PE6);       // pin 6 von port E auf low schalten
        _delay_ms(500);             // warte 500ms
    }
    return 0;
}

Danach kann mit

$ avr-gcc -DF_CPU=16000000 -Os -mmcu=atmega32u4 -o helloworld.o helloworld.c

der Quelltext compiliert werden.

Das erzeugte helloworld.o wird mit folgendem Befehl in eine HEX-Datei umgewandelt.

$ avr-objcopy -O ihex helloworld.o helloworld.hex

Jetzt muss das HEX-File noch auf den TinyMega geschubst werden. Damit der Atmega den neuen Code annimmt muss der Bootloader gestartet werden:

  1. TinyMega mit dem PC verbinden
  2. Taste BOOT drücken (und gedrückt halten)
  3. Taste RESET drücken (und wieder loslassen)
  4. Taste BOOT loslassen

Jetzt kann der neue Code auf den Atmega geladen werden. Die folgenden Befehle müssen dafür als root ausgeführt werden:

# dfu-programmer atmega32u4 erase
# dfu-programmer atmega32u4 flash helloworld.hex
# dfu-programmer atmega32u4 start

Jetzt sollte die rote LED auf dem Entwicklungsboard blinken.

Makefile

Für die obige Toolchain gibt es auch ein einfaches Makefile:

AVR_CHIP = atmega32u4
AVR_CHIP_FREQUENCY = 16000000
CODE_MAIN = helloworld

AVR_PROGRAMMER = dfu-programmer
AVR_COMPILER = avr-gcc
AVR_HEX = avr-objcopy

all: $(CODE_MAIN).hex
	
%.o: %.c
	$(AVR_COMPILER) -DF_CPU=$(AVR_CHIP_FREQUENCY) -Os -mmcu=$(AVR_CHIP) -o $@ $<
	
%.hex: %.o
	$(AVR_HEX) -O ihex $< $@
	
.phony flash: $(CODE_MAIN).hex
	sudo $(AVR_PROGRAMMER) $(AVR_CHIP) erase
	sudo $(AVR_PROGRAMMER) $(AVR_CHIP) flash $<
	sudo $(AVR_PROGRAMMER) $(AVR_CHIP) start ; true

Testprogramm für die I/O-Pins

Das folgende Testprogramm lässt die LED per Interrupt blinken und schaltet alle weiteren Pins auf HIGH. Um die Pins zu testen, kann eine beliebige LED mit Vorwiderstand (180 Ohm) mit der Kathode an den GND-Pin des TinyMega angeschlossen und mit der Anode an alle anderen Pins gehalten werden. Die LED sollte bei allen Pins aufleuchten, ausser bei E6 (wo sie natürlich blinkt ,), bei E2 (das haben wir schon durch den Bootloader-Taster getestet), bei VREF (das kann so nicht getestet werden) und bei RST (das wird aber einen Reset auslösen, weil die LED durch den Vorwiderstand den Reset-Pin auf Ground zieht).

#include <avr/io.h>
#include <avr/power.h>
#include <avr/interrupt.h>

#define LEDDDR DDRE
#define LEDPORT PORTE
#define LEDBIT (1 << PE6)

ISR(TIMER1_COMPA_vect)
{
	LEDPORT ^= LEDBIT;
}

int main(void)
{
	clock_prescale_set(clock_div_1);                        // systemtakt teiler
        MCUCR = (1 << JTD);					//jtag ausschalten
	MCUCR = (1 << JTD);					//this need to be executed twice 
        
        
	/* Timer/Counter 1 für Interrupts aufsetzen */
	TCCR1A = 0;
	TCCR1B = 5 << CS10 | 1 << WGM12;
	OCR1A = 8192;
	TIMSK1 = 1 << OCIE1A;
	TIFR1 = 1 << OCF1A;

	MCUCR = 1 << JTD;  /* JTAG abschalten, sonst funktionieren */
	MCUCR = 1 << JTD;  /* einige Pins von PORTF nicht wie erwartet */
	DDRB = DDRC = DDRD = DDRF = 0xFF;
	PORTB = PORTC = PORTD = PORTF = 0xFF;
	LEDDDR = LEDBIT;

	sei();

	while (1);
}

Funktion für Sprung in den Bootloader

void bootloader (void)
{
	MCUCR |=  (1 << IVCE);  //IVCE  = 1		//register für restet
	MCUCR |=  (1 << IVSEL); //IVSEL = 1		//register für restet
	TIMSK0 = 0;             //Timer-Interrupt ausschalten
        // hier sollten die anderen aktiven timer ausgeschaltet werden (TIMSK1,TIMSK2,TIMSK3,...)
	_delay_ms(50);
	asm volatile ("jmp 0x3800"); //springe an die richtige stelle
}

Linksammlung

project/tinymega.txt · Zuletzt geändert: 2014/10/03 00:00 von 89.13.168.70