ATtiny: midgets très grand

les cartes Arduino sont disponibles dans différents facteurs de forme et des classes de performance. Pour les circuits plus compacts sont parfois les plus petites cartes Arduino "mini". "micro" ou "nano" à lourd. Qui il s'agit de petites dimensions et un bon rapport qualité-prix, devrait jeter un oeil à la famille ATtiny.

les cartes Arduino Arduino Uno, Mega, Mini, Nano ou Micro avec les puces puissantes ATmega conviennent à diverses applications. à côté de la MCU intégrer un certain nombre d'autres composants tels qu'un cristal, la logique de puissance, les LED, le bouton RESET et bien plus encore. Cependant, ils ont donc aussi une taille à laquelle ils ne peuvent pas facilement être utilisés pour les circuits compacts. Heureusement, il existe une alternative appelée ATtiny.

Près de 40 processeurs ont une famille ATtiny 8 bits. Votre mémoire flash se déplace dans une plage de 512 Ko à 16 Ko. Leur nombre de broches allant de 6 à 32. Les autres caractéristiques de performance varie d'une puce à puce. Par conséquent, les développeurs devraient être en mesure de trouver un représentant ATtiny facilement appropriés en fonction de l'application, et non seulement dans le cas où la compacité est l'une des exigences.

Le ATtiny85 est relativement souvent utilisé par les fabricants ArduinoLe ATtiny85 est relativement souvent utilisé par les fabricants Arduino(Photo: sparkfun.com)

Le processeur de ATtiny minuscule apporte à pas plus que sur des dimensions de 1,4 mm x 1,5 mm et sont à une tension de 0,7 V satisfaite, de sorte que l'alimentation est suffisante, une batterie de piles ou un bouton. Les broches individuelles d'un ATtiny se révéler très souple car les repères individuels Maker peut être utilisé pour l'entrée / sortie, la conversion analogique / numérique ou modulation d'impulsions en largeur en option. Même la broche RESET peut être reconfiguré (voir ci-dessous) pour I / O. Pour la fréquence d'horloge de l'oscillateur interne de la puce fournit. Pour le lecteur intéressé reconnaît haut à droite de l'image architecturale du imagée ATtiny25 / 45/85:

Architecture d'un ATtiny 25/45/85-chipArchitecture d'un ATtiny 25/45/85-chip(Photo: ATMEL)

ATtiny25, ATtiny45 & ATtiny85

pour discuter de toutes les puces ATtiny en détail, est compliqué et ennuyeux. Par conséquent, le présent article se concentre un exemple aux représentants fréquemment utilisés. Parmi les jetons ATtiny bénéficient des représentants ATtiny25, ATtiny45 et ATtiny85 particulièrement attrayante, car ils combinent compacité avec des performances élevées. En particulier, ce dernier ATtiny85 est particulièrement abondant dans la nature. Avec 8K Flash, 512 octets de EEPROM et 512 octets de SRAM car ils ont le potentiel pour les petits projets. Contrairement à son petit facteur de forme, il a mentionné les représentants ATtiny aussi en termes de puissance de calcul en elle-même. Ils sont basés sur une architecture RISC avec 120 commandes qui nécessitent presque toujours un seul cycle d'horloge. Comme pour les processeurs RISC est typiquement un grand ensemble de 32 registres généraux (8 bits).

Le fonctionnement de la puce peut être fait avec différentes fréquences et tensions:

ATtiny25V / 45V / 85V: 0 - 4 MHz @ 1,8 - 5,5 V, 0 - 10 MHz @ 2.7 - 5.5V
ATtiny25 / 45/85: 0 - 10 MHz @ 2,7 - 5,5 V, 0 - 20 MHz @ 4.5 - 5.5V

En mode actif, basse fréquence, basse tension (1 MHz, 1,8 V), la consommation d'énergie à 300 uA assez modeste.

Le ATtiny85 et ATtiny25 ou ATtiny45 ses frères ont 8 sorties. La photo montre l'option package DIP-8. Bien sûr, aussi les versions SMT sont disponibles.

