Horloge de ventilateur LED à hélice USB - Schéma de circuit et code de projet

Horloge analogique de ventilateur de lumière LED USB utilisant Arduino NANO - Code de projet et schéma de circuit avec fonction de réglage de l'heure

Si vous avez regardé la vidéo du célèbre gadget de l'horloge de ventilateur à lumière LED Mini USB, préparez-vous car nous allons concevoir la même horloge analogique à lumière LED basée sur Arduino NANO, capteur à effet Hall , résistances, batterie, moteur à courant continu et voyants.

Les LED tourneront en mouvement circulaire et afficheront une horloge analogique dans l'affichage à hélice avec les trois aiguilles pour l'heure, la minute et la seconde respectivement ainsi que la forme arrondie (circulaire) comme une horloge ordinaire ou une horloge murale.

La meilleure chose dans ce projet est que vous pouvez modifier le réglage de l'heure pour les minutes et les secondes en téléchargeant le code source sur l'Arduino NANO via un câble USB. Voyons comment faire.

Vérifiez le gadget de l'horloge LED Light FAN

Composants requis :

Arduino NANO
Capteur Hall W130
R1 à R16 =330Ω
R17 =2,2 kΩ
R18 =10kΩ
LED 1 à LED 11 =lumière rouge
LED 12 à LED 16 =Lumière verte
DEL 17 =Lumière bleue
Batterie =3,7 V, 240 mAh (9 V à 12 V en cas de moteur puissant pour un fonctionnement à grande vitesse)
Interrupteur =ON/OFF unipolaire (bascule à glissière)
Autres composants :carte PCB, moteur à courant continu jouet, fils et câbles, fer à souder, etc.

Schéma de câblage et de circuit

Suivant le schéma de circuit donné pour l'horloge analogique du ventilateur LED à hélice USB. Si vous souhaitez réaliser le même projet avec une fonction de réglage de l'heure, consultez le deuxième schéma de circuit donné au bas de cet article.

Procédure :

Découpez un petit morceau de circuit imprimé en fonction du circuit.
Insérez une LED verte dans les trous avec la longue jambe sur le côté gauche. Maintenant, du côté cuivre, pliez ses pattes d'un côté (LED vertes, c'est-à-dire LED 12 - LED 16 via R12 à R16 et A5 à A1 respectivement).
De la même manière, insérez les LED rouges restantes (LED 1 - LED 11 via R1 à R11 et D2 à D12 respectivement).
Insérez la LED bleue au-dessus de la LED verte comme indiqué sur la fig (LED bleue 17 via R17 et A7). Connectez R17 en tant que 2,2 kΩ et joignez la cathode de cette LED à la cathode des autres LED. Maintenant, connectez la branche positive de cette Led à une extrémité de la résistance R17 et l'autre extrémité à la broche Arduino +5V.
Toutes les connexions cathodiques des LED sont réunies. Coupez les câbles en excès si nécessaire.
Insérez maintenant les résistances et pliez ses fils comme vous l'avez fait pour les LED. Coupez les fils supplémentaires en conséquence.
Maintenant, soudez les composants selon le schéma de circuit.
Maintenant, soudez les connecteurs à l'Arduino NANO.
Connectez un fil de la cathode commune des LED à la broche Arduino GND.

Connectez le fil des résistances à la broche numérique "D" de l'Arduino et à la broche analogique "A" comme suit :

R1 à D2
R2 à D3
R3 à D4
R4 à D5
R5 à D6
R6 à D7
R7 à D8
R8 à D9
R9 à D10
R10 à D11
R11 à D12
R12 à A1
R13 à A2
R14 à A3
R15 à A4
R16 à A5

Connectez le capteur Hall comme suit :

Broche de sortie vers la broche Arduino A0.
Broche VCC vers broche Arduino +5 V.
Broche de terre du capteur à la broche Arduino GND.

En guise de touche finale :

Connectez la batterie 3,7 V, 240 mAh en fonction du circuit et n'oubliez pas d'ajouter un interrupteur à bascule unipolaire sur le câble positif pour le fonctionnement ON et OFF du circuit.
Maintenant, montez l'ensemble du projet sur un panneau de particules à l'aide d'un petit moteur à courant continu. Gardez à l'esprit que si vous utilisez un moteur puissant pour une vitesse élevée, vous pouvez utiliser une batterie de 9 V à 12 V à la place.
Enfin, téléchargez le code du projet (indiqué ci-dessous) via le câble USB viva et allumez le circuit. Le ventilateur affichera l'horloge sous forme de lumière LED pendant le mouvement de l'hélice.

Code du projet

Vous pouvez apporter les modifications nécessaires au code source suivant de l'horloge du ventilateur LED USB et le télécharger sur l'Arduino NANO via un câble USB si nécessaire.

Coder via :hobbyprojects

int LED1 = 2;
int LED2 = 3;
int LED3 = 4;
int LED4 = 5;
int LED5 = 6;
int LED6 = 7;
int LED7 = 8;
int LED8 = 9;
int LED9 = 10;
int LED10 = 11;
int LED11 = 12;
int LED12 = A1;
int LED13 = A2;
int LED14 = A3;
int LED15 = A4;
int LED16 = A5;

