Mot-clé - Electronique

Fil des billets - Fil des commentaires

Vendredi, janvier 10 2014

OpenAlarm : Un système d'alarme libre

Après de multiples recherches sur Internet, je m'avoue vaincu : pas moyen de trouver un système d'alarme libre suffisamment avancé et les systèmes propriétaires sont beaucoup trop chères, même d'occasion...

Bien sûr, il reste les systèmes d'alarmes bas de gamme mais que valent t'ils vraiment face à des pros du vol qui connaissent bien les parades...

J'ai donc décidé de développer mon propre système libre, les toutes premières briques ont été posées sur le wiki SystèmeDAlarmeLibre et dans cet article, je vais détailler mes choix.

Cahier des charges

  • Multi-zones sans fil, hors de question de tirer des cables partout, il faudra donc prévoir des capteurs autonomes en énergie et capable de communiquer avec la base par radio
  • Système d'avertissement local sonore et lumineux ainsi qu'un envoi de SMS avec détail sur l'incident (zone, type d’évènement, horodatage)
  • Type de capteurs : Infra rouge (PIR), ouverture (reed switch), vibration, sonore, lumière, fumée, fuite d'eau et pourquoi pas la température et l'humidité
  • Communications sécurisées : Multi-bandes et il ne doit pas être possible de brouiller la bande de fréquences utilisée sans déclencher d'alerte, on ne doit pas pouvoir forger de faux messages de « tout va bien »
  • Alarmes techniques en cas de batterie faible des capteurs autonomes ou perte du signal d'un capteur
  • Watchdog : La centrale doit être capable de se sortir elle même d'un plantage inopiné
  • Autonomie électrique de la centrale : en cas de coupure d'alimentation, elle doit tenir suffisamment longtemps pour avoir le temps de lancer ces alertes
  • Les boitiers des capteurs et de la centrale devront être autant que possible réalisables grâce aux outils d'un fablab (impression 3d, découpe laser, etc...)

Choix techniques

Centrale

La centrale devra donc gérer la communication avec les capteurs, être capable de déclencher des alertes en rapport avec l'incident reporté (effraction supposée : signal sonore et lumineux, envoi de SMS), gérer l'interface utilisateur par le biais d'un serveur web embarqué et d'un clavier déporté.

Le coeur

Le coeur du système sera un RaspberryPi, tout simplement car je connais bien cette carte, elle est peu onéreuse et ces capacités seront largement suffisantes pour ce qu'on va lui demander de faire... La faible consommation du RaspberryPi facilitera son alimentation en cas de perte de la tension du secteur.

Raspberry_Pi_-_Model_A.jpg

En terme de logiciel, Python sera employé et le système sera donc adaptable à toute carte ou PC...

python.png

La communication