Les 8 broches du ATtiny85 Les 8 broches du ATtiny85(Photo: sparkfun.com)

Pinbelcontours:

Dans l'ensemble, les broches des ATtiny85 sont donc utiles à bien des égards, ainsi que la figure suivante illustre:

Lorsque ATtiny85 toutes les broches peut fournir de multiples fonctions et rôles Lorsque ATtiny85 toutes les broches peut fournir de multiples fonctions et rôles

La communication avec le monde extérieur

Question de prix: Si un ATtiny un I2C ou SPI? La réponse est complexe, en fonction de votre point de vue, que ce soit "ni l'un ni l'autre" ou "à la fois ...", Le support de bus à thème est via un composant universel. Le ATtiny85, grâce à un module USI (Interface série universel) à la fois I2C (TWI) - ainsi que le support du protocole SPI. Ceux-ci se trouvent dans tous les ATtiny85 une normale et une minuterie supplémentaire à haute résolution pour fournir le moment précis requis

Le ATtiny25 / 45/85 par la voie ne pas de bus série, ce qui explique pourquoi la communication avec le moniteur de série sur l'Arduino IDE par défaut impossible. Comment la technologie logicielle de rencontre, décrit le site "La communication avec Tiny",

clignotant

Comme le firmware ou bootloader vient en fait à un ATtiny? représentants ATtiny sont programmables avec ISCP ou ISP (programmation série en circuit). PIDDC comprend ainsi six ports MOSI, MISO, SCK, RESET, VCC et GND. Soit dit en passant, les six pôles, port ISCP rectangulaire se trouve au pied des puces ATmega sur un Arduino.

Pour la programmation d'un ATtiny85 il existe de nombreux programmeur, à propos USBtiny ou USBasp. solutions correspondant est d'acheter le fabricant sur eBay pour une poignée d'euros.

Dans le menu Outils Arduino | Programmer trouvé un support pour plusieurs programmeur prédéfini. L'Arduino en option FAI est là sur l'offre. Dis: Une Uno Arduino ou d'une autre carte Arduino peuvent être utilisés en tant que programmeur. C'est la plus simple et la moins coûteuse solution, à part le câblage nécessaire. Les amateurs qui veulent programmer souvent un ATtiny, bien sûr, peuvent construire une solution simple mais durable basée sur une carte Arduino Uno.

Le circuit nécessaire est illustré dans le tableau Fritzing suivant:

Programmer un ATtiny85 avec l'Arduino Uno en tant que matériel de programmation Programmer un ATtiny85 avec l'Arduino Uno en tant que matériel de programmation

Le câblage des broches des deux composants est la suivante:

ATtiny85 Arduino
Pin 1 .................... broche 10 (reset)
Broche 2 .................... n / a
Broche 3 .................... n / a
Broche 4 GND ....................
Pin 5 Pin .................... 11
Broche 6 .................... 12 Pin
Broche 7 .................... 13 Pin
Pin 8 .................... 5V

Recommandé en outre à la solution d'auto-mesure décrit est un condensateur électrolytique vous à l'entrée RESET de la carte Arduino Uno (plus) et une sortie GND (moins) collé.

Ainsi, l'Arduino IDE prend également en charge ATtiny circuits intégrés, il a besoin d'un gestionnaire de conseil correspondant. Tapez Préférences (Arduino | Préférences) l'URL du Gestionnaire de conseil supplémentaires suivantes:

https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager
/package_damellis_attiny_index.json

Pour programmer la ATtiny85 Uno en utilisant l'IDE Arduino, vous devez maintenant encore dans les conseils Manager (Outils | Gestionnaire de cartes) à la recherche de ATtiny. Vous devriez trouver les conseils de bibliothèques suivantes et installer:

Installation ATtiny Soutenir Tung dans l'Arduino IDE Installation ATtiny Soutenir Tung dans l'Arduino IDE

Maintenant, sélectionnez le menu (Outils | Conseils) l'entry correspondante: ATtiny25 / 45 / 85e

