Gestion Boutons/Trigger avec µC ATtiny85

[alka]

Pour un ampli dont le on/off sera commandé a la fois par un Trigger (en continu) et par un Bouton Poussoir (en impulsion), il faut un peu d’électronique pour bien gérer les commandes et priorités.

On peut faire a l'ancienne avec quelques circuits logique autour d'une bascule D comme ici ou utiliser un micro-controleur.

Pour un bouton poussoir, un trigger et une led, pas besoin de gros système. Et ça tombe bien car dans la famille des micro-processeurs Atmel utilisés pour l'arduino, il y a l'ATtiny85.

C'est un circuit µC avec tout inclus, 8 pins en boitier DIP8 ou SOIC avec quelques entrées/sorties pour un prix d'environ 1Euro.

En clair c'est moins cher, plus compact et bien plus flexible et puissant que les circuits logiques, donc a essayer d'urgence

Comme un bonheur n'arrive jamais seul, Digispark a fait des micro-cartes de développement qui ont tout ce qu'il faut, connectables en USB et compatibles avec l'environnement de développement ARDUINO On trouve des clones de ces cartes pour quelques euros sur ebay.

La version Digispark , pour donner l'échelle


C'est mon premier projet µC, j'apprend et vous en fait profiter

Dans les posts suivants on détaillera ces cartes Attiny85, leur installation et programmation. Ensuite mon projet.
a suivre..

[alka]

Un petit tour sur ebay où on trouve des clones qui ressemblent à l'originale Digispark et aussi d'autres formats. J'ai choisi un modèle avec fiche USB et l'ATtiny85 en DIP8 sur support pour pouvoir le retirer après programmation et le placer dans mon circuit. Le schéma est toujours le même. Le prix tourne autour de $2 livré sur ebay !!

la mienne ressemble a ça :


Avec des cartes a ce prix, on peut laisser la carte de développement entière dans le projet ! Elles sont a peine plus grandes que le chip et contiennent un régulateur 5V.

Ces cartes sont minimalistes : quelque résistance et capas, une led power on, une led controlée sur une sortie, un régulateur 5V pour que la carte puisse être alimentée par ailleurs, et un connecteur USB. Le protocole USB est émulé par le µC.

Je n'entre pas dans tous les détails sur ces puces, la datasheet et le site Digispark donnent plein d'infos pour celui qui veut les utiliser. Pour aller a l'essentiel :

L'ATtiny85 a 8 pins, le 5V et 0V et 6 GPIOs.
Deux pins sont utilisées pour la communication USB (P3, P4). On peut les utiliser dans son programme mais faut alors faire très attention si on fait tourner le programme pendant que la carte est branchée sur l'USB.

C'est un µC 8 bits, en standard à 16MHz. Peut se downclocker a 8 ou 1MHz et dans ce cas consomme autour de 2mA. Pas étonnant que des projets utilisant ce µC soient alimentés par pile bouton !

8K de mémoire dont 2 occupés par le bootloader préconisé par Digispark (micronucleus). Reste 6K pour les programmes. C'est peu et suffisant pour des petites choses qu'on attend de lui. Il peut aussi faire comme les grands : existe des librairies et cartes additionnelles pour gérer écran lcd, clavier, moteur, etc.

Il est programmable avec l'IDE Arduino, donc un terrain favorable bien que toutes le librairies Arduino ne fonctionnent pas avec ce petit processeur.

Lien wiki digispark : http://digistump.com/wiki/digispark
schéma de la carte : http://www.mcmelectronics.com/content/P ... -17748.pdf
datasheet Attiny85 : http://www.atmel.com/Images/Atmel-2586- ... ummary.pdf

Le principe de ces cartes :

Une fois installée et reconnue par le pc et l'IDE Arduino (ces points seront détaillés dans le post suivant) on programme en C dans l'IDE de l'arduino, puis on transfère le programme vers la carte.
Contrairement a l'Arduino standard, il faut débrancher la carte, cliquer sur "Téléverser" on est alors invité a brancher la carte sur l'USB du pc. Ding-dong de windows, la carte est reconnue et le programme est alors transféré sur l'ATtiny85 et exécuté.