La communication avec les capteurs sera effectuée à l'aide d'un nRF905 (http://www.nordicsemi.com/eng/Products/Sub-1-GHz-RF/nRF905), un circuit intégré spécialisé ayant la particularité de pouvoir émettre au choix sur 3 bandes (433, 868 et 915MHz), d'avoir une très faible consommation et d'être très simple à mettre en oeuvre.

Le module GSM pour l'envoi de SMS sera un SIM900.

nrf905.jpg sim900.jpg

Module capteurs

Une des partie les plus critiques du système est la capture des événements par le biais de capteurs (infra-rouge, etc...), ces modules doivent être totalement autonome, alimenté par batterie, voici les parties communes :

  • La partie radio basé sur un nRF905
  • Le coeur : Un Avr (tinyAvr) d'Atmel se chargera de lire l'état du capteur, de communiquer avec la base, de vérifier l'état de la batterie
  • Des entrées / sorties pour y brancher le ou les capteurs
  • Une batterie

L'autonomie étant critique, l'AVR pourra se mettre en veille et en sortir soit au bout d'un temps déterminé pour vérifier l'état du capteur et avertir la base que tout va bien (ou que tout va mal), ou il pourra également sortir de veille par le biais d'un changement d'état du capteur.

Je pense faire une carte électronique générique pour tous les capteurs afin de gagner en coût et en facilité.

La suite

Dans un premier temps, je veux m'assurer de la bonne portée pratique des modules radios ainsi que de leur consommation car il s'agit DES parties critiques du système.

Ayant d'autres projets sur le feu (dont certain qui trainent depuis bien trop longtemps), j'essaierai d'avancer sur OpenAlarm au mieux...En attendant, j'attends vos retours / avis / conseils / idées, etc...

Un dépôt GitHub OpenAlarm à été ouvert oû je mettrai toutes les informations utiles au développement, le wiki sur GitHub sera aussi tenu à jour.

Mercredi, décembre 11 2013

RaspberryPi + Grove = RaspiO'Mix

RaspiO'Mix est une carte fille pour Raspberry Pi développée par mes soins sur une idée de Michel d'Erasme qui va vous permettre de connecter facilement et rapidement tout un tas de modules de type Grove initialement prévus pour Arduino.

Caractéristiques

  • Aux dimensions du RaspberryPi
  • 4 entrées / sorties tolérantes 5V (basée sur un TXS0108PWR)
  • 4 entrées analogiques, 0-5V, 18 bits de résolution
  • 2 entrées numériques via DIP switch
  • Horloge temps réel avec batterie de sauvegarde
  • 2 connecteurs pour I2C
  • 1 connecteur pour communication série
  • Alimentation 5V via jack

Connecteurs

Bien entendu, cette carte est entièrement libre, toutes les informations nécessaires pour la fabriquer sont disponibles sur GitHub / RaspiO'Mix.

Fonctionnement

Voici le schéma de principe :
schema.png

La conversion analogique / numérique est assurée par un MCP3424, un CAN I2C de 18 bits de résolution, une horloge temps réel DS1307 est présente sur le même bus.

Une librairie Python est disponible et vous permet d'accéder simplement aux différentes fonctions d'entrées / sorties, I2C, série et ainsi d'intéragir avec un monde 5V bien au chaud dans l'environnement 3V3 du RaspberryPi...

La carte en action

Je veux mon propre RaspiO'Mix

2 solutions s'offre alors à vous :
  1. DIY : Tout est à votre disposition pour le faire vous même, sur GitHub, vous trouverez la liste des composants, des informations techniques, les fichiers Eagle, les fichier gerber, bref, TOUT est disponible pour le faire vous même !
  2. Je peux vous les fabriquer, pour le moment, je n'ai pas de magasin en ligne donc, contactez moi directement pour un devis (je suis en mesure de produire des séries et de faire des réductions sur quantité)

Samedi, août 10 2013

Cordon coupé sur une alimentation de portable

Sur un portable récupéré récemment, le cordon de l’alimentation est coupé juste à la sortie du boitier. Juste un bout de cordon à raccourcir et 2 soudures à faire… Sauf que le boitier est collé et il n’est pas prévu pour être ouvert !

La Dremel vient à la rescousse pour ouvrir la boite à l’aide d’un disque de découpe. Il faut y aller doucement, il y a la carte électronique pas loin.

DREMEL

DREMEL

 

Environ 2mm de profondeur sont suffisants. Ensuite, un gros tournevis dans un coin pour faire levier et les derniers points d’attache cèdent.

Boitier ouvert

Boitier ouvert

C’est un peu barbare mais au moins le boitier est ouvert. Ensuite rien de compliqué, on dessoude le cordon, on le coupe de quelques centimètres et on ressoude.

Cordon remplacé

Cordon remplacé

 

Ensuite pour refermer la boite correctement ( il ne faudrait pas qu’elle s’ouvre lors d’une chute par exemple ) elle va être collée à l’époxy. Encore une utilisation possible de la colle Epoxy JB-WELD.

Collage

Collage

Une fois collée, les 2 parties sont maintenues en place par 3 presses en C, le temps du séchage qui peut prendre une bonne dizaine d’heures.

 

ça sèche

ça sèche

 

Une fois la colle sèche, l’excès d’Epoxy sera poncé.

Après ponçage

Après ponçage

Samedi, avril 13 2013

Premiers pas avec le pcDuino

Si vous êtes un peu au courant de tout ce qui se passe dans le monde du DIY, vous avez peut-être entendu parler du pcDuino, concurrent direct du RaspberryPi. Certes, il n’a pas bénéficié du même effet d’annonce, mais pourtant il le mérite au moins autant. En effet, c’est une incroyable petite bestiole qui pousse le concept de mini-ordinateur hackable à souhait bien plus loin encore que le RasPi…

Trêve de bla-bla, voyons un peu à quoi ressemble l’engin:

featured-image

Au programme:

  • CPU: Cortex A8 cadencé à 1GHz
  • GPU: OpenGL ES2.0, OpenVG 1.1 Mali 400 core
  • 1Go de RAM
  • Ports: HDMI, Ethernet, 3 ports USB
  • Slot micro-SD (pour le stockage)

Déjà là, on sent bien que le Raspberry Pi a du souci à se faire! CPU beaucoup plus puissant, 1Go de RAM contre 256/512Mo…Mais attendez, ce n’est que le début!

La carte embarque une mémoire flash NAND de 2Go. Ca semble con comme ça, mais l’intérêt est avant tout d’y loger le système d’exploitation. Et oui, là où le Raspi charge l’OS en RAM à partir d’une carte SD, le pdDuino utilise une mémoire flash. Et là, croyez-moi, ça dépote. A titre d’info, le pcDuino effectue un reboot complet en 45 secondes. D’ailleurs, parlons-en de l’OS…

Le pcDuino est livré avec Ubuntu 12.10, mais il est possible d’y installer un Android Ice Cream Sandwich. Oui, vous avez bien lu. Ubuntu et Android. Je vous laisse imaginer la suite!

Bon, on est pas mal là quand même! Et si je vous dit que ce n’est pas fini? Si je vous dis en plus que le pcDuino est compatible avec la plupart des shields Arduino?

Elle est pas belle la vie?

Le pcDuino dispose en effet des quatres séries de pins d’un Arduino standard: les analog, les PWM, les TX/RX…et ça, c’est vraiment cool.

Maintenant, passons au travaux pratiques!

Première prise en main

Pour lancer la bestiole, rien de plus simple: clavier, souris, écran sur le HDMI, Ethernet, alimentation. Quelques secondes plus tard, tadaaaaa:

2013-04-05-180149_1280x720_scrot

Petit test de Chrome:

2013-04-05-180809_1280x720_scrot

Bon, visiblement ça fonctionne! Maintenant, il s’agit de configurer tout ce petit monde!

Configurer le clavier

Parce que le QWERTY ça va 5 minutes:

sudo dpkg-reconfigure keyboard-configuration

Si nécessaire, rebootez:

sudo reboot

Configurer SSH

Oui, ça peut aider, non? Cette partie est un basée sur cet article.

Tout d’abord, on se créé un utilisateur qu’on ajoute de suite au groupe admin, histoire d’avoir les droits qui vont bien et de pouvoir faire du sudo avec ce compte:

sudo su
adduser deabdird
puis:
adduser deadbird admin
Ensuite, récupérez votre adresse IP:
ifconfig
Installez le package SSH:
apt-get install ssh
Puis nano, un éditeur de texte en ligne de commande:
apt-get install nano
Le but est d’éditer un peu la conf de SSH pour le sécuriser un tout petit peu plus. Modifiez la ligne suivante:
PermitRootLogin yes
en
PermitRootLogin no
et ajoutez celle-ci:
AllowUsers deadbird

Ces changements permettent de n’autoriser que l’user que vous avez créé à se logger en SSH. Maintenant, rebootez et testez avec une autre machine.

Changer la résolution

Si comme moi vous brancher votre pcDuino sur un écran d’ordi avec un adapteur HDMI vers VGA, vous devriez avoir une résolution moisie. Mon but: avoir du 1280*1024. Changer la résolution d’affichage n’est pas une partie de plaisir, mais voici la manip, tirée du site the greathouses:

Tout d’abord, installez git, libusb et pkg-config:

sudo apt-get install git libusb-1.0.0-dev pkg-config

Ensuite, nous allons récupérer et compiler les sources de sunxi-tools, un programme permettant d’éditer le fichier evb.bin, où se trouve la configuration de l’affichage.

git clone https://github.com/linux-sunxi/sunxi-tools

cd sunxi-tools

make

Maintenant, il va nous falloir accéder à evb.bin, qui est stocké dans la partition de boot, plus précisément dans la mémoire flash de la carte:

sudo mount /dev/nanda /boot

Maintenant, vous avez accès à evb.bin:

ls /boot

Avant de modifier le fichier, faites-en une copie:

sudo cp /boot/evb.bin /boot/evb.bin.bak

Ensuite, décompilez le fichier evb.bin et faites-en un fichier:

./bin2fex /boot/evb.bin >evb.conf

Ouvrez-le avec nano.

Attention à ce que vous touchez dans ce fichier, il y a là de quoi cramer votre pcDuino!

A ce propos, di vous voulez vraiment mettre les mains dans le cambouis, allez donc voir le FEX Guide ici, vous y trouverez de quoi charcuter l’evb.bin. Mais encore une fois, attention…

Cherchez une section nommée “disp_init” (utilisez Ctrl+W pour chercher avec nano). Elle devrait ressembler à ceci:

[disp_init]
disp_init_enable = 1
disp_mode = 0
screen0_output_type = 3
screen0_output_mode = 5
screen1_output_type = 3
screen1_output_mode = 9
fb0_framebuffer_num = 2
fb0_format = 10
fb0_pixel_sequence = 0
fb0_scaler_mode_enable = 1
fb1_framebuffer_num = 2
fb1_format = 10
fb1_pixel_sequence = 0
fb1_scaler_mode_enable = 0

Modifiez la valeur de la variable “screen0_output_mode”:

HDMI Mode Resolution
0 480i
1 576i
2 480p
3 576p
4 720p50
5 720p60 (default)
6 1080i50
7 1080i60
8 1080p24
9 1080p50
10 1080p60
11 PAL
12 PAL_SVIDEO
14 NTSC
15 NTSC_SVIDEO
17 PAL_M
18 PAL_M_SVIDEO
19 PAL_NC
21 PAL_NC_SVIDEO
23 1080p24-3D
24 720p50-3D
25 720p60-3D
26 1360×768-60
27 1280×1024-60

Une fois les modifs enregistrées, transformez le fichier en un nouvel evb.bin:

sudo ./fex2bin evb.conf /boot/evb.bin

puis démontez la partition:

umount /boot

et redémarrez:

sudo reboot

Et là…croisez les doigts. Si ca ne fonctionne pas, recommencez la manip inverse ou restaurez l’evb.bin que vouz avez sauvegardé. Essayez d’autres résolutions jusqu’à tomber sur quelque chose de bien.

Dimanche, mars 3 2013

Réparation de la carte vidéo d’un portable Samsung Q45

Après avoir rendu de bon et loyaux services pendant quelques années, j’ai un portable Q45 qui a une panne d’affichage vidéo des plus ennuyeuse: Pas de vidéo du tout ou alors un affichage rayé de lignes violettes.

Symptômes

Symptômes

 

Souvent dans ce cas, il s’agit d’une ou plusieurs soudures défectueuses sur le chipset vidéo. Malheureusement, ce sont des composants BGA dont les soudures sont sous le corps et non sur les côtés.

BGA Chipset

BGA Chipset

 

Elles sont donc inaccessibles aux fers à souder classiques ! Il faut utiliser des technique à air chaud pour arriver à réparer ce type de problème.

Ce type de composant contrairement à ce que l’on pourrait penser résiste bien aux hautes températures (250°C) à condition de bien respecter le cycle de chauffe.

Il faut comme indiqué sur wikipédia,   suivre une montée en température progressive avec un préchauffage autour de 150°C.

 

Cycle de chauffe

Cycle de chauffe

 

Dans la vidéo qui suit, j’ai utilisé une station de soudure aoyue 906+ ( Du matériel chinois mais suffisant pour l’amateur à un prix dérisoire… )

Station de soudure

Station de soudure

 

Pour le reste, du bon DIY avec un cache en papier d’aluminium pour protéger de la chaleur et du souffle de la buse les composants avoisinant. Un multimètre avec sonde de T° est aussi utilisé pour contrôler la montée en température.

Cache

Cache

 

L’opération #screensaver en vidéo

Et le résultat, pas si mal :-)

