Overblog Suivre ce blog
Administration Créer mon blog
1 novembre 2016 2 01 /11 /novembre /2016 13:15

Cette année j'avais envie de faire un truc bruyant et lumineux pour Halloween. Et forcément, ça devait faire peur :)

Je me suis d'abord mis en quête de sons d'Halloween effrayants, et j'ai trouvé mon bonheur en quelques minutes.

La partie logicielle principale est  faite en Processing. Un outil vraiment très sympa pour du développement rapide et facile (ainsi que pour l'apprentissage de l'informatique sous une forme créative). 

Reste ensuite à savoir comment déclencher le truc via un appui sur la sonnette et à transmettre l'info au code en Processing.

Le moyen le plus simple est d'utiliser le réseau Wifi de la maison pour cela. Ca tombe bien j'ai un ESP8266 sous la main. Le truc a l'avantage d'avoir une carte WIFI intégrée et se programme en C facilement avec l'IDE Arduino. J'ai prévu un circuit électrique isolé via un optocoupleur, passant par le bouton de la sonnette car avant d'ouvrir le boitier je pensais que le bouton était alimenté en 230V, alors qu'il est en fait alimenté en 9V alternatif.  J'ai donc temporairement débranché l'inter de son transformateur pour l'insérer dans mon circuit, via une alimentation de récup' en 7.5V continu.

Lorsqu'on appuie sur la sonnette, ça envoie simplement un caractère via une socket réseau au programme en Procesing qui tourne dans le garage.

Le code dans l'ESP est le suivant:

 

 

/**
* "interrupteur sans fil" rudimentaire.
**/
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>

//pin mapping
#define D0 16
#define D1 5
#define D2 4
#define D3 0
#define D4 2
#define D5 14
#define D6 12
#define D7 13
#define D8 15
#define D9 3
#define D10 1

#define DEBUG
#define PIN_LED D10
#define PIN_BUTTON D5

//wifi network name
const char* ssid = "monRéseau";
//wifi network password
const char* password = "monPwd";

ESP8266WiFiMulti WiFiMulti;
WiFiClient client;

void connectWifi(){
#ifdef DEBUG
Serial.print("Connecting to ");
Serial.println(ssid);
#endif
WiFiMulti.addAP(ssid,password);
delay(500);
while (WiFiMulti.run() != WL_CONNECTED) {
delay(500);
}
#ifdef DEBUG
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
#endif
}

void disconnectWifi(){
#ifdef DEBUG
Serial.println("Disconnecting Wifi");
#endif
WiFi.disconnect();
}

void setup() {
#ifdef DEBUG
Serial.begin(9600);
while (!Serial); // wait for serial attach
delay(5000);
digitalWrite(PIN_LED,HIGH);
delay(250);
digitalWrite(PIN_LED,LOW);
#endif

connectWifi();
}

//Connexion au PC distant, provoque le démarrage de l'animation
void sendCommand(){
if (!client.connect("192.168.1.12", 12345)) {
Serial.println("connection failed");
return;
}
client.print(65);
client.flush();
client.stop();
}

void loop() {
if(digitalRead(PIN_BUTTON)){
Serial.println("bouton!");
digitalWrite(PIN_LED,HIGH);
sendCommand();
digitalWrite(PIN_LED,LOW);
//simple debouncing
delay(100);
while(digitalRead(PIN_BUTTON));
}
delay(50);
}


Côté Processing il s'agit de jouer des sons associés à des animations lumineuses de circonstance.

Sur le "rire machiavélique" j'ai rapidement eu l'idée d'un fade-in & fade-out entre le rouge et le noir, avec en surimpression une tête de monstre qui apparaîtrait à travers une des fenêtres du garage.

Sur le cri du monstre l'idée était de surprendre et de faire peur et j'ai pas mal tâtonné pour arriver à faire une succession de flashes blanc, noir et rouges à une fréquence variable et aléatoire.

L'animation est déclenchée par un clic (c'est pratique pour tester) et lors de la connexion de l'interrupteur wifi, lorsque quelqu'un sonne à la porte.

Le code est celui-ci:

import processing.net.*;