Il y a un programme résident dans l'Attiny85 appelé bootloader. C'est un programme qui gère la communication USB et permet de charger un programme utilisateur et de le lancer.
Quand on met la carte sous tension, le bootloader attend pendant 5 secondes pour voir si l'IDE Arduino essaie de lui envoyer un programme par USB. Si oui, il le télécharge et remplace celui qui est en mémoire. Sinon, au bout des 5 secondes il lance le programme utilisateur qui est dans la mémoire de l'ATtiny.
On peut mettre un bootloader alternatif pour éviter ce délai de 5 sec s'il est genant.

C'est tout. Maintenant faut prototyper avec une breadboard sur laquelle on branche boutons, leds et autres choses qu'on veut, brancher les pins de sa carte de développement sur la breadboard puis faire son programme (le croquis ou sketch en arduinolang) et le "téléverser" pour vérifier que son code fonctionne. Et recommencer

[alka]

L'installation.

Là j'ai perdu du temps... mérite d'être détaillé pour éviter de tomber dans les pièges. Une fois qu'on sait, c'est fait en quelques minutes.

Les instructions sont très courtes et bien décrites sur le wiki DIGISTUMP:
https://digistump.com/wiki/digispark/tu ... connecting

Cette procédure commence par l'installation de l'IDE Arduino. Il faut juste savoir que la version actuelle 1.6.6 a un bug qui empêche d'utiliser avec ces cartes. J'y ai laissé quelques heures pour comprendre ce qui m'arrive
Utiliser IDE Arduino 1.6.5

La suite de la procédure d'installation consiste à indiquer à l'IDE Arduino l'endroit où récupérer la description de ces cartes. Suivre le guide du wiki.

Le boards-manager est censé aussi installer le driver usb windows pour la carte. Cette étape a échoué chez moi. Le driver a bien été téléchargé sur le pc mais pas installé. Il a fallu l'installer "a la main" a la fin de l'installation automatique.

Le plus dur a été de trouver où a été téléchargé ce satané driver !!! sur XP c'est ici :

Code : Tout sélectionner

C:\Documents and Settings\**user**\Local Settings\Application Data\Arduino15\packages\digistump\tools\micronucleus\2.0a4