Télécharger un croquis de l'échantillon dans lequel vous remplacez la DEL du 13 à 0 comme l'exemple clignotant obligatoire. Les clients doivent certainement être connectés à la sortie numérique 0 du ATtiny85 aussi une LED réelle.

En tant que programmeur vous donnez dans Outils | Programmeur un Arduino comme fournisseur d'accès Internet. Si une autre utilisation de matériel de programmation (voir ci-dessus), vous spécifiez les applications que vous programmeur à la place.

Maintenant, enfin, le fabricant peut charger le croquis sur le ATtiny85. Le flux contient de la puce sur l'ONU Arduino ou son programmateur ICSP / fournisseur de services Internet associé. Bien sûr, les ATtiny85 peuvent alors à partir Arduino ou séparé du programmateur et autrement fournir de l'énergie, ainsi, par exemple, une carte de batterie ou FTDI.

La broche RESET peut être, comme mentionné plus haut dans cet article, sur les attitudes de la soi-disant "fusibles" reconfigurer le ATtiny à une entrée normale. Cela se fait avec un programmeur ISP ordinaire. Cependant, cela signifie que l'utilisateur ne peut pas programmer avec le programmateur ISP, le MCU (Micro Controller), mais nécessite un programmeur avec une tension plus élevée.

Pour la configuration modifiée inversée, est également un "Programmer haute tension" nécessaire. Ce qui est disponible à l'achat ou peut au contraire créer un self-made, tel que décrit sur le site Web stocké. illustre un autre site comment les développeurs utilisent la broche RESET sans interventions supplémentaires en sortie.

Des options plus confortables

L'option la plus pratique et plus facile à utiliser un ATtiny sans trop d'effort, sont finis des mini-cartes comme le OLIMEXINO-85, qui peuvent être achetés soit prémontées pour quelques euros en kit de bricolage ou.

OLIMEXINO-85 comprend un ATtiny85 ainsi que tous les autres composants nécessairesOLIMEXINO-85 comprend un ATtiny85 ainsi que tous les autres composants nécessaires(Photo: olimex.com)

Le kit intègre une carte FTDI à la puissance, une ATtiny85 connectable, un bouton de réinitialisation et les voyants et des composants passifs. Le panneau fini est compatible carte de test et effectue toutes les sorties des ATtiny85 vers l'extérieur. Des démonstrations, des bibliothèques et firmware, le fabricant Olimex sur cette page GitHub disponibles.

Nous arrivons au sujet bootloader. Pour les processeurs ATtiny la communauté open source a créé son propre projet appelé micronoyau dans la vie. Son objectif principal de conception est compact. Le Conseil OLIMEXINO-85 comprend, par exemple, par défaut, le bootloader du micronoyau.

Pour utiliser la carte OLIMEXINO-85 sous l'IDE Arduino, les développeurs doivent ajouter le gestionnaire du conseil de l'IDE dans les préférences suivantes URL: http://digistump.com/package_digistump_index.json.

Entrée de l'URL dans les paramètres du Conseil de Gérance Arduino IDE Entrée de l'URL dans les paramètres du Conseil de Gérance Arduino IDE

Après cela, le menu Outils | Conseil | directeur des conseils ATtiny les conseils offerts pour l'installation:

Installation de panneaux ATtiny (Digistump) le Conseil directeur de l'Arduino IDE Installation de panneaux ATtiny (Digistump) le Conseil directeur de l'Arduino IDE

Il suffit de chercher les conseils Digistump AVR.

Sélectionnez le OLIMEXINO-85 la carte Digispark (par défaut - 16,5 mhz).

Une fois que vous voulez jouer un sketch sur la carte, retirez la carte du port USB de l'ordinateur hôte. Après avoir appuyé sur le bouton de téléchargement invite l'IDE pour connecter la carte via USB, puis micronoyau charge automatiquement le croquis sur le ATtiny.

Adafruit babiole & co