import ddf.minim.spi.*;
import ddf.minim.signals.*;
import ddf.minim.*;
import ddf.minim.analysis.*;
import ddf.minim.ugens.*;
import ddf.minim.effects.*;

Minim minim;
AudioPlayer player;
AudioInput input;
Server srv;
Client client;
boolean pressed=false;
int anim=0;
int count=0;
int speed=2;
PImage img;

//dessine le monstre à la bonne taille & position
void drawMonster(){
float scaleFactor = 0.45;
int x = 86;
int y = height - int(img.height * 0.7) ;
image(img,x,y,img.width*scaleFactor,img.width*scaleFactor);
}

void setup()
{
fullScreen();
frameRate(50);
background(#000000);

img = loadImage("monster.png");
minim = new Minim(this);
//se met en attente des conexions de l'interrupteur wifi
srv = new Server(this, 12345);
noStroke();
}

//boucle principale
void draw(){
if (keyPressed == true && pressed == false) {
mousePressed();
pressed = true;
}
if(keyPressed == false){
pressed = false;
}
client = srv.available();
if (client != null) {
client.read();
mousePressed();
}

//séquencement des deux animations
switch (anim){
case 1:
anim1();
break;
case 2:
anim2();
break;
}

count++;
}

void mousePressed()
{
if(anim==0){
count=0;
anim=1;
}
}

//première animation: monstre & flashes
void anim1(){
if(player == null){
player = minim.loadFile("Monster.mp3");
player.play();
}
int modulo = count % speed;
if(modulo >= 0 && modulo <= 1)
background(modulo ==0?#FFFFFF:#FF5555);
else
background(#000000);

speed = floor(count/50)+2;
if(count >= 7.5*50){
anim=2;
count=0;
player = null;
}
}

//seconde animation: rire machiavélique & fade-in-out en rouge
void anim2(){
if(player == null){
player = minim.loadFile("Evil_Laugh.mp3");
player.play();
}
int modulo = count % 1;
if(modulo == 0){
colorMode(HSB, 100);
int b = round(abs(sin(((float)count/1.5)/360*TWO_PI)*100));
background(color(0,100,b));
}
if(count >= 9.5*50){
background(#000000);
anim=0;
player=null;
}
drawMonster();
}

Pour ajouter plus de réalisme à la chose je voulais faire bouger la porte du garage en même temps que le monstre rugit.

N'ayant pas de moteur électrique assez puissant sous la main pour faire un truc qui cogne fort contre la porte, j'ai pris le plus gros moteur pas à pas que j'avais, récupéré sur un photocopieur.

Son rôle est de tirer à plusieurs reprises sur la porte du garage pour qu'elle bouge comme si on essayait de l'ouvrir.

Il est commandé par un Arduino. La séquence de mouvements de déclenche par un capteur de luminosité (dès que les flashes de l'animation démarrent). Le capteur s'auto-calibre au démarrage du sketch et démarre les mouvements si la luminosité mesurée dépasse le seuil déterminé au démarrage de plus de 15%. Ca permet de rendre le truc relativement indépendant de la luminosité ambiante.

 

 

Le code est le suivant:

#include <Stepper.h>

#define INITIAL_DELAY 2000
#define PIN_LDR A0
#define THRESHOLD_FACTOR 1.15

const int stepsPerRevolution = 200;
Stepper myStepper(stepsPerRevolution, 2, 3, 4, 5);
int light=0;
int threshold=0;
int running=0;

//auto-calibrage de la luminosité ambiante au démarrage
void calibrate(){
delay(150);
threshold = analogRead(PIN_LDR);
}

//désactive toutes les sorties pilotant le moteur pas à pas
void disableOutputs(){
digitalWrite(2,LOW);
digitalWrite(3,LOW);
digitalWrite(4,LOW);
digitalWrite(5,LOW);
}

void setup() {
myStepper.setSpeed(200);
calibrate();
}

//boucle principale
void loop() {
if(analogRead(PIN_LDR) > threshold * THRESHOLD_FACTOR){
running = 1;
}
if(running){
delay(INITIAL_DELAY);
myStepper.step(stepsPerRevolution*3+4);
disableOutputs();
delay(1500);
myStepper.step(stepsPerRevolution+4);
disableOutputs();
running = 0;
}
}

Un résumé en images.

Le truc a bien fonctionné  :)

 

Repost 0
Published by breizhmakers - dans Arduino ESP8266
commenter cet article
8 avril 2016 5 08 /04 /avril /2016 16:45

Comme souvent je traînais sur un site de makers et je suis tombé sur la création d'un artiste, Lorenzo Bravi, qui est un séquenceur de percussions à base d'Arduino et Solénoïdes. L'idée étant ensuite de pouvoir changer facilement sur quoi les solénoïdes frappent afin d'en changer le son.

J'ai trouvé le concept sympa mais j'ai voulu faire quelque chose de plus versatile, pilotable via un vrai séquenceur MIDI (mais bien moins réussi niveau esthétique ;) )

 

J'ai commencé par faire un shield Arduino pour pouvoir commander les solénoïdes.

Version DYI bien sûr, c'est à dire sur une plaque à trous, au format shield Arduino.

6 MOSFET, quelques résistances, LED de contrôle et une poignée de connecteurs.

Comme souvent avec ce genre de montage, c'est pas très propre côté pistes, mais ça fonctionne.

MOSFET ShieldMOSFET Shield

MOSFET Shield

 

J'ai ensuite cherché un séquenceur MIDI pour Android, mais comme souvent dans le domaine de la musique, je n'ai trouvé mon bonheur que sur iPad. Le seul truc réellement utilisable par tous est Nord Beat 2, et gratuit en plus. Oui, le système est destiné à des enfants. J'aime bien faire des instruments d'éveil musical ludiques (voir le Mycophone par exemple).

 

Là s'est posé l'épineux problème de la connexion entre l'iPad et l'Arduino. Surtout que le Midi à la sauce Wifi Apple c'est comment dire....compliqué (doux euphémisme!...).

Après pas mal de recherches, j'ai opté pour l'excellent logiciel gratuit RTPMidi côté PC, que j'avais découvert en bricolant avec TouchDAW auparavant.

Donc après avoir installé RTPMidi et ce qui va avec (protocole "Bonjour"), et avoir lu attentivement la doc pas très claire, j'ai enfin vu mon iPad apparaître dans la liste des sessions Midi côté PC.

 

Restait à déterminer comment envoyer ces messages MIDI à l'Arduino.

C'est là qu'entre en jeu LoopBe1, un port midi virtuel et gratuit.

Ceci va en quelque sorte créer un câble MIDI virtuel entre les messages provenant de l'iPAD et...un programme Processing chargé de faire le relais entre le port MIDI virtuel et le port série sur lequel écoute l'Arduino.

J'ai opté pour un format de messsage entre Processing est l'Arduino qui n'est pas MIDI mais un format binaire ou chaque bit d'un octet correspond à un solénoïde à activer. Le tout transmis à 115200 bauds. C'est mon côté optimisateur fou :)

Le Sketch Processing transforme donc un message MIDI de type NoteOn en un bit à 1 et un NoteOff en un bit à 0.

Côté Arduino, un simple masque binaire permet de calculer l'état des sorties et d'utiliser les "fast I/O" pour les piloter.

Lors des premiers essais, des problèmes de latence sont vite apparus, le système était injouable dès que le tempo était un peu rapide.

La solution a été de passer par un réseau wifi pair-à-pair (mode ad-hoc) entre le PC et l'iPad. C'est une fonction wifi peu connue mais très pratique pour des échanges entre machines sans nécessiter un autre point d'accès.

Une fois le PC et l'iPad sur leur propre réseau wifi ad-hoc, la latence est retombée à quelques ms et le système a fonctionné à merveille.

 

Ma fille aime beaucoup et moi je m'amuse parfois à jouer de la basse avec ce type de boite à rythme.

J'ai ensuite cherché un séquenceur MIDI pour Android, mais comme souvent dans le domaine de la musique, je n'ai trouvé mon bonheur que sur iPad. Le seul truc réellement utilisable par tous est Nord Beat 2, et gratuit en plus. Oui, le système est destiné à des enfants. J'aime bien faire des instruments d'éveil musical ludiques (voir le Mycophone par exemple).

Là s'est posé l'épineux problème de la connexion entre l'iPad et l'Arduino. Surtout que le Midi à la sauce Wifi Appel c'est comment dire....compliqué (doux euphémisme!...).

Après pas mal de recherches, j'ai opté pour l'excellent logiciel gratuit RTPMidi côté PC, que j'avais découvert en bricolant avec TouchDAW auparavant.

Donc après avoir installé RTPMidi et ce qui va avec (protocole "Bonjour"), et avoir lu attentivement la doc pas très claire, j'ai enfin vu mon iPad apparaître dans la liste des sessions Midi côté PC.

Restait à déterminer comment envoyer ces messages MIDI à l'Arduino.

C'est là qu'entre en jeu LoopBe1, un port midi virtuel et gratuit.

Ceci va en quelque sorte créer un câble MIDI virtuel entre les messages provenant de l'iPAD et...un programme Processing chargé de faire le relais entre le port MIDI virtuel et le port série sur lequel écoute l'Arduino.

J'ai opté pour un format de messsage entre Processing est l'Arduino qui n'est pas MIDI mais un format binaire ou chaque bit d'un octet correspond à un solénoïde à activer. Le tout transmis à 115200 bauds. C'est mon côté optimisateur fou :)

Le Sketch Processing transforme donc un message MIDI de type NoteOn en un bit à 1 et un NoteOff en un bit à 0.

Côté Arduino, un simple masque binaire permet de calculer l'état des sorties et d'utiliser les "fast I/O" pour les piloter.

Lors des premiers essais, des problèmes de latence sont vite apparus, le système était injouable dès que le tempo était un peu rapide.

La solution a été de passer par un réseau wifi pair-à-pair (mode ad-hoc) entre le PC et l'iPad. C'est une fonction wifi peu connue mais très pratique pour des échanges entre machines sans nécessiter un autre point d'accès.

Une fois le PC et l'iPad sur leur propre réseau wifi ad-hoc, la latence est retombée à quelques ms et le système a fonctionné à merveille.

Ma fille aime beaucoup et moi je m'amuse parfois à jouer de la basse avec ce type de boite à rythme.

Démo avec ma fille

 

Le code source des sketches Arduino et Processing est disponible sur GitHub.

Repost 0
Published by breizhmakers - dans arduino
commenter cet article
18 décembre 2015 5 18 /12 /décembre /2015 20:51

J'aime terminer un projet, et celui-là est vraiment sympa puisqu'il s'agit d'animer un tableau de Je Peins Des Aliens.
J'ai encore plein d'idées pour donner vie à ces créatures

Voilà ce que ça donne:

Repost 0
Published by breizhmakers - dans arduino
commenter cet article
21 mai 2015 4 21 /05 /mai /2015 10:49

Pour des raisons d'économie (d'argent mais aussi et surtout de place) je voulais utiliser un ATMega328P sans quartz externe, en utilisant simplement son oscillateur interne à 8MHz.

 

J'ai cherché un peu comment faire mais je n'ai trouvé aucune doc vraiment claire.

Voici comment faire en détail:

 

Tout d'abord, la majorité des ATMega328P sont pré-configurés pour utiliser un quartz externe, et beaucoup son pré-chargés avec un bootloader compatible Arduino. Certains sont livrés bruts et semble-t-il préconfigurés pour utiliser l'oscillateur interne.

 

Nous allons utiliser l'IDE Arduino et un programmateur ISP ou bien le sketch ArduinoISP (c'est ce que j'ai utilisé).

Il n'existe pas de définition de "board" pour un Uno avec oscillateur interne, nous allons donc la créer. Pour ce faire, il faut commencer par ouvrir avec un éditeur de texte le fichier boards.txt qui se trouve dans le dossier <Arduino_home>\hardware\arduino\avr et y dupliquer l'entrée concernant le Uno pour y apporter les modifications suivantes:

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


uno_internal_osc.name=Arduino Uno (internal 8 MHz oscillator, prescaler: 8)


uno_internal_osc.vid.0=0x2341
uno_internal_osc.pid.0=0x0043
uno_internal_osc.vid.1=0x2341
uno_internal_osc.pid.1=0x0001
uno_internal_osc.vid.2=0x2A03
uno_internal_osc.pid.2=0x0043


uno_internal_osc.vid.0x2A03.warning=Uncertified


uno_internal_osc.upload.tool=avrdude
uno_internal_osc.upload.protocol=arduino
uno_internal_osc.upload.maximum_size=32256
uno_internal_osc.upload.maximum_data_size=2048
uno_internal_osc.upload.speed=115200


uno_internal_osc.bootloader.tool=avrdude
uno_internal_osc.bootloader.low_fuses=0x62
uno_internal_osc.bootloader.high_fuses=0xDE
uno_internal_osc.bootloader.extended_fuses=0x07
uno_internal_osc.bootloader.unlock_bits=0x3F
uno_internal_osc.bootloader.lock_bits=0x0F
uno_internal_osc.bootloader.file=optiboot/optiboot_atmega328.hex


uno_internal_osc.build.mcu=atmega328p
uno_internal_osc.build.f_cpu=1000000L
uno_internal_osc.build.board=AVR_UNO
uno_internal_osc.build.core=arduino
uno_internal_osc.build.variant=standard

 

Remarquez les points suivants:

  • Le préfixe des entrées de configuration: uno_internal. Il doit être unique pour chaque carte définie.
  • Le nom de l'entrée: Arduino Uno (internal 8 MHz oscillator, prescaler: 8)
  • Les fusibles et en particulier le low_fuses= 0x62 qui indique d'utiliser l'oscillateur interne à 8 MHz avec le prescaler à 8, ce qui fait une horloge CPU à 1 MHz (vous pouvez désactiver le prescaler en utilisant la valeur 0xE2 si vous souhaitez un CPU à 8MHz)
  • La fréquence CPU f_cpu positionnée à 1000000L (à mettre à 8000000L si vous désactivez le prescaler). Cette entrée est importante pour assurer une durée d'exécution correcte des fonctions telles que delay() par exemple.

Changement des fusibles de l'ATMega328P

Le changement des fusibles de l'ATMega328P s'effectue via AVRDude:

Ouvrir une ligne de commande et se placer dans le dossier <Arduino_Home>\\hardware\tools\avr\bin

Afficher les valeurs actuelles des fusibles avec une commande de ce genre (adapter le port COM utilisé):

avrdude -v  -C ..\etc\avrdude.conf -p atmega328 -c STK500v1 -P\\.\COM8\ -b 19200 -n -F

 

AVRDude doit vous répondre entre autres quelque chose comme ceci:

avrdude: safemode: lfuse reads as 62
avrdude: safemode: hfuse reads as DE
avrdude: safemode: efuse reads as 7
avrdude: safemode: Fuses OK (H:07, E:DE, L:62)

 

Il ne reste plus qu'à programmer les fusibles avec les valeurs souhaitées, en l'occurence ceci pour un ATMega328P programmé via ArduinoISP, avec une horloge interne à 8MHz et un prescaler à 8:

avrdude  -C ..\etc\avrdude.conf -p atmega328 -c STK500v1 -P\\.\COM8\ -b 19200  -F -U lfuse:w:0x62:m -U hfuse:w:0xDE:m -U efuse:w:0x07:m

 

Tout ceci peut parraître abscons mais fort heureusement il existe de nombreux outils pour aider à calculer les valeurs des bits des différents fusibles. J'utilise souvent ce site.

 

Téléverser un Sketch dans l'ATMega328P modifié

  • Relancer si nécessaire l'IDE Arduino, charger votre sketch (Blink par exemple, il vous permettra de vérifier facilement que votre ATMega continue de fonctionner sans quartz) et changer le type de carte à "Arduino Uno (internal 8 MHz oscillator, prescaler: 8)"
  • Utiliser votre programmeur favori pour uploader le sketch (j'utilise un autre Arduino comme ISP tel que décrit ici) via le menu "Téléverser avec un programmateur"
  • Débrancher l'alimentation électrique enlever le quartz et rebrancher l'alimentation électrique, votre sketch doit continuer de s'exécuter normalement.
  • Relancer si nécessaire l'IDE Arduino, charger votre sketch (Blink par exemple, il vous permettra de vérifier facilement que votre ATMega continue de fonctionner sans quartz) et changer le type de carte à "Arduino Uno (internal 8 MHz oscillator, prescaler: 8)"
  • Utiliser votre programmeur favori pour uploader le sketch (j'utilise un autre Arduino comme ISP tel que décrit ici) via le menu "Téléverser avec un programmateur"
  • Débrancher l'alimentation électrique enlever le quartz et rebrancher l'alimentation électrique, votre sketch doit continuer de s'exécuter normalement.
Repost 0
Published by breizhmakers - dans arduino
commenter cet article
28 avril 2015 2 28 /04 /avril /2015 21:28

Votre Arduino Nano V3 Chinois cloné n'est pas reconnu? La solution est ici: https://www.youtube.com/watch?v=SPdSKT6KdF8

Ca m'a sauvé la soirée!

Mon Nano V3 commandé chez dx.com est maintenant parfaitement reconnu sous Windows 7.

Repost 0
Published by breizhmakers - dans arduino
commenter cet article
22 septembre 2013 7 22 /09 /septembre /2013 22:02

On m'a offert une sculpture métallique en forme de coq dans laquelle on peut placer un photophore pour obtenir un bel effet lumineux.

C'est sympa mais j'avais envie de pouvoir profiter de cet effet à la demande, et de jouer un peu avec un ATTiny.

 

J'ai profité d'une contribution d'un membre du forum Arduino francophone qui a fait un programme qui donne un résultat vraiment sympathique.

Je l'ai simplement modifié pour n'utiliser que deux sorties PWM (le maximum disponible sur un ATTiny). J'ai aussi changé le mécanisme d'initialisation du générateur aléatoire.

 

Il y a 4 LED rouges et 4 LED jaunes, pilotées par deux transistors.

Le schéma est le suivant:

photophore_scema.png

 

Le circuit est assez simple pour tenir sur une plaque pré-percée:

2013 09 21 5534

 

Le tout est placé dans un diffuseur fait d'un tube en carton de papier toilette évidé sur lequel j'ai collé deux épaisseurs de papier sulfurisé.

2013-09-22_5531.JPG

 

Voici ce que ça donne une fois installé dans le coq métallique:

 

 

 


 

 

Sympa, non?

Repost 0
Published by breizhmakers - dans Arduino
commenter cet article
19 septembre 2013 4 19 /09 /septembre /2013 12:31

L'utilisation d'un Arduino Uno comme ISP (In-System Programmer) est relativement bien documentée.

Il en va tout autrement concernant l'utilisation d'un Arduino Leonardo. Cette carte est très différente quant à sa gestion du port USB et au branchement de l'ATTiny.

Fort heureusement un bloggueur a décrit le processus en détails.

J'en propose ici une version francisée et un peu complétée, peut-être plus accessible aux makers francophones:

 

Tout d'abord munissez-vous d'un environnement de développement Arduino récent.

1) Comme indiqué dans le schéma ci-dessous, connecter les broches MISO/MOSI et SCK de l'ATTiny sur les pins correspondants du connecteur ICSP de l'Arduino.

Connecter la broche Reset de l'ATTiny sur la broche 10 de l'Arduino.

 

http://petervanhoyweghen.files.wordpress.com/2012/09/leo_attiny851.png?w=249&h=300

 

2) Ouvrir l'IDE Arduino et charger le sketch "Arduino ISP".

Changer la ligne:

#define RESET SS

en:

#define RESET 10

 

Cela définit la pin 10 comme pin de Reset de l'ATTiny.

Sauvegarder ce sketch sous le nom "Arduino ISP (Leonardo)"

3) Compiler et uploader ce sketch dans l'Arduino.

 

4) Dans l'IDE ouvrir le moniteur série et s'assurer que le baud rate n'est pas égal à 1200bps. Refermer le moniteur série. Cette étape enlève le magic baud rate du port série, qui causerait des auto-resets unintentionnels.

 