int sensorPin = A0;

int minuteSensor = A7;
int hourSensor = A6;

unsigned int n,ADCvalue,propeller_posn;
unsigned long previousTime = 0;

byte hours = 12;    // set hours
byte minutes = 15;  // set minutes
byte seconds = 00;  // set seconds

int val;

void setup() 
{
  pinMode(LED1,OUTPUT);  
  pinMode(LED2,OUTPUT);  
  pinMode(LED3,OUTPUT);  
  pinMode(LED4,OUTPUT);  
  pinMode(LED5,OUTPUT);  
  pinMode(LED6,OUTPUT);  
  pinMode(LED7,OUTPUT);  
  pinMode(LED8,OUTPUT);  
  pinMode(LED9,OUTPUT);  
  pinMode(LED10,OUTPUT);  
  pinMode(LED11,OUTPUT);  
  pinMode(LED12,OUTPUT);  
  pinMode(LED13,OUTPUT);  
  pinMode(LED14,OUTPUT);  
  pinMode(LED15,OUTPUT);  
  pinMode(LED16,OUTPUT);  
  
  pinMode(sensorPin,INPUT_PULLUP);   
  
  if(hours == 12)
  hours = 0;

//****************************************
  // Uncomment these lines for IR sensor testing
/* 
    Serial.begin(9600);

    while(1)
  {
    ADCvalue = analogRead(minuteSensor);
    Serial.print("minuteSensor ");
    Serial.println(ADCvalue);
     
    ADCvalue = analogRead(hourSensor);  
    Serial.print("hourSensor   ");
    Serial.println(ADCvalue); 
    
    Serial.println();         
    delay(1000); 
  }
*/
//****************************************  
}

void loop() 
{
    val = digitalRead(sensorPin);
    
    while (val == LOW)
  {
    val = digitalRead(sensorPin);
  }

      
  if (millis() >= (previousTime)) 
  {
     previousTime = previousTime + 1000;
     seconds = seconds+1;
     if (seconds == 60)
     {
        seconds = 0;
        minutes = minutes+1;
     }
     if (minutes == 60)
     {
        minutes = 0;
        hours = hours+1;
     }
     if (hours == 12)
     {
        hours = 0;
     }   
  }  
  
  propeller_posn=30;
  n=0;
  
  while(n < 60)
  {
    
  ADCvalue = analogRead(minuteSensor);
  if(ADCvalue < 500)
  {
  minutes = propeller_posn;
  seconds = 0;
  }

  ADCvalue = analogRead(hourSensor);
  if(ADCvalue < 500)
  {
  hours = propeller_posn/5;
  seconds = 0;
  }
      
  drawMinuteMarker();

  if ((propeller_posn==0) || (propeller_posn==5) || (propeller_posn==10) || (propeller_posn==15) || (propeller_posn==20) || (propeller_posn==25) || (propeller_posn==30) || (propeller_posn==35) || (propeller_posn==40) || (propeller_posn==45) || (propeller_posn==50) || (propeller_posn==55))
  drawHourMarker();
  
  if ((propeller_posn==0) || (propeller_posn==15) || (propeller_posn==30) || (propeller_posn==45))
  drawQuarterMarker(); 
  
  if((propeller_posn == hours*5) || (( propeller_posn == 0 ) && (hours == 0)))
  drawHoursHand();
  
  if(propeller_posn == minutes)
  drawMinutesHand();   
  
  if(propeller_posn == seconds)
  drawSecondsHand();
  
  delayMicroseconds(100);     // for LED pixel width   (change the value according to motor speed. Increase for low speed, decrease for high speed motor)
  
  displayClear(); 

  drawInner_Circle();
 
  delayMicroseconds(450);   // for the gap between LED pixels/minutes markers  (change the value according to motor speed. Increase for low speed, decrease for high speed motor)
  
  n++;
  propeller_posn++;
  if(propeller_posn == 60)
  propeller_posn=0;
  }
  
    val = digitalRead(sensorPin);  
    
    while (val == HIGH)
    {
    val = digitalRead(sensorPin); 
    }     
}

//=========================