En plus Olimex aussi Adafruit a un conseil d'basé sur la ATtiny85 pour quelques euros. Le Conseil Trinket comprenait également l'utilisation en tout lieu et de micronoyau OLIMEXINO-85. Adafruit le conseil d'administration fournit dans un 3-V ou la version 5-V.

Adafruit Bijou bord avec Micro USB Adafruit Bijou bord avec Micro USB(Photo: adafruit.com)

Pour plus d'informations sur ses caractéristiques, l'utilisation et l'installation se trouvent sur le site Web de babiole.

Un autre conseil comparable est le Digistump:

digistumpUne autre carte ATtiny85 vient de Digistump(Photo: digistump)

Mais cela est loin d'être suffisant. Le Wattuino nanites 85 sont disponibles pour six euros à Watterott. Ce conseil fait suite à la conception nanites. En outre Watterott propose également un conseil basé sur la ATtiny841 qui a un paquet DIP-14 et donc plus de connexions:

Watterott nanites 86Watterott nanites 86(Photo: watterott.com)

Et il peut certainement retrouver quelques conseils plus abordables qui ont des fonctionnalités similaires sur Internet. Beaucoup trop de possibilités de différenciation n'existe pas de toute façon.

Par exemple le contrôle des feux de circulation

Pour illustrer le travail avec les processeurs ATtiny suit maintenant une simple esquisse d'exemple qui réalise une simple lumière de la circulation. Pour ce faire, nous devons d'abord comprendre comment fait un travail feu de circulation. Au total, il y a quatre phases de feux de circulation connue (voir figure):

Il y a quatre feux de circulation Il y a quatre feux de circulation(Photo: http://bascom-forum.de/mediawiki/index.php/Datei:Ampelphasen.png)

Bien sûr, peut faire les différentes phases de différentes longueurs aux feux de circulation. Le tout peut aussi compliquer arbitraire. Certains feux de signalisation sont éteints complètement dans le trafic lumineux ou un signal jaune clignotant. Dans le monde réel aussi la connexion simultanée et coordonnée de plusieurs feux de circulation a lieu aux intersections.

Cependant, un contrôle des feux de circulation trivial comme décrit ci-dessous un mini-projet ne nécessite que des efforts limités.

Un schéma Fritzing destiné à illustrer le circuit à base de carte de test trivial avec trois DEL (rouge, vert, jaune), trois résistances 220 ohms, et un fil de décalage de bit:

circuit de feux de circulation simple ayant OLIMEXINO-85 (Conseil représenté schématiquement) circuit de feux de circulation simple ayant OLIMEXINO-85 (Conseil représenté schématiquement)

Le code du contrôle des feux de circulation

Le code pour le contrôleur de feux de signalisation met en oeuvre les phases de ces quatre dans la forme d'une simple machine d'état (modèle d'état), dans lequel les méthodes les différents états (phaseOne, PhaseTwo, la troisième phase, phaseFour) représenter. Un changement d'état se produit selon la méthode simple appel, tel que l'appel PhaseTwo () dans le corps de boucle (). La liste est explicite.

////////////////////////////////////////////////// ///////////
//
// Esquisse pour ATtiny85 Simpler
// contrôle de la circulation de la lumière
//
////////////////////////////////////////////////// ///////////


const int RED = 4; // LED rouge
const int YEL = 2; // LED jaune
const int GRN = 0; // LED verte



// Déclarations auxiliaires:

// LED rouge on / off:

#define Redon () digitalWrite (ROUGE, HIGH)
#define RedOff () digitalWrite (ROUGE, LOW)
// LED jaune on / off:
#define YellowOn () d'écriture numérique (YEL, HIGH)
#define YellowOff () d'écriture numérique (YEL, LOW)
// LED verte on / off:
#define Greenon () écriture numérique (GRN, HIGH)
#define Greenoff () d'écriture numérique (GRN, LOW)
// minuterie phase rouge:
#define DelayOne () retard (5000)
// rouge de transition minuterie au vert:
délai #define DelayTwo () (2000)
// minuterie phase verte:
Délai #define délai de trois () (5000)
// vert transition minuterie rouge:
Délai #define délai de quatre () (2000)

void setup () {
// LED comme sorties:
pinMode (RED, OUTPUT);
pinMode (YEL, OUTPUT);
pinMode (GRN, OUTPUT);
// Une fois que tous les voyants sont éteints:
initialiser ();
}

// Tous les voyants sont éteints:
initialize void () {
RedOff ();
YellowOff ();
Greenoff ();
}

// phase rouge:
phaseOne vide () {
Redon ();
YellowOff ();
Greenoff ();
DelayOne ();
}

// RotNachGrünPhase:
PhaseTwo vide () {
Redon ();
YellowOn ();
Greenoff ();
DelayTwo ();
}

// phase verte:
phase de vide à trois () {
RedOff ();
YellowOff ();
Greenon ();
Trois Delay ();
}

// GrünNachRotPhase:
phaseFour vide () {
RedOff ();
YellowOn ();
Greenoff ();
Quatre Delay ();
}

// default => clignotement du signal jaune:
urgence void () {
RedOff ();
Greenoff ();
YellowOn ();
retard (500);
YellowOff ();
retard (500);
}

void loop () // Commencer par la phase verte:
trois phases ();
phaseFour ();
phaseOne ();
PhaseTwo (); }
}