5a) Sur Linux (et probablement aussi sur Mac), vous pouvez sumplement aller dans le menu "Tools > Programmer" et sélectionner le programmateur "Arduino as ISP". L'Arduino Leonardo est maintenant prêt à être utilisé en tant qu'ISP.

 

5b) Sur Windows les choses sont un peu plus compliquées. Quand on utilise l'Arduino en tant qu'ISP, l'IDE utilise AVRDude avec le protocole stk500v1. Avec l'IDE Arduino 1.0.2, 1.0.3 et probablement d'autres versions, cela ne fonctionne pas et produit le message d'erreur suivant:

avrdude.exe: Send: 0 [30]   [20]

avrdude.exe: Send: 0 [30]   [20]

avrdude.exe: Send: 0 [30]   [20]

avrdude.exe: Recv:

avrdude.exe: stk500_getsync(): not in sync: resp=0x00


Une solution temporaire (mais qui fonctionne parfaitement) a été suggérée ici. Il s'agit de définir un programmateur qui utilise le protocole "Arduino" au lieu de "stk500v1". 

Pour ce faire, créer un dossier "hardware\leofix" dans votre dossier "carnet de croquis" (sketchbook). Dans ce dossier, créer un fichier programmers.txt avec le contenu suivant:

 

arduinoispleo.name=Arduino as ISP (Leonardo)

