Vendredi, août 22 2014

Des bricoles en 3D réelle -1-

  • Je vais faire quelques photos pour chaque trucs potable que j'imprime.

Voici une première série !

dsc00112.jpg Un boitier pour le raspberry pi en PLA gris.
J'ai dû élargir à la lime et au cutter la fente pour passer la nappe GPIO.
Défaut de conception, pour cet objet téléchargé ici : http://www.thingiverse.com/thing:47776

dsc00111.jpg dsc00117.jpg


dsc00114.jpg Un boitier pour le second Raspberry pi, en PLA gris.
L'ordinateur est ici présenté sur le dos, car il y a la possibilité de passer des vis pour le fixer au mur.
dsc00113.jpg dsc00115.jpg
À télécharger ici : http://www.thingiverse.com/thing:30843


dsc00121.jpg dsc00120.jpg dsc00119.jpg

Un support en ABS bleu, pour transformer ma mini perceuse en perceuse à colonne, bien pratique pour percer des circuits imprimés électronique.

Car jusqu'à présent je faisais ça les deux coudes bien calés sur la table les mains jointes tenant fermement la perceuse.

dsc00122.jpg dsc00118.jpg

Le trou de blocage pour la roue dentée est perfectible, car trop grand pour empêcher la rotation de l'écrou que j'ai dû noyer dans la colle; mais ça fait l'affaire, à voir ici : http://www.thingiverse.com/thing:144333





Jeudi, août 21 2014

Un cyclone pour l’aspirateur

Voilà un petit bricolage simple qui vous permettra de disposer d’un cyclone sur votre aspirateur de chantier et ainsi vous pourrez aspirer gravats et sciure sans utiliser de sac !

Il vous faudra un tube PVC de 100mm et un de 40mm d’une longeur d’environ 50cm chacun. Un bouchon pour le tube de 100mm (le mien est découpé dans une plaque de MDF) et un réducteur 100/40mm.

Pour récupérer les poussières il faut un sceau étanche et résistant. Si comme moi il s’écrase avec la pression vous pourrez le renforcer avec un croisillion en bois.

 

Le cyclone
Le cyclone

Le séparateur
Le séparateur
Prise d'aspiration
Prise d’aspiration
Insertion sur la tangente
Insertion sur la tangente
Le tube de 40mm au centre
Le tube de 40mm au centre
Les mesures
Les mesures
Contre l'écrasement de la cuve
Contre l’écrasement de la cuve
Le renfort du couvercle
Le renfort du couvercle
Supprimer les inserts
Supprimer les inserts
Le réducteur
Le réducteur

Le résultat est visible dans la vidéo :)

Je n’ai pas inventé grand chose, je me suis inspiré de cet article

Samedi, août 16 2014

Une Borne d'Arcade maison, petite touche déco

  • Même si je ne suis pas satisfait de la déco du chapeau de la borne à cause des ratés que j'évoquais plus tôt, il restait les artwork side à poser, ces deux bandes marquées « Astro City », habituellement imprimées en vinyle autocolant.

J'aurais pu faire comme beaucoup, les commander sur le web auprès d'un imprimeur, mais j'avais des craintes quant au collage du vinyle… Genre qu'adviendrait-il de la peinture en cas de décollement volontaire, histoire de changer la déco ?
C'est que la peinture m'a donné tant de travail que j'étais flippé à l'idée de la ruiner d'une manière ou d'une autre, tôt ou tard…
Du coup, j'avais laissé tombé, en attendant le jour où ?

Et bien, où j'ai eu l'idée qui va bien ^^

Satisfait de l'essai réalisé sur le sticker « insert coin » j'ai décidé d'appliquer la même méthode, cependant améliorée pour ces grandes surfaces que sont les sides.

  • La technique est simple !
  1. Imprimer (laser conseillée) en mode miroir la déco sur une feuille de plastique transparent.
  2. La découper soigneusement au cutter.
  3. L'enduire de colle bâton (côté encre donc).
  4. L’apposer sur la borne, presser et frotter fortement.

Les sides imprimé sur un A3 en deux morceaux chacun[1], puis découpés :
dsc00082.jpg dsc00084.jpg

dsc00085.jpg dsc00087.jpg Premier essai…

Pour une petite surface donc tout va bien, l'étalage de colle étant facile à rendre uniforme, mais ici vu la taille des bandes sides, j'ai pu constater avec effrois que les traces d'application de la colle étaient bien visible et ne disparaissaient pas au séchage !

Qu'à ce la ne tienne, décollage facile et nettoyage à l'eau, et on recommence…
Tiens… à l'eau, hum… Mais oui !!