Bingo !

Bingo !

Elle n'est pas belle ma Debian ?

Elle n’est pas belle ma Debian ?

 

L’opération qui au premier abord peut paraître compliquée est en réalité assez simple ! Et un portable qui va éviter la benne…

 

 

 

Dimanche, février 24 2013

Pédale égaliseur graphique à base d’arduino et de MSGEQ7



Le projet d’aujourd’hui consiste, comme le  titre de l’article l’indique, en la réalisation d’une pédale égaliseur graphique à base d’Arduino. Dans ce qui va suivre, je vais vous expliquer comment utiliser le MSGEQ7 (un égaliseur 7 bandes), afficher le résultat sur un écran LCD et, cerise sur le gâteau, comment faire votre propre shield Arduino maison.

Etape 1: le MSGEQ7.

Je rentre direct dans le vif du sujet, je vais vous montrer comment fonctionne ce merveilleux petit circuit. Tout d’abord, où le trouver. Si vous résidez en France, je vous conseille hobbyelectro de l’ami Furrtek. Rapide et pas cher. Sinon, le MSGEQ7 est aussi dispo chez Sparkfun (trois fois plus cher, mais bon…).

Une fois que vous avez votre puce en main, il suffit de chercher la datasheet pour trouver le pinout:Screen Shot 2013-02-24 at 6.06.08 PM