amener à afficher

Certes, ce fut une application triviale. Un autre exemple est d'illustrer une application plus complexe. Dans cet exemple plus complexe, un 0.96 vient" OLED 128 x 64 pixels est utilisée (le type des OLEDs est SSD1306). Étant donné que cet affichage nécessite un port I2C, le croquis montre aussi un exemple de l'utilisation I2C sur le ATtiny85.

Le port 0 (PB0) des actes ATtiny85 (SDA) en tant que connexion de données, tandis que le port 2 (PB2) sert de ligne de SCL, le temps.

(Note: Port 0 ou PB0 est sur la broche 5, Port 2 et PB2 à la broche 7 de puces de ATtiny85).

Pour mettre l'écran OLED via I2C en marche ATtiny85, une bibliothèque spéciale est nécessaire, car la bibliothèque standard I2C représente fil pour ATtiny85 morsure trop luxuriante. Heureusement, il existe des remèdes:

Le circuit est le suivant:

Fil bleu: ATtiny85 GND GND avec SSD1306
Fil rouge: ATtiny85 3,3 V ou 5 V avec SSD1306 Vcc
Fil vert: ATtiny85 Port 0 (= Pin 5) avec SSD1306 SDA
Fil jaune: ATtiny85 Port 2 (= Pin 7) avec SCL SSD1306

qui montre aussi dans le Fritzing-diagramme suivant:

SSD1306 écran OLED à Adafruit Trinket 5VSSD1306 écran OLED à Adafruit Trinket 5V

Bien qu'un Conseil Adafruit-Trinket peut être vu sur le diagramme, mais ils peuvent le remplacer par ATtiny85 tout moment par OLIMEXINO-85, un Wattuino nanites 85 ou tout autre conseil d'évasion.

Tout ce que vous avez besoin est un code

L'utilisateur AndyB2 a mis sur instructables.com un très bon guide et le code source pour la connexion à un écran OLED aux ATtiny85 sont disponibles pour que vous référer deux exemples plus que matériel d'illustration et de l'utilisation. Trouvez fabricant les instructions à ce point. Je me suis orienté dans mon propre exemple AndyB2.

En raison de la mémoire de données limitée du ATtiny85 le schéma suivant les rejets de l'information ne change pas comme la configuration binaire des logos de thermomètre utilisés dans la mémoire du programme. Cela est évident à partir du PROGMEM d'attribut dans le code du programme.

Le scénario du programme de démonstration est rapidement dit.

#include "SSD1306_minimal.h" // pilote OLED

// stocker des données dans la mémoire de programme:
#include

#define ° "\ xa7" "C"

SSD1306_Mini oled; // un écran 128x64 OLED 0,97"