arduinoispleo.communication=serial

arduinoispleo.protocol=arduino

arduinoispleo.speed=19200

 

Après redémarrage de l'IDE, vous aurez une entrée "Arduino as ISP (Leonardo)" dans le menu "Outils / Programmateur". L'explication technique détaillée du fix est donnée dans la version originale de l'article.

 

6) Il est maintenant temps de tester le programmateur. La suite de cet article s'inspire de celui-ci, qui m'a été fort utile pour configurer l'IDE Arduino pour l'ATTiny. En effet les ATTiny n'apparaissent pas par défaut dans le menu des cartes disponibles.

Il va falloir télécharger le fichier master.zip

Décompresser ce fichier. Il contient un dossier atttiny-master contenant un dossier attiny.

Créer un dossier hardware dans votre dossier "carnet de croquis", s'il n'existe pas déjà.

Y copier le dossier attiny (pas le dossier attiny-master!). Vous devriez maintenant avoir une structure de dossiers du genre Documents\Arduino\hardware\attiny contenant le dossier atttiny.

Redémarrer l'IDE Arduino. Vous devriez maintenant avoir des entrées ATTiny dans le menu "Outils / Type de carte"

 

7) Connecter une LED à travers une résistance de 220Ω entre la broche 2 (Pin 3) de l'ATTiny et la masse.

http://hlt.media.mit.edu/wp-content/uploads/2011/10/ATtiny45-85.png

 

8) Charger le sketch d'exemple "Blink".

Modifier la ligne:

int led = 13;

en

int led = 3; 

 

9) Dans le menu Outils/Type de carte, choisir le modèle d'ATTiny que vous utilisez.

Si vous souhaitez changer la fréquence d'horloge (1Mhz par défaut), cliquer sur Outils/Graver la séquence d'initialisation. Cela va modifier les fusibles de l'ATTiny selon vos réglages de type de carte.

Dans le menu Outils/Programmateur choisir "Arduino as ISP (Leonardo)".

Compiler et uploader le sketch.

Vous aurez ce message d'erreur, qui est normal!

avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85

avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny8

 

La LED de l'ATTiny doit maintenant clignotter!

 

FAQ:

*La LED ne clignotte pas: 

Branchez-là sur la broche 3 de l'Arduino Leonardo. Si elle clignotte c'est que vous avez oublié de sélectionner le programmateur "Arduino as ISP (Leonardo)" et c'est le Leonardo qui a été programmé à la place. Re-sélectionner le programmateur "AVRISP mkII", et re-uploader "Arduino ISP (Leonardo)", puis recommencer la procédure au point 6).

 

Repost 0
Published by breizhmakers - dans Arduino
commenter cet article
24 juin 2013 1 24 /06 /juin /2013 16:51

