Helvetiny84

Der Helvetiny84 ist der grosse Bruder vom Helvetiny85 und Helvetiny85 BB. Auch er ist für Schulungszwecke/Workshops gebaut. Er hat mehr Anschlüsse und kann dadurch noch flexibler eingesetzt werden.

Er basiert auf einem Attiny84 mit der USB Implementierung von Micronucleus. Er kann als 3.3 Volt oder 5 Volt Version aufgebaut werden. Er kann direkt hier als Kit gekauft werden: (Shop)

Bald findet Ihr hier Anwendungsbeispiele: Helevtiny84 Tutorials Alle eigentlich für den kleineren Bruder, den Helvetiny85 gemachten Tutorials funktionieren auch mit dem Helvetiny84.

Hier die 3.3 Volt Version. ( Zu erkennen am Spannungsregler und den fehlenden Z-Dioden )

Hier seht Ihr Ihn im Betrieb. Direkt im USB Anschluss eingesteckt.

Wenn man Headers anschliesst kann er auch direkt auf ein Breadboard gesteckt werden.

Es gibt auch ein kleines Shield. Auf dem Mini Shield kann man einfache kleine Schaltungen aufbauen

Die Bauteile sind alle Standard Bauteile einzig spezielle Beachtung liegt auf dem PCB und dem Attiny84. Das PCB wird man bald bestellen können. Den Attiny84 muss noch mit dem Micronucleus USB Bootloader beladen werden, dazu ist ein normaler Arduino als ISP Programmierer nötigt. Hier die beiden Anleitungen:

• Arduino als ISP attiny_mit_arduinoisp_programmieren
• Micronucleus Bootloader Micronucleus

Der Helvetino84 kann als 5 Volt oder 3.3 Volt Version aufgebaut werden. In der 5 Volt Version wird kein 3.3 Volt Spannungsregler benötigt jedoch die beiden Z-Dioden. In der 3.3 Volt Version genau umgekehrt. also keine Z-Dioden dafür ein 3.3 Volt Spannungsregler.

Hier die einzelnen Bestandteile:

• 2 x Zener Diode 3.6V (Shop) [D1,D2] (nur für 5 Volt Version!)
• 1 x 3.3 Volt Spannungsregler MCP1700 (Shop) [IC1] (nur für 3.3 Volt Version!)
• 2 x 68 Ohm Widerstand (Shop) [R1,R2]
• 1 x 1.5 KOhm Widerstand (Shop) [R3]
• 1 x 10 KOhm Widerstand (Shop) [R4]
• 3 x 100nF Keramik Kondensator (Shop) [C1,C2,C3]
• 1 x Mini Taster (Shop) [S1]
• 2 x 3 Pin Stift (Shop)
• 2 x Jumper (Shop)
• 1 x 14 Pin IC Sockel (Shop) [U1]
• 1 x Attiny84 (Shop) [U1] ( Mit installiertem Micronucleus Bootloader! )

Wie bereits geschrieben gibt die Möglichkeit den Helvetiny84 als 3.3 Volt oder 5 Volt Version aufzubauen. Die folgenden Schritte sind jedoch noch für beide Versionen gültig. Später unterscheiden wir dann den Aufbau.

Hier sind alle Teile beschriftet bis auf den Attiny84 IC selber.

Als erstes empfiehlt es sich die Wiederstände einzubauen. Die Farbcodierung beachten.

Dann die 3 Kondensatoren. Alles sind gleich und die Einbaurichtung ist egal.

Dann den IC Sockel und den Taster einlöten. Die Kerbe im Sockel muss richtung USB Stecker zeigen. Soweit sind beide Versionen gleich.

Hier noch der letzte Schritt zur 3.3 Volt Version. Der Spannungsregler IC1 wird eingebaut und fertig ist der Helvetiny84. Es empfiehlt sich zuerst den Helvetiny84 ohne Attiny84 in Betrieb zu nehmen und die Spannung zu prüfen. Wenn alles passt kann der Attiny84 eingesetzt werden. Achtung die Kerbe muss Richtung USB Stecker zeigen.

Bei der 5 Volt Version braucht es noch 2 Schritte. Die beiden Z-Dioden müssen eingesetzt werden. Der Schwarze Balken der Z-Dioden muss Richtung USB Stecker zeigen. Danach braucht es noch eine Drahtbrücke zwischen zwei Anschlüssen vom IC1. Weil wir in der 5 Volt Version den Spannungsregler nicht einbauen. Fertig ist der Helvetiny84. Jetzt noch den Attiny84 einsetzen. Achtung die Kerbe muss Richtung USB Stecker zeigen.

Hier der Schaltplan. Für die 3.3 Volt Version wird der Spannungsregler (B) benötigt, und für die 5 Volt Version müssen die beiden Z-Dioden (A) eingebaut werden.

