Manifeste du droit à réparer soi-même

Une belle affiche découverte sur laconcha.net

Join the repair revolution sur Ifixit.com

Et la lumière fut \o/

Bon alors, enfin cinq minutes pour tester la Leonardo. Le petit lien qui va bien découvert ce matin :  Getting started with Arduino kit v3.0 et on suit le tutoriel vidéo : 



Et on l'adapte pour la Leonardo

Première étape on positionne la Led

On branche ensuite la carte, on demarre arduino.exe et l'on vérifie dans le menu outils le type de carte et le port série.

Ensuite dans le menu Fichier/Exemple/Basics on ouvre le sketch Blink

On le téléverse

et ô victoire : ça marche \o/

A tester

Quand je serai grande, j'y comprendrai quelque chose.... :)))

Voici deux beaux schémas réaliser par Gérard à l'aide de Fritzing : à tester au plus vite

Et le petit code qui va avec :

------------------------------------------------------------------------------------------------------------------------------

                                                                    
                                             
//Squishy RGB LED Controller - Code written by Matthew Schmidtbauer for the Squishy Circuits Project with AnnMarie Thomas

// permet de definir l'usage de la carte (relier une ou plusieurs de ces broches à la masse permet de choisir un programme particulier.)
// C'est un bon moyen d'avoir un seul sketch pour tous les bidouillages. Avec 3 broches, 8 montages différents sont possibles


// Une broche non reliée à la masse = 1 = défaut
// SW3  SW2  SW1    montage                     Valeur décimale    Valeur du registre PIND <= VALEUR A PRENDRE EN COMPTE
//  1    1    1      Led RVB                      7                 14
//  1    1    0      Speaker                      6                 10
//  1    0    1      Moteur                       5                 12 (ralentir / accélerer un moteur DC/DC)
//  
//  2    8    4


#define SW1 0 //4
#define SW2 1 //8
#define SW3 2 //2


const boolean debug = false;
int borne_min, borne_max;
byte mode = 0;
int speaker = 5;
int vRefPin = 4;   // pin (digitale OUT) pour activer le vRef seulement quand on en a besoin
                    // permet d'éviter une perte de charge dans la pâte si on reste sur le +5v en permanence (la pâte semble être une charge capacitive)
int RED_LED = 9;
int GREEN_LED= 10;
int BLUE_LED = 11;
int squishy = 0; // squichy sur A0 --> RED
int squishy2 = 1; // squichy sur A1 --> GREEN
int squishy3 = 2; // squichy sur A2 --> BLUE




void setup()
{  
  noTone(speaker);
  pinMode(vRefPin, OUTPUT);
  digitalWrite(vRefPin, LOW);
  
  pinMode(RED_LED, OUTPUT);
  pinMode(GREEN_LED, OUTPUT);
  pinMode(BLUE_LED, OUTPUT); 
  
  pinMode(speaker, OUTPUT);
  pinMode(squishy, INPUT);
  pinMode(squishy2, INPUT);
  pinMode(squishy3, INPUT);

  
  // Les valeurs min et max de la resistance du squishy
  borne_min = 300;
  borne_max = 1023;
  
  if (!debug) {
    Serial.begin(9600); //Uncomment all Serial Commands to allow Serial Communications for Debugging
    while(!Serial) {} // Leonardo seulement
    delay(500);
  } else {
    digitalWrite(SW1, HIGH);
    digitalWrite(SW2, HIGH);
    digitalWrite(SW3, HIGH);
  }
}

void loop()
{
  if (!debug) { 
    mode = 0;
    mode |=  (B00001110 & PIND);
  } 
// a remplir
  switch (mode) {
    case 14: rgbLed(); break;
    
    case 10: sound(); break;
    default: break;
  }
} 


void rgbLed() {
// pour le squishy RGB

int analog_RED = 0; // common resistor connected to analog pin 0 outside leads to ground and +5V
int raw_RED = 0; // variable to store the raw input value
int BRIGHTNESS_RED = 0; //Variable to store Brightness Value (0-255)
int analog_GREEN = 1; // common resistor connected to analog pin 1 // outside leads to ground and +5V
int raw_GREEN = 0; // variable to store the raw input value
int BRIGHTNESS_GREEN = 0; //Variable to store Brightness Value (0-255)
int analog_BLUE = 2; // common resistor connected to analog pin 2 // outside leads to ground and +5V
int raw_BLUE = 0; // variable to store the raw input value
int BRIGHTNESS_BLUE = 0; //Variable to store Brightness Value (0-255)
  
  digitalWrite(vRefPin, HIGH);
  delay(2);
  raw_RED = analogRead(squishy);
  delay(2);
  raw_GREEN = analogRead(squishy2);
  delay(2);
  raw_BLUE = analogRead(squishy3);
  digitalWrite(vRefPin, LOW);

  //Generate Brightness Value (PWM Values = 0-255) from Raw Voltages (0-1023)  
  BRIGHTNESS_RED = map(constrain(raw_RED, borne_min, borne_max), borne_min, borne_max, 0, 255); 
  BRIGHTNESS_GREEN = map(constrain(raw_GREEN, borne_min, borne_max), borne_min, borne_max, 0, 255);  
  BRIGHTNESS_BLUE = map(constrain(raw_BLUE, borne_min, borne_max), borne_min, borne_max, 0, 255);  
  
  if (raw_RED == 1023) { BRIGHTNESS_RED = 0; }
  if (raw_GREEN == 1023) { BRIGHTNESS_GREEN = 0; }
  if (raw_BLUE == 1023) { BRIGHTNESS_BLUE = 0; }
     
  
  analogWrite(RED_LED, BRIGHTNESS_RED); //Output PWM Value to Light
  analogWrite(GREEN_LED, BRIGHTNESS_GREEN); //Output PWM Value to Light
  analogWrite(BLUE_LED, BRIGHTNESS_BLUE); 

  if (debug) {
    Serial.print("RED: ");
    Serial.print(raw_RED);
    Serial.print("/");
    Serial.print(BRIGHTNESS_RED);
    Serial.print(" Green: ");
    Serial.print(raw_GREEN);
    Serial.print("/");
    Serial.print(BRIGHTNESS_GREEN);
    Serial.print(" Blue: ");
    Serial.print(raw_BLUE); 
    Serial.print("/");
    Serial.println(BRIGHTNESS_BLUE);
    delay(10);
  }
}