mais aussi et surtout le schéma de câblage:

Screen Shot 2013-02-24 at 6.07.40 PMBon, ça fait peur comme ça, mais en cherchant un peu sur le net j’ai trouvé une version plus facile à comprendre:

schem1-450x600

J’ai utilisé ce schéma que j’ai câblé sur une breadboard, et ça donne ça:

IMG_2585

Les plus tâtillons d’entre vous aurons remarqué que j’ai utilisé 3 condos de 100pf en série pour faire un condo de 33pf, de même que deux résistances de 100kohms pour faire une de 200. J’ai beau avoir des milliers de résistances, j’en ai pas une seule de 200kohms…

Maintenant, la partie logicielle…

Etape 2: le code

Nous avons 3 pins à utiliser:

  • STROBE, connectée à la pin Digital 2 sur l’arduino,
  • RESET, connectée à la pin Digital 3,
  • OUT, connectée à la pin Analog 0.

Vous pouvez utiliser les pins que vous voulez, le MSGEQ7 n’utilise pas d’interrupt, pas d’I2C, pas de SPI, rien de spécial. Chaque patte a une utilisation particulière, comme l’explique le chronogramme de la datasheet:

Screen Shot 2013-02-24 at 9.28.00 PM

Là vous vous dites: “ohlàlà, mais qu’est-ce qu’il nous gonfle avec tous ces détails?”…le MSGEQ7 est une puce relativement simple à comprendre, autant se pencher un peu sur la théorie!

