Translate

mercredi 12 février 2014

Commande de leds RVB en Bluetooth

Je vous propose ici de piloter des leds RVB avec une tablette ou un téléphone sous Androïde via Bluetooth.
Nous avons vu précédemment un montage pilotant plusieurs leds, ici on va piloter une ou plusieurs leds RVB ou un bandeau de leds.

Le Schéma


Le schéma est assez simple, on utilise ici un ATM328 avec le bootloader UNO, un module bluetooth, quelques composants et 3 transistors MOSFET permettant de driver jusqu'a 4A sans chauffer.

Comme vous pouvez le voir sur le schéma, il nous faut deux alimentations 1x12V et 1x5V  il suffit de mettre un régulateur 7805 sur l'alimentation 12V, je ne l'ai pas mis sur le schéma (peut être un peu de fainéantise lol).





Le circuit terminé.

Pour gagner de la place, celui-ci est en double face





Comme vous pouvez le voir sur la face 2, j'ai apporté quelques modifications de dernière minutes, a la base j'étais parti sur le pilotage via un ULN 2803 mais vu le courant que consomme un bandeau de leds, j'ai laissé cette solution de coté et opter pour des transistors MOSFET. J'ai malgré tout laissé le dessin du circuit intégré, cela permet d'utiliser l'une ou l'autre des solution suivant l’utilisation que l'on veut faire du montage.

En vidéo



Désolé, on ne voit pas bien les couleurs de la leds. Une petite précision concernant les leds, on a toujours tendance a prendre des leds haute luminosité c'est bien lorsqu'elle sont derrière un diffuseur sinon le mélange RVB ne se voit pas. L'idéal est de prendre des leds RVB diffusantes. Idem pour le bandeau de leds, attention il en existe deux sortes l'une ne permet pas le mélange des couleur (une couleur par led), la seconde est full color (les 3 couleurs sont dans la même led).

Le sketch

J'ai crée un programme permettant de piloter les leds par couleur
- Rouge
- Vert
- Bleu
- Jaune
- Blanc
- Blanc clair
- Rose
- Variation de couleur automatique


/*Commande de leds RVB en Bluetooth via Android
Mode de fonctionnement par couleurs

Rouge
Bleu
Jaune
Rose
Bleu clair
Blanc
Automatique
By Jojo Bricolo*/


int ldr = 9;
int ldv = 10;
int ldb = 11;
#define FADESPEED 10 // Vitesse de transition


int state;
int flag=0;
void setup() {
 
pinMode (ldr,OUTPUT);
pinMode (ldv,OUTPUT);
pinMode (ldb,OUTPUT);

Serial.begin(9600);
}

void loop() {


  if(Serial.available() > 0){
state = Serial.read();
flag=0;
  }

  if (state == 'a') {
  digitalWrite (ldr,HIGH);
  digitalWrite (ldv,HIGH);
  digitalWrite (ldb,HIGH);
 
  if(flag == 0){
Serial.println("Led Blanc");
flag=1;
}
}
else
 if (state == 'z') {
  digitalWrite (ldr,HIGH);
  digitalWrite (ldv,HIGH);
  digitalWrite (ldb,LOW);
 
  if(flag == 0){
Serial.println("Led Jaune");
flag=1;
}
}
else
 if (state == 'e') {
  digitalWrite (ldr,HIGH);
  digitalWrite (ldv,LOW);
  digitalWrite (ldb,HIGH);
 
  if(flag == 0){
Serial.println("Led Rose");
flag=1;
}
}
  else
   if (state == 'r') {
  digitalWrite (ldr,LOW);
  digitalWrite (ldv,HIGH);
  digitalWrite (ldb,HIGH);
 
  if(flag == 0){
Serial.println("Led Bleu clair");
flag=1;
}
}
else
 if (state == 't') {
  digitalWrite (ldr,LOW);
  digitalWrite (ldv,LOW);
  digitalWrite (ldb,HIGH);
 
  if(flag == 0){
Serial.println("Led Bleu");
flag=1;
}
}

else
 if (state == 'y') {
  digitalWrite (ldr,LOW);
  digitalWrite (ldv,HIGH);
  digitalWrite (ldb,LOW);
 
  if(flag == 0){
Serial.println("Led vert");
flag=1;
}
}
else
 if (state == 'u') {
  digitalWrite (ldr,HIGH);
  digitalWrite (ldv,LOW);
  digitalWrite (ldb,LOW);
 
  if(flag == 0){
Serial.println("Led Rouge");
flag=1;
}
}
else
 if (state == 'h') {
  digitalWrite (ldr,LOW);
  digitalWrite (ldv,LOW);
  digitalWrite (ldb,LOW);
 
  if(flag == 0){
Serial.println("Led : Arret");
flag=1;
}
}
else

 if (state == 'i') {
   Serial.println("Led Automatique");
    int r, g, b;
    for (r = 0; r < 256; r++) {
    analogWrite(ldr, r);
    delay(FADESPEED);
    }
   
    for (b = 255; b > 0; b--) {
    analogWrite(ldb, b);
    delay(FADESPEED);
   
    }
  
    for (g = 0; g < 256; g++) {
    analogWrite(ldv, g);
    delay(FADESPEED);
    }
   
    for (r = 255; r > 0; r--) {
    analogWrite(ldr, r);
    delay(FADESPEED);
    }
   
    for (b = 0; b < 256; b++) {
    analogWrite(ldb, b);
    delay(FADESPEED);
    }
   
    for (g = 255; g > 0; g--) {
    analogWrite(ldv, g);
    delay(FADESPEED);
    }
  
  if(flag == 0){

flag=1;
  }
 }

 }

