Affichage mécanique avec servos

Arduino / Horloge

Ajouté 2 commentaire

Le principe de fonctionnement de l'affichage proposé, qui a été fabriqué et construit par Instructables sous le surnom d'alstroemeria, est le suivant: les segments avancés par les servos projettent une ombre, ce qui les rend visibles. Les segments restants, situés dans le même plan que l'arrière-plan, fusionnent avec lui.

Il est clair que fait maison Cela s'avère coûteux, car pour elle, le maître acquiert jusqu'à 28 de ces servos:

Et un module de gestion qui se connecte à Arduino comme ceci:

Le module d'horloge en temps réel (RTC) dans ce contexte semble être une très petite dépense.

Ayant acquis tous les composants nécessaires, le maître les a jusqu'à présent mis de côté pour travailler sur des modèles pour faire la partie mécanique de l'affichage. Il obtient quatre fichiers: 1, 2, 3, 4. L'assistant affiche les fichiers 1 et 3 deux fois sur un traceur de découpe, et 2 et 4, un à la fois, tous à l'échelle 1: 1, et obtient six parties, dont certaines ressemblent en quelque sorte à d'anciennes cartes perforées. Vous pouvez également imprimer, également à l'échelle 1: 1 et dans les mêmes quantités, et couper manuellement.

Dremel coupe des goupilles métalliques creuses d'une longueur de 20 mm et des tubes d'un diamètre extérieur légèrement supérieur au diamètre extérieur de la goupille d'une longueur de 10 mm:

Colle les couches avec du ruban adhésif double face épais, ajoute des tubes:

Il ajoute des segments mobiles collés aux broches passées à travers les tubes, sur le revers colle des poussoirs en fil d'acier aux mêmes broches, et c'est là que les broches sont creuses:

Il plie les poussoirs, colle les servos et s'y connecte:

Ferme les servos avec la feuille perforée restante:

Le module de servocommande se connecte selon le schéma donné au début de l'article. Les entraînements eux-mêmes sont connectés au module dans l'ordre correspondant aux désignations de segment standard:

Le module RTC se connecte comme suit: SDA - broche 4 de l'Arduino, SCL - broche 5, plus l'alimentation et le fil commun - parallèle aux lignes Arduino correspondantes. Voici le résultat:

L'assistant définit l'heure dans le module RTC avec cette esquisse (vous avez besoin de la bibliothèque RTClib):

Esquissez ici

#include
#include "RTClib.h"

RTC_DS1307 RTC;

void setup () {
    Serial.begin (57600);

    Wire.begin ();

    RTC.begin ();
  
    if (! RTC.isrunning ()) {
    Serial.println ("RTC n'est PAS en cours d'exécution!");
    RTC.adjust (DateTime (__ DATE__, __TIME__));
    }
}

Ensuite, il remplit l'esquisse principale nécessitant la même bibliothèque:

#include 
#include "RTClib.h"

RTC_DS1307 RTC;

segA court = 0; // Afficher la broche 14
segB court = 1; // Afficher la broche 16
segC court = 2; // Afficher la broche 13
segD court = 3; // Afficher la broche 3
segE court = 4; // Afficher la broche 5
segF court = 5; // Afficher la broche 11
segG court = 6; // Afficher la broche 15

segA_OUT court = 110;
segB_OUT court = 110;
segC_OUT court = 110;
segD_OUT court = 110;
segE_OUT court = 110;
segF_OUT court = 110;
segG_OUT court = 110;

segA_IN court = 90;
segB_IN court = 90;
segC_IN court = 90;
segD_IN court = 90;
segE_IN court = 90;
segF_IN court = 90;
segG_IN court = 90;

int TIME = 2000;

DateTime datePast;
DateTime dateNow;

// ménage
void setup () {
  Serial.begin (9600);
  Wire.begin ();
  RTC.begin ();
  RTC.adjust (DateTime (__ DATE__, __TIME__));
  datePast = RTC.now ();
}

// boucle principale
boucle vide () {
  dateNow = RTC.now ();
  if (! (datePast.hour () == dateNow.hour () && datePast.minute () == dateNow.hour ()))
  {
    displayNumber (dateNow.hour () * 100 + dateNow.minute ());
    datePast = dateNow;
  }
}