Hier das Board Layout:

Hier die Pin Definition vom Helvetiny84:

Das Laden vom 1. Programm sollte am besten unter Linux oder OS X vorgenommen werden, weil da keine Treiber benötigt werden. Im Gegensatz zum Helvetiny85 und Helvetiny85 BB braucht der Helvetiny84 ein eigenes Setup in der Arduino IDE.

Als erstes prüfen wir ob der Helvetiny84 sich am USB Anschluss auch richtig am Computer anmeldet. Nach dem Einstecken vom USB Stecker prüfen wir per lsusb Befehl ob der Micronucleus Bootloader vom Betriebssystem erkannt wurde. Vorsicht der Chip ist so programmiert dass er sich nur wenige Sekunden mit dem USB Anschluss verbindet.

Hier sehen wir wie sich der Helevtiny84 richtig mit der Digistump Kennung angemeldet hat.

Als nächstes kümmern wir uns um die Arduino IDE.

Dazu laden wir das micronucleus V-USB Paket herunter https://github.com/micronucleus/micronucleus/archive/master.zip

Wir entpacken es und gehen in den Ordner “micronucleus-master/commandline”. Zuerst installieren wir noch das Paket libusb-dev mit:

sudo apt-get install libusb-dev

Jetzt können wir make aufrufen

make

Das sieht dann so aus:

Jetzt ist eine ausführbare Datei mit dem Namen “micronucleus” erstellt worden. Wir prüfen jetzt mal die Version mit:

./micronucleus --help

Wir sehen es ist die Verion 2.0a5

Jetzt müssen wir noch die Arduino IDE für den Helvetiny84 einrichten.

Als erstes prüfen wir die aktuelle Arduino IDE installation. Wir brauchen das Hardware Verzeichnis

Wenn die Arduino IDE normal installiert ist finden wird das im Ordner:

/usr/share/arduino/hardware

Wenn die Arduino nur heruntergeladen wurde und nicht im Linux installiert wurde finden wir das Hardware Verzeichnis im Arduino Ordner, bei mir hier:

/home/reto/Documents/arduino-1.6.8/hardware

Wir kopieren jetzt die ausfürhbare Datei micronucleus-master/commandline/micronucleus in den Ordner den wir vorher gefunden haben: <Arduino_inst>/hardware/tools

Das sieht dann so aus:

Jetzt brauchen wir noch eine Board Definition für die Arduino IDE anzulegen. Dazu benötigen wir folgende Dateien:

boards.txt > Hier wird er Chip selber definiert (Takt, Speicher, usw.) platform.txt > Zusatz Informationen welche der Compiler braucht (z.B.: AVRDUDE) pins_ardiuno.h > Hier werden die Pins vom Chip definiert

Die folgenden Ordner und Dateien sind hier alle als .zip Datei verfügbar:

helvetiny84.zip

Die muss in den Ordner <Arduino_inst>/hardware entpackt werden.

Alternativ hier die einzelnen Schritte das ganze manuell zu erstellen:

Als erstes erstellen wir ein neues Verzeichnis mit dem Namen “Helvetiny84” unter dem <Arduino_inst>/hardware Verzeichnis.

Wir kopieren folgenden Text in eine Neue Datei mit dem Namen boards.txt im Helvetiny84 Verzeichnis:

menu.cpu=Processor

################################################################################

Helvetiny84.name=Helvetiny84 (ATtiny84 USB, 3.3V, 8Mhz)

Helvetiny84.upload.using=micronucleusprog
Helvetiny84.upload.protocol=usb
Helvetiny84.upload.tool=micronucleus
Helvetiny84.upload.maximum_size=6012

Helvetiny84.build.mcu=attiny84
Helvetiny84.build.f_cpu=8000000L
Helvetiny84.build.board=Helvetiny84
Helvetiny84.build.core=arduino:arduino
Helvetiny84.build.variant=tiny14

Und wir erstellen nochmals eine neue Datei mit dem Namen “platform.txt” im gleichen Ordner wir vorher. Ebenfalls kopieren wir den folgenden Inhalt in die Text Datei.

name=Helvetiny84 Boards
version=0.0.1