void displayClear()
  {
  digitalWrite(LED1,LOW);
  digitalWrite(LED2,LOW);
  digitalWrite(LED3,LOW);
  digitalWrite(LED4,LOW);
  digitalWrite(LED5,LOW);
  digitalWrite(LED6,LOW);
  digitalWrite(LED7,LOW);
  digitalWrite(LED8,LOW);
  digitalWrite(LED9,LOW);
  digitalWrite(LED10,LOW);
  digitalWrite(LED11,LOW);
  digitalWrite(LED12,LOW);
  digitalWrite(LED13,LOW);
  digitalWrite(LED14,LOW);
  digitalWrite(LED15,LOW);
  digitalWrite(LED16,LOW);  
  }

  void drawMinuteMarker()
  {
  digitalWrite(LED16,HIGH);
  }

  void drawHourMarker()
  {
  digitalWrite(LED15,HIGH);
  digitalWrite(LED14,HIGH); 
  }

  void drawQuarterMarker()
  {
  digitalWrite(LED13,HIGH);
  digitalWrite(LED12,HIGH); 
  }

  void drawHoursHand()
  {
  digitalWrite(LED1,HIGH);
  digitalWrite(LED2,HIGH);
  digitalWrite(LED3,HIGH);
  digitalWrite(LED4,HIGH);
  digitalWrite(LED5,HIGH);
  digitalWrite(LED6,HIGH);
  digitalWrite(LED7,HIGH);
  }

  void drawMinutesHand()
  { 
  digitalWrite(LED1,HIGH);
  digitalWrite(LED2,HIGH);
  digitalWrite(LED3,HIGH);
  digitalWrite(LED4,HIGH);
  digitalWrite(LED5,HIGH);
  digitalWrite(LED6,HIGH);
  digitalWrite(LED7,HIGH);
  digitalWrite(LED8,HIGH);
  digitalWrite(LED9,HIGH);
  }

  void drawSecondsHand()
  { 
  digitalWrite(LED1,HIGH);
  digitalWrite(LED2,HIGH);
  digitalWrite(LED3,HIGH);
  digitalWrite(LED4,HIGH);
  digitalWrite(LED5,HIGH);
  digitalWrite(LED6,HIGH);
  digitalWrite(LED7,HIGH);
  digitalWrite(LED8,HIGH);
  digitalWrite(LED9,HIGH);
  digitalWrite(LED10,HIGH);
  digitalWrite(LED11,HIGH);  
  }  

  void drawInner_Circle()
  {
  digitalWrite(LED1,HIGH);  
  delayMicroseconds(30);
  digitalWrite(LED1,LOW);
  }

Comment modifier le réglage de l'heure dans l'horloge du ventilateur LED ?

Pour l'IR de base Destinataire avec le circuit principal

Composants requis :

R19 et R20 =10k
DEL du phototransistor IR (près de la DEL n° 13 pour le réglage des minutes)
DEL du phototransistor IR (près de la DEL n° 16 pour le réglage de l'heure)

Connectez simplement le R19 avec la première LED IR (près de la LED #13 pour le réglage des minutes) et le R20 avec le deuxième IR (près de la LED #16 pour le réglage des heures). Connectez le commun des LED IR et les deux résistances aux broches GND et 5V d'Arduino NANO respectivement. Enfin, connectez le cavalier de la broche A7 à entre R19 et le deuxième IR. Faites de même pour la broche A6 vers R20 et le premier IR.

Pour la télécommande infrarouge de base Émetteur

Composants requis :

Batterie 9 V
Connecteur de batterie
DEL IR (DEL infrarouge)
Résistance 1kΩ
Interrupteur tactile
Carte PCB

Pour créer un simple émetteur de télécommande infrarouge pour régler et contrôler les fonctions de réglage de l'heure dans l'horloge du ventilateur LED USB, il suffit de connecter tous les composants en série (c'est-à-dire la pile 9 V, la LED IR , résistance de 1k ohm et un interrupteur tactile sur la borne positive). Cet émetteur sera utilisé pour placer et faire face aux LED#13 et LED#16 pour régler l'heure.

Le code suivant est utilisé pour modifier et ajuster l'axe des heures et des minutes (aiguilles des minutes et des heures dans les horloges murales ordinaires et les montres analogiques) de l'horloge de ventilateur LED USB analogique.

Vérifiez la sortie du circuit du détecteur IR à l'aide du moniteur série Arduino. Par exemple, la lecture avec une lumière ambiante normale est> 500 et la lecture avec une lumière IR est <500. Ainsi, vous pouvez modifier le code ou les valeurs ici en fonction des capteurs utilisés.


propeller_posn=30;
  n=0;
  
  while(n < 60)
  {
    
  ADCvalue = analogRead(minuteSensor);
  if(ADCvalue < 500)
  {
  minutes = propeller_posn;
  seconds = 0;
  }

  ADCvalue = analogRead(hourSensor);
  if(ADCvalue < 500)
  {
  hours = propeller_posn/5;
  seconds = 0;
  }

Pour régler l'aiguille des minutes, pointez la télécommande infrarouge vers le marqueur des minutes et appuyez sur le bouton de la télécommande. Pour régler l'aiguille des heures, pointez la télécommande infrarouge vers l'horloge et appuyez sur le bouton de la télécommande.

Regarder la vidéo :

Ressources :

Gadget d'horloge de ventilateur à lumière LED

Kits et composants pour ce projet

Arduino NANO pour ce projet

Test de court-circuit et test de circuit ouvert du transformateur Comment dimensionner un générateur ? Portable, de secours et de veille pour les applications domestiques et commerciales

Technologie industrielle

Processus de fabrication

impression en 3D

Système de contrôle d'automatisation

Technologie industrielle