(remplacer **user** par votre nom d'utilisateur)

En branchant la carte sur le pc, windows détecte un nouveau périphérique et demande le pilote. Ne pas prendre l'installation automatique et lui indiquer le répertoire où se trouve le driver et tout va bien.

Le pilote s'appellle DigiUSB.inf

Voilà, c'est tout. Moins de 5 minutes quand on sait.

Pour démarrer la programmation :
Il y a des programmes exemples (Fichier > Exemples > Digispark-examples) mais j'ai pas trouvé là le plus simple qui consiste a faire clignoter la led commandée qui est sur la carte. Ca ne nécessite rien d'autre d'externe et permet de voir un résultat immédiat.

Un copier/coller de ce code et c'est fait :

Code : Tout sélectionner

// the setup routine runs once when you press reset:
void setup() {               
  // initialize the digital pin as an output.
  pinMode(0, OUTPUT); //LED on Model B
  pinMode(1, OUTPUT); //LED on Model A   
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(0, HIGH);   // turn the LED on (HIGH is the voltage level)
  digitalWrite(1, HIGH);
  delay(1000);               // wait for 1000 milisecond
  digitalWrite(0, LOW);    // turn the LED off by making the voltage LOW
  digitalWrite(1, LOW);
  delay(1000);               // wait for 1000 milisecond
}

modifier les délais pour voir ce qui se passe et se familiariser avec le rythme a trois temps : retirer la prise USB, cliquer sur téléverser, rebrancher la fiche USB. Si on téléverse avec la carte déjà branchée, il finit en erreur. Faut recommencer en retirant la fiche usb.

Sur ma carte, la led commandée est sur pin1.

La lecture du wiki est instructive.
A commencer par le chapitre quickref https://digistump.com/wiki/digispark/quickref

[thierryvalk]

Il reste combien de GPIO en décomptant ce qui est nécessaire pour l'émulation ?

[alka]

:ghee:
Il reste combien de GPIO en décomptant ce qui est nécessaire pour l'émulation ?

c'est écrit dans le post "réservé".

comment ça, c'est pas encore écrit ?
bah, voilà.
Il y a 6 E/S au total. Avec le 5V et le GND ça fait 8 pins.
Deux sont utilisées pour l'USB (p3 et p4). On peut les utiliser dans son programme mais faut faire gaffe si on fait tourner son programme en étant connecté a l'usb évidemment.
Comme j'ai besoin que de 4 pins (entrée BP, entrée Trigger, sortie Led et sortie commande) je préfère ne pas utiliser du tout P3 et 4.

[thierryvalk]

Comprend pas, sur la page du site d'Atmel pour le ATtiny85 :
USB Interface: No

[alka]

Comprend pas, sur la page du site d'Atmel pour le ATtiny85 :
USB Interface: No

ça c'est pour l'ATtiny85 seul.
Une fois mis sur la carte digispark ET le bootloader qui gère l'usb installé, il émule l'USB en software.

je viens de remplir un des posts réservé où je parle de ça.

[alka]

mon code qui gère l'allumage de la led avec un BP

Code : Tout sélectionner

// definitions

// quelques constantes pour faciliter la lecture du code
const boolean UP = LOW;       // définition pour BP non appuyé
const boolean DOWN = HIGH;    // définition pour BP appuyé
const boolean OFF = LOW;      // définition pour LED éteinte
const boolean ON = HIGH;      // définition pour LED allumée

// définition et initialisation des variables
boolean ButtonState = UP;     // état du bouton poussoir
boolean ButtonPrevState = UP; // état précédent du bouton poussoir
boolean LedState = OFF;       // initialisation LED éteinte

int PinLED = 1;               // LED cms embarquée sur pcb sur pin1 (model A)
int PinButton = 0;            // bouton poussoir sur pin0 dans mon cablage

int i = 0;

// fonction appelée une seule fois au demarrage ou au reset
void setup() {
  pinMode(PinButton, INPUT);  // déclare la pin PinBouton comme une entrée
  pinMode(PinLED, OUTPUT);    // déclare la pin PinLED comme une sortie
  digitalWrite(PinLED, LOW);  // initialise LED éteinte
}

// la fonction loop est executee en permanence et contient tout le code
void loop() {

  // LED cligotte 5 fois au départ
  while (i < 5) {               // tant que le compteur est < 5
    digitalWrite(PinLED, ON);   // LED sur pin1 allumée
    delay(100);                 // attend 100 ms
    digitalWrite(PinLED, OFF);  // LED sur pin1 eteinte
    delay(200);                 // attend 200 ms
    i++;                        // incrément compteur
  } ;                           // a la sortie, i=5 et ce code ne sera plus exécuté bien que dans loop()


  // allumage-extinction de la LED selon appui du Bouton Poussoir

  ButtonState = digitalRead(PinButton);         //lecture de l'état de la pin0 du bouton

  if (ButtonState != ButtonPrevState) { // action seulement si le bouton a changé d'état
                                        // maintenir le bouton appuyé ne provoque pas d'action 
    if (ButtonState == DOWN) {
      // bouton appuyé
      LedState = !LedState;           // bascule l'état courant de la led et le mémorise
      digitalWrite(PinLED, LedState); // met la pin led au voltage correspondant à l'état courant
      ButtonPrevState = DOWN;         // mémorise l'état appuyé du bouton
    } else {
      // bouton relaché
      ButtonPrevState = UP;           // mémorise l'état relaché du bouton
    }
    delay(500);                       // attente avant prochaine lecture. debounce et évite double appui erroné
  }


} // end loop 

c'est pour montrer que c'est utile de commenter. Comment ça "y a un message"

[alka]

[thierryvalk]

Ca manque de fonctions mais pas de commentaires.

[alka]

Ca manque de fonctions mais pas de commentaires.

je vois que le message est passé

Avec ce gadget, je me sens comme un gamin qui a reçu une boite de mécano J'ai une idée par minute pour faire des chose!
En revanche l'outil est très rudimentaire pour le debug. Je vois pas comment ils font pour des développements plus poussés. A part faire clignoter la led ou afficher une tension sur une pin, on sait rien. C'est loin d'un environnement eclipse comme LCPXpresso avec carte debug ou on a les breakpoints, surveillance de variables, etc. Faut que je continue d'investiguer le monde arduino, sans doute un truc m'a échappé.

[thierryvalk]

Pas simple le debug, les breakpoints, oui très utiles mais comme son nom l'indique arrête le programme.
Pas toujours pratique pour des applications sur des IO en temps réels.
Doù la simple sortie "test" que l'on place à des endroits stratégiques en la mettant à 1 ou 0 ou toggle, connectée à un oscillo rend aussi de grands services.
Faut surtout avoir de l'imagination et un système simple / rapide pour lancer le programme.

PS, j'ai cherché et pas encore trouvé comment afficher du code sur le forum avec une syntaxe en couleur.
Il existe la balise [code=php], c'est pas du C mais déjà plus présentable.

[alka]

joli les couleurs du code

Si on manque de GPIOs, il y a Digispark Pro. Le même principe avec l'ATtiny167. Processeur semblable avec 16K de flash au lieu de 8K et surtout 16 GPIOs. Aussi quelques communications de plus (SPI, I2C, UART natifs). Les clones de la carte se trouvent autour de 5E sur ebay.


Adafruit a aussi fait ses versions avec Trinket et Trinket pro. Semblent mieux documenté.

Pour le debug, en effet quelquechose m'a échappé : on peut utiliser la liaison USB pour communiquer avec le pc. C'est bidirectionnel. Pour du debug ou autre chose d'ailleurs.
Cela dit, chez moi impossible de le faire fonctionner. Sans doute un truc a installer quelquepart ou qui manque. Il faut avouer que le wiki digistump est incomplet et parfois mal rédigé, les forums pas toujours fiables, des choses a downloader en plusieurs versions sans savoir qui va avec qui. Ca manque de structuration, ce que adafruit fait avec son trinket et ses autres produits.

Si on a un logiciel un peu compliqué nécessitant de bons outils de debug, le mieux est peut etre de développer sur un vrai Arduino et de porter sur le Digispark.

[thierryvalk]

A mon avis pas possible de faire de l’émulation.
L’USB est software donc prend des ressources (et surement beaucoup) pour fonctionner.
Donc, je présume qu’ il charge en flash ton soft puis fait redémarrer le µC sur ton soft.
Pour de l’émulation, il faut aussi que le µC le permette et c’est rarement documenté.

[alka]

C'est sur que ça marche. J'ai vu une video sur Youtube ou l'écran pc affiche une ligne avec la valeur quand le gars tourne un potentiometre connecté sur une pin du digispark. Trouve plus le lien!
C'est que chez moi, le soft coté pc (digiUSB.exe) ne fonctionne pas correctement et ne détecte jamais le digispark. J'ai laissé tomber car pour mon projet c'est inutile. J'y reviendrai un jour de pluie

La connexion par USB est émulée par le fameux micronucleus qui est résident (le bootloader) pour causer avec l'IDE arduino ou avec leur programme sur pc (digiUSB). Ca fait juste le minimum vital. Il semble qu'on se contente de l'équivalent d'une liaison série pas très rapide, suffisant pour afficher des messages ou en saisir avec un clavier.

[thierryvalk]

C’est tout de même la première fois que j’entends parler d’USB réalisé en software.
De l’USB 1.0 en mode lent c’est déjà 190 ko/s. C’est encore supporté le 1.0 ?

[alka]

Pour mon projet (il est temps que j'en parle enfin !)

C'est pour un ampli commandé par un Trigger (tension continue présente ou absente) et aussi commandé par un Bouton Poussoir (impulsion).
Ce sera sur un pcb et le µC controlera un relais qui controle la tension d'alimentation de l'ampli. La carte électronique sera décrite par ailleurs.

Le fonctionnement :
Si le Trigger est présent, allumer l'ampli
Si le Trigger s'en va, éteindre l'ampli
Si le BP est appuyé, éteindre l'ampli s'il est allumé ou allumer l'ampli s'il est éteint, et dans les deux cas, que le trigger soit présent ou pas.

Pour faire simple: le BP gagne sur le Trigger. Cela permet d'utiliser l'ampli sans Trigger et aussi de prendre le contrôle manuel si ce que fait le Trigger ne convient pas pour une raison ou une autre.

En logique:
Trigger de OFF à ON : Ampli ON
Trigger de ON à OFF : Ampli OFF
BP appuyé : toggle Ampli

Faut aussi se prémunir contre des parasites éventuels sur la liaison Trigger et les appuis erratiques sur le BP.
Pour le trigger, je fais une double lecture après un délai pour éviter de commuter l'ampli sur un glitch. Pour le BP un simple délai suffit pour le debounce et l'appui trop long n'a pas d'effet.


Ce code allume/éteint la led sur pin1 pour simuler le on/off de l'ampli. Ca tient en quelques lignes. Trop frustrant : faudra ajouter des guirlandes

Code : Tout sélectionner

// definitions

// quelques constantes pour faciliter la lecture du code
const boolean UP = LOW;         // définition pour BP non appuyé
const boolean DOWN = HIGH;      // définition pour BP appuyé
const boolean OFF = LOW;        // définition pour LED éteinte
const boolean ON = HIGH;        // définition pour LED allumee

// définition et initialisation des variables
boolean ButtonState = UP;       // état du bouton poussoir
boolean ButtonPrevState = UP;   // état précédent du bouton poussoir
boolean LedState = OFF;         // initialisation LED éteinte
boolean TriggerState = OFF;     // état initial du Trigger
boolean TriggerPrevState = OFF; // état précédent du Trigger

int PinLed = 1;                 // LED commandée embarquée sur pcb sur pin1 (model Rev2)
int PinButton = 0;              // Bouton Poussoir sur pin0 dans mon cablage
int PinTrigger = 2;             // Trigger sur pin2

int i = 0;

// fonction appelée une seule fois au demarrage ou au reset
void setup() {
  pinMode(PinButton, INPUT);    // déclare la pin PinBouton comme une entrée
  pinMode(PinTrigger, INPUT);   // déclare la pin du Trigger comme entrée
  pinMode(PinLed, OUTPUT);      // déclare la pin de la Led comme une sortie
  digitalWrite(PinLed, LOW);    // initialise LED éteinte
  }

// la fonction loop est executee en permanence et contient tout le code
void loop() {

  // LED cligotte 5 fois au départ
  while (i < 5) {               // tant que le compteur est < 5
    digitalWrite(PinLed, ON);   // LED sur pin1 allumée
    delay(100);                 // attend 100 ms
    digitalWrite(PinLed, OFF);  // LED sur pin1 eteinte
    delay(200);                 // attend 200 ms
    i++;                        // incrément compteur
  } ;                           // a la sortie, i=5 et ce code ne sera plus exécuté bien que dans loop()

  // TRIGGER

  TriggerState = digitalRead(PinTrigger);   // Lecture de l'état de la pin du trigger 
  
  if (TriggerState != TriggerPrevState) {   
    // le trigger a changé d'état
    delay(300);                             // délai d'attente avant double lecture
    TriggerState = digitalRead(PinTrigger); // re-lecture de l'état de la pin du trigger 
    
    if (TriggerState != TriggerPrevState) { 
      // la double lecture confirme le changement 
      LedState = TriggerState;              // la LED prend l'état du Trigger
      digitalWrite(PinLed, LedState);       // sortie pinled mise au voltage correspondant a l'état de la Led
      TriggerPrevState = TriggerState;      // mémorise l'état précédent du Trigger
      delay(300);
      }                      
  }

  // BOUTON POUSSOIR

  ButtonState = digitalRead(PinButton);   //lecture de l'état de la pin du bouton

  if (ButtonState != ButtonPrevState) {   // action seulement si le bouton a changé d'état
                                          // maintenir le bouton appuyé ne provoque pas d'action 
    if (ButtonState == DOWN) {
      // bouton appuyé
      LedState = !LedState;               // bascule l'état de la led et le mémorise
      digitalWrite(PinLed, LedState);     // met la pin Led au voltage correspondant
      ButtonPrevState = DOWN;             // mémorise l'état appuyé du bouton
    } else {
      // bouton relaché
      ButtonPrevState = UP;               // memorise l'état relaché du bouton
    }
    delay(300);                           // attente avant prochaine lecture. debounce et double appui erroné
  }
  
} // end loop   

[thierryvalk]

Sans rapport :

et même pas de goto.