Lire cette vidéo sur YouTube.

Ce module est constitué de 2 boitiers, le premier est le capteur qui va « lire » le niveau du réservoir et le second contient le buzzer pour avertir, un bouton test, et une led pour indiquer une lecture en cours.

Le tout est alimenté par une batterie (un powerbank utiliser pour recharger les téléphones par exemple).

J’ai utilisé les composant de ce deuxième kit fourni par Elegoo : kit de 37 capteurs pour Arduino avec CD d’exemples et de doc : https://www.amazon.fr//dp/B01N8U8OJL

Les boitiers sont imprimés en 3D et contiennent un aimant pour tenir en place.

Ci-dessous le schéma électronique, le code Arduino et les modèles 3D des boitiers.

Alerte_niveau_reservoir_poele_a_pellet.zip

Lire cette vidéo sur YouTube.

Pour cela j’ai utilisé des goulottes pour câbles où sont installées des LEDs NeoPixel. La détection est assurée en haut et en bas par des détecteurs de présence PIR, installés dans les supports imprimés en 3D. La partie « intelligente » est confiée à un Arduino Nano.
Un capteur de lumière permet de n’activer le système que si il fait assez sombre, et 2 potentiomètres permettent les réglages, l’un pour la sensibilité à la lumière, et l’autre pour la durée d’allumage (0 à 5 minutes)

Matériel :

• 4 moulures blanches 3×1 cm x 2 m (1,3€ x 4)
• 26 LED WS2812B adressable 5050 RGB NeoPixel (lien rémunéré par Amazon, 4,23 € les 100)
• 1 Alimentation 220V – 5V 3A (lien rémunéré par Amazon, 13,28 €)
• 1 Arduino Nano
• 2 capteurs PIR HC-SR501 (lien rémunéré par Amazon, 9,59 € les 5)
• 1 photorésistance
• 2 potentiomètres 10 Kohms
• 2 résistances 470 ohms (1/4 w)
• 1 résistance de 10 Kohms (1/4 w)
• 1 condensateur 1000 µF

Dans cette vidéo, je vous présente aussi un Stater Kit avec tout ce qu’il faut pour débuter avec Arduino.
Ce kit m’a été offert par ELEGOO. Si j’ai accepté c’est parce qu’ils proposent un bon kit de démarrage à un prix tout à fait abordable, et qu’il est bien fait, complet, et en français. Mais sachez que dans tous les cas, je reste maitre des choix, contenus et jugements dans mes vidéos.

Le schéma électronique est dispo ici :

Le support 3D à imprimer :

Galerie photos :

Circuit imprimé et schéma électronique :

Code Arduino :

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#define inIR_H 		  2  // Input PIR top
#define inIR_B 		  3  // Input PIR bottom
#define PIND        6  // Input Neopixel right
#define PING        5  // Input Neopixel left
#define PHOTOSENS   A0 // Input Photoresistor
#define POTARLUM    A2 // Input Brightness detection adjustment
#define POTARTPS    A4 // Input Light duration adjustment
#define NUMPIXELS   13 // Number of pixel by side

bool IR_H = LOW;
bool IR_B = LOW;
bool MemH = LOW;
bool MemB = LOW;

int PhotoVal;
int AdjLum;
int AdjTps;
long AdjTpsMil;