Le Mycophone a bien marché à la fête de l'école.

mycophone 20130623 144552

Les enfants ont apprécié, même si certains n'osaient pas essayer au début.

Les parents ont souvent été surpris et j'ai eu quelques discussions intéressantes avec certains d'entre eux.

Je pense remettre ça l'an prochain, mais avec une nouvelle version du logiciel sur PC. Scratch est un peu trop rudimentaire pour ce genre d'application. Je pense la ré-écrire en HTML5. Ca me fera un bon exercice 

Repost 0
Published by breizhmakers - dans Arduino
commenter cet article
9 avril 2013 2 09 /04 /avril /2013 22:20

C'est lors du Jardin Numérique #2 que j'ai découvert le projet Makey Makey.

La carte Makey-Makey est en fait un Arduino Leonardo customisé et les inventeurs ont eu la bonne idée de rendre leur logiciel open-source. Ce sont des entrées à haute impédance. La carte est vue comme un clavier et une souris USB.

 

J'ai eu envie d'essayer la chose. Plutôt qu'acheter une Makey-Makey à 50 euros j'ai acheté un Arduino Leonardo à 25 Euros et je me suis fait un shield Makey-Makey, en quelque sorte.

L'idée est de faire un instrument de musique en utilisant de vrais champignons comme clavier!

 

Le shield Makey-Makey est essentiellement constitué de résistances de pull-up de 20 MOhms. (2 résistances de 10MOhms en série sur chaque entrée). Il y a aussi quelques LED témoins.

Voilà ce que ça donne sur ma plaque de prototypage:

 

2013 04 09 5052

 

C'est artisanal mais ça marche. C'était la première fois que je faisais un circuit double face avec ce genre de plaque!

2013 04 09 5053

 

Ensuite il restait à faire le clavier.

Le voilà à l'endroit. Les pointes vont servir à fixer les champignons ainsi que la clémentine qui servira à changer d'instrument. Les punaises sont les embases des boutons de sélection. On remarque aussi le plan de masse ainsi que le bracelet lui aussi relié à la masse, qui sert à pouvoir jouer avec les deux mains.

2013 04 09 5049

 

Le câblage du clavier:

2013 04 09 5050

 

Restait à faire le logiciel côté PC.

J'ai découvert récemment le langage Scratch, un langage graphique développé par des ingénieurs du MIT pour aider à l'enseignement de la programmation. C'est vraiment sympa et facile d'accès. Mon fils de 11 ans adore (il est en train de se faire un casse-brique, avec un peu d'aide tout de même).

 

J'ai donc développé un logiciel d'éveil musical qui permet soit de jouer librerment, soit d'apprendre une comptine parmi 4 possibles. La gamme est limitée à la gamme de Do majeur sur une octave.

 scratch

Les enfants adorent.

Une petite démo avec ma fille au clavier:

 

 


 

 

Ca va faire un tabac à la fête de l'école!

Repost 0
Published by breizhmakers - dans Arduino
commenter cet article
26 février 2013 2 26 /02 /février /2013 15:28

J'ai encore eu une idée folle dans un moment d'ennui au boulot: 

Construire une machine de Rube-Goldberg avec les différents jouets et objets de récupération qui traînent à la maison.

Sur le thème de l'aviation et pilotée par un Arduino (Leonardo en l'occurence).