// image d'un petit thermomètre:
const unsigned char ThermometerIcon [] PROGMEM = {
0x00, 0xfe, 0x03, 0xfe, 0x50,
0x00, 0xff, 0x00, 0xff, 0x55,
0x60, 0x9f, 0x80, 0x9f, 0x65,
};


////////////////////////////////////////////////// /
//
// show écran de démarrage ()
// renvoie les informations initiales sur l'affichage
//
////////////////////////////////////////////////// /


show start void () {

oled.startScreen (); Commutateur // affichage
oled.clear (); // affichage clair

oled.cursorTo (0,7); // position du curseur
oled.printString ( "et fonctionnalités");

retard (3000);

oled.clear ();
oled.cursorTo (15.1);// position du curseur
oled.printString ( "ATtiny85 démo");
}

////////////////////////////////////////////////// /
//
// montrer la puissance indicateur ()
// Infos sorties d'exploitation
// logo (thermomètre)
// et une valeur de température
//
////////////////////////////////////////////////// /


vide montrent l'affichage de fonctionnement () {

oled.clear (); // affichage clair
oled.startScreen (); Commutateur // affichage


oled.cursorTo (0,0);
oled.printString ( "OLED de connexion");
oled.cursorTo (10.2);
oled.printString ( "température");
// affichage et même graphique:
oled.drawImage (ThermometerIcon, 20,4, 5, 3);
}



////////////////////////////////////////////////// /
//
mesure de la température //
// simule un thermomètre
//
////////////////////////////////////////////////// /
température de mesure char () {
retour 20 + aléatoire (-5,5);
}


////////////////////////////////////////////////// /
//
// configuration
// Initialiser OLED
Afficher // Écran de démarrage
Afficher // Indicateur d'alimentation
//
////////////////////////////////////////////////// /


void setup () {
pinMode (3, INPUT);

oled.init (0x3c); // OLED dépend de 0x3c IIC-Id
oled.clear (); // affichage clair

retard (1000);
voir start (); // écran de démarrage initial
retard (2000);
VITRINE d'exploitation (); // Indicateur d'alimentation
}



////////////////////////////////////////////////// /
//
// boucle
// la boucle de mesure réelle
// mesurer en continu et à l'affichage de fonctionnement
// sortie
//
////////////////////////////////////////////////// /


void loop () {

carbonisation buf [10];

// Déterminer la température:
température de carbonisation = mesure de température ();

// Création d'informations formatées:
sprintf (buf, "% + 0.2hd" DEG, température);

// position du curseur:
oled.cursorTo (30, 5);

// sortie de la valeur de la température:
oled.printString (BUF);
retard (500); // rupture entre les mesures
}

Comme toujours, l'exemple de la forme imprimée peut encore beaucoup à désirer. Si vous sentez que vous pouvez utiliser, par exemple, au lieu de la température simulée d'un mètre capteur réel et étendre le circuit en conformité avec un autre capteur ou bien sûr de votre choix. Bien sûr, un système mis à jour en conséquence ATtiny doit être transféré dans un ensemble de données de position par radio (RF). Libérez votre imagination tranquille gratuit.

résumé

Le voyage aux représentants de la famille ATtiny montre que nous ne devons pas nécessairement accès à une carte Arduino comme une panacée pour les projets. Qui aime compact, abordable et d'économie d'énergie, peut mettre en place avec l'aide d'un circuit de ATtiny. Ensuite, peut également atteint une batterie plus petite ou une opération de cellules solaires.

Cependant, cette approche a aussi des contraintes physiques en ce qui concerne l'épaisseur des mécanismes de communication disponibles, la taille de la mémoire ou le nombre d'entrées et de sorties. De plus, les bibliothèques ne fonctionnent que partiellement Arduino et souvent qu'après des changements majeurs aux systèmes ATtiny ensemble.

Une fois que les inconvénients ne sont pas importants et les avantages l'emportent, est l'utilisation de la famille ATtiny certainement rien de la manière.