Adafruit_NeoPixel pixelsD = Adafruit_NeoPixel(NUMPIXELS, PIND, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixelsG = Adafruit_NeoPixel(NUMPIXELS, PING, NEO_GRB + NEO_KHZ800);

void setup() { 
  pinMode(inIR_H,INPUT);
  pinMode(inIR_B,INPUT);
  
  pixelsD.begin();
  pixelsG.begin();
  
  pixelsD.clear();
  pixelsG.clear();

  pixelsD.show();
  pixelsG.show();
}

void loop() {
  
  PhotoVal = analogRead(PHOTOSENS);
  AdjLum   = analogRead(POTARLUM);
  AdjTps   = analogRead(POTARTPS);

  AdjTpsMil = AdjTps / (1024 / 300); // 0 to 300 seconds (5 minutes)
  AdjTpsMil *= 1000;         // to miliseconds
  
  IR_H = digitalRead(inIR_H);
  IR_B = digitalRead(inIR_B);
  
  if (IR_H != MemH){
    if (IR_H == HIGH and PhotoVal < AdjLum){
      downHigh();
      delay(AdjTpsMil); 
      downLow();
    }
    MemH = IR_H;
  }

  if (IR_B != MemB){
    if (IR_B == HIGH and PhotoVal < AdjLum){
      upHigh();
      delay(AdjTpsMil); 
      upLow();
    }
    MemB = IR_B;
  }  
  
}

void downLow() {
  int16_t i, j;
  
  for(i=0; i<=NUMPIXELS; i++) {
   	long lngRGB = pixelsD.getPixelColor(i);	// actual color
   	uint8_t u8R = (uint8_t)((lngRGB >> 16) & 0xff),
    	    u8G = (uint8_t)((lngRGB >> 8) & 0xff),
    	    u8B = (uint8_t)(lngRGB & 0xff);
 
    for(j=1; j<10; j++) {
      pixelsD.setPixelColor(i, u8R / j, u8G / j, u8B / j);
      pixelsG.setPixelColor(i, u8R / j, u8G / j, u8B / j);
      pixelsD.show();
      pixelsG.show();
      delay(15);  
    }      
    pixelsD.setPixelColor(i, 0, 0, 0);
    pixelsG.setPixelColor(i, 0, 0, 0);
    pixelsD.show();
    pixelsG.show();    
    delay(500);      
  }
}


void downHigh() {
  int16_t i, j;
  int32_t Color[3];
  
  for(i=0; i<NUMPIXELS; i++) {
    for(j=20; j>0; j--) {
      Rainbow(256 / NUMPIXELS * i, Color);   
      pixelsD.setPixelColor(i, Color[0] / j, Color[1] / j, Color[2] / j);
      pixelsG.setPixelColor(i, Color[0] / j, Color[1] / j, Color[2] / j);
      pixelsD.show();
      pixelsG.show();
      delay(5);  
    }
    delay(200);    
  }
}

void upLow() {
  int16_t i, j;
  
  for(i=NUMPIXELS; i>=0; i--) {
    //Serial.println(i);
   	long lngRGB = pixelsD.getPixelColor(i);	// actual color
   	uint8_t u8R = (uint8_t)((lngRGB >> 16) & 0xff),
    	    u8G = (uint8_t)((lngRGB >> 8) & 0xff),
    	    u8B = (uint8_t)(lngRGB & 0xff);
 
    for(j=1; j<10; j++) {
      pixelsD.setPixelColor(i, u8R / j, u8G / j, u8B / j);
      pixelsG.setPixelColor(i, u8R / j, u8G / j, u8B / j);
      pixelsD.show();
      pixelsG.show();
      delay(15);  
    }      
    pixelsD.setPixelColor(i, 0, 0, 0);
    pixelsG.setPixelColor(i, 0, 0, 0);
    pixelsD.show();
    pixelsG.show();    
    delay(500);      
  }
}

void upHigh() {
  int16_t i, j;
  int32_t Color[3];
  
  for(i=NUMPIXELS; i>=0; i--) {
    for(j=20; j>0; j--) {
      Rainbow(256 / NUMPIXELS * (i * -1 + NUMPIXELS - 1), Color);   
      pixelsD.setPixelColor(i, Color[0] / j, Color[1] / j, Color[2] / j);
      pixelsG.setPixelColor(i, Color[0] / j, Color[1] / j, Color[2] / j);
      pixelsD.show();
      pixelsG.show();
      delay(5);  
    }
    delay(200);    
  }
}

void Rainbow(byte WheelPos, int32_t TheColors[3]) {
  WheelPos = 255 - WheelPos;
  
  if(WheelPos < 85) {
    TheColors[0] = 255 - WheelPos * 3;
    TheColors[1] = 0;
    TheColors[2] = WheelPos * 3;
  }
  else if(WheelPos < 170) {
    WheelPos -= 85;
    TheColors[0] = 0;
    TheColors[1] = WheelPos * 3;
    TheColors[2] = 255 - WheelPos * 3;    
  }
  else {
  	WheelPos -= 170;
    TheColors[0] = WheelPos * 3;
    TheColors[1] = 255 - WheelPos * 3;
    TheColors[2] = 0;    
  }
}

Suite à plusieurs demandes voici la version du code Arduino sans photocellule et sans le potentiomètre de réglage de luminosité associé : Stair2.ino

Lire cette vidéo sur YouTube.

J’ai réalisé ce projet à l’occasion du Concours Ambassadeurs CONRAD 2018.
Le principe ? Conrad m’a proposé une tekkie box au choix d’une valeur de 200 €, j’ai choisis la « Greenhouse Box » qui comprend :
Arduino Mega, éclairage LED pour plantes, programmateur horaire, capteur de lumière, capteur de température/humidité, ventilateur USB et un bon d’achat de 76€ pour la compléter.

Pour mettre en valeur tout ça, j’ai créer un structure en bois et plexi et j’ai ajouté tous les composants électroniques qui vont bien.

Modélisation 3D avec Tinkercad :

Dimensions : 50 x 50 x 45 cms
Temps passé : 35H (hors étude)
Outillage : Scie circulaire, défonceuse, perceuse à colonne, scie à onglet, scie sauteuse, Dremel, outillage à main…

Composants de la tekkie box Conrad :
– Arduino Mega 2560
– Eclairage LED pour plantes TRU-PL-WR
– Programmateur horaire Renkforce 1289404
– Capteur de lumière Fayalab 801-NU0014
– Capteur de température et humidité DHT11 Velleman VMA311
– Ventilateur USB Arctic Breeze

Composants ajoutés avec le bon d’achat :
– Alim LED à courant constant TRU-NETZTEIL-8W 700mA
– Module LCD et clavier Velleman VMA203 (Shield Arduino)
– 2 Mini-servo analogique Modelcraft Y-3009
– Alimentation CA/CC 230V 5V 3A Mean Well RS-15-5
– Nappe de liaison 40 broches Velleman VMA414
– Carte 2 relais 5 V SMTRELAY02
– 2 Module Led RGB Velleman VMA307
– Enjoliveur H-Tronic FR 216 pour écran LCD
– 2 Voyants standards (Orange / bleu)
– 2 LED 10 mm TRU COMPONENTS

Hors Conrad :
– MDF (Medium) 19 et 10mm
– Polystyrène transparent 2,5 mm (Plexi)
– Ventilateur Alim PC 80mm
– Tapis chauffant pour reptile 220V 7W ChenRui
– Peinture, quincaillerie…

Plan de la serre, schéma électronique et code Arduino à télécharger ici :

https://www.magicmanu.com/wp-content/uploads/2018/05/TerraDome.zip

Juste pour le fun 😉

Lire cette vidéo sur YouTube.

Les instructions détaillées et en anglais sont dispo sur Instructables

Lire cette vidéo sur YouTube.

Hauteur totale : 47 cms
Temps passé : 1 journée
Principal outillage : Dremel 3000 + Adaptateur défonceuse 335, outillage à main

Programme Arduino et logo en PDF à télécharger ici :

Code Arduino :

// Assassin's Creed LED Clock
// MagicManu - 02/2018
// http://blog.magicmanu.com
// https://www.youtube.com/MagicManu

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#define PIN            6
#define NUMPIXELS      24

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

uint16_t delayval = 500; // delay for half a second
uint16_t j;
uint16_t LastCol;
uint16_t NbCycle = 0;

uint32_t TheColors [12] [3] {
  {0, 0, 0}, 
  {255, 0, 0},    
  {0, 255, 0},
  {0, 0, 255},
  {255, 255, 0},
  {0, 255, 255},
  {255, 0, 255},
  {34, 66, 124},
  {233, 56, 63},
  {109, 7, 26},
  {127, 0, 255},
  {0, 201, 87}
};


void setup() {
  randomSeed(analogRead(0)); // This initializes the random value
  
  pixels.begin(); // This initializes the NeoPixel library.

  theaterChase(pixels.Color(120, 120, 120), 30);
}

void loop() {
  // Never same color 2 time
  for(uint16_t c=0; c<10; c++) {
    j = random(1, 12);
    if (j != LastCol)
      break;
  }
  LastCol = j;
 
  colorWipe(0, 2);   // OFF  
  colorWipe(j, 230); // Color
  
  NbCycle++;

  // Rainbow
  if (NbCycle >= 10){
    rainbowCycle(5);
    NbCycle = 0;
  }
}


void colorWipe(int j, uint8_t wait) {
  for(uint16_t i=0; i<pixels.numPixels(); i++) {
    for(int b=10; b>0; b--) {
      pixels.setPixelColor(i, pixels.Color(TheColors[j][0] / b, TheColors[j][1] / b, TheColors[j][2] / b));
      pixels.show();
      delay(wait);
    }
  }
}


// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256*2; j++) { // 2 cycles of all colors on wheel
    for(i=0; i< pixels.numPixels(); i++) {
      pixels.setPixelColor(i, Wheel(((i * 256 / pixels.numPixels()) + j) & 255));
    }
    pixels.show();
    delay(wait);
  }
}

//Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j=0; j<10; j++) {  //do 10 cycles of chasing
    for (int q=0; q < 3; q++) {
      for (uint16_t i=0; i < pixels.numPixels(); i=i+3) {
        pixels.setPixelColor(i+q, c);    //turn every third pixel on
      }
      pixels.show();

      delay(wait);

      for (uint16_t i=0; i < pixels.numPixels(); i=i+3) {
        pixels.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}


// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return pixels.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return pixels.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return pixels.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

Idée : Colyne, notre fille de 5 ans, est fan de l’émission « The Wall : Face au mur » sur TF1, alors pour son anniversaire je me suis lancé dans la construction d’une version miniature de table.
Fabriqué en bois, je jeu est composé d’un plateau avec 200 clous où traversent les billes. Un affichage à matrice de LED indique les différentes étapes et les points. Le système est piloté par un Arduino Nano et le tout est alimenté par une prise USB (5V).

Cadeau ! Dans le ZIP suivant vous trouverez les plans, code Arduino, schéma, image de fond…
The Mini Wall by MagicManu.zip

Vous trouverez tous les détails dans la vidéo ci-dessus.

Fonctionnement :
– au démarrage on choisis le nombre de joueurs (1 à 9),
– le jeu se déroule en 7 manches,
– à chaque manche, les joueurs reçoivent entre 1 et 3 billes (distribution automatique) et les LED s’allument en vert ou en rouge,
– le joueur place la, ou les billes dans l’emplacement souhaité (1 à 7 en haut) et lance le départ (en baissant la manette bleu sur le côté droit ou gauche)
– les billes tombent et le score est comptabilisé (en + si vert et en – si rouge) et affiché sur l’écran
– a la fin des 7 manches, le gagnant est affiché ainsi que tous les scores

Temps passé : 50H (+ presque autant pour l’étude et la programmation)
Coût : enriron 60 €
Outillage utilisé : Scie circulaire, mini scie, perceuse, visseuse, défonceuse, pistolet à colle, outils à main…

Merci à Alisson : pour la création de l’intro et de l’illustration de ma chaîne Youtube.

Quelques photos :

Voici un moyen pratique et original de retrouver votre quincaillerie (vis, clous, boulons…) : un carrousel de 32 pots de confiture, motorisé grâce à un moteur d’essuie-glace.
Trouver une pièce devient rapide car un échantillon de chaque pièce est visible dans un casier numéroté.

Fonctionnement : on repère la pièce souhaitée sur le présentoir, on appui sur le bouton correspondant, le système tourne dans le sens le plus court, ralenti, s’arrête, la lumière s’allume 10 secondes et on peut prendre les pièces en dévissant le pot de son couvercle.

Lire cette vidéo sur YouTube.

Temps passé : environ 70H
Outillage utilisé : Scie circulaire, scie à onglet, perceuse, visseuse, défonceuse…
Principaux matériaux : Bois Médium (MDF), pots de confiture en verre, moteur d’essuie glace, roulements à bille…
Partie électronique : Alimentation 12V 10A, Arduino Uno, module moteur VNH2SP30 (pont H), 74HC165 (boutons), bandeau LED 12V, capteurs ILS…

Et vous ? Vous rangeriez quoi dans le Caroustore ? Des bonbons ? Des bijoux ?

Plan, schéma électronique et code de l’Arduino ici : Caroustore.MagicManu

Edit du 22 juin 2017 : J’ai aussi ajouté le PCB et le schéma d’implantation du 74HC165 et du bandeau de LED dans le ZIP

Pour Noël j’ai fabriqué 2 petites machines à laver en bois pour offrir à 2 enfants, une pour notre fille Colyne et une pour son copain Noah.
Les Magic Wash sont fabriquées en bois (MDF) et fonctionnent vraiment (sans eau bien sûr). La vidéo :

Lire cette vidéo sur YouTube.

Code de l’Arduino Nano à télécharger ici : LaveLingeArduino

Caractéristiques :
Échelle : 1/2
Dimensions : largeur 30 cms, hauteur 40 cms
Poids : 6 kgs
Affichage digital du temps restant et d’autres infos
Rotation du tambour par tranche de 10 secondes (60 secondes maxi)
Accélération progressive et inversion du sens de rotation toutes les 10 secondes
Arrêt immédiat du moteur lors de l’ouverture de la porte (affichage PO)
Affichage du prénom de l’enfant au démarrage
Mise en veille automatique après 5 minutes
Bips de fin de lavage
Alimentation sur batterie 12V rechargeable
Pilotée par microcontroleur (Arduino Nano)

Lire cette vidéo sur YouTube.

Le code de l’ATTiny 85 à programmer avec un Arduino Uno : fire-attiny-85-code-for-arduino

Le schéma électronique et le code en PDF : barbie-wood-stove-rgb-led-attiny-85-by-magicmanu

Ça faisait longtemps que je n’avais rien publié, je change un peu mes habitudes avec pour la 1ère fois une vidéo très détaillée d’une heure pour vous expliquer en détail comment fabriquer une maison de poupée Barbie en bois.
Je l’ai créé à l’occasion du 4ème anniversaire de notre fille, Colyne.

Caractéristiques :
– 8 pièces sur 2 niveaux
– Apparence briques rouges et tuiles (classique dans le Nord)
– S’ouvre en 2 et se déplace facilement grâces à des roulettes
– Fenêtres et portes ouvrantes
– Eclairage prévu dans toutes les pièces (LED + Arduino)
– Echelle : 1/6 (selon la taille d’une Barbie)
– Dimensions : 80 x 50 cms et hauteur totale : 104 cms
– Poids : environ 34 kg
– Matière principale : MDF (Médium)

Reste à faire (prochaine vidéo) :
– Terminer l’électricité
– Créer le mobilier (lits, cuisine équipée, meubles, TV, déco…)

Vous pouvez télécharger les plans de cette maison au format PDF sur le lien suivant :

Plan de la maison de poupée

 

Lire cette vidéo sur YouTube.