void setColor(int red, int green, int blue)
{
    analogWrite(ldr, 255-red);
    analogWrite(ldv, 255-green);
    analogWrite(ldb, 255-blue);
   
}



J'ai utilisé les lettres "a-z-e-r-t-y-u-i" pour les diverse couleurs et "h" pour l'arrêt mais rien ne vous empêche de modifier ces lettres. Petit détail, dans le programme j'utilise la fonction "delay" pour le mode fondue de couleur, cela ralenti la fonction suivante demandée quand ce mode est en cours. Donc si le module en fondu, que vous appuyer sur une couleur fixe le programme attends la fin de la séquence avant de valider la commande demandée.

Si cela vous intéresse, je suis en mesure de vous faire un kit ou même vous réaliser ce montage !!!
N'hésitez pas a me contacter.

samedi 8 février 2014

Temporisation LCD de 1s a 99mn 99s

Vous trouverez ici une temporisation LCD réglable par boutons.

Le schéma

Très simple comme la plus part des montages a base de arduino.
L'afficheur est un LCD 1x16 ligne.


Quoi de plus simple!!!! A la fin de la temporisation, le buzzer vibrera pendant 2 secondes.

Le code

/* Temporisation by Jojo Bricolo*/

#include <LiquidCrystal.h>

int Bpdepart = 7; //Bouton start
int Bpplus = 8; //Bouon +
int Bpmoins = 9; //Bouton -
int Relai = 10; //Base du transistor
int buzzer = 11; //buzzer

int upRead1 = 0; //variable Bouton +
int upRead2 = 0; //Variable vitesse bouton +
int downRead1 = 0; //variable Bouton -
int downRead2 = 0; //Variable vitesse bouton -
int startRead1 = 0; //variable Bouton start
int startRead2 = 0;

int timerCount = 0; //variable comptage
int minutesCount = 0; //variable minutes
int secondsCount = 0; //Variable secondes


LiquidCrystal lcd(5, 6, 4, 3, 2, 1); // E, RS, D4, D5, D6, D7


void setup() {
lcd.print("Tempo");
delay(1000);
lcd.clear();
lcd.print("Appui BP");
pinMode(Relai, OUTPUT);
pinMode(buzzer, OUTPUT);
pinMode(Bpdepart, INPUT);
pinMode(Bpplus, INPUT);
pinMode(Bpmoins, INPUT);
Serial.begin(9600); //open serial port
}


void lcdWrite()
{
   lcd.setCursor(0, 0);
   lcd.print(minutesCount); //Affichage de la valeur des minutes
   lcd.setCursor(3, 0);
   lcd.print("min");
   lcd.setCursor(0, 1);
   lcd.print(secondsCount); //Affichage de la valeur des minutes
   lcd.setCursor(3,1);
   lcd.print("sec");
}


