Archives Mensuelles: juin 2012

Du pliage de plexiglas – aka Je fais mes boites moi même

Il y a quelques temps j’ai acheté une plaque de plexiglas au casto le plus proche dans le but de faire une boite pour mon arduino. D’après ce que j’avais lu sur ce matériaux sur divers forums il suffit de chauffer et de tordre.

Je suis tombé sur une vidéo très didactique sur ce sujet :

Pour ma part je n’ai pas de cornières métallique comme dans la vidéo j’ai donc pris des tasseaux rabotés et des planches de parquet. J’ai fixé au bureau avec des sert joints.

Pour le chauffage j’ai pris le sèche cheveux de madame, à plus forte puissance il monte à 1500W, à croire qu’il peut décaper de la peinture.

Le but est de plier en prenant appui entre deux planches en bois comme sur la vidéo.

Je n’avais pas de gants et cela m’a manqué, le plastique devenant vite chaud, il ne faut pas espérer plier le plastique à main nue d’où l’utilisation d’une seconde planche pour appuyer sur le point à plier.

Le chauffage doit être appliqué sur l’extérieur  de la pliure, c’est à dire du coté où on va appuyer avec la planche.

Le film de protection est à enlever (entièrement je dirais), il fond beaucoup plus tôt que le plexiglas et peut laisser des coulures inélégantes.

A noter qu’un chauffage peu rendre mou au mauvais endroit, c’est d’ailleurs ce qui m’est arrivé, certaines parties sont « pas très droite ». Pour un premier test ça ira ^^.

Pour finir la boite j’ai collé avec un tube de colle qui me tombait sous la main : la bonne vielle colle Gel de chez Scotch. ça colle mais ça fait quelques « bulles ». Attention j’ai fait une coulure et elle reste … le plexi est attaqué

Image

Publicités

Instabilité de l’Arduino relié au WR703N – Part 2

Comme je l’avais dis dans mon précédent billet, j’ai des soucis de stabilité de lecture du port serie depuis le WR703N.

J’ai donc modifié le programme de lecture pour faire une fermeture puis une réouverture du port série, le problème se reproduit donc ce n’est pas la solution.

En complément j’ai modifié mon code Arduino pour allumer une led pendant la mesure, la led reste donc allumée quelques secondes avant de s’éteindre pendant la phase d’attente. J’ai bien constaté que pendant le figeage des lecture la led s’allumait et s’éteignait. L’Arduino n’est donc pas figé.

Le problème semble donc se situer au niveau du module cdc_acm ou du programme C. Sachant que le meme programme se déroule sans encombre sur mon PC Linux, je privilégie un pb module ou une spécificité à apporter à l’initialisation du port série. 

Pour le moment je n’ai pas d’idée comment avancer … si un lecteur en a … je prends

Instabilité de l’Arduino relié au WR703N

Comme je l’ai décris ici a plusieurs reprises, j’utilise un WR703N pour lire la liaison série de l’Arduino.

Cependant le montage s’arrête au bout d’un certain temps sans raison apparente. J’ai d’abord incriminé le matériel et le système, après tout le WR703N est du low cost Made in China ^^ et la version d’OpenWRT est en Bleeding Edge (danger Béta ^^).

L’Arduino me paraissait hors de cause vu qu’une fois branché sur l’USB du Linux il marche pendant des jours.

Il y a quelques jours je suis tombé sur l’article d’Andy Brown qui a eu le même soucis.

Lui a récupéré les données par un autre biais qu’un programme C, une lecture direct par le shell . Son hypothèse étant d’ouvrir à chaque lecture le port. Chez lui ça à l’air de fonctionner. Apres en avoir discuté ensemble je me suis mis en tete de modifier mon programme de lecture pour ré ouvrir le port périodiquement.

Mais hier, j’ai eu une autre idée (vous ne vous y attendiez pas hein ^^), et si le problème ne venait pas du système (un bug sur le driver cdc_acm qui m’aurait fort embetté) ? Hier j’ai donc fait le test en ajoutant une alimentation externe à l’Arduino.

 

Au moment où je vous parle (H+12), ça tourne toujours sans planter …

Est-ce la solution ? L’avenir le dira …