J'ai donc amélioré le point N°3, en diluant des morceaux de colle dans un peu d'eau, que j'ai ensuite appliqué au pinceau brosse.

Une fois la bande de plastique appliquée, on voit des flaques d'eau gluante se former, ainsi que des bulles, qu'il suffit alors de chasser en frottant énergiquement à l'aide d'un chiffon.

C'est assez long, mais on peut surveiller le bon déroulement des opérations, car non seulement il y a les zones transparentes du plastique, mais aussi les endroits pas bien collés qui ne font pas apparaître la même teinte aux couleurs.

  • Voila ^__^

dsc00086.jpg dsc00089.jpg

Note

[1] À télécharger ci-dessous

Dimanche, août 3 2014

Fabrication d'un vélo Cargo - Etape 1 : Le chassis

Bonjour à tous, je me suis mis en tête de fabriquer avec un ami un vélo Cargo (Cargo Bike, Triporteur, ...). J'utilise de plus en plus le vélo et c'est vrai que ce n'est pas toujours pratique pour aller faire les courses, aller faire un pic-nic.... Plusieurs solutions: remorque, tricycle, cargo 3 roues, cargo 2 roues... J'ai choisi le cargo 3 roues car j'ai récupéré un vieux VTT qui se prête bien à la transformation.
J'ai toujours eu envie d'apprendre à souder à l'arc donc, ça tombe bien.






Ce n'est pas si facile....Ce que j'ai retenu de mon expérience de soudure:

- toujours bien préparer les surfaces (meulage, dégraissage),
- caler au maximum les pièces, car au moment de la soudure, tout a tendance à bouger et à se tordre avec la chaleur
- souder toujours à plat ou en descendant, jamais en montant,
- toujours des épaisseurs du même ordre de grandeur (pour les tubes, il m'est parfois arrivé de doubler leur épaisseurs en mettant un autre bout de tube à l'intérieur pour éviter qu'il perce pendant la soudure. C'est une super astuce), et les baguettes adaptées