// Étant donné un nombre, nous affichons 10:22
// Après avoir parcouru les 4 chiffres, l'affichage reste éteint
void displayNumber (int toDisplay) {
  pour (int digit = 4; digit> 0; digit--) {
    lightNumber (toDisplay% 10, digit);
    toDisplay / = 10;
  }

  // commencer le mouvement
  Serial.print ("T"); Serial.println (TIME);
}

void move (int servo, int position) {
  Serial.print ("#");
  Serial.print (servo);
  Serial.print ("P");
  Serial.print (position);
}

// Étant donné un nombre, active ces segments
// Si nombre == 10, désactiver le nombre
void lightNumber (int numberToDisplay, int segment) {

  int offset = (segment - 1) * 7;
  switch (numberToDisplay) {

  cas 0:
    move (segA + offset, segA_OUT);
    move (segB + offset, segB_OUT);
    move (segC + offset, segC_OUT);
    move (segD + offset, segD_OUT);
    move (segE + offset, segE_OUT);
    move (segF + offset, segF_OUT);
    move (segG + offset, segG_IN);
    casser;

  cas 1:
    move (segA + offset, segA_IN);
    move (segB + offset, segB_OUT);
    move (segC + offset, segC_OUT);
    move (segD + offset, segD_IN);
    move (segE + offset, segE_IN);
    move (segF + offset, segF_IN);
    move (segG + offset, segG_IN);
    casser;

  cas 2:
    move (segA + offset, segA_OUT);
    move (segB + offset, segB_OUT);
    move (segC + offset, segC_IN);
    move (segD + offset, segD_OUT);
    move (segE + offset, segE_OUT);
    move (segF + offset, segF_IN);
    move (segG + offset, segG_OUT);
    casser;

  cas 3:
    move (segA + offset, segA_OUT);
    move (segB + offset, segB_OUT);
    move (segC + offset, segC_OUT);
    move (segD + offset, segD_OUT);
    move (segE + offset, segE_IN);
    move (segF + offset, segF_IN);
    move (segG + offset, segG_OUT);
    casser;

  cas 4:
    move (segA + offset, segA_IN);
    move (segB + offset, segB_OUT);
    move (segC + offset, segC_OUT);
    move (segD + offset, segD_IN);
    move (segE + offset, segE_IN);
    move (segF + offset, segF_OUT);
    move (segG + offset, segG_OUT);
    casser;

  cas 5:
    move (segA + offset, segA_OUT);
    move (segB + offset, segB_IN);
    move (segC + offset, segC_OUT);
    move (segD + offset, segD_OUT);
    move (segE + offset, segE_IN);
    move (segF + offset, segF_OUT);
    move (segG + offset, segG_OUT);
    casser;

  cas 6:
    move (segA + offset, segA_OUT);
    move (segB + offset, segB_IN);
    move (segC + offset, segC_OUT);
    move (segD + offset, segD_OUT);
    move (segE + offset, segE_OUT);
    move (segF + offset, segF_OUT);
    move (segG + offset, segG_OUT);
    casser;

  cas 7:
    move (segA + offset, segA_OUT);
    move (segB + offset, segB_OUT);
    move (segC + offset, segC_OUT);
    move (segD + offset, segD_IN);
    move (segE + offset, segE_IN);
    move (segF + offset, segF_IN);
    move (segG + offset, segG_IN);
    casser;

  cas 8:
    move (segA + offset, segA_OUT);
    move (segB + offset, segB_OUT);
    move (segC + offset, segC_OUT);
    move (segD + offset, segD_OUT);
    move (segE + offset, segE_OUT);
    move (segF + offset, segF_OUT);
    move (segG + offset, segG_OUT);
    casser;

  cas 9:
    move (segA + offset, segA_OUT);
    move (segB + offset, segB_OUT);
    move (segC + offset, segC_OUT);
    move (segD + offset, segD_OUT);
    move (segE + offset, segE_IN);
    move (segF + offset, segF_OUT);
    move (segG + offset, segG_OUT);
    casser;

  cas 10:
    move (segA + offset, segA_IN);
    move (segB + offset, segB_IN);
    move (segC + offset, segC_IN);
    move (segD + offset, segD_IN);
    move (segE + offset, segE_IN);
    move (segF + offset, segF_IN);
    move (segG + offset, segG_IN);
    casser;
  }
}

Tout fonctionne: