Overblog
Suivre ce blog Administration + Créer mon blog
4 novembre 2019 1 04 /11 /novembre /2019 10:01

Cette année Halloween était encore à base de:

  • Arduino MKR1000
  • EasyDriver stepper driver
  • Laser commandé en DMX via Processing
  • Machine à fumée pilotée via un relais.
  • Gros son de monstre joué via Processing
  • Brumisateur à ultrasons

C'était cool, même si j'ai encore fait pleurer des enfants devil.

Un résumé en vidéo:

Partager cet article
Repost0
30 décembre 2018 7 30 /12 /décembre /2018 13:55

Je cherchais un moyen d'utiliser des composants qui trainaient sur mes étagères depuis longtemps et puis à force de voir les réalisations de différents artistes, l'idée d'une sculpture animée en forme d'insecte a germé en moi.

Ce fut aussi l'occasion de découvrir FreeRTOS, excellent micro-noyau temps-réel vraiment très simple à mettre en oeuvre pour gérer des tâches concurrentes sur micro-contrôleur (en l'occurence un ATMEGA328P).

Le code source est disponible sur GitHub.

La bête en action: 

 

Partager cet article
Repost0
2 janvier 2018 2 02 /01 /janvier /2018 22:11

Il est possible de faire un adaptateur USB => DMX simplement à l'aide d'un convertisseur TTL => RS485 tel que celui-ci et d'un vieil Adruino disposant d'un circuit convertisseur USB => Série tels que les vieux Arduino Duemilanove.

Pour cela, il suffit de câbler l'entrée DI du convertisseur TTL => RS485 sur la broche RX de l'Arduino et son entrée DE sur VCC (il faut bien sûr aussi alimenter le convertisseur entre VCC et GND).

Il n'y a pas besoin d'uploader un sketch particulier sur l'Arduino. J'y ai simplement mis un sketch qui ne fait qu'un delay(3600) dans le fonction loop().

Il reste ensuite à utiliser un logiciel DMX compatible avec le protocole Enttec Open DMX USB. C'est une implémentation du protocole DMX complètement logicielle.

Je ne suis parvenu à utiliser que Q Light Controller+.

J'ai fait un shield à base de plaque perforée qui me permet d'utiliser simplement le convertisseur soit via l'USB ou bien sur un autre microcontrôleur.

Arduino Duemilanove DMX Shield
Shield DMX Maison

Capture d'écran de la console de Q Light Controller+

Q Light Controller +

 

Partager cet article
Repost0
25 septembre 2017 1 25 /09 /septembre /2017 12:59

REMARQUE: Cet article est obsolète! Avec la version actuelle de la librairie MIDI-USB gère maintenant tous les Arduinos disposant d'un port USB Natif, dont le Leonardo.

 

Je laisse l'article original pour référence, ça pourrait encore servir:

 

Tout d'abord, je déconseille d'utiliser un Arduino pour faire du Midi-USB. 

Ca ne fonctionne qu'avec un Leonardo au prix de manips pas forcément simples décrites ci-après.

Il est infiniment plus simple d'utiliser un Teensy 3.x! En plus ces cartes disposent d'une véritable sortie analogique et sont pour certaines moins coûteuses qu'un Arduino.

 

Ceci dit, j'ai un Arduino Leonardo inutilisé et il peut être transformé en périphérique Midi-USB en utilisant les librairies du Teensy et TeeOnArdu.

 

J'ai donc utilisé la définition de carte Arduino TeeOnArdu.

J'ai suivi la démarche indiquée mais avec quelques modifications, car la doc n'est pas tout assez précise, et surtout, ça ne fonctionne pas avec les versions récentes de l'IDE Arduino (la compilation échoue).

 

La dernière version de l'IDE Arduino qui soit à la fois compatible avec TeeOnArdu et TeensyDuino est la 1.6.5-rc5.

Après avoir installé cette version (à côté de la dernière version, en ce qui me concerne), il faut aussi installer TeensyDuino

Après avoir téléchargé TeeOnArdu.zip, la doc n'est pas claire.

Il faut en fait décompresser le fichier, qui produit un dossier TeeOnArdu-Master.

Il faut ensuite renommer ce dossier en TeeOnArdu et le déplacer dans le dossier hardware de l'IDE Arduino (soit chez moi: E:\arduino\arduino-1.6.5-r5\hardware)

Mais ça ne suffit pas...et la nouvelle carte n'est pas trouvée.

Il faut en fait créer un dossier avr dans le dossier TeeOnArdu et y déplacer tout l'ancien contenu.

On a donc quelque chose comme E:\arduino\arduino-1.6.5-r5\hardware\TeeOnArdu\avr qui contient le contenu de l'ancien TeeOnArdu\

 

Après redémarrage de l'IDE Arduino on a un nouvel ensemble de cartes "TeeOnArdu" dans lequel on doit choisir TeeOnArdu (Leo on TeensyCore), puis dans le menu USB-Type, choisir "Midi".

 

On peut alors utiliser un des exemples disponibles ici.

Attention: Comme indiqué dans la doc de TeeOnArdu, pour uploader un sketch midi une fois le premier sketch midi uploadé, il faut maintenir la touche Reset appuyée au début de l'upload.

 

J'ai uploadé le sketch d'exemple suivant qui allume la LED intégrée à chaque noteOn et l'éteint à chaque noteOff reçu:

 

// USB MIDI receive example, Note on/off -> LED on/off
// contributed by Alessandro Fasan

int ledPin = 13;

void OnNoteOn(byte channel, byte note, byte velocity)
{
  digitalWrite(ledPin, HIGH);
}

void OnNoteOff(byte channel, byte note, byte velocity)
{
  digitalWrite(ledPin, LOW);
}

void setup()
{
  pinMode(ledPin, OUTPUT);
  usbMIDI.setHandleNoteOff(OnNoteOff);
  usbMIDI.setHandleNoteOn(OnNoteOn) ;
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

void loop()
{
  usbMIDI.read();
}

 

Après démarrage du Sketch, Windows devrait automatiquement détecter un nouveau périphérique Midi et en installer le driver.

 

Afin de tester le bon fonctionnement, j'ai utilisé Midi-OX, une fantastique boite à outils de diagnostic MIDI.

Un périphérique Midi TeeOnArdu doit apparaitre dans la liste des périphériques de sortie Midi disponible. Une fois sélectionné, chaque appui sur une touche du clavier virtuel de MIDI-OX doit provoquer l'allumage de la Led intégrée à l'Arduino.

 

Voici une vidéo de démo avec le sketch ci-dessus légèrement amélioré pour piloter un anneau de NeoPixel ainsi qu'un servo selon la note jouée (pour une idée d'application sympa que j'ai en tête).

J'utilise l'appli TouchDaw pour Android et RTPMidi, Midi-Ox et le VSTi GTG-K 1 (qui tourne dans VSTHost pour l'occasion)

Je ferai probablement un billet de blog pour expliquer comment on configure tout ça. C'est pas simple la première fois :)

 

 

 

 

 

 

 

Partager cet article
Repost0
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é  :)

 

Partager cet article
Repost0
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.

Partager cet article
Repost0
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:

Partager cet article
Repost0
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.
Partager cet article
Repost0
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.

Partager cet article
Repost0
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?

Partager cet article
Repost0