Le châssis est entièrement fait avec des tubes acier de 25mm de diamètre (2 mm d'épaisseur) et du plat de 35x4mm.


Voici le détail des pièces:


Vous pouvez remarquer que nous avons écrasé et plié les tubes afin de faciliter les soudures.

Pour le calage avant la soudure, il faut être imaginatif. J'ai utilisé une tige filetée avec rondelles et écrous pour bien positionner les fixations des roues. J'ai oublié de prendre en photo cette étape mais je vous la montre sur un autre projet similaire:




Voici aussi une photo sur le doublage de tube (pas utilisé sur ce projet mais très utile quand on veut souder un tube en bout sur un plat ou sur une tôle):



 Et pour finir, une autre photo du châssis:




Je vous donne rendez-vous pour la suite du projet: le cadre.
Ce sera certainement prêt pour la semaine prochaine

A+


Vendredi, août 1 2014

RaspiO'Mix ou GrovePi ?

On m'a demandé par courriel quelles étaient les différences entre le RaspiO'Mix et la carte GrovePi et j'ai pensé qu'il serait intéressant d'en faire un article...et je vais tâcher de faire un effort pour rester objectif, promis !

raspiomixvsgrovepi.png

Tout comme RaspiO'Mix, GrovePi vous permet de connecter vos modules Grove à votre Raspberry, même finalité mais choix technique différent : là ou RaspiO'Mix utilise directement les entrées / sorties du Raspberry, GrovePi utilise en fait un ATMega jouant le rôle d'intermédaire entre le Raspberry et le monde extérieur via une liaison I2C.

L'avantage pour l'un, c'est que GrovePi utilise moins d'entrées / sorties et du coup, vous pouvez les utiliser pour autre chose, l'inconvénient, c'est qu'on ne les pilote par directement, supprimant certaines fonctionnalités des IO du PI.

RaspiO'Mix fait office d'interface direct entre le Raspberry et le monde extérieur, vous pouvez donc utiliser des lignes de commandes, du Python, ce que vous voulez sans avoir à passer par une librairie spécialisée, en gros, pour faire cours, vous n'avez pas besoin d'utiliser un drivers contrairement à GrovePi.

Détails sur le mapping des ports : RaspiO'Mix et GrovePi.

Fonctionnalité GrovePi RaspiO'Mix
Entrées / Sorties 7 4
Entrées analogiques 3 4
Résolution CAN 10bits 18bits
Lignes I2C 4 2
Lignes série 1 1
Horloge Non Oui (via DS1307) avec batterie de sauvegarde
Interrupteur 0 2
Alimentation via le Raspberry via le Raspberry ou une prise jack / bornier

Flag_of_France.svg.png
Autre chose importante, les RaspiO'Mix sont fabriquées en France !

oshw-logo-100-px.png
Dans les 2 cas, GrovePi et RaspiO'Mix sont des projets OpenSource et OpenHardware et vous pouvez retrouver toutes les sources sur GitHub : GitHub / GrovePi et GitHub / RaspiO'Mix

Les cartes RaspiO'Mix devraient être disponible dans des boutiques en ligne mais en attendant, si vous en voulez une, contactez moi directement !

Mercredi, juillet 30 2014

WebRadioRéveilWifi -2-

Suite de l'étude précédente :

Nouveau billet d'étape, cette fois-ci concernant l'horloge, et je me rend compte que je n'ai pas encore présenté le projet complet, oups !
Bon je verrais ça plus tard avec un billet N° zero…

  • Donc après les quelques tests réalisés sur le Raspberry pi pour la partie WebRadio, on va s'occuper ici de la partie horloge.

Au départ je voulais la faire avec un µC Atmega, et puis comme ça sans trop réfléchir, je me suis procuré un Arduino.
Je n'avais jusqu'alors pas essayé, considérant que l’utilisation d'un µC était finalement la même chose, en bas niveau il s'entend.
Sauf que j'avais tord ! Pas sur le fond, puisque c'est bel et bien le cas, mais sur la forme. En effet programmer un AVR n'a rien de sexy, et lorsqu'on connaît mal le composant, il faut beaucoup de temps et de persévérance avant de savoir ce qu'il est possible de faire et d'en appréhender le fonctionnement, notamment le plus complexe pour moi qui ne suis pas codeur, la programmation.
Je me voyais donc mal barré, et s'il y a bien une chose fondamentale que j'ai apprise, c'est qu'il faut avant tout se faire plaisir pour avancer.
Il me fallait donc emprunter une voie différente, et de découvrir l'Arduino et son langage simplifié aura débloqué la situation.
J'ai donc été très surpris de parvenir à faire fonctionner mon horloge en à peine un week-end, fort des nombreux exemples et réalisations documentées en ligne.
j'aurais dû essayer Arduino plus tôt ^^;
J'ai ensuite pris plaisir à continuer de perfectionner mon système pour y ajouter des fonctionnalités, que je vais détailler ici.


Premiers essais, premières erreurs :

  • Le système d'affichage repose sur des registres à décalages. J'avais d'abord entrepris les 74HC164, car j'en avais sous la main.

Sauf que, voici le résultat :

Comme diraient nos amis anglo-saxon, ça « flicke », et ce à chaque boucle du programme, plus ou moins vite en fonction de sa vitesse d'exécution, que j'ai réglé ici à 1/4 de secondes pour qu'on voit bien le résultat.
J'ai perdu pas mal de temps à chercher dans mon code ce qui n'allait pas, avant de constater que ce comportement était dû à la nature du registre, qui ne dispose pas de fonction Latch permettant d'interrompre la transmission de donnée.

  • J'ai alors opté pour des 74HC595…

Le montage :

Voici le schéma structurel :
horloge-structurel-0.1.png

  • On a donc l'Arduino connecté à un module chronodot, et à 4 afficheurs 7 segments via des registres à décalages.

Oui j'ai omis volontairement de mettre des résistances de protection sur chaque segments, et les résistances de polarisation des transistors, je verrais ça plus tard.
Pour le moment c'est du prototype, donc voilà, et puis ces afficheurs mangent du 4,3V sur les 5V de l'alimentation, ce qui laisse très peu d'énergie néfaste aux diodes, d'autant qu'on va les utiliser en PWM.

  • La maquette sur plaque labo :

dsc00056.jpg dsc00070.jpg

  • Le composant DS3231, ainsi câblé forme le module chronodot, qu'il me suffit d'enficher dans une plaquette labo. Une library assez simple pour s'adresser à ce composant existe, il faut donc l'installer dans le logiciel Arduino.

dsc00074.jpg dsc00058.jpg

dsc00069.jpg

Le développement :

Ce qui me paraissait une montagne obscure et sombre à franchir, quoique bien éclairée par la plateforme Arduino n'a pas été franchie d'un seul coup, et le programme que vous trouverez plus loin s'est construit par petits bouts de codes que j'ai ensuite assemblés et fait évoluer, en m'aidant d'exemples Arduino pour l'affichage sur les 7 segments, et de l'exemple fournit avec la librairie pour le chronodot, le circuit électronique allant en se complexifiant.

Étape après étape on va se rapprocher de l'objectif :

  • Partie afficheurs,

- Allumer une led (exemple arduino).
- Allumer un afficheur.
- Afficher le chiffre de mon choix sur l'afficheur (datasheet 74HC164).
- Afficher un compte à rebours sur un afficheur.
- Ajouter un second afficheur, et afficher un nombre.
- Faire varier l'intensité d'une LED avec la PWM (exemple arduino).
- Modification du circuit avec transistor pour utilisation de la PWM avec les afficheurs.
- PWM fixée sur l'intensité de mon choix dans le code.

  • Module chronodot,

- Câblage du module chronodot et connexion à l'Arduino (datasheet DS3231).
- Récupération de l'heure et affichage dans la console série Arduino (exemple lib chronodot).

  • Affichage de l'heure,

Ça se complique, c'est le passage avec lequel j'ai eu le plus de mal et qui m'aura donné des rêves étrange entre samedi et dimanche.

- Affichage des secondes sur deux afficheurs (brainstorming).
- Simplification de ce code à l'aide d'un tableau.
- Fixé dans le code, affichage au choix, soit des heures, minutes ou secondes.

Bloqué sur le problème de flicker, fin du week end.

- Lundi, remplacement des 74HC164 pour les 74HC595, flicker out, ouf ^^
Plus tard,
- Ajout d'un bouton poussoir, allumer une led quand on le presse (exemple arduino).

Je suis resté un peu bloqué car je ne comprenais pas comment utiliser la librairie chronodot, alors qu'il suffit de décrypter le fichier Chronodot.h pour comprendre ce que la librairie permet de faire.

- Mise à l'heure le chronodot à l'aide de deux boutons poussoir.

  • La plaque labo étant trop étroite, câblage sur plaque d'essais à trou.

dsc00076.jpg dsc00077.jpg dsc00079.jpg dsc00080.jpg
- Affichage des heures et secondes, mise à l'heure manuelle ok.

  • PWM automatique,

- Câblage de la photodiode et affichage dans la console série Arduino de la valeur renvoyée par la diode (exemple arduino).
- Variation de la PWM en fonction de la valeur envoyée par la photodiode, dans le but de baisser l'intensité lumineuse des afficheurs dans la pénombre, et de l'augmenter quand il fait soleil.

C'est tout pour le moment !

  • Il me reste à voir comment implémenter le système pour les alarmes du réveil, et à communiquer certains événements avec la Raspberry et je pense que ce sera tout pour cette partie du projet.

Voici le programme, dont j'ai commenté chaque ligne afin de ne pas perdre les débutants.

/****** Domaine publique, youpi ! ******/
#include <Wire.h>       // Communication avec le RTC
#include "Chronodot.h"  // Fonctions du Chronodot
 
/****************/
/* Déclarations */
/****************/
 
/****** Signaux ******/
#define datapin 10   // pin 10 pour les données vers les registres à décallages
#define clockpin 11  // pin 11 pour l'horloge qui coordonne les registres à décallages
#define latchpin 8   // pin 8 pour le déclencheur des registres à décallages
 
/****** Boutons poussoir ******/
#define BoutonMinutes 12    // pin 12 pour le bouton poussoir d'incrément des minutes
#define BoutonHeures 13     // pin 13 pour le bouton poussoir d'incrément des heures
#define BoutonShift 7       // pin 7 pour le bouton poussoir shift
int EtatBoutonMinutes = 1;  // variable pour stocker l'état du bouton aprés sa lecture
int EtatBoutonHeures = 1;   // variable pour stocker l'état du bouton aprés sa lecture
 
/****** Alimentation des 7 segments en PWM ******/
#define ledPin 9                    // pin 9 pour le signal PWM de cadencement des afficheurs et leds
#define photodiodepin 0             // pin A0 pour la photodiode
unsigned int ValeurPhotoDiode = 0;  // variable pour stocker l'état de la photodiode aprés sa lecture
 
/****** Variables temporelles ******/
unsigned int heures;    // pour stocker les heures
unsigned int heuresINC; // pour stocker l'incrément des heures
unsigned int minutes;   // pour stocker les minutes
unsigned int minutesINC;// pour stocker l'incrément des minutes
unsigned int secondes;  // pour stocker les secondes
unsigned int annee;     // pour stocker l'annee
unsigned int mois;      // pour stocker le mois
unsigned int jour;      // pour stocker le jour
Chronodot HORLOGE;      // HORLOGE, nom choisis arbitrairement, référence à la librairie Chronodot
 
/****** Variables d'affichage ******/ 
int dizH = 0;          // pour stocker les dizaine des heures
int unitH = 0;         // pour stocker les unités des heures
int dizM = 0;          // pour stocker les dizaine des minutes
int unitM = 0;         // pour stocker les unités des minutes
byte AfficheurUN;      // données binaire pour l'afficheur UN, situé le plus à droite
byte AfficheurDEUX;    // données binaire pour l'afficheur DEUX
byte AfficheurTROIS;   // données binaire pour l'afficheur TROIS
byte AfficheurQUATRE;  // données binaire pour l'afficheur QUATRE, situé le plus à gauche
byte dataArray[10];    // Tableau de données
 
/*******************/
/* Initialisations */
/*******************/
void setup ()      // Fonction d'initialisation obligatoire
{
  dataArray[0] = B00000011;  // Case du tableau qui contient la valeur binaire pour afficher zero sur un afficheur 7 segments
  dataArray[1] = B10011111;  // Case du tableau qui contient la valeur binaire pour afficher un sur un afficheur 7 segments
  dataArray[2] = B00100101;  // Case du tableau qui contient la valeur binaire pour afficher deux sur un afficheur 7 segments
  dataArray[3] = B00001101;  // Case du tableau qui contient la valeur binaire pour afficher trois sur un afficheur 7 segments
  dataArray[4] = B10011001;  // Case du tableau qui contient la valeur binaire pour afficher quatre sur un afficheur 7 segments
  dataArray[5] = B01001001;  // Case du tableau qui contient la valeur binaire pour afficher cinq sur un afficheur 7 segments
  dataArray[6] = B01000001;  // Case du tableau qui contient la valeur binaire pour afficher six sur un afficheur 7 segments
  dataArray[7] = B00011111;  // Case du tableau qui contient la valeur binaire pour afficher sept sur un afficheur 7 segments
  dataArray[8] = B00000001;  // Case du tableau qui contient la valeur binaire pour afficher huit sur un afficheur 7 segments 
  dataArray[9] = B00001001;  // Case du tableau qui contient la valeur binaire pour afficher neuf sur un afficheur 7 segments 
 
  pinMode(clockpin, OUTPUT);     // pin correspondant à "clockpin" initialisée en sortie
  pinMode(datapin, OUTPUT);      // pin correspondant à "datakpin" initialisée en sortie
  pinMode(latchpin, OUTPUT);     // pin correspondant à "latchpin" initialisée en sortie
  pinMode(BoutonMinutes, INPUT); // pin correspondant à "BoutonMinutes" initialisée en entrée 
  pinMode(BoutonHeures, INPUT);  // pin correspondant à "BoutonHeures" initialisée en entrée     
 
  Wire.begin();     // initialisation du chronodot, référence à la librairie wire
  HORLOGE.begin();  // initialisation du chronodot, référence à la librairie Chronodot
 
//************ MISE à L'heure du module RTC DS3231 ************
  HORLOGE.adjust(DateTime(2014,12,25,10,30,12));  // années, mois, jour, heures, minutes, secondes
}
 
/*************/
/* Programme */
/*************/
void loop ()      // boucle du programme !
{
  horloge ();                // appelle la fct "horloge", récupération des données temporelles
  affiche ();                // appelle la fct "affiche", transfert des données temporelles sur les afficheurs 7 segments
  SurveilleBoutonHeures ();  // appelle la fct "SurveilleBoutonHeures", incrémente les heures si appuyé  
  SurveilleBoutonMinutes (); // appelle la fct "SurveilleBoutonMinutes", incrémente les minutes si appuyé  
  AjusteLuminosite();        // appelle la fct "AjusteLuminosite", plus il fait sombre, plus la lumière des afficheurs baisse
}
 
/***** Fonction d'horloge *******/   
void horloge ()
{
  DateTime now = HORLOGE.now();  // lecture de l'heure en cours dans la puce DS3231, référence à la librairie Chronodot
  heures = now.hour(), DEC;      // stocke l'heure en décimale dans la variable "heures" grace à la fct "hour" de la lib chronodot
  minutes = now.minute(), DEC;   // stocke les minutes en décimale dans la variable "minutes" grace à la fct "minute" de la lib chronodot
  secondes = now.second(), DEC;  // stocke les secondes en décimale dans la variable "secondes" grace à la fct "second" de la lib chronodot
  annee = now.year(), DEC;       // stocke l'année en décimale dans la variable "annee" grace à la fct "year" de la lib chronodot
  mois = now.month(), DEC;       // stocke le mois en décimale dans la variable "mois" grace à la fct "month" de la lib chronodot 
  jour = now.day(), DEC;         // stocke le jour en décimale dans la variable "jour" grace à la fct "day" de la lib chronodot
}
 
/***** Fonction d'affichage sur les 7 segments *******/  
void affiche ()
{
  dizH = heures / 10;   // par calcul, extrait la dizaine de "heures" et stocke le résultat dans "dizH" 
  unitH = heures % 10;  // par calcul, extrait l'unités de "heures" et stocke le résultat dans "unitH" 
  dizM = minutes / 10;  // par calcul, extrait la dizaine de "minutes" et stocke le résultat dans "dizM"   
  unitM = minutes % 10; // par calcul, extrait l'unité de "minutes" et stocke le résultat dans "dizM" 
 
  AfficheurUN = dataArray[unitM];    // stocke la valeur binaire 7 segments de l'unité de minutes dans "AfficheurUN"
  AfficheurDEUX = dataArray[dizM];   // stocke la valeur binaire 7 segments de la dizaine de minutes dans "AfficheurDEUX"
  AfficheurTROIS = dataArray[unitH]; // stocke la valeur binaire 7 segments de l'unité d'heures dans "AfficheurTROIS"
  AfficheurQUATRE = dataArray[dizH]; // stocke la valeur binaire 7 segments de la dizaine d'heures dans "AfficheurQUATRE"
 
  digitalWrite(latchpin, 1);                              // latch à l'état HAUT pour autoriser le transfert des données série   
  shiftOut(datapin, clockpin, LSBFIRST, AfficheurUN);     // envoi l'unités minute au registre à décallage
  shiftOut(datapin, clockpin, LSBFIRST, AfficheurDEUX);   // envoi la dizaine minute au registre à décallage
  shiftOut(datapin, clockpin, LSBFIRST, AfficheurTROIS);  // envoi l'unités heure au registre à décallage
  shiftOut(datapin, clockpin, LSBFIRST, AfficheurQUATRE); // envoi la dizaine heure au registre à décallage  
  digitalWrite(latchpin, 0);                              // latch à l'état BAS pour arreter le transfert des données série  
}
 
/***** Fonction Surveillance du BoutonHeures *******/        
void SurveilleBoutonHeures ()
{ 
  EtatBoutonHeures = digitalRead(BoutonHeures);  // Lit l'état du bouton (appuyé ou relaché) et stocke la valeur dans la variable "EtatBoutonHeures"
  if (EtatBoutonHeures == LOW)   // si le bouton est appuyé
    {  
    delay(170);                  // alors, attendre 170 ms, permet un appuie bref pour incrémenter de 1, et un appuie long pour incrémenter rapidement d'autant qu'on veut
    RegleHeures ();              // et appeller la fonction "RegleHeures"
    }  
}
 
/***** Fonction Surveillance du BoutonMinutes *******/        
void SurveilleBoutonMinutes ()
{ 
  EtatBoutonMinutes = digitalRead(BoutonMinutes);  // Lit l'état du bouton (appuyé ou relaché) et stocke la valeur dans la variable "EtatBoutonMinutes"
  if (EtatBoutonMinutes == LOW)    // si le bouton est appuyé
    {  
    delay(170);                    // alors,  attendre 170 ms, permet un appuie bref pour incrémenter de 1, et un appuie long pour incrémenter rapidement d'autant qu'on veut
    RegleMinutes ();               // et appeller la fonction "RegleMinutes"
    }  
}
 
/***** Fonction d'incrément Heures *******/ 
void RegleHeures ()
{ 
  heuresINC = heures + 1;  // additionne 1 à la valeur contenue dans la variable "heures" et stocke le résultat dans la variable "heuresINC"
  if (heuresINC > 23)      // si la valeur de "heuresINC" dépasse 23 (23h)
  {
    heuresINC = 0;         // alors, et la variable "heuresINC" à zero (minuit)
  }
    HORLOGE.adjust(DateTime(annee,mois,jour,heuresINC,minutes,0));  // récup des données temporelles depuis les différentes variables pour mise à l'heure la puce DS3231, secondes à zero
}
 
/***** Fonction d'incrément minutes *******/ 
void RegleMinutes ()
{ 
  minutesINC = minutes + 1;  // additionne 1 à la valeur contenue dans la variable "minutes" et stocke le résultat dans la variable "minutesINC"
  if (minutesINC > 59)      // si la valeur de "minutesINC" dépasse 59 (59min)
  {
    minutesINC = 0;         // alors, met la variable "minutesINC" à zero
  }
    HORLOGE.adjust(DateTime(annee,mois,jour,heures,minutesINC,0));  // récup des données temporelles depuis les différentes variables pour mise à l'heure la puce DS3231, secondes à zero
 }
 
 /***** Fonction d'ajustement automatique de la luminosité des afficheurs *******/ 
void AjusteLuminosite()
{
  ValeurPhotoDiode = analogRead(photodiodepin);  // Lit la valeur renvoyée par la photodiode, et stocke la valeur dans la variable "ValeurPhotoDiode"
  if (ValeurPhotoDiode > 500)       // si la valeur est supérieure à 500 (beaucoup de lumière reçue, genre en plein jour)
  {
     analogWrite(ledPin, 255);      // alors, illumination des afficheurs et leds à 100% (PWM de 0 à 255)
  }
  else if (ValeurPhotoDiode > 400)  // sinon, si la valeur est supérieure à 400
  {
    analogWrite(ledPin, 212);       // alors, illumination des afficheurs et leds moins forte    
  }
  else if (ValeurPhotoDiode > 300)  // sinon, si la valeur est supérieure à 300
  {
    analogWrite(ledPin, 169);       // alors, illumination des afficheurs et leds moins forte 
  }
  else if (ValeurPhotoDiode > 200)  // sinon, si la valeur est supérieure à 200
  {
    analogWrite(ledPin, 127);       // alors, illumination des afficheurs et leds moins forte 
  }
  else if (ValeurPhotoDiode > 100)  // sinon, si a valeur est supérieure à 100
  {
    analogWrite(ledPin, 83);        // alors, illumination des afficheurs et leds moins forte 
  }
  else                              // sinon,  (très peu voire pas du tout de lumière reçue, genre dans la nuit)
  {
    analogWrite(ledPin, 40);        // alors, illumination des afficheurs et leds aux minimum
  } 
}


À suivre…


Ressources :

- http://pichonjulien.blogspot.fr/2009/11/pilotage-dun-afficheur-7-segments.html
- http://home.roboticlab.eu/fr/examples/display/segment_display
- http://www.sonelec-musique.com/electronique_theorie_afficheurs_led.html
- http://www.robot-maker.com/index.php?/tutorials/article/41-composant-les-afficheurs-7-segments/
- http://www.pobot.org/Piloter-des-afficheurs-7-segments.html
- http://playground2014.wordpress.com/arduino/1-3-7-segment-display/
- http://www.wikidebrouillard.org/index.php/Afficheur_7_segments_pilot%C3%A9_par_Arduino
- http://www.instructables.com/id/Different-methods-of-driving-7-Segment-LED-display/?ALLSTEPS
- http://www.sonelec-musique.com/electronique_realisations_afficheur_leds_7seg_007.html
- http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/?ALLSTEPS
- http://www.instructables.com/id/Multiplexing-with-Arduino-and-the-74HC595/?ALLSTEPS
- http://wiki.t-o-f.info/Arduino/ExempleD%C3%A9multiplexeurNum%C3%A9rique74HC595

- http://docs.macetech.com/doku.php/chronodot_v2.0
- http://schazamp.wordpress.com/2010/01/21/chronoblot/
- http://homecoder.wordpress.com/2013/12/12/getting-to-grips-with-a-real-time-clock/
- http://skyduino.wordpress.com/2012/01/07/tutoriel-arduino-horloge-rtc-ds1307-librairie-liquidcrystal/

- http://www.bricobidules.com/index.php?post/2012/04/29/iTime%2C-une-horloge-sous-Arduino-dans-un-bo%C3%AEtier-de-Mac-Mini
- http://www.instructables.com/id/Arduino-based-clock/
- http://kevinrye.net/electronics/source/

Lundi, juillet 28 2014

Une Borne d'Arcade maison, PS

  • Il est des jours comme ça, où lors d'un surf incité par les stats du blog, puis au détour d'un forum, on se retrouve à tomber sur un stock de photos pour le moins impressionnantes.

Pas d'articles ou de notes associés qui détaillent la fabrication de cette borne d'arcade, mais juste le compte de page perso free. http://famillemafieuse.free.fr/borneArcade/photos/

  • Le système de rotation est tout bonnement très ingénieux et d'une simplicité telle que je me fais un plaisir de relayer ici ces travaux qui m'ont laissés pantois…

À y repenser, si j'avais eu connaissance d'un tel système, je l'aurais adopté direct pour ma borne !!
Après analyse ce système semble tellement évident qu'on se demande pourquoi je n'y ai pas pensé, encore faudrait-il avoir intégré dans mon schéma de pensée, la compétence soudure métallique, afin de pouvoir raisonner jusque là.
Maintenant que je sais un peu souder, le champ des possibles est bien plus large qu'auparavant, je le comprend avec cette borne que je vous laisse découvrir tranquillement…

Le Support rotatif du téléviseur :

Une roue de vélo, quatre roues de rollers, et un cadre métallique… Il fallait y penser !
ch.jpg cj.jpg
ci.jpg cl.jpg cm.jpg cr.jpg

Avec deux barres supplémentaires pour recevoir le chassis électronique de la télé, voici le système de rotation au complet pour essais.
cs.jpg ef.jpg
eg.jpg ia.jpg
ib.jpg ic.jpg hc.jpg hd.jpg
fe.jpg ff.jpg fg.jpg fh.jpg

Fixation du téléviseur sur le support rotatif :

Démontage de la télé et assemblage fixation au cadre métallique à l'aide de longues vis… bien vu !
Nous voilà avec un écran réglable en profondeur.
aa.jpg bc.jpg ck.jpg
ca.jpg cn.jpg co.jpg
db.jpg da.jpg dc.jpg

Intégration de l'ensemble dans la borne :

La position de l'écran est bloquée avec une vis qui traverse la roue de vélo.
il.jpg im.jpg
ik.jpg ii.jpg ij.jpg
in.jpg io.jpg ip.jpg iq.jpg
ir.jpg is.jpg iu.jpg jj.jpg

La rotation s'effectue vers la gauche, c'est à dire dans le sens inverse des aiguilles d'une montre, ce qui est le BON sens (la majorité des jeux verticaux sur PCB sont orientés ainsi).
Pour ma part, vu que je me suis planté sur ma borne, qui tourne à droite, impossible de jouer à Ikaruga sur Game Cube ! L'image se retrouvant à l'envers…
la.jpg ld.jpg lf.jpg
lc.jpg le.jpg

Une Borne d'Arcade maison, PS

  • Il est des jours comme ça, où lors d'un surf incité par les stats du blog, puis au détour d'un forum, on se retrouve à tomber sur un stock de photos pour le moins impressionnantes.

Pas d'articles ou de notes associés qui détaillent la fabrication de cette borne d'arcade, mais juste le compte de page perso free. http://famillemafieuse.free.fr/borneArcade/photos/

  • Le système de rotation est tout bonnement très ingénieux et d'une simplicité telle que je me fais un plaisir de relayer ici ces travaux qui m'ont laissés pantois…

À y repenser, si j'avais eu connaissance d'un tel système, je l'aurais adopté direct pour ma borne !!
Après analyse ce système semble tellement évident qu'on se demande pourquoi je n'y ai pas pensé, encore faudrait-il avoir intégré dans mon schéma de pensée, la compétence soudure métallique, afin de pouvoir raisonner jusque là.
Maintenant que je sais un peu souder, le champ des possibles est bien plus large qu'auparavant, je le comprend avec cette borne que je vous laisse découvrir tranquillement…

Le Support rotatif du téléviseur :

Une roue de vélo, quatre roues de rollers, et un cadre métallique… Il fallait y penser !
ch.jpg cj.jpg
ci.jpg cl.jpg cm.jpg cr.jpg

Avec deux barres supplémentaires pour recevoir le chassis électronique de la télé, voici le système de rotation au complet pour essais.
cs.jpg ef.jpg
eg.jpg ia.jpg
ib.jpg ic.jpg hc.jpg hd.jpg
fe.jpg ff.jpg fg.jpg fh.jpg

Fixation du téléviseur sur le support rotatif :

Démontage de la télé et assemblage fixation au cadre métallique à l'aide de longues vis… bien vu !
Nous voilà avec un écran réglable en profondeur.
aa.jpg bc.jpg ck.jpg
ca.jpg cn.jpg co.jpg
db.jpg da.jpg dc.jpg

Intégration de l'ensemble dans la borne :

La position de l'écran est bloquée avec une vis qui traverse la roue de vélo.
il.jpg im.jpg
ik.jpg ii.jpg ij.jpg
in.jpg io.jpg ip.jpg iq.jpg
ir.jpg is.jpg iu.jpg jj.jpg

La rotation s'effectue vers la gauche, c'est à dire dans le sens inverse des aiguilles d'une montre, ce qui est le BON sens (la majorité des jeux verticaux sur PCB sont orientés ainsi).
Pour ma part, vu que je me suis planté sur ma borne, qui tourne à droite, impossible de jouer à Ikaruga sur Game Cube ! L'image se retrouvant à l'envers…
la.jpg ld.jpg lf.jpg
lc.jpg le.jpg

- page 1 de 38