EDIT : J’ai parlé trop vite, en rentrant cet apres-midi j’ai trouvé la bête figée, plus d’accès au port ttyACM1 😦 Dans ces cas là obligé de relancer l’Arduino (électriquement)

 

Capteur de pluie – DIY

J’ai eu l’idée saugrenue de fabriquer un capteur de pluie pour m’envoyer un signal sonore quand il se met à pleuvoir la nuit et que la fenêtre est ouverte.

Le montage

Je suis parti d’une plaque de polystyrène mince et de deux fils de cuivre (une chute de câble multi brin dénudé). Il est tout a fait possible de prendre d’autres matériaux tant qu’ils ne craignent pas l’eau et qu’ils ne sont pas trop flexibles (il faut tendre les fils pour éviter qu’ils fassent contact entre eux). Sur le schéma les fils se chevauchent mais il faut imaginer qu’il passent derrière la carte par des trous percés. Il serait aussi tout a fait possible de faire un PCB mais pas sûr que cela soit rentable si la surface est énorme.

Le but est d’avoir deux fils dénudés qui ne sont pas en contact entre eux. C’est l’eau qui assurera leur contact, fermant ainsi le circuit comme un interrupteur. Reste a voir à l’usage à quelle vitesse l’eau va encrasser/oxyder les fils.

 

Capteur de pluie - DIY

 

Je mesure la résistance entre A et B (cf schéma), au repos il ne dois pas y avoir de contact. A est relié à GND et B à A0, une résistance de 1k Ohm est placée entre A0 et 5V.

 

Le code Arduino

J’ai réalisé un rapide programme d’alerte sur l’Arduino qui utilise mon bus ARV pour la communication. C’est le WR703N qui assure la connexion à distance de la sonde.

Je me contente d’une lecture toutes les 100 millisecondes, ça doit être assez précis dans la majorité des cas.

Pour éviter de noyer le bus sous les messages j’évite d’envoyer un message si la variation entre deux mesures est trop faible, j’estime que le changement ne se fera que brutalement, si la variation en 100ms est de 1 unité (sur 1023 …) c’est uniquement dû à l’incertitude de mesure.

De la même manière je considère que les valeurs qui m’intéressent sont < 1000, au dessus c’est sec , sauf si j’ai besoin de savoir si le capteur a séché … à voir si physiquement l’inclinaison du capteur peut aider à le sécher naturellement.

int sensorPin = A0;    // select the input pin for the potentiometer
int sensorValue = 0;  // variable to store the value coming from the sensor
int oldValue = 0;
int sensorDelay=100;

// Seuil en dessous duquel regarder l'évolution
int seuil = 1000;

void setup() {
  Serial.begin( 115200 );
}

void loop() {
  // read the value from the sensor:
  sensorValue = analogRead(sensorPin); 

  if ( sensorValue < seuil )
  {
    // si la valeur a changé de 1 on n'en tient pas compte, il y a trop de fluctuation sur la ligne pour que ce soit important
    if ( abs(  oldValue - sensorValue ) > 1 )
    {
      Serial.print("D");
      Serial.println(sensorValue);
    }
  }

  delay(sensorDelay);
  oldValue = sensorValue;
}

Paramétrage d’ARV

Pour ceux qui suivent ce carnet de note, j’ai développé un bus de communication en TCP/IP qui peut acheminer des messages lus depuis le port série de  l’arduino pour être traités ailleurs.

Pour le test je trace les informations dans un fichier texte grâce au plugin toFile d’ARV. Il faudra d’ailleurs que je développe un plugin qui peut appeler un programme/lire un son/tweeter/… quand il reçoit un message. Le problème sera de régler la sensibilité pour ne pas envoyer de messages trop fréquemment … Peut être en fixant un seuil et en ne notifiant que ce passage de seuil ?

collector.ini

Le fichier collector.ini permet d’associer à un type de message reçu un plugin qui va traiter celui-ci. La « paramétrabilité » est encore sommaire pour l’instant, mais ça viendra au fil du temps.

Pour l’exemple ci-dessous, l’arvcollector lisant le port série arduino envoie des messages de type « arduinoTP.WarningStation ». Un autre arvcollector déporté (celui ayant le collector.ini renseigné comme703 ci-dessous)  tracera les messages reçus (plugin toFile) en les horodatant (timestamp=TRUE).

[plugins]
arduinoTP.WarningStation=toFile.so

[toFile:arduinoTP.WarningStation]
timestamp=TRUE
fileOut=warning.csv

Lancement des processus

Sur le serveur je lance l’arvserveur et l’arvcollector pour traiter les messages via les plugins

./arvserver
./arvcollector [ip_serveur] PluginMaster

Enfin sur le WR703N je lance un collecteur lisant le port série

./arvcollector [ip_serveur] DropWarner /dev/ttyACM0 arduinoTP.WarningStation

L’instance DropWarner enverra des messages au serveur quand la valeur du capteur descendra en dessous de 1000. Le serveur va relayer à tous les autres collecteurs, dont PluginMaster qui a été configuré pour tracer dans le fichier warning.csv.

Application du capteur

Pour tester en situation j’ai mis le capteur cette nuit sous ma chaudière (qui depuis une semaine à une fuite une ou deux fois pas jour et dont on ne connait pas la provenance ). Cela m’a permis de détecter que la fuite a eu lieu à 2h34 du matin, au moment où tout le monde était assoupi dans la maison … surement la faute des chats.

Transformation de mouvement … en carton

Bielle Manivelle ... en carton

Bielle Manivelle … en carton

Après avoir réalisé un robot « en carton », j’ai fait un petit montage pour mon fils afin d’illustrer la transformation d’un mouvement de rotation (un servomoteur) en un mouvement linéaire de translation.

Pour ce faire j’ai réalisé une Bielle-manivelle en carton.

Un disque en carton est  accroché sur un servo moteur. (droite de la photo)

Sur ce disque en carton est accroché avec une attache parisienne (un bout de fil électrique rigide ou un trombone fait l’affaire aussi) une tige.

Cette tige propage le mouvement à la pièce qui doit adopter le mouvement de translation (sur la gauche).

J’ai branché le servo moteur en lieu et place d’un de ceux de robocarton. La commande se fait avec le nunchuk. Cela m’a permit de réaliser la vidéo suivante


Bielle Manivelle en action

C’est simple et avec un peu de chance mon fils s’en souviendra dans quelques années ^^

Capteur de pression – DIY

J’ai réalisé une ébauche de détecteur de pression à base de matériel de tous les jours. Attention il s’agit de détecteur si quelque-chose appuie sur le détecteur, pas du poids de la colonne d’air (pression atmosphérique), nos amis anglo-saxon parleraient de Force Sensor, mais en Français je n’ai pas trouvé de terme moins ambiguë.

Pour ce test vous aurez besoin de :

  • papier aluminium
  • feuille de papier
  • ruban adhésif
  • fils de couleurs
  • cutter
  • règle

Prenez une feuille d’aluminium à laquelle vous allez attacher un fil dénudé  (pour ce test je l’ai tout bêtement scotché, pas de soudure pour cette fois).

Prenez une feuille de papier dans laquelle vous allez découper des bandes d’un millimètre de largeur et d’une longueur légerement  inférieure à celle de l’aluminium (pas comme sur les photos).

Scotchez là sous la feuille de papier.

Faites de même de l’autre coté du papier avec une autre feuille d’aluminium, la feuille de papier sera donc prise en sandwitch entre les deux feuille d’aluminium.

Reliez votre ohmmètre entre les deux fils qui doivent être reliés chacun à une des feuilles d’alu. Normalement il ne doit pas y avoir de continuité . Sinon cela veut dire que les fentes dans la feuille de papier sont trop large.

Posez votre main ou un objet d’un certain poids, la feuille d’alu va se déformer, passer à travers le papier et faire contact avec l’autre feuille d’alu.

Ce projet est très imparfait car tout à été fait « au pif », en particulier la taille des fentes dans le papier et le choix de l’épaisseur de papier. Un papier plus épais ou des fentes plus étroites devrait changer la tolérance du système, permettant de le glisser sous un paillasson ou un tapis sans être perturbé par ceux-ci. Cela dit les (patients) lecteurs de ce billet auront peut être le courage de poursuivre l’expérimentation.