void loop() {

  //Gestion des boutons
  upRead1 = digitalRead(Bpplus);
  downRead1 = digitalRead(Bpmoins);
  startRead1 = digitalRead(Bpdepart);

 
  delay(40);
  upRead2 = digitalRead(Bpplus);
  downRead2 = digitalRead(Bpmoins);
  startRead2 = digitalRead(Bpdepart);


  delay(100);

 
  if(upRead1==upRead2 && upRead1==HIGH)
  {
   lcd.clear();
   secondsCount = secondsCount+5; //Valeur d'incrémentation, ici de 5 en 5 secondes peut être modifié suivant les besoins
   if(secondsCount==60)
   {
    minutesCount++;
    secondsCount=0;
   }
   lcdWrite();
  }

 
    if(downRead1==downRead2 && downRead1==HIGH)
  {
   lcd.clear(); //clear lcd
   secondsCount = secondsCount-5; // Valeur d'incrémentation, ici de 5 en 5 secondes peut être modifié suivant les besoins
   if(minutesCount>0)
   {
    if(secondsCount==-5)
   {
    secondsCount=55;
    minutesCount--;
   }
   else
   {
    if(secondsCount<0)
   {
    secondsCount = 0;
    minutesCount = 0;
   }
   }
   }
   lcdWrite();

   if(secondsCount<0)
   {
     secondsCount=0;
     lcd.clear();
     lcd.print("0");
   }
  }

  if(startRead1==startRead2 && startRead1==HIGH)
  {

    timerCount = (minutesCount*60) + secondsCount;
    int timerCount2 = timerCount;
    Serial.println(timerCount);
    for(int i=timerCount;i>0;i--)
    {
       lcd.clear();

       if(timerCount2>60)
       {
         minutesCount = timerCount2/60;
         secondsCount = timerCount2%60;
       }
       else if(secondsCount==60)
       {
          secondsCount=59;
       }
       else
       {
        minutesCount = 0;
        secondsCount = timerCount2;
       }


   lcdWrite();

       digitalWrite(Relai, HIGH);
       delay(1000);
       timerCount2--;
    }

   lcd.clear();
   lcd.print("Fin");

     digitalWrite(Relai, LOW);

   //turn on piezo buzzer
   analogWrite(buzzer, 255);
   delay(3000);

     analogWrite(buzzer, 0);
   delay(2000);
   lcd.clear();
   lcd.print("Tempo");
   delay(3000);
   lcd.clear();
   lcd.print("BY JOJO"); // vous pouvez ici mettre votre nom

 
   timerCount = 0;
   minutesCount = 0;
   secondsCount = 0;
  }

}


Si cela vous intéresse, je suis en mesure de vous faire un kit ou même vous réaliser ce montage !!!
N'hésitez pas a me contacter.

Thermostat multi sondes et multi sorties a affichage LCD

Version afficheur 128X64



Aujourd’hui, je vous propose la réalisation d'un thermostat a affichage digital utilisant 1 a 10 sondes ds18B20. Cette réalisation servira pour la régulation des diverses température du graveur Laser.  Rien n'interdit de l'utiliser pour la gestion du chauffage ou pour avoir plusieurs indications de température.


Le schéma est assez simple, j'utilise un afficheur 128x64 avec la librairie GLCD a télécharger ici
L'avantage de l'afficheur 128x64 est qu'on peut mettre des petits dessins, un fichier java permettant de générer un fichier .h a partir d'une image est joint dans la librairie, je vous montrerai un peu plus loin comment l'utiliser.

Le schéma



Le schéma est assez simple, afin de pouvoir câbler de cette manière, j'ai du modifier l'ordre des broches dans la librairie. Sinon le câblage est éparpillé sur la UNO. L'afficheur est piloté par un K01008 mais d'autres afficheurs peuvent être utilisés avec la même librairie.
 Dans le schéma j'ai oublié de donner la valeur de la résistance se trouvant sur les sondes, il s'agit d'une 4K7.

Le code

#include <glcd.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS_PIN A5 // raccordement des sondes sur la broche A6
OneWire oneWire(ONE_WIRE_BUS_PIN);
DallasTemperature sensors(&oneWire);
DeviceAddress Probe01 = {
  0x28, 0x7F, 0x47, 0xFC, 0x04, 0x00, 0x00, 0xE7 };
DeviceAddress Probe02 = {
  0x28, 0x59, 0x92, 0xFC, 0x04, 0x00, 0x00, 0x6F };
  DeviceAddress Probe03 = {
  0x28, 0x59, 0x92, 0xFC, 0x04, 0x00, 0x00, 0x6F };
// Les adresses des sondes peuvent être trouvées grace a un petit programme arduino


#include "fonts/Arial14.h"        
#include "fonts/SystemFont5x7.h"  
#include "bitmaps/JhIcon.h"    
#include "fonts/Arial_bold_14.h"      
#include "fonts/Corsiva_12.h"
#include "fonts/Verdana_digits_24.h"  
#include "fonts/fixednums7x15.h"     
#include "fonts/fixednums8x16.h"     
#include "fonts/fixednums15x31.h"  
//#include "bitmaps/thermo.h" // image a remplacer, dans la librairie il y a un fichier java permettant de convertir de petites images.


#if DISPLAY_HEIGHT < 64
#error ks0108 example requires a display at least 64 pixels tall
#endif
#if DISPLAY_WIDTH < 128
#error ks0108 example requires a display at least 128 pixels wide
#endif

//unsigned long startMillis;
//unsigned int loops = 0;
//unsigned int iter = 0;


int R1 = A0; // relai 1
int R2 = A1;//relai 2
int R3 = A2; //relai 3

int value_T1 = 0;
int value_T2 = 0;
int value_T3 = 0;

int consT1 = 23; // consigne de température T1
int consT2 = 24;
int consT3 = 25;