void sound() {
  int raw_data = 0; // donnée brute (utilisée comme fréquence)
  int duration = 50; // durée de chaque tone fixée à une seconde
  digitalWrite(vRefPin, HIGH);
  delay(2);
  
  
  raw_data = analogRead(squishy); // (plage de fréquence plus étendue que 0 - 1023 Hz ^_^ là ça monte jusqu'à 10khz)
  if (raw_data == 1023) { raw_data = 0; }  // si la pate est coupée, on coupe le son... Meilleur pour les nerfs ^^
  digitalWrite(vRefPin, LOW);
  if (debug) { 
    Serial.print("Setting tone to "); 
    Serial.print(raw_data*5); 
    Serial.print(" Hz / ");
    Serial.println(raw_data);
  }
  
  tone(speaker, raw_data*5, duration);

}
  
  ------------------------------------------------------------------------------

Fête de la science

Squishy circuits : premiers tests

Début septembre avec Gégé nous avons fait nos premiers essais "Squishy Circuits" à partir de deux tutoriels : Celui trouvé sur le site Public Digital Art et sur Wiki debrouillard.

Première étape : préparation de la pâte isolante

Deuxième étape : préparation de la pâte conductrice

Troisième étape : premiers essais

La semaine prochaine, afin de célébrer la fête de la science, nous partagerons nos expériences avec les enfants des centres de loisirs.

Installation de Leonardo

Bon, c'est bien beau d'avoir une carte, mais faut quand même bien qu'elle puisse se connecter....

Première étape télécharger la dernière version du logiciel la 1.0.1 pour windows dans mon cas, et non la arduino-0018-fr comme jle pensais hier (merci Gégé pour l'info) et suivre les instructions en anglais. Une fois finie, Leonardo est reconnu youpi !

Bon, par contre : si la première led "ON" est verte et s'allume en continu, la "L" clignote orange... je doute que ça soit bon signe !  Affaire à suivre...

*EDIT / Ouf sauvée, du moins,  je crois "sur la carte c normal, le vert c'est pour indiquer qu'il y a bien l'alimentation, le orange doit clignoter en pulsant pendant qques secondes au début, et ensuite clignoter de façon nette. c'est le logiciel "par défaut" installé dans la leonardo qui fait ça. Pendant qu'il pulse, c'est le moment ou on peut uploader un skecth, si on rate il faut soit débrancher/rebrancher, soit appuyer sur le bouton a coté du connecteur usb" Dixit Gégé !

huhu même pas j'avais vu qu'il y avait un bouton... le truc rond marron en bas à droite !

Hello Arduino

Voilà ça y est, enfin, la commande Go Tronic tant attendue est arrivée \o/ Tout ce qu'il faut parait-il pour faire de folles expériences avec un groupe d'enfants à l'occasion de la fête de la science :)

Au menu : des pinces croco, des Led, des jumpers, des coupleurs, des boites de connexion et ô bonheur suprême non pas une mais deux cartes Arduino Leonardo.

Cette commande n'a certainement pas été faite par hasard, elle doit nous servir (d'après mon pote Gégé) à réaliser des squishy circuits (circuits électroniques composés entre autre de pâtes conductrice et isolante), une animation que je veux tester depuis déjà pas mal de temps. Seul petit soucis, j'suis une quiche en électronique et pire je n'ai vraiment aucune idée de la manière dont fonctionne une carte Arduino :) alors du coup tu rejettes un coup d'oeil sur ton colis et tu fais mumuse avec :)

Léonardo :)

Mais bon, comme dit si bien le célèbre proverbe : "qui ne teste rien, n'apprend rien", il faut bien tôt ou tard se jeter à l'eau !

Le problème quand tu reçois une telle commande c'est que tu as hâte de commencer, alors premier réflexe, tu tapes : "Arduino Leonardo" dans ton moteur de recherche préféré et tu commences à parcourir les pages "Pour débuter" du site arduino.cc/fr/ (ouf c'est en français j'suis sauvée !)

Tu dévores en diagonale (parce que tu es pressée) les sections "Introduction", "Matériel", "Description du logiciel Arduino" (ça risque d'être un poil compliqué), tu arrives enfin à la rubrique "Installation", tu télécharges illico presto l'arduino-0018-fr.zip*,  tu lis en gros : "Installation du logiciel Arduino et du driver USB" et là tu te dis : purée mais oui le câble USB !!! Tu fouilles et tu farfouilles pour trouver un câble USB micro B... Ouf si t'as un Galaxy S2... t'es sauvée !

Demain c'est décidé, installation du logiciel !!!

* rectification : faut télécharger la 1.0.1 !