Ce que nous dit ce chronogramme:

  1. la puce crache les valeurs de chaque fréquence (il y en a 7 différentes, d’où le “7″ de “MSGEQ7″) sur OUT.
  2. pour cela, il faut effectuer un reset de la puce avant chaque lecture. pour cela, il faut passer la patte RESET à haut puis à bas.
  3. ensuite, il faut passer la pin STROBE à bas
  4. attendre 36 microsecondes, que la puce crache la valeur sur OUT
  5. passer STROBE à haut.
  6. recommencer à l’étape 3

En termes d’arduino, voici ce que cela donne:

const int ANALOG = 0;
const int STROBE = 4;
const int RESET = 5;
int outputValues[7];

void setup(void) {
  //setup MSGEQ7
  pinMode(ANALOG, INPUT);
  pinMode(STROBE, OUTPUT);
  pinMode(RESET, OUTPUT);

  analogReference(DEFAULT);

  digitalWrite(RESET, LOW);
  digitalWrite(STROBE, HIGH);

}

void loop(void) {
  //reset chip
  digitalWrite(RESET, HIGH);
  digitalWrite(RESET, LOW);

  for (int i = 0; i < 7; i++) {
    digitalWrite(STROBE, LOW);
    delayMicroseconds(30);
    outputValues[i] = analogRead(ANALOG);
    digitalWrite(STROBE, HIGH);
  }
}

Ok, c’est bien tout ça, mais comme savoir si ça fonctionne? Simple: ajoutez un Serial.begin(9600) dans le setup et quelques Serial.print dans le loop pour afficher les valeurs sur le serial monitor et hop, c’est gagné! Et là vous vous rendrez certainement compte que le MSGEQ7 est une véritable perle: donnez lui du son et il fera le reste! Je l’ai utilisé avec une basse possédant un gros niveau de sortie et avec la carte son de mon iMac, il réagit aussi bien avec l’un qu’avec l’autre. Bon maintenant, il s’agirait peut-être d’afficher les valeurs autrement, non?