void setup(){
  sensors.setResolution(Probe01,10);
  sensors.setResolution(Probe02, 10);

  GLCD.Init(NON_INVERTED);  // initialisation de l'afficheur en fond clair pour un fond sombre, il suffit d'enlever le NON_
  GLCD.ClearScreen(); 
 

  pinMode (R1,OUTPUT);
  pinMode (R2,OUTPUT);
  pinMode (R3,OUTPUT);
}


void  loop(){  

  GLCD.SelectFont(SystemFont5x7);  
  GLCD.GotoXY(2, 2);
  GLCD.DrawRoundRect(0,0,127,63, 5, BLACK); 

  sensors.requestTemperatures();

  GLCD.GotoXY(22, 24);

  GLCD.SelectFont(Corsiva_12);
  GLCD.Puts("Temp 1 "); // texte affiché a modifier selon vos envies
  printTemperature(Probe01);

  GLCD.GotoXY(22, 36);
  GLCD.Puts("Temp 2 ");
  printTemperature(Probe02);
  delay(1000);
 }

void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);

  if (tempC == -127.00)
  {
    GLCD.Puts("Erreur "); message d'erreur si une des sondes est déconnectée
  }
  else
  {

    GLCD.PrintNumber(tempC);
    GLCD.Puts("C ");
  }

   
//xxxxxxxxxxxxxxxxxx temperaturexxxxxxxxxxxxxxx

  int temp1 = sensors.getTempC(Probe01); // déclaration des température associée a la sonde
  int temp2 = sensors.getTempC(Probe02);
  int temp3 = sensors.getTempC(Probe03);
{
  digitalWrite (R2,HIGH);
}

  if ((temp1) >= consT1 + 1)
// formule a adapter suivant les besoins, ici on dit : si la température de la sonde 1 est égale ou    supérieur a la consigne consT1 + 1°, on commande le relais sinon on l'éteint
  // cela veut dire que si on donne une consigne de 20°,  a 21° le relai s'enclenche et a 19.9° il s'éteint
  {
    digitalWrite (R1,HIGH); // allumage relai 1
  }
  else

   {
    digitalWrite (R1,LOW);
  }

if ((temp2) >= consT2 + 1)
{
  digitalWrite (R2,HIGH);
}

else
   {
    digitalWrite (R2,LOW);
  }

if ((temp3) >= consT3 + 1)
{
  digitalWrite (R3,HIGH);
}
else
   {
    digitalWrite (R3,LOW);
  }
}


Version 4x20 lignes


Sur ce schéma, il y a un afficheur 2x16 lignes, cela conviens aussi il suffit de faire les bonnes déclarations dans le sketch. Le câblage entre le 2x16 et le 4x20 lignes est identique.

Le code

#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd (5,6,4,3,2,1);

#define ONE_WIRE_BUS 15

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

DeviceAddress Probe01 = { 0x28, 0x13, 0x2A, 0xA8, 0x04, 0x00, 0x00, 0x72 };
DeviceAddress Probe02 = { 0x28, 0x71, 0x17, 0xA8, 0x04, 0x00, 0x00, 0xB7 };
DeviceAddress Probe03 = { 0x28, 0x35, 0x98, 0xFC, 0x04, 0x00, 0x00, 0x6C };


void setup() {


sensors.begin();

  sensors.setResolution(Probe01, 10);
  sensors.setResolution(Probe02, 10);
  sensors.setResolution(Probe03, 10);


 lcd.begin (20,4);
 delay (10);
  lcd.clear ();
  delay (10);
  lcd.setCursor (3,1);
   lcd.print ("Fraiseuse CNC");
   lcd.setCursor (2,2);
   lcd.print ("BY JOJO BRICOLO");
   delay(4000);
   lcd.clear ();
  delay (10);

}

void loop() {
  //lcd.clear ();
  //delay (10);
  sensors.requestTemperatures();
 
 lcd.setCursor(0,3); //Start at character 0 on line 0
  lcd.print("X");
  displayTemperature(Probe01); 
 
  lcd.setCursor(7,3); //Start at character 0 on line 1
  lcd.print("Y");
  displayTemperature(Probe02); 
 
  lcd.setCursor(14,3); //Start at character 0 on line 2
  lcd.print("Z");
  displayTemperature(Probe03); 
 
   delay(1000);
 
}

void displayTemperature(DeviceAddress deviceAddress)
{

float tempC = sensors.getTempC(deviceAddress);

   if (tempC == -127.00) // Measurement failed or no device found
   {
    lcd.print("Erreur");
   }
   else
   {
   //lcd.print("C=");
   lcd.print(tempC);
  
   }
}

Le sketch pour trouver l'adresse des DS 18B20


Si cela vous intéresse, je suis en mesure de vous faire un kit ou même vous réaliser ce montage !!!
N'hésitez pas a me contacter.