# Default "compiler.path" is correct, change only if you want to overidde the initial value
compiler.path={runtime.tools.avr-gcc.path}/bin/
compiler.c.cmd=avr-gcc
compiler.c.flags=-c -g -Os -w -ffunction-sections -fdata-sections -MMD
compiler.c.elf.flags=-Os -Wl,--gc-sections
compiler.c.elf.cmd=avr-gcc
compiler.S.flags=-c -g -x assembler-with-cpp
compiler.cpp.cmd=avr-g++
compiler.cpp.flags=-c -g -Os -w -fno-exceptions -ffunction-sections -fdata-sections -MMD
compiler.ar.cmd=avr-ar
compiler.ar.flags=rcs
compiler.objcopy.cmd=avr-objcopy
compiler.objcopy.eep.flags=-O ihex -j .eeprom --set-section-flags=.eeprom=alloc,load --no-change-warnings --change-section-lma .eeprom=0
compiler.elf2hex.flags=-O ihex -R .eeprom
compiler.elf2hex.cmd=avr-objcopy
compiler.ldflags=
compiler.size.cmd=avr-size
# this can be overriden in boards.txt
build.extra_flags=

# AVR compile patterns
# --------------------

## Compile c files
recipe.c.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.c.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

## Compile c++ files
recipe.cpp.o.pattern="{compiler.path}{compiler.cpp.cmd}" {compiler.cpp.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

## Compile S files
recipe.S.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.S.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

## Create archives
recipe.ar.pattern="{compiler.path}{compiler.ar.cmd}" {compiler.ar.flags} "{archive_file_path}" "{object_file}"

## Combine gc-sections, archives, and objects
recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" {compiler.c.elf.flags} -mmcu={build.mcu} -o "{build.path}/{build.project_name}.elf" {object_files} "{archive_file_path}" "-L{build.path}" -lm

## Create eeprom
recipe.objcopy.eep.pattern="{compiler.path}{compiler.objcopy.cmd}" {compiler.objcopy.eep.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.eep"

## Create hex
recipe.objcopy.hex.pattern="{compiler.path}{compiler.elf2hex.cmd}" {compiler.elf2hex.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.hex"

## Compute size
recipe.size.pattern="{compiler.path}{compiler.size.cmd}" -A "{build.path}/{build.project_name}.elf"
recipe.size.regex=^(?:\.text|\.data|\.bootloader)\s+([0-9]+).*
recipe.size.regex.data=^(?:\.data|\.bss|\.noinit)\s+([0-9]+).*
recipe.size.regex.eeprom=^(?:\.eeprom)\s+([0-9]+).*


# Micronucleus Loader
# -------------------
tools.micronucleus.cmd.path={runtime.hardware.path}/../tools
tools.micronucleus.upload.params.verbose=-verbose
tools.micronucleus.upload.params.quiet=
tools.micronucleus.upload.pattern="{cmd.path}/micronucleus" --timeout 60 "{build.path}/{build.project_name}.hex"
#tools.micronucleus.upload.pattern="{cmd.path}/micronucleus" --run --timeout 60 "{build.path}/{build.project_name}.hex"
#tools.micronucleus.upload.pattern="{cmd.path}" -cdigispark --timeout 60 -Uflash:w:{build.path}/{build.project_name}.hex:i

# USB Default Flags
# Default blank usb manufacturer will be filled it at compile time
# - from numeric vendor ID, set to Unknown otherwise
build.usb_manufacturer=
build.usb_flags=

Das sollte jetzt so aussehen:

Jetzt erstellen wir im Helvetiny84 Ordne ein zusätzliches zweites neues Verzeichnis mit dem Namen “variants”. Und gleich darin nochmals ein Verzeichnis mit dem Namen “tiny14”. Darin erstellen wir eine Datei “pins_arduino.h” mit dem folgenden Inhalt:

/*
  pins_arduino.c - pin definitions for the Arduino board
  Part of Arduino / Wiring Lite

  Copyright (c) 2005 David A. Mellis

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General
  Public License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  Boston, MA  02111-1307  USA

  $Id: pins_arduino.c 565 2009-03-25 10:50:00Z dmellis $

  Modified 28-08-2009 for attiny84 R.Wiersma
  Modified 09-10-2009 for attiny45 A.Saporetti
*/

#ifndef Pins_Arduino_h
#define Pins_Arduino_h

#include <avr/pgmspace.h>

// ATMEL ATTINY84 / ARDUINO
//
//                           +-\/-+
//                     VCC  1|    |14  GND
//             (D 10)  PB0  2|    |13  AREF (D  0)
//             (D  9)  PB1  3|    |12  PA1  (D  1) 
//                     PB3  4|    |11  PA2  (D  2) 
//  PWM  INT0  (D  8)  PB2  5|    |10  PA3  (D  3) 
//  PWM        (D  7)  PA7  6|    |9   PA4  (D  4) 
//  PWM        (D  6)  PA6  7|    |8   PA5  (D  5)        PWM
//                           +----+

const static uint8_t A0 = 0;
const static uint8_t A1 = 1;
const static uint8_t A2 = 2;
const static uint8_t A3 = 3;
const static uint8_t A4 = 4;
const static uint8_t A5 = 5;
const static uint8_t A6 = 6;
const static uint8_t A7 = 7;

#define digitalPinToPCICR(p)    ( ((p) >= 0 && (p) <= 10) ? (&GIMSK) : ((uint8_t *)0) )
#define digitalPinToPCICRbit(p) ( ((p) <= 7) ? PCIE0 : PCIE1 )
#define digitalPinToPCMSK(p)    ( ((p) <= 7) ? (&PCMSK0) : (((p) <= 10) ? (&PCMSK1) : ((uint8_t *)0)) )
#define digitalPinToPCMSKbit(p) ( ((p) <= 7) ? (p) : (10 - (p)) )

#ifdef ARDUINO_MAIN

// these arrays map port names (e.g. port B) to the
// appropriate addresses for various functions (e.g. reading
// and writing)
const uint16_t PROGMEM port_to_mode_PGM[] = 
{
  NOT_A_PORT,
  (uint16_t)&DDRA,
  (uint16_t)&DDRB,
};

const uint16_t PROGMEM port_to_output_PGM[] = 
{
  NOT_A_PORT,
  (uint16_t)&PORTA,
  (uint16_t)&PORTB,
};

const uint16_t PROGMEM port_to_input_PGM[] = 
{
  NOT_A_PORT,
  (uint16_t)&PINA,
  (uint16_t)&PINB,
};

const uint8_t PROGMEM digital_pin_to_port_PGM[] = 
{
  PA, /* 0 */
  PA,
  PA,
  PA,
  PA,
  PA,
  PA,
  PA,
  PB, /* 8 */
  PB,
  PB,
};

const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = 
{
  _BV(0), /* port A */
  _BV(1),
  _BV(2),
  _BV(3),
  _BV(4),
  _BV(5), 
  _BV(6),
  _BV(7),
  _BV(2), /* port B */
  _BV(1),
  _BV(0),
};

const uint8_t PROGMEM digital_pin_to_timer_PGM[] = 
{
  NOT_ON_TIMER,
  NOT_ON_TIMER,
  NOT_ON_TIMER,
  NOT_ON_TIMER, 
  NOT_ON_TIMER,
  TIMER1B, /* OC1B */
  TIMER1A, /* OC1A */
  TIMER0B, /* OC0B */
  TIMER0A, /* OC0A */
  NOT_ON_TIMER,
  NOT_ON_TIMER,
};

#endif

#endif

Das ganze sieht jetzt so aus:

die Anleitung für Windows folgt bald

Jetzt wo die Arduino IDE vorbereitet ist versuchen wir das erste einfache Test Program auf den Helevtin84 zu übertragen.

Falls noch nicht geschenen starten wir die Arduino IDE neu. Jetzt sollte unter <Tools><Board> das Helvetiny84 Board verfügbar sein. Wir wählen es aus:

Für einen ersten Test genügt die Blink Vorlage. Hier müssen wir jedoch den PIN für die Led von 13 auf 3 anpassen. Dann drücken wir auf Upload. Jetzt wird mit micronucleus versucht den Scetch per USB auf den Helvetiny84 zu laden. Das funktioniert nur in den ersten Sekunden wenn sich der Helvetiny84 beim start am USB Port anmeldet. Jetzt ist genau der Zeitpunkt um den Helvetiny84 einzustecken oder fall das bereits vorher der Fall war Ihn mit dem Reset Knopf zu reseten. Hier unten in der Arduino IDE ist das Protokoll sichtbar.

Sobald der Upload startet, wird das auch in der Arduino IDE im unteren Bereich sichtbar. Hier sieht man dass der Upload bei 100% steht und somit fertig ist.

Die Led blinkt jetzt schön im Takt.

Fritzing ist eine tolle Software um elektronische Schaltungen am Computer zu entwerfen. Fritzing hat 3 Ansichen: Breadboard, Schema und PCP. Damit man den Helvetiny84 in Fritzing einfach integrieren kann, stelle ich hier den Helvetiny84 als Fritzing Bauteil zur Verfügung:

GitHup Helvetiny84 Fritzing Part

Am meisten Sinn macht es, die Breadboard Ansicht von Fritzing zu nutzen. Der Helvetiny84 kann dann neben das Breadboard positioniert werden. Oder aber direkt in das Breadboard gesteckt werden, das sieht dann zum Beispiel so aus:

Hier eine Sammlung der bekannten Probleme und Lösungen. Falls Du nicht weiter kommst melde dich einfach hier im Support Thread zum Helvetiny85 und Helvetiny84:

http://forum.boxtec.ch/index.php/topic,3162.msg6141.html

• Helvetiny84 Tutorials
• Micronucleus Bootloader
• Eagle Files & Fritzing Part
• Der kleinere Bruder, der Helvetiny85 mit Attiny85