Etape 3: l’écran LCD

Les écrans LCD pour arduino, c’est pas ce qu’il y a de plus difficile à trouver. On en trouve une tétrachiée chez Sparkfun par exemple…mais si on veut quelque chose de sympa et pas cher, il faut creuser un peu plus. En ce qui me concerne, eBay m’a encore une fois sauvé la vie.

Petit aparté.

Je tiens à remercier du fond du coeur nos amis les chinois sans qui ce qui va suivre aurait couté un bras, un oeil et un rein. Merci à tous les chinois qui vendent des trucs complètement dingues sur eBay à des prix ahurissants, le tout avec frais de ports offerts. Je vous aime les mecs, sincèrement.

Voilà, tout ça pour dire que j’ai déniché sur eBay cette petite perle:

IMG_2618

Les specs: 128*64 pixels bleus, rétro éclairé, le tout pour 7€, alors qu’un modèle équivalent peut valoir jusqu’à 30$ chez adafruit ou sparkfun.  Mais le top, c’est qu’il est utilisable en mode parallèle et en série! Là tout de suite, c’est beaucoup plus intéressant! En parallèle on a facilement besoin de 15 pins, et donc d’un arduino Mega…En mode série, 8 pins suffisent!

Le câblage est le suivant pour un arduino uno ou équivalent:

  • pin 10 (SS) vers RS
  • pin 11 (MOSI) vers R/W
  • pin 12 (MISO) vers E
  • +5V vers VDD et BLA (BLA c’est l’anode du rétro éclairage)
  • GND vers VSS, PSB (PSB à 0 = mode série) et BLK (cathode du rétro éclairage).

Simple, non? Ben non, parce que la partie logicielle se corse un peu. Pour afficher quoi que ce soit sur ce LCD, vous aurez besoin d’une librairie, dispo ici: http://code.google.com/p/u8glib/ . Autre astuce: pour cet écran, le constructeur à utiliser est “U8GLIB_ST7920_128X64 u8g(12, 11, 10, U8G_PIN_NONE);”. Pour le reste, à savoir comment dessiner sur l’écran, regardez la doc de la librairie. En attendant, voici le code de l’égaliseur:

#include "U8glib.h"

U8GLIB_ST7920_128X64 u8g(12, 11, 10, U8G_PIN_NONE);

const int ANALOG = 0;
const int STROBE = 4;
const int RESET = 5;
const int outputValues[7];

void drawMediumBars(void) {
  for (int i = 0; i < 7; i++) {
    u8g.drawBox(5+18*i, 64-(outputValues[i]/16), 10, outputValues[i]/16);
  }
}

void setup(void) {
  //setup MSGEQ7
  pinMode(ANALOG, INPUT);
  pinMode(STROBE, OUTPUT);
  pinMode(RESET, OUTPUT);
  analogReference(DEFAULT);
  digitalWrite(RESET, LOW);
  digitalWrite(STROBE, HIGH);
}

void loop(void) {
  u8g.firstPage();  
  do {
    //reset chip
    digitalWrite(RESET, HIGH);
    digitalWrite(RESET, LOW);

    for (int i = 0; i < 7; i++) {
      digitalWrite(STROBE, LOW);
      delayMicroseconds(30); // to allow the output to settle
      outputValues[i] = analogRead(ANALOG);
      digitalWrite(STROBE, HIGH);
    }

    //draw values
    drawMediumBars();
  } while(u8g.nextPage());
}

Avec ça, vous devriez afficher de jolies barres sur l’écran, quelque chose de ce style:

IMG_2597

Sympa, non? Mais bon, un seul design, ca craint, si seulement on pouvait en changer à la volée…

Etape 4: les boutons et les interruptions

Tout d’abord, kesséssé une interruption? C’est tout simplement un bout de code qui est lié à une évènement matériel: le passage d’une pin de l’état haut à l’état bas par exemple. Quand l’évènement se déclenche, le code est exécuté. Le but de ce qui va suivre est de modifier la routine qui dessine les barres grâce à une interruption.