J'ai profité d'une pause déjeuner pour gribouiller une esquisse:

arduiRG1

L'idée a un peu évolué depuis suite à différents tests de faisabilité.

*Au départ il n'y a pas d'ascenceur mais une rampe sur laquelle est positionné un camion de pompier.

*En fin de rampe un contact déclenche l'allumage d'une lumière (un DC3 lumineux).

*Mais comme l'avion solaire n'est pas assez puissant pour avancer avec cette lumière, on va le faire tracter par un treuil jusqu'à l'hélicoptère.

*L'hélicoptère radiocommandé décolle (guidé par un systèmes à base de fils de nylon tendus) et à une certaine hauteur, il libère une bille qui dévale alors une rampe en spirale.

*En bas de la rampe, la bille déclenche l'avion radio-commandé pour bébé qui va avancer jusqu'au bout de la piste.

*Quand il atteind le bout de la piste, l'avion en attente de décollage décolle (il décolle vraiment via un système de guides à base de fils en nylon).

*En fin de course un mécanisme arrête l'avion et l'empêche de revenir en arrière.

 

L'Arduino est là pour coordonner et piloter le tout (via un mélange d'entrées/sorties numériques et servos qui à leur tour vont piloter les radio-commandes IR, Radio et Infra-rouge des différents jouets).

 

Y'a plus qu'à continuer les tests des différents modules .

Repost 0
Published by breizhmakers - dans Arduino
commenter cet article