Voici le code avec les modifications:

#include "U8glib.h"

U8GLIB_ST7920_128X64 u8g(12, 11, 10, U8G_PIN_NONE);

const int ANALOG = 0;
const int STROBE = 4;
const int RESET = 5;
int outputValues[7];

const int BT1 = 0;
const int DEBOUNCE_DELAY = 200;

uint8_t mode = 0;
uint8_t nModes = 3;

void drawJointFatBars(void) {
  for (int i = 0; i < 7; i++) {
    u8g.drawBox(1+18*i, 64-(outputValues[i]/16), 18, outputValues[i]/16);
  }
}

void drawMediumBars(void) {
  for (int i = 0; i < 7; i++) {
    u8g.drawBox(5+18*i, 64-(outputValues[i]/16), 10, outputValues[i]/16);
  }
}

void drawTopLine(void) {
  for (int i = 0; i < 6; i++) {
    u8g.drawLine(10+18*i, 64-(outputValues[i]/16), 10+18*(i+1), 64-(outputValues[i+1]/16));
  }
}

void setup(void) {
  //setup MSGEQ7
  pinMode(ANALOG, INPUT);
  pinMode(STROBE, OUTPUT);
  pinMode(RESET, OUTPUT);
  analogReference(DEFAULT);
  digitalWrite(RESET, LOW);
  digitalWrite(STROBE, HIGH);

  //change mode button
  attachInterrupt(BT1, button1, FALLING);
}

void loop(void) {
  u8g.firstPage();  
  do {
    //reset chip
    digitalWrite(RESET, HIGH);
    digitalWrite(RESET, LOW);

    for (int i = 0; i < 7; i++) {
      digitalWrite(STROBE, LOW);
      delayMicroseconds(30); // to allow the output to settle
      outputValues[i] = analogRead(ANALOG);
      digitalWrite(STROBE, HIGH);
    }

    //draw values
    if (mode == 0) drawJointFatBars();
    else if (mode == 1) drawMediumBars();
    else if (mode == 2) drawTopLine();

  } while(u8g.nextPage());
}

void button1() {
  static unsigned long last_interrupt_time = 0;
  unsigned long interrupt_time = millis();
  // If interrupts come faster than 200ms, assume it's a bounce and ignore
  if (interrupt_time - last_interrupt_time > DEBOUNCE_DELAY) {
    last_interrupt_time = interrupt_time;

    //interrupt code
    if (mode == (nModes-1)) mode = 0;
    else mode++;

  }
}

La fonction “attachInterupt” relie une fonction (ici button1) à  un évènement (FALLING = passage de l’état haut à l’état bas) sur une interruption donnée (ici l’interruption 0, laquelle correspond à la pin DIGITAL 2).

En ce qui concerne le corps de la fonction button1, j’utilise une variable pour mesurer le temps entre deux appels à la fonction. Pourquoi? Parce que les boutons poussoirs ne sont pas parfaits et peuvent déclencher deux fois l’interruption lors d’un seul appui, faute à la mécanique. En ce qui me concerne, le délai minimum entre deux appuis est de 200ms.

Pour câbler l’interruption, voici le schéma:

IMG_2619

Simple, non?

Au final, vous devez obtenir ceci:

IMG_2599

Etape 5: transformer un prototype en shield

Quelle satisfaction de transformer un projet qui fonctionne en un produit fini! Et là, on a un montage qui ne demande qu’à être transformé en shield arduino. Pour les shields vierges, allez donc faire un tour chez l’ami semageek.

Un seul conseil: placez vos composants, soudez une fois que vous êtes sûrs. Voici à quoi ressemble le mien:

IMG_2603

IMG_2607

IMG_2606

Etape 6: la mise en boîte.

Pour mettre ma pédale en boite, je voulais un boîtier petit, super costaud, transparent. J’ai donc utilisé une otterbox que j’avais chopé dans un PX sur une base militaire US. Ces boîtiers sont géniaux. Vous en trouverez chez adafruit.

Pour la découpe en rectangle dans le boitier, voici ma méthode pour faire un rectangle bien propre. C’est aussi valable pour du métal ou du bois:

  • faites le tracé de votre découpe.
  • réalisez une découpe grossière. tous les moyens sont bons: dremel, scie à métaux…le tout c’est de ne pas trop s’approcher du contour final.
  • finissez les bords à la lime fine et plate.

De cette façon vous pourrez faires des découpes très propres et très droites à travers à peu près n’importe quel matériau:

IMG_2621

Par exemple, mon boitier:

IMG_2613

IMG_2612

Pour attacher l’arduino au fond du boîtier, j’ai utilisé un pistolet à colle:

IMG_2620

Une bande de velcro plus tard, et hop:

IMG_2617

Mardi, février 12 2013

Réparation d’un écran LCD Samtron 94v – Mode non optimal

Certains écrans LCD SAMSUNG / SAMTRON sont connus pour avoir des problèmes après quelques années de fonctionnement. J’ai récupéré un écran SAMTRON 94 H.S qui a des symptômes plutôt étranges. Pour une fois, nous n’avons pas affaire aux classiques condensateurs secs. L’écran s’allume mais ne veut rien afficher d’autre que le message « Mode non optimal ».

Mode non optimal

Mode non optimal

A priori, il devrait donc s’agir non pas de la carte d’alimentation mais plutôt de la carte logique. Quelques recherches à coup d’oscillo et de multimètre ne donnent rien de bon.  Sans disposer du datasheet du microcontroleur NT68F63LG ni du manuel de service de l’écran, difficile d’aller plus loin avec mes connaissances.

L'électronique

Je me rabat donc sur Internet :) J’ai trouvé au fin fond d’un forum une personne qui discutait d’une panne sur un modèle similaire. Le pin 6 du NT68F63LG doit être alimenté entre 3.3v et 5v hors lorsque le problème se produit, il ne reçoit plus que 2v. Placer une résistance d’environ 50 ohms entre les pins 5 et 6 permettent de « remonter » le voltage à 4v et de régler le problème !

Fix

Voilà un fix qui coûte quelques centimes et qui prend une trentaine de minutes. Pensez-y si vous avez un écran Samsung  / Samtron qui présente les mêmes symptômes. Moi je viens de sauver un 19″ pour quelques centimes :)

Sauvé !

Mercredi, décembre 19 2012

Support DIY pour caméra USB de chez Adafruit

Adafruit vend une petite webcam USB à utiliser comme outil d’inspection pour vérifier ses soudures, lire les inscriptions sur les composants, ou s’amuser avec les enfants… C’est une sorte de microscope USB low cost mais qui donne néanmoins de très bon résultats, pour peu que l’on arrive à faire la mise au point correctement. En effet, celle-ci est manuelle et dépend de la distance lentille / objet et du niveau de grossissement. Une fois le grossissement choisit, il faut approcher / éloigner le microscope pour avoir une image nette. Avec le support de base, c’est quasiment impossible de maintenir une image stable.

Microscope

Microscope

 

D’où l’idée de construire un support réglable !

Les pièces sont modélisées avec openscad puis imprimées sur mon imprimante 3D.

Support modélisé

Support modélisé

 

Fixation basse

Fixation basse

Plaque de contreplaqué 3mm

Plaque de contreplaqué 3mm

Coulisseau réglable

Coulisseau réglable

Coulisseau réglable

Coulisseau réglable

Bras de support

Bras de support

Vis de réglage

Vis de réglage

Fixation sur le support en bois

Fixation sur le support en bois

Réglage de hauteur

Réglage de hauteur

Support

Support

Molette de réglage

Molette de réglage

Molette de réglage

Molette de réglage

 

Les supports hauts et bas sont collés à l’epoxy ( JB weld, quel produit miracle :)

Tests :)

Tests :)

 

L’ensemble des fichiers pour reproduire les pièce est disponible sur Thingiverse.

 

et voici pour finir ce bref article des images à divers niveaux de grossissement.

 

Capteur d'humidité x200

Capteur d’humidité x200

Capteur d'humidité x10

Capteur d’humidité x10

 

Pour l’électronique, le grossissement x10 à x20 est largement suffisant. Au delà, c’est plus pour explorer l’infiniment petit ;)

 

P.S: vous avez vu, mes impressions sont quand même meilleurs qu’avant ! J’ai augmenté la température de l’extrusion de 185° à 220° ! Depuis fini les buses bouchées ou les bulles en cours d’impression.

 

- page 1 de 11