Mot-clé - projet - DIY Planet : Made in Fr

Mot-clé - projet

Fabien B.

Samedi, avril 13 2013

[Réparation] Et la lumière fut

Par Fabien B. le Samedi, avril 13 2013, 18:36 - Planet

Bonjour tout le monde !

Il y a quelques temps (une grosse semaine environ) ma "lampe loupe" d’atelier a rendu l’âme.
Bien sûr, comme il s’agit de ma lampe il a fallu que celle-ci crame de manière spectaculaire.
Juste s’éteindre sans se rallumer c’était trop lui en demander …

Du coup sans que je ne m’y attende le néon ET le starter (quitte à faire) ont explosé dans un ultime flash lumineux.

Comme certains diront que j’exagère un peu voici à quoi ressemble désormais le néon :

L’étincelle (si on peut vraiment appeler ça une étincelle) a fait fondre le support en fer + plastique qui est maintenant complétement collé au verre du néon …

Et le starter ?
Ce truc made in chinois de mauvaise qualité ?

Et bien lui aussi a décidé d’avoir une fin grandiose …

Résistance cramée x1

Résistance cramée x2 (juste derrière la broche centrale du transistor de puissance)

Et bonus fusible fondu !
(Il servait franchement à rien ce fusible de 1A. Il a largement eu le temps de laisser tout le circuit cramer avant de fondre …)

–

Réparation

Une fois la fumée et l’infâme odeur de plastique brulé dissipée j’ai tenté de réparer le starter.
Pour le néon … pas trop le choix je suis allé en acheter un neuf dans un magasin de bricolage.

J’ai donc testé le circuit : diodes ok, transistors ok, condo ok et bobinage ok.
En gros deux résistances de 11 et 13 ohms à remplacer … facile !

–

Le test

Pour pouvoir tester ma réparation j’ai fait un truc HYPER DANGEREUX, que seul un abruti comme moi avec un Qi proche de celui d’un concombre de mer pourrait imaginer.
NE FAITE PAS ÇA CHEZ VOUS – non sérieux c’est dangereux !

En gros j’ai branché deux grippes-fils dans une prise, elle même reliée au 220v du secteur pour alimenter manuellement le circuit.
C’est l’idée de merde par excellence mais j’avais pas mieux sur le moment.

Et le résultat ?
Je vous laisse juger par vous même :

Manifestement il y a eu comme un "petit" problème

–

La solution

Si j’ai décidé de faire un article sur ce fail monumental c’est que j’avais un truc à vous montrer

La solution à mon problème de starter m’as été donné par NETeagle sur twitter :

@skywodd Tu peux le remplacer en récupérant un starter de puissance équivalente sur des lampes à économie d’énergie

— NETeagle (@t4nk8) 7 avril 2013

(désolé amis tweetos je ne peux pas inclure le jolie widget twitter sur mon wordpress)

Sur le coup j’étais un peu septique mais en fait c’est THE solution !

L’astuce consiste à prendre le starter d’une lampe néon à économie d’énergie.
Comme souvent le néon crame avant le starter (sauf chez moi bien sûr) on peut récupérer un starter dans une lampe HS de même puissance que la lampe qu’on veut sauver.

Ça demande une scie et un peu de patience mais le résultat est là.

J’ai démonté deux lampes HS de respectivement 10 et 12 watts.
Le circuit est similaire, pour ne pas dire identique, à celui de mon starter.

En cherchant sur le net j’ai même trouvé le schéma "type" de ce genre de starter électronique.
En fait c’est tout bête, le circuit est composé de 4 parties :
- un pont de diode pour redresser le 220v alternatif + un gros condensateur de lissage
- un auto-oscillateur à self
- un hacheur de tension réalisé avec deux gros transistors (bipolaires) de puissance
- un transformateur pour générer la haute tension qui alimente le néon

Si j’avais le temps j’aurai presque pu faire mon propre starter … mais bon c’est pas mon but.

Pour tester j’ai câblé le starter de 12W sur mon néon de 22W.
Celui-ci s’est allumé sans problème mais pas à pleine puissance (ce qui est assez logique avec un starter de seulement 12W), qu’importe cela prouve bien que le principe marche.

Du coup je suis allé acheter une lampe à économie d’énergie de 23W, cout total : un peu moins de 6€ !
Comparé aux 40€ d’une lampe neuve c’est une réelle économie d’argent

(montage définitif avec le starter de la lampe de 23w)

Remarque : le starter "hacké" est 2 voire 3 fois plus petit que celui de base … comme quoi la taille ne compte pas

–

Conclusion

Si vous avez une "lampe loupe" et des lampes à économie d’énergie HS (de même puissance) ne les jetez pas !
Gardez de côté le starter il vous sera peut être utile par la suite

Bon WE et bon bidouillage à tous !

Classé dans:Corrigé, projet Tagged: hack, madeinfr

aucun rétrolien

Fabien B.

Dimanche, mars 10 2013

[DIY] Dév-board pour CPU Propeller de Parallax

Par Fabien B. le Dimanche, mars 10 2013, 17:38 - Planet

Bonjour tout le monde !

Il y a de cela quelques temps j’ai acheté pour quelque chose comme 8€ un micro-contrôleur "Propeller" de Parallax : le P8X32A.

Le P8X32A est un micro-contrôleur 32 bits multi-cœurs (8 cœurs au total !) pouvant tourner à un maximum de 80MHz.
Comme il est vendu en version CMS et DIP (utilisable sur une breadboard comme sur la photo) je me suis permis une petite folie et j’en ai pris un au détour d’une commande de composants.

Les informations détaillées sur le micro-contrôleur sont disponible ici :
http://www.parallax.com/tabid/768/ProductID/334/Default.aspx

Les cartes de démo et autre "starter kit" pour le P8X32A coutent entre 25€ et 75€ … c’est bien cher pour un morceau de pcb, un P8X32A et une EEPROM I2C !
J’ai donc décidé de faire ma propre "mini dév board" DIY histoire de tester un peu les possibilités du CPU propeller.

–

Le schéma :

J’ai bêtement suivi la documentation du fabricant.

Le schéma se résume à 5 grandes parties :
- une alimentation 3v3 régulée
- un bouton de reset
- un quartz
- une EEPROM I2C
- un P8X32A et des connecteurs

Remarque : la broche 3v3 du connecteur J2 est volontairement laissé non-câblé.
Je me suis rendu compte après coup que cela poserait des problèmes d’avoir une broche d’alim juste à coté d’une sortie …

Voici le typon avec les différentes pistes :

Remarque : j’étais parti pour monter un régulateur 3v3 avec le même brochage qu’un LM7805, pas de bol le régulateur que j’avais n’avait pas tout à fait le même brochage.
Du coup j’ai dû faire un peu de bricolage pour inverser deux broches de celui ci.

–

Le résultat final :

Sur la droite la partie alimentation, sur la gauche la partie mémoire + port série, au centre le P8X32A en boitier DIP.

J’ai caché en dessous du micro-contrôleur les résistances de tirage du bus I2C de l’EEPROM et le quartz.

A noter que le quartz est remplaçable !
J’ai préféré faire cela car je n’ai pas de quartz de 5MHz (valeur "idéal" pour pouvoir tirer profit des 80MHz maximum du CPU) et je n’avais pas envie de souder / dessouder le quartz "temporaire" de 4MHz (qui ne me permet que d’aller à un maximum de 64MHz).

Comme vous pouvez le voir il y a un joli fil vert pour réparer mon erreur de brochage du régulateur et plein de coups de cutter entre les pistes pour éviter les court-circuits.
Je n’ai pas eu de chance sur ce pcb, j’ai eu plein de petit morceaux de cuivre qui sont restés entre les pistes …

–

Le logiciel :

Parallax fourni un éditeur graphique pour son langage de programmation nommé "spin".
On peut coder avec deux langages sur le micro-contrôleur : en "spin" (une sorte de mix entre BASIC et indentation "à la Python") et en assembleur.
Note: depuis peu il existe aussi un portage de GCC pour le P8X32A mais je n’ai pas essayé pour le moment.

Pour la syntaxe du langage "Spin" (qui est un langage semi-compilé) wikipedia donne les grandes lignes :
http://en.wikipedia.org/wiki/Spin_(programming_language)#Built_in_SPIN_byte_code_interpreter

Avec un peu de mal (ce n’est pas très intuitif comme syntaxe) et beaucoup de recherche sur le net j’ai pu faire un exemple "blink" fonctionnel :

CON
  ledpin = 0

PUB main
dira[ledpin] := 1
repeat
  outa[ledpin] := 1
  waitcnt(clkfreq + cnt)
  outa[ledpin] := 0
  waitcnt(clkfreq + cnt)

(ne me demandez pas d’expliquer comment marche la fonction d’attente j’ai moi même pas vraiment compris …)

Le truc vachement sympa avec le micro-contrôleur Propeller c’est qu’il exécute tout depuis la RAM et uniquement depuis la RAM.
Du coup on peut envoyer son code "pour test" dans la RAM et s’il marche on peut ensuite l’écrire en dure dans l’EEPROM.

Mais cela a un gros, très gros désavantage !
Lors du boot le CPU lit l’EEPROM (s’il y en a une) et copie son contenu en RAM.
Du coup TOUT les programmes quels qu’ils soit ont une limite de taille : 32 Ko, la taille de la RAM dédiée à l’exécution du programme.

C’est pour moi un peu bête d’avoir un cpu surpuissant capable de mettre à genoux n’importe quel ARM mono-cœur et d’avoir une limite aussi contraignante …

Pire on se retrouve à devoir faire un choix dés plus surprenant !
Le code spin compilé est bien plus compact que le code assembleur compilé, se pose donc le dilemme suivant :
- coder en spin en sachant que c’est une langage semi-compilé (donc lent) mais en sachant qu’on disposera de plus de place pour le programme
- coder en pure assembleur qui tourne à la vitesse du CPU mais qui prend plus de place …

–

A tester absolument :

Si j’ai pris un P8X32A (j’aurai pu prendre autre chose, voire même rien du tout) c’est parce que j’avais une idée derrière la tête

Je vous présente le projet "SIDcog", un émulateur (quasi) complet de chipset SID comme celui du Commodore 64 !
http://forums.parallax.com/showthread.php/118285-SIDcog-The-sound-of-the-Commodore-64-!-(Now-in-the-OBEX)

Pour le moment je n’ai testé que la démo "minimaliste" mais dés que j’aurai un lecteur de carte SD je testerai le lecteur de chiptune complet

Bon WE et bon bidouillage à tous !

EDIT: commentaires désactivés pour cause de spam massif sur cet article, désolé.

Classé dans:Autre, Corrigé, programmation, projet Tagged: diy, madeinfr

aucun rétrolien

Fabien B.

Jeudi, février 28 2013

[DIY + arduino] Alimentation d’atelier DIY – partie 2

Par Fabien B. le Jeudi, février 28 2013, 13:45 - Planet

Bonjour tout le monde !

Aujourd’hui j’ai le plaisir de publier la seconde partie de mon projet d’alimentation d’atelier DIY.
Pour ceux qui n’auraient pas suivi la première partie est disponible ici :
http://skyduino.wordpress.com/2012/09/04/bricolage-partie-1-alimentation-datelier-diy-a-partir/

Certains points ont évolué depuis la rédaction de cette première partie, en particulier concernant le schéma du montage que j’ai du entièrement revoir.
Trêve de bavardages, voici venu l’heure du DIY

–

Le matériel :

Pour la réalisation de la carte mère j’ai utilisé :
1x carte arduino pro mini
1x écran LCD compatible HD44780
3x capteurs de courant ACS712
2x protoboards 3x7cm
3x prises banane (rouge)
3x prises banane (noir)
3x leds rouge 5mm
2x leds verte 5mm
1x buzzer
1x résistance de 100 ohms
3x résistance de 10K
5x résistances de 330 ohms
1x condensateur de 100µF
1x potentiomètre de 47K
1x capteur LM35 (optionnel)
+ des connecteurs tulipes mâles et femelles
+ des fils de câblages

Remarque : sur la photo vous pouvez voir un écran "POWERTIP PC1602-H", j’ai du changer d’écran après coup suite à un problème technique (j’en parlerai plus tard).

–

Le câblage :

Le montage est constitué de plusieurs parties qui une fois assemblées forment le montage final.

Les capteurs de tension :

Une des fonctionnalités de base d’une alimentation c’est de fournir un retour sur la tension réel en sortie.

Pour ceux faire j’ai utilisé 3 ponts diviseurs de tension, abaissant les 3 tensions de sortie de l’alimentation à un maximum de 5V pouvant être mesuré par la suite par l’arduino.
Les sorties +3v3 et +5v de l’alimentation sont mesurées au travers d’un pont diviseurs 1/2 pouvant donc accepter 10v maximum en entrée (j’ai vu large "au cas où").
La sortie +12v est mesuré au travers d’un pont diviseur 1/4 pouvant donc accepter 20v en entrée.

Les capteurs de courant :

Une autre fonctionnalité bien pratique pour une alimentation c’est de fournir une mesure du courant consommé sur chaque sortie.
Dans mon cas j’ai utilisé trois capteurs de courant intégrés du fabricant Alegro facilement disponible en breakout sur ebay ou dealExtreme : le ACS712.
Comme je ne sait pas encore très bien dans quelle fourchette de courant je vais me situer j’ai choisi de taper haut, j’ai donc pris une version x30A avec un maximum mesurable de 30A.
(autant dire qu’avec 30A j’ai de la marge)

Datasheet du ACS712-30A : http://www.allegromicro.com/~/Media/Files/Datasheets/ACS712-Datasheet.ashx

Les signaux de contrôle de l’alimentation :

Pour pouvoir fonctionner correctement mon système à besoin de deux signaux reliés à l’alimentation d’ordinateur qui me sert de source de tension.

Un PSU d’ordinateur (= une alimentation à haut rendement) ce contrôle via deux signaux :
- PSU_ON (entrant, actif à l’état bas)
- POWER_OK (sortant, actif à l’état haut)
Ce sont tout les deux des signaux TTL, si PSU_ON est mis à GND l’alimentation démarre, de même quand POWER_OK passe à 5v cela signifie que la tension de sortie est stabilisé.

Vous remarquerez que j’ai mis la led du signal PSU_ON à l’envers (actuellement elle s’allume quand l’alimentation est arrêté).
Une fois le montage fini et testé je ferai une petite modification afin qu’elle s’allume quand PSU_ON = 0v, mais pour le moment je garde la configuration du schéma.

L’écran LCD :

Pour l’affichage j’ai pris un écran LCD 16×2 compatible HD44780, du classique disponible dans n’importe quelle boutique d’électronique.

J’ai cependant fait les frais d’une petite erreur d’inattention lors de ma commande !
J’avais commandé à l’origine un écran de la marque POWERTIP de référence : "PC1602-H".
Grosse boulette !

Le suffixe "-H" dans la référence signifie qu’il s’agit d’un écran pour une utilisation assujetti à de fortes températures (plein soleil, fours, …).
En dessous de 60° l’écran est totalement vierge, au dessus, miracle il est parfaitement lisible …
Pour pouvoir l’utiliser dans des applications "classique" (à 20-25°) il faut envoyer une tension négative dans la broche VO (contraste).
Dans mon cas cela n’était absolument pas envisageable …
J’ai donc du changer d’écran, au final j’ai pris un écran lcd 16×2 qui traînait dans un tiroir.

Les leds de statut :

Mon alimentation DIY a une petite fonctionnalité bonus : chaque sortie est géré indépendamment.
Ainsi j’ai prévu 3 leds rouges qui s’allumeront pour prévenir d’une surcharge imminente sur une sortie.
Cela me permettra de savoir quelle sortie pose problème si l’alimentation se coupe par sécurité.

Le bouton start / stop / restart :

Pour l’allumage / arrêt / redémarrage de l’alimentation j’ai prévu un unique bouton.
Ainsi pour démarrer l’alimentation il suffira de presser le bouton, de même pour l’éteindre.
Et dans le cas où l’alimentation se couperait par sécurité il suffirait de presser ce même bouton pour redémarrer l’alimentation.

Afin d’éviter tout problème côté arduino j’ai inclus un anti-rebond matériel au niveau du bouton.
L’anti-rebond se résume à un condensateur de 100µF en parallèle de l’interrupteur, soit un anti-rebond de ~100ms (T = RxC, R = 10000, C = 10E-6 soit T = 0.1).

Le buzzer :

Une bonne alimentation (surtout DIY !) se doit d’avoir un buzzer
C’est pourquoi j’ai prévu dans mon montage un buzzer avec une résistance de limitation de courant de 100 ohms.

Ce buzzer aura pour but d’alerter d’une coupure de l’alimentation, d’une surcharge ou de la stabilisation des tensions de sortie.
Ce sera aussi une bonne occasion d’inclure un "easter eggs" dans le code arduino

Le capteur de température :

Après avoir fini mon montage je me suis rendu compte qu’il me restait une entrée analogique de libre …
Cela aurait été dommage de la laisser tel quelle, c’est pourquoi j’ai ajouté un capteur de température analogique LM35 au montage.
Celui ci permettra de surveiller la température des capteurs de courant qui risque de chauffer avec de fortes charges sur les sorties.

–

Montage sans câbles :

Voici quelques photos prisent durant le montage avant la mise en place des différents câbles.

La "carte mère", vue côté buzzer :

(le potentiomètre sur la gauche est celui de l’écran lcd)

La "carte mère", vue côté capteurs de courant :

Les différents morceaux constituant la "carte mère" :

La base de la "carte mère" :

Le support déporté pour l’écran lcd et les leds :

(il s’agit de la première version, avant que je découvre le problème de l’écran lcd)

–

Petite parenthèse concernant l’écran lcd :

Comme je vous le disait l’écran d’origine posait problème de part son alimentation négative pour le contraste.
Dans la première version de mon montage l’écran venait s’enficher dans un connecteur dédié comme vous pouvez le voir sur la photo.

C’était propre, mais bon … tant pis.
Refaire une commande pour prendre le même écran en version standard m’aurait coûté trop chère (surtout en frais de port), j’ai donc sacrifié mon montage "propre" au profit d’un montage fonctionnel.

–

Montage fini avec les câbles :

Ça fait tout de suite beaucoup moins propre je vous l’accorde.

Vous remarquerez que les broches A6 et A7 (disponibles uniquement dans la version CMS de l’ATmega328p) sont derrière le bouton reset, de même que A4 / A5 sont situés juste à coté du régulateur.
J’ai du jouer du cutter pour couper une piste reliée sur A5, cette version chinoise de l’arduino pro mini intégrant des résistances de pull-up pour l’I2C qui venaient fausser mes mesures analogiques.

(la colle chaude c’est la vie !)

Astuce : les capteurs de courants que j’ai utilisé avaient déjà des borniers de base.
J’ai donc juste mis un câble pour "piquer" la tension au niveau du capteur de courant et l’injecter dans les ponts diviseurs mesurant la tension des sorties.

Voici un exemple très parlant de l’expression : "cacher la merde sous le tapis"

Annexe, le capteur de température :

Comme je l’ai déjà dit j’ai ajouté un capteur de température LM35 au circuit.
Celui ci sera monté à terme sur une petite lame de métal qui recouvrira les trois capteurs de courant (avec de la patte thermique pour faire la liaison).
Cela permettra de dissiper la chaleur émise par les capteurs tout en la mesurant.

–

Premier essai du hardware :

Histoire de tester sommairement mon montage j’ai réalisé un petit code de test :

#include <LiquidCrystal.h>

/* Pin mapping */
static const byte LED_PIN[3] = {
  11, 12, 13
};
static const byte VOLTAGE_SENSOR_PIN[3] = {
  A0, A1, A2
};
static const byte CURRENT_SENSOR_PIN[3] = {
  A3, A6, A7
};
static const byte BUTTON_PIN = 2;
static const byte POWER_OK_PIN = 3;
static const byte PSU_ON_PIN = 4;
static const byte BUZZER_PIN = A4;
static const byte TEMP_PIN = A5;

/* LCD mapping */
LiquidCrystal lcd(10, 9, 8, 7, 6, 5);

/* PSU state */
static byte PSU_state;

void setup() {

  /* Setup pins */
  for(byte i = 0; i < 3; ++i) {
    pinMode(LED_PIN[i], OUTPUT);
    pinMode(VOLTAGE_SENSOR_PIN[i], INPUT);
    pinMode(CURRENT_SENSOR_PIN[i], INPUT);
  }
  pinMode(BUTTON_PIN, INPUT);
  pinMode(POWER_OK_PIN, INPUT);
  pinMode(PSU_ON_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  /* PSU_ON and button signals interrupt setup */
  attachInterrupt(0, buttonPressCallback, FALLING);
  attachInterrupt(1, powerOkCallback, CHANGE);

  /* Serial setup */
  Serial.begin(115200);

  /* LCD setup */
  lcd.begin(16, 2);

  /* Get current PSU state */
  PSU_state = digitalRead(POWER_OK_PIN);

  /* Test code */
  lcd.print("Hello World !");
  digitalWrite(LED_PIN[0], HIGH);
  digitalWrite(LED_PIN[1], HIGH);
  digitalWrite(LED_PIN[2], HIGH);
  tone(BUZZER_PIN, 440, 500);
}

void loop() {

  /* Test code */
  for(byte i = 0; i < 3; ++i) {
    Serial.print(i);
    Serial.print(": ");
    Serial.print(analogRead(VOLTAGE_SENSOR_PIN[i]));
    Serial.print(" , ");
    Serial.println(analogRead(CURRENT_SENSOR_PIN[i]));
  }

  static byte s = LOW;
  digitalWrite(PSU_ON_PIN, (s = !s));
  
  delay(500);
}

void buttonPressCallback() {

  /* Test code */
  tone(BUZZER_PIN, 440, 500);
}

void powerOkCallback() {

}

Il est vraiment basique mais il m’as permis de tester grossièrement chaque partie du montage et de concevoir un squelette de code pour la suite.

Test de la carte arduino :

Test des leds :

Test de l’écran lcd :

Test des capteurs de courant :

–

La suite ?

Il me reste encore à réaliser un boitier pour le montage, de même qu’une jolie façade (sérigraphié ça serait top).
Ensuite il me faudra faire le code est finir le câblage des prises banane et des sorties de l’alimentation.
J’ai encore du boulot pour un petit moment

Bon bidouillage et bon WE à tous

Classé dans:arduino, Corrigé, programmation, projet Tagged: diy, hack, madeinfr

aucun rétrolien

Fabien B.

Vendredi, février 15 2013

[DIY] Dock micro USB OTG

Par Fabien B. le Vendredi, février 15 2013, 07:40 - Planet

Bonjour tout le monde !

Pour notre projet tutoré à l’IUT nous avions besoin d’un dock micro usb OTG (je ne rentre pas dans les détails du projet en lui même ce serait trop long à expliquer).
On trouve plein de câble micro usb OTG dans le commerce, souvent en import direct de chine, le tout pour moins de 10$ voir moins.

Un câble "du commerce" c’est bien mais le problème c’est que ça prend de la place, qu’il soit coudé à 90° ou non !
Pour notre projet nous avions plutôt besoin d’un dock "low profil" avec un connecteur micro usb câblé en OTG qu’un simple câble coudé.
Après des heures de recherche sur ebay, dealExtreme & co le constat est sans appel, ça n’existe pas en "tout fait" …

Du coup, ni une ni deux, une commande de connecteur chez farnell, un petit typon sous Ares et voila ce que cela donne en image

–

Le connecteur :

J’ai choisi d’utiliser des connecteurs micro usb traversant miniature SANS "bouclier" de métal autour du connecteur afin d’éviter que le dock ne soit trop dur à brancher / débrancher.
Pour ceux qui veulent la référence ce sont des ZX20-B-5S disponibles chez farnell pour un prix dérisoire.

Aussi par miniature, j’entends "vraiment" miniature, le bout de pince que vous pouvez apercevoir sur la photo fait en réalité 2mm, ça vous donne une idée de la taille globale du connecteur.

–

Mon "environnement de travail" :

Bon j’avoue c’est pas très "pro" comme environnement de travail

–

1er étape : le pré-câblage du connecteur :

Comme les broches du connecteur ne font qu’un millimètre de long je ne pouvais pas les souder directement sur un morceau de pcb.
L’astuce des câbles OTG "du commerce" utilisant ce genre de connecteur est d’insérer un pcb très fin entre les deux rangées de broches et de souder le connecteur directement dessus.

Le problème c’est qu’ils nous faillaient un dock, soit un connecteur perpendiculaire au câble.
J’ai résolu le problème en soudant des fils de cuivre émaillés très fin à chaque broche du connecteur, fils qui seront soudés par la suite sur le pcb.

Gros plan sur les soudures, ça m’a pris une bonne demi-heure pour tout souder et vérifier que les soudures étaient bonnes.

–

2iéme étape : le pcb :

Ce que vous voyez là c’est ma cuisine … on a vu mieux comme atelier gravure …

Le typon a été réalisé sous Ares, puis transféré sur la plaque de cuivre au moyen d’une imprimante laser et de la célèbre méthode du "transfert de toner".
Pour la gravure en elle même je suis resté sur la solution "classique" du perchlorure de fer.

Le pcb âpres 8 minutes de gravure à ~38°C, à ce stade il est prêt à être rincé.

Le pcb rincé avec le toner encore présent sur les pistes de cuivre.

–

3iéme étape : l’assemblage :

Vous remarquerez le magnifique effet miroir … c’est pas grave pour ce typon mais la prochaine fois je ferais plus attention.

Petite particularité de mon câble USB OTG, celui ci est destiné à être "pluggé" dans une carte arduino !
Les cartes arduino possédant un connecteur USB-B mâle (ou femelle je me rappelle jamais …) j’ai donc massacré deux câbles usb-a / usb-b pour faire mon câblage.

Voila ce que ça donne une fois le câble (la partie usb-b) soudé sur le pcb, avec en plus un petit strap pour tenir le câble solidement en place.

–

Les câbles OTG, trucs et astuces :

Quand j’ai voulu tester mon câble OTG pour la première fois rien ne c’est passé … rien de chez rien, quedal, niét, nada !

J’avais pourtant fait le test avec une clef usb (formaté en FAT) et l’application "usb otg helper" pour android, censée fonctionner parfaitement … mais sans succès.

L’astuce est vraiment conne, mais une fois qu’on la connait tout marche tout de suite beaucoup mieux !

Vous voyez la broche "sense" (aussi appelait "ID") ?
Si elle est flottante c’est un câble normal, si elle est reliée à GND c’est un câble OTG.

La différence est mince mais le résultat totalement différent !

On voit clairement les deux fils GND et ID reliés ensemble sur cette photo.

Et bien sûr une fois les deux broches reliées tout marche parfaitement :

Pour les curieux ceci est ma clef usb "d’installation linux", avec mon wallpaper, mon script d’installation apt-get, un log u-boot (qui sort de je ne sais où) et une image openWRT que je garde de côté pour mon eeepc.

À noter aussi que le galaxy S3 n’est pas à moi mais à l’IUT … je n’ai pas le budget pour m’acheter un téléphone à +450€ (j’ai un HTC HD2 flashé sous android 4.1 ça me suffit largement ).

–

Fabrication du dock :

Histoire de faire un truc "solide" j’ai collé le connecteur avec de la résine epoxy (tube avec deux composants à mélanger).
Mes essais avec de la colle cyanoacrylate n’ont pas été concluant, c’était trop cassant.

Vous remarquerez le fait que le strap qui maintient le câble usb est volontairement fondu sur la gaine du câble pour éviter que celui ci ne bouge dans le futur.

–

4iéme étape : soudure des fils :

Tous d’abord les fils ont été coupés à la bonne longueur :

Puis avec une bonne "lampe loupe" et un fer à souder bien chaud ça donne ça :

Remarque : oui j’ai complétement raté le centrage de mon perçage sur la 1er plaque …
Remarque 2 : les fils sont émaillés donc aucun risque de court-circuit

–

Fignolages :

La colle chaude c’est la vie ! Je le répéterai jamais assez : bénis soit l’inventeur de la colle chaude !

–

Résultat final :

(le deuxième câble est identique au premier )

Je peux vous garantir que vous trouverez jamais un connecteur micro USB OTG aussi DIY que celui là
Le cout total s’élève à 3.5€ (pcb et colle exclut) par dock, soit pas grand chose au final.

Bon bidouillage et bon WE à tous

Classé dans:arduino, programmation, projet Tagged: diy, madeinfr

aucun rétrolien

Fabien B.

Lundi, février 11 2013

[DIY] Un port série … audio

Par Fabien B. le Lundi, février 11 2013, 16:58 - Planet

Bonjour tout le monde !

Fut un temps je cherchais un moyen de programmer un ATmega de la façon la plus tordu possible (oui j’ai que ça à foutre).
Dans le genre bien tordu j’avais trouvé ce programmateur d’AVR à base de clavier usb :
http://hackaday.com/2012/11/26/usb-keyboard-becomes-an-avr-programmer/

J’ai eu beau chercher je n’ai pas pu trouver d’idée encore plus tordue …
Du coup je suis parti sur une autre idée, émuler un port série au moyen d’une carte son !

–

Le montage :

Pour ce montage j’ai piqué le schéma ici :
http://robots-everywhere.com/re_wiki/index.php?title=Serial_on_Android_using_the_audio_port

En réalité c’est un bête montage avec un amplificateur opérationnel (en saturation), monté en inverseur.

Quand l’entrée dépasse le seuil fixé par le potentiomètre la sortie bascule.
Cela permet d’avoir un signal TTL 0v/5v "propre" à partir d’un signal audio de +/- 1v d’amplitude.

Comme une carte son possède (dans 99.9% des cas) une sortie stéréo il est possible d’avoir deux sorties.
Du coup on peut imaginer émuler autre chose qu’un port série, voire même faire des sorties TTL tout ce qui à de plus classique.

Remarque : dans mon montage physique (pas sur le schéma) j’ai inversé par erreur les entrées V+ et V-, du coup j’ai un montage non inverseur.
Ne vous faites pas avoir, il faut bien un montage inverseur, vous comprendrez par la suite pourquoi

–

Le prototype :

Sur la gauche les deux sorties et les alimentations +5v et GND.
Et juste à côté l’entrée audio (gauche, droite, masse).

Pour l’amplificateur opérationnel j’utilise un LM393 qui a l’avantage de fonctionner sans problème en +5V, contrairement à un TL082 par exemple qui a besoin d’une alimentation symétrique.

Oui je sais c’est dégueulasse …
(ne pas vous fier à mon câblage, rappel : j’ai inversé V+ et V-)

–

Découpage d’une trame série :

Pour pouvoir vous expliquer rapidement la composition d’une trame série j’avais besoin d’une trame.
L’image ci dessous provient donc de batsocks.co.uk et est disponible dans son contexte d’origine ici :
http://www.batsocks.co.uk/products/Other/SweeperMeter_Technical.htm

Une trame série se décompose en plusieurs parties :
- un bit de start
- 8 (ou 7) bits de données
- 1 (ou 2) bit de stop

Le bit de start correspond à un niveau bas (0v), un bit de stop correspond à un niveau haut (5v).
Au repos le signal doit être à l’état haut (historiquement cela permettait de détecter une coupure sur la ligne).

Concernant la durée des temps haut / temps bas c’est très simple à calculer.
Imaginons que l’on souhaite une vitesse de communication de 9600 bauds par seconde.
9600 bauds/s = 9600 bits/s -> durée d’une période = 1 / fréquence = 1 / 9600 = 0.104 millisecondes

De même pour connaître la durée d’une trame complète il suffit de multiplier le tout par le nombre de bits par octet.
Ici avec 8 bits de données et 1 bits de stop :
1 bit de start + 8 bits de données + 1 bits de stop = 10 bits
10 bits = 10 x (1 / 9600) = 1.04 millisecondes

Un niveau haut de plus d’une fois la durée d’un octet s’appelle un "break", si un récepteur série reçoit un "break" il est obligé de se recaler sur le bit de start qui suit, cela permet de ne pas perdre la synchronisation avec le signal série.

Remarque : on peut aussi déduire la vitesse réelle de transmission en octets par seconde :
9600 bits/s / 10 bits = 960 octets par seconde

–

Le logiciel :

Comprendre le fonctionnement d’une communication série asynchrone c’est une chose, émuler un signal série en est une autre.
Et émuler un signal série avec une carte son d’ordinateur est encore une autre histoire.

Pour me simplifier la tache j’ai conçue un script python prenant un fichier (texte ou binaire) en entrée et générant un fichier wave en sortie.
Pour lire le fichier il suffit d’ouvrir un éditeur comme audacity par exemple ou n’importe quel lecteur de musique supportant la lecture des .wav.

Voici un exemple de fichier audio généré et ouvert sous audacity :

Note : le signal présenté ci dessus est volontairement non-inversé, il ne devrait pas être dans le même sens que sur le schéma vu plus haut.
L’amplificateur inversant le signal audio celui ci doit être lui inversé pour au final avoir un signal série avec des niveaux logiques corrects.

Vous vous demandez sûrement pourquoi inverser le signal ?
Réfléchissons une petite seconde.
Le signal série doit être à l’état haut au repos, la carte son elle ne sort aucun signal au repos.
En utilisant un montage inverseur le signal est de base au niveau haut et passe au niveau bas lorsque la carte son envoie un signal.
il faut donc inverser le signal audio pour que le montage inverse de nouveau le signal et que celui ci finisse par être dans "le bon sens".
L’avantage de cette méthode est que si l’on débranche l’entrée audio le récepteur série ne se retrouvera pas avec un signal corrompu mais avec un "break" constant.
Cela évite aussi d’avoir à générer un signal haut avec la carte son au repos.

Le code du script (avec des commentaires pour expliquer chaque sous-parties) :

# -- Imports --
# sys: for argv / argc
# wave: for wave file generation
# struct: for pack
import sys, wave, struct

# Vitesse de communication série
SERIAL_RATE = 2400

# Fréquence d'échantillonnage (min 4000 ~ max 48000)
SAMPLE_RATE = 48000

# Vérification des arguments CLI
if len(sys.argv) < 3:
    print "USAGE: data2wav.py <input file> <output file>"
    exit(1)

# Nom de fichier source / sortie
i_filename = sys.argv[1]
o_filename = sys.argv[2]

# Ajoute l'extension .wav au fichier de sortie si nécessaire
if o_filename[-4:] != '.wav':
    o_filename += '.wav'

# Ouvre le fichier source (en mode binaire)
fi = open(i_filename, 'rb')
if not fi:
    print "Cannot open input file: %s" % i_filename
    exit(1)

# Ouvre le fichier de sortie (en mode binaire)
fo = wave.open(o_filename, 'wb')
if not fo:
    print "Cannot open output file: %s" % o_filename
    exit(1)

# Configure l'entête du fichier Wave
fo.setnchannels(1) # Mono
fo.setsampwidth(1) # 8 bits
fo.setframerate(SAMPLE_RATE)

# Calcul le nombre d'échantillons audio par bit
# Plus il y a d'échantillons par bit plus la qualité du signal audio sera grande
# Une fréquence d'échantillonnage élevé donnera donc les meilleurs résultats
NB_SAMPLES_PER_BIT = SAMPLE_RATE / SERIAL_RATE

# Buffer audio
audio_output = []

# Ajoute un bit dans le buffer audio
def appendBit(bit):
    for i in range(0, NB_SAMPLES_PER_BIT):
        if bit: # Inversion du signal : 0 -> 1, 1 -> 0
            audio_output.append(struct.pack('B', 0))
        else:
            audio_output.append(struct.pack('B', 255))

# Ajoute un "break" dans le buffer audio
def serialBreak():
    for i in range(0, 20):
        appendBit(True)

# Début du processus de conversion
b = fi.read(1)
serialBreak()
serialBreak()
while b != '':

    # Converti la valeur d'un octet du fichier source en décimal
    b = ord(b)
    
    # Ajoute un bit de start au buffer audio
    appendBit(False)

    # Ajoute 8 bits de données au buffer audio
    for i in range(0, 8):
        appendBit(b & (1 << i))

    # Ajoute un bit de stop au buffer audio
    appendBit(True)

    # Lit l'octet suivant du fichier source
    b = fi.read(1)

# Écrit le contenu du buffer audio dans le fichier de sortie
fo.writeframes(''.join(audio_output))

# Fermeture du fichier source et du fichier de sortie
fi.close()
fo.close()

–

Test IRL :

Le montage finit :

Sur la photo :
- une carte son usb
- un dongle usb/série
- un câble audio jack bricolé
- quelques fils
- et le montage

Il suffit ensuite de lancer la lecture du fichier wave :

Et voila, un joli "Lorem ipsum" transmit au moyen d’un "vrai faux" port série émulé par une carte son !
Peut être qu’un jour on programmera nos arduino au moyen d’un simple lecteur de musique

Classé dans:Corrigé, projet Tagged: diy, madeinfr

aucun rétrolien

Fabien B.

Samedi, septembre 22 2012

[hack] TL-MR3020 + openWRT = bidouillage USB / Wifi / Ethernet

Par Fabien B. le Samedi, septembre 22 2012, 13:50 - Planet

Bonjour tout le monde !

Pour continuer mon projet de « Blyss box DIY » j’ai entrepris d’utiliser un petit routeur usb / wifi / ethernet.
Celui ci va servir de « lien » entre une carte arduino (et mon code BlyssSpoofer / BlyssSniffer) et une interface web (ou autre, à voir).

D’autres membres du forum arduino.cc se sont aussi lancés dans l’aventure, voici un des nombreux topic sur le sujet :
http://arduino.cc/forum/index.php?topic=115889

Le plus gros problème a été de trouver un routeur wifi capable de gérer la situation.
Celui devant respecter les critères suivant :
- être de petite taille, idéalement de la taille d’une carte arduino UNO
- avoir un port usb (ou à défaut un port série) pour connecter la carte arduino
- être compatible avec openWRT (distribution linux pour routeurs)
- avoir un interface réseau : wifi, ethernet ou les deux

Après pas mal de recherche et les conseils avisés des membres du forum arduino deux candidats sont sortis du lot :
- le TL-WR703N (dispo uniquement en chine),
- le TL-MR3020 (dispo en france mais plus chère)

Niveau hardware c’est quasiment la même chose (même chipset Atheros, même RAM, même Flash) à quelques différences prêt (port ethernet blindé vs non blindé, nombre de led, …).

Pour ma part j’ai choisi d’utiliser le TL-MR3020 avec openWRT (version trunk) :
http://wiki.openwrt.org/toh/tp-link/tl-mr3020

Pourquoi le TL-MR3020 et non son clone chinois le TL-WR703N ?
- plus de led = plus de GPIO = plus de possibilités de bidouillage
- connecteur série au pas 2.54mm (pas standard = pas à ce casser la tête avec des fils « volants »)

Bon par contre niveau prix c’est pas du tout la même chose … 17€ environ pour le TL-WR703N sur ebay contre quasiment le double pour le TL-MR3020 sur amazon, ldlc, …
A vous de choisir

Dans ce premier article je vais détailler uniquement la partie hardware. Je parlerai de la partie software dans un article séparé.

–

La boite :

Si vous lisez mes articles depuis un certain temps déjà vous devez avoir remarqué que j’adore déballer tout ce que je reçois en photo
Ce routeur ne fait pas exception, voici donc à quoi ressemble la boite :

Le routeur à l’intérieur de la boite avec son film de protection :

Et tout les accessoires divers et variés :

Un câble mini usb d’alimentation, un adaptateur 5v secteur, un câble ethernet, bref tout le nécessaire pour un utilisateur « classique ».

–

Le routeur, petit tour du propriétaire :

Le routeur dans son ensemble :

A part la couleur (gris au lieu de bleu) et le duo led + bouton il n’y a aucune différence esthétique avec le TL-WR703N.

Au niveau de la face avant :

On retrouve :
- le port ethernet
- le port mini usb POUR L’ALIMENTATION UNIQUEMENT
- le switch permettant de choisir le mode de fonctionnement du routeur (avec le firmware d’origine)

Sur le côté droit :

On retrouve le port usb permettant (normalement) de connecter un dongle 3G.
Dans mon cas ce sera un hub avec une clef usb (pour le rootfs) et une carte arduino qui seront connectés au port usb.

Sur le dessus :

Les 5 leds :
- power
- 3G
- wifi
- ethernet
- WPS

Et le boutons WPS.

-> 1ère différence avec le TL-WR703N, celui ne possède que 2 led (dont une qui n’est pas montée par défaut) et un bouton reset.

Ps: ceci est un câble ethernet … j’ai pas trop confiance en sa solidité ^^ »

–

Opération décorticage, ou comment ouvrir un boitier impossible à ouvrir :

Ouvrir le boitier du TL-MR3020 est juste impossible sans un couteau avec une lame très fine (et solide) et beaucoup, beaucoup de patience …

Pour ouvrir le boitier il faut faire sauter les deux clips du capots coloré, tout en glissant une lame tout autour du capot pour briser les points de colle.

Le premier clip se trouve juste au dessus du port mini usb, le second est en face à ~1.5cm à gauche du logo TP-LINK.
Voila ce que ça donne une fois le boitier ouvert :

Vous remarquerez les petites équerres tout autour du boitier qui sont TOUTES collées par ultrason au capot supérieur.

Ps: attention de ne pas vous blesser en glissant la lame du couteaux dans la fente du boitier, un accident est si vite arrivé …

–

Le circuit électronique :

Une fois le boitier ouvert il est (enfin) possible de voir ce qui ce cache dans la bête :

Le numéro de révision du circuit se trouve sur le connecteur ethernet :

Comme on peut le voir j’ai un version 1 révision 7.

-> 2éme différence avec le TL-WR703N, sur le TL-WR703N le port ethernet est blindé, sur le TL-MR3020 il ne l’est pas …

–

Le détails du hardware :

J’ai pas vraiment respecté d’ordre particulier, c’est un peu en vrac

Le chipset Atheros + antenne :

Le chipset Atheros est le cœur du routeur, il est composé du CPU et de la partie réseau ethernet / wifi.

Il s’agit d’un chipset Atheros AR9330 révision 1 (= AR9331).
Le cpu à l’intérieur est de la série des AR72xx et plus précisément un AR7240 tournant à 400MHz.

La partie wifi supporte au maximum du 802.11 b/g/n à 150Mbps.
La partie ethernet quand à elle supporte les modes 10Mpbs et 100Mbps.

Le port mini usb d’alimentation et le port usb « classique » :

Le port mini usb n’est là que pour fournir l’alimentation +5v du circuit.
Il ne peut donc pas être utilisé en usb device ou autre.

D’après le wiki d’openWRT le TL-MR3020 peut fonctionner avec des tensions relativement basses de l’ordre de 2.6/2.7v.
Cela laisse donc la possibilité d’utiliser des batteries lipo 1S 3.7v pour l’alimentation (il faudra que je test pour voir).

Le second port usb, plus « classique » peut quand à lui être utilisé en usb host comme n’importe quel port usb normal.
Il suffit d’avoir les drivers adéquat dans son image openWRT et tout ira bien

La RAM et les leds :

La mémoire RAM est d’une taille de 32Mo ce qui laisse pas mal de place pour l’utilisateur.

Quand aux leds elles sont aux nombres de 5 comme je le précisais un peu plus haut.

Le détail du câblage des leds est disponible sur le wiki d’openWRT :
http://wiki.openwrt.org/toh/tp-link/tl-mr3020#leds

La mémoire flash SPI :

La mémoire flash SPI est d’une taille de 4Mo, celle ci est découpée suivant ce plan mémoire si dessous :
mtd0 (128Ko) : u-boot mtd1 (1Mo) : kernel mtd2 (2.75Mo) : rootfs mtd3 (64Ko) : configuration mtd4 (64Ko) : art (= Atheros Radio Test)

Ne surtout pas toucher à la zone mémoire nommé « ART » sinon le chipset wifi ne fonctionnera plus du tout.

Si jamais vous brickez le bootloader du routeur il est possible de sauver les meubles en dessoudant la flash et en la reliant à un programmateur.

Le wiki d’openWRT fourni même une image d’usine de l’intégralité de la flash :
http://wiki.openwrt.org/toh/tp-link/tl-mr3020#restoring.original.firmware
(2éme lien de la section « link dump »)

Par mesure de sécurité je ferai un dump complet des zone mtd0 et mtd4 …
Mais j’en reparlerai dans l’article sur la partie software

Les boutons :

Il y a deux boutons, câblés sur trois GPIO.
Le premier bouton est de type « bouton poussoir », il est normalement utilisé pour activer l’authentification WPS wifi.
Le second bouton est de type « glissière » et comporte trois positions, il est normalement utilisé pour choisir le mode de fonctionnement du routeur.

Le détail du câblage des boutons est disponible sur le wiki d’openWRT :
http://wiki.openwrt.org/toh/tp-link/tl-mr3020#buttons

Le port série :

C’est la partie la plus intéressante car c’est celui ci qui permet d’accéder au bootloader (u-boot) et de modifier en profondeur le kernel linux et le rootfs du routeur.

Je n’utilise pas la méthode de flash par l’interface web, je trouve ça trop bancale.
La méthode de flash par le bootloader demande une extrême vigilance pour ne pas bricker le routeur mais quand on est habitué c’est beaucoup plus fiable.

Le port série est câblé de la manière suivante :
| (vcc) (gnd) (rx) [tx] |
() représente une pastille ronde et [] la pastille carré (repère de la broche 1).

Le port série est configuré en 115200 bauds, 8 bits de données, 1 bit de start, 1 bit de stop, pas de parité et pas de contrôle de flux.

Problème : le port série est câblé un peu bizarrement, ce qui fait qu’avec certains adaptateurs série -> usb celui ci ne marche pas correctement.
J’ai testé avec mon ftdi basic de sparkfun, effectivement ça ne fonctionnait pas de base.

Mais ne paniquez pas, il suffit de mettre une résistance de 10K entre VCC et Tx pour régler le problème
(Merci à celui qui a pris le temps de rajouter une note à ce sujet dans le wiki d’openWRT, sinon je serait encore en train de chercher le problème ^^)

Histoire de faire les choses propre j’ai fait un adaptateur série -> FTDI basic avec un morceau de pcb qui trainait :

Note: je n’ai pas relié la broche VCC du connecteur FTDI basic au VCC du circuit, ainsi je peux utiliser un ftdi basic 5v ou 3v3 sans problème

Une fois le connecteur série soudé ça donne ceci :

Il suffit ensuite de brancher l’adaptateur sur le connecteur série :

Et le ftdi basic sur l’adaptateur :

Ensuite on branche l’usb d’alimentation et hop tout s’allume !

Et sur le moniteur série on obtient une jolie console série :

U-Boot 1.1.4 (Mar 20 2012 - 11:37:54)

AP121 (ar9330) U-boot

DRAM:  32 MB
led turning on for 1s...
id read 0x100000ff
flash size 4194304, sector count = 64
Flash:  4 MB
Using default environment

In:    serial
Out:   serial
Err:   serial
Net:   ag7240_enet_initialize...
No valid address in Flash. Using fixed address
No valid address in Flash. Using fixed address
: cfg1 0x5 cfg2 0x7114
eth0: 00:03:7f:09:0b:ad
ag7240_phy_setup 
eth0 up
: cfg1 0xf cfg2 0x7214
eth1: 00:03:7f:09:0b:ad
athrs26_reg_init_lan
ATHRS26: resetting s26
ATHRS26: s26 reset done
ag7240_phy_setup 
eth1 up
eth0, eth1
Autobooting in 1 seconds
## Booting image at 9f020000 ...
   Uncompressing Kernel Image ... OK

Starting kernel ...

Booting AR9330(Hornet)...
Linux version 2.6.31--LSDK-9.2.0.312 (root@localhost.localdomain) (gcc version 4.3.3 (GCC) ) #199 Tue Mar 20 11:38:41 CST 2012
flash_size passed from bootloader = 4
CPU revision is: 00019374 (MIPS 24Kc)
Determined physical RAM map:
 memory: 02000000 @ 00000000 (usable)
User-defined physical RAM map:
 memory: 02000000 @ 00000000 (usable)
Zone PFN ranges:
  Normal   0x00000000 -> 0x00002000
Movable zone start PFN for each node
early_node_map[1] active PFN ranges
    0: 0x00000000 -> 0x00002000
Built 1 zonelists in Zone order, mobility grouping on.  Total pages: 8128
Kernel command line: console=ttyS0,115200 root=31:02 rootfstype=squashfs init=/sbin/init mtdparts=ar7240-nor0:128k(u-boot),1024k(kernel),2816(rootfs),64k(config),64k(ART) mem=32M
PID hash table entries: 128 (order: 7, 512 bytes)
Dentry cache hash table entries: 4096 (order: 2, 16384 bytes)
Inode-cache hash table entries: 2048 (order: 1, 8192 bytes)
Primary instruction cache 64kB, VIPT, 4-way, linesize 32 bytes.
Primary data cache 32kB, 4-way, VIPT, cache aliases, linesize 32 bytes
Writing ErrCtl register=00000000
Readback ErrCtl register=00000000
Memory: 29876k/32768k available (1884k kernel code, 2892k reserved, 521k data, 116k init, 0k highmem)
Hierarchical RCU implementation.
NR_IRQS:128
plat_time_init: plat time init done
Calibrating delay loop... 266.24 BogoMIPS (lpj=532480)
Mount-cache hash table entries: 512
NET: Registered protocol family 16
===== ar7240_platform_init: 0


Whoops! This kernel is for product mr3020 v1.0!

bio: create slab <bio-0> at 0
SCSI subsystem initialized
usbcore: registered new interface driver usbfs
usbcore: registered new interface driver hub
usbcore: registered new device driver usb
NET: Registered protocol family 2
IP route cache hash table entries: 1024 (order: 0, 4096 bytes)
TCP established hash table entries: 1024 (order: 1, 8192 bytes)
TCP bind hash table entries: 1024 (order: 0, 4096 bytes)
TCP: Hash tables configured (established 1024 bind 1024)
TCP reno registered
NET: Registered protocol family 1
AR7240 GPIOC major 0
squashfs: version 4.0 (2009/01/31) Phillip Lougher
NTFS driver 2.1.29 [Flags: R/O].
msgmni has been set to 58
alg: No test for lzma (lzma-generic)
alg: No test for stdrng (krng)
io scheduler noop registered
io scheduler anticipatory registered
io scheduler deadline registered
io scheduler cfq registered (default)
Serial: 8250/16550 driver, 1 ports, IRQ sharing disabled
ttyS0: detected caps 00000000 should be 00000100
serial8250.0: ttyS0 at MMIO 0xb8020000 (irq = 19) is a 16550A
console [ttyS0] enabled
PPP generic driver version 2.4.2
NET: Registered protocol family 24
cmdlinepart partition parsing not available
set partition boot 
set partition kernel 
set partition rootfs 
set partition config 
set partition art 
set partition ÿ 
Searching for RedBoot partition table
5 RedBoot partitions found on MTD device ar7240-nor0
Creating 5 MTD partitions on "ar7240-nor0":
0x000000000000-0x000000020000 : "boot"
0x000000020000-0x000000120000 : "kernel"
0x000000120000-0x0000003e0000 : "rootfs"
0x0000003e0000-0x0000003f0000 : "config"
0x0000003f0000-0x000000400000 : "art"
->Oops: flash id 0x10215 . 
ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
Port Status 1c000004 
ar7240-ehci ar7240-ehci.0: ATH EHCI
ar7240-ehci ar7240-ehci.0: new USB bus registered, assigned bus number 1
ehci_reset Intialize USB CONTROLLER in host mode: 3
ehci_reset Port Status 1c000000 
ar7240-ehci ar7240-ehci.0: irq 3, io mem 0x1b000000
ehci_reset Intialize USB CONTROLLER in host mode: 3
ehci_reset Port Status 1c000000 
ar7240-ehci ar7240-ehci.0: USB 2.0 started, EHCI 1.00
usb usb1: configuration #1 chosen from 1 choice
hub 1-0:1.0: USB hub found
hub 1-0:1.0: 1 port detected
TCP cubic registered
NET: Registered protocol family 17
802.1Q VLAN Support v1.8 Ben Greear <greearb@candelatech.com>
All bugs added by David S. Miller <davem@redhat.com>
ar7240wdt_init: Registering WDT success
VFS: Mounted root (squashfs filesystem) readonly on device 31:2.
Freeing unused kernel memory: 116k freed
init started:  BusyBox v1.01 (2012.01.16-03:21+0000) multi-call binary
This Board use 2.6.31
xt_time: kernel timezone is -0000
nf_conntrack version 0.5.0 (512 buckets, 5120 max)
ip_tables: (C) 2000-2006 Netfilter Core Team
insmod: cannot open module `/lib/modules/2.6.31/kernel/iptable_raw.ko': No such file or directory
insmod: cannot open module `/lib/modules/2.6.31/kernel/flashid.ko': No such file or directory
PPPoL2TP kernel driver, V1.0
PPTP driver version 0.8.3
insmod: cannot open module `/lib/modules/2.6.31/kernel/harmony.ko': No such file or directory

 (none) mips #199 Tue Mar 20 11:38:41 CST 2012 (none)
(none) login: Now flash open!
Now flash open!
ATHR_GMAC: Length per segment 1536
ATHR_GMAC: fifo cfg 3 01f00140
ATHR_GMAC: Mac address for unit 1:bf1f0006
ATHR_GMAC: 25:51:9d:db:e0:5c 
ATHR_GMAC: Max segments per packet :   1
ATHR_GMAC: Max tx descriptor count :   40
ATHR_GMAC: Max rx descriptor count :   96
ATHR_GMAC: Mac capability flags    :   4D83
ATHR_GMAC: Mac address for unit 0:bf1f0000
ATHR_GMAC: 03:30:dc:d3:6e:49 
ATHR_GMAC: Max segments per packet :   1
ATHR_GMAC: Max tx descriptor count :   40
ATHR_GMAC: Max rx descriptor count :   252
ATHR_GMAC: Mac capability flags    :   4403
athr_gmac_ring_alloc Allocated 640 at 0x81e7d800
athr_gmac_ring_alloc Allocated 4032 at 0x81d61000
Setting Drop CRC Errors, Pause Frames and Length Error frames 
Setting PHY...mac 0
athr_gmac_ring_alloc Allocated 640 at 0x81e7d400
athr_gmac_ring_alloc Allocated 1536 at 0x81f2b000
athr_gmac_mii_setup: MDC check failed
Setting Drop CRC Errors, Pause Frames and Length Error frames 
ATHRS26: resetting s26
ATHRS26: s26 reset done
Setting PHY...mac 1
device eth0 entered promiscuous mode
Now flash open!
nf_conntrack_rtsp v0.6.21 loading
nf_nat_rtsp v0.6.21 loading
asf: module license 'Proprietary' taints kernel.
Disabling lock debugging due to kernel taint
ath_hal: 0.9.17.1 (AR9380, DEBUG, REGOPS_FUNC, WRITE_EEPROM, 11D)
ath_rate_atheros: Copyright (c) 2001-2005 Atheros Communications, Inc, All Rights Reserved
ath_dev: Copyright (c) 2001-2007 Atheros Communications, Inc, All Rights Reserved
ath_ahb: 9.2.0_U5.508 (Atheros/multi-bss)
Boostrap clock 25MHz
ar9300RadioAttach: Need analog access recipe!!
Restoring Cal data from Flash
ath_get_caps[4735] rx chainmask mismatch actual 1 sc_chainmak 0
ath_get_caps[4710] tx chainmask mismatch actual 1 sc_chainmak 0
wifi0: Atheros 9380: mem=0xb8100000, irq=2
wlan_vap_create : enter. devhandle=0x80d202c0, opmode=IEEE80211_M_HOSTAP, flags=0x1
wlan_vap_create : exit. devhandle=0x80d202c0, opmode=IEEE80211_M_HOSTAP, flags=0x1.
VAP device ath0 created 
 
 DES SSID SET=TP-LINK_POCKET_3020_D6E207 
ieee80211_scan_unregister_event_handler: Failed to unregister evhandler=c0aeb860 arg=80c1aac0
wlan_vap_delete : enter. vaphandle=0x81eaa000
wlan_vap_delete : exit. vaphandle=0x81eaa000
wlan_vap_create : enter. devhandle=0x80d202c0, opmode=IEEE80211_M_HOSTAP, flags=0x1
wlan_vap_create : exit. devhandle=0x80d202c0, opmode=IEEE80211_M_HOSTAP, flags=0x1.
VAP device ath0 created 
 
 DES SSID SET=TP-LINK_POCKET_3020_D6E207 
 ieee80211_ioctl_siwmode: imr.ifm_active=393856, new mode=3, valid=1 
WARNING: Fragmentation with HT mode NOT ALLOWED!!
device ath0 entered promiscuous mode
br0: port 2(ath0) entering forwarding state
 ieee80211_ioctl_siwmode: imr.ifm_active=918144, new mode=3, valid=1 
br0: port 2(ath0) entering disabled state
 
 DES SSID SET=TP-LINK_POCKET_3020_D6E207 
br0: port 2(ath0) entering forwarding state

 TL-MR3020 mips #199 Tue Mar 20 11:38:41 CST 2012 (none)
TL-MR3020 login: root
Password: 5up
Jan  1 00:01:13 login[150]: root login  on `ttyS0'



BusyBox v1.01 (2012.01.16-03:21+0000) Built-in shell (msh)
Enter 'help' for a list of built-in commands.

# help

Built-in commands:
-------------------
	. : break cd continue eval exec exit export help login newgrp
	read readonly set shift times trap umask wait

# cd /bin
# ls
busybox       df            kill          msh           sh
cat           echo          login         ping          true
chmod         false         ls            ps            umount
date          iptables-xml  mount         rm
#

Mot de passe par défaut pour la console série :
login = root
password = 5up

Mot de passe par défaut pour l’interface web :
login = admin
password = admin

Ps: Je n’ai pas pris le temps de regarder l’interface web de base …
J’ai juste booté le routeur pour être sûr qu’il fonctionnait puis immédiatement après je l’ai démonté

–

Prochaines étapes à réaliser :
- Compilation de openWRT trunk pour le TL-MR3020
- Flash du nouveau firmware
- Mise à jour du bootloader u-boot (quoi que celui d’origine semble déjà à jour)
- Boot de la uImage et d’un rootfs sur une partition de la clef usb
- Intégration de la carte arduino avec mon code BlyssSpoofer / BlyssSniffer
- Mise en place d’un GUI html + cgi

–

Bonus pour les curieux :

Les deux côtés du pcb en haute résolution

–
Bon WE et bidouillage à tous !

Classé dans:Corrigé, projet, tutoriel Tagged: madeinfr, openwrt

aucun rétrolien

Fabien B.

Mardi, septembre 4 2012

[Bricolage - partie 1] Alimentation d’atelier DIY à partir d’une alimentation d’ordinateur

Par Fabien B. le Mardi, septembre 4 2012, 15:47 - Planet

Bonjour tout le monde !

Aujourd’hui j’entame la première partie d’une série de deux voir trois articles au sujet d’un projet/bricolage en cours.
Le but de ce projet est de fabriquer une alimentation d’atelier à la pointe de la technologie (humm … ou pas) à partir d’une vieille alimentation d’ordinateur.

Dans cette première partie je vais vous parler de la phase « décorticage » de l’alimentation ainsi que du projet en lui même
Pour la suite on verra plus tard quand j’aurai reçu les divers composants.

Ps: histoire de rendre l’article un peu moins barbant il est écrit sous la forme d’un « cahier photo ».
(Ok en réalité c’est juste que j’ai la flemme de tout détailler )

–

Le projet :

-> Faire une alimentation d’atelier high-tech à partir d’une alimentation d’ordinateur trouvé à la casse
Ça peut paraitre un peu ambitieux comme projet mais c’est réalisable sans problème

Mon cahier des charges (rien ne dit que je le respecterai jusqu’à la fin mais bon) :
- 3 sorties de puissance : +3v3, +5v et +12v
- Un écran avec affichage des tensions / courants sur chaque sortie
- Une gestion avancé du PSU (allumage, réarmement en cas de surcharge, …)
- Avertissement en cas de surcharge imminente sur une sortie
- Un minimum de sécurité (fusible remplaçable, liaison à la terre, bouton ON / OFF secteur, …)
- Un boitier design pour contenir tout le bordel

–

Étape 1, trouver une alimentation :

Si vous avez une casse/décharge d’électroménager prés de chez vous, ou une entreprise qui fait le ménage ça se trouve assez facilement ce genre de petite alimentation d’ordinateur

–

Étape 2, comprendre la connectique ATX :

Une alimentation d’ordinateur comporte plein de connectiques différentes mais une seule est vraiment intéressante dans notre cas, à savoir celle de la carte mère.
Et pour avoir son câblage il suffit de demander à l’ami google

Cf : http://pinouts.ru/Power/atx_v2_pinout.shtml

On peut voir que l’alimentation comporte plusieurs lignes de sorties :
- +3v3 : +3v3 de puissance
- +5v : +5v de puissance
- +12v : +12v de puissance
- -12v : -12v (/!\ faible ampérage disponible sur cette ligne)
- GND : Masse commune
- POWER_OK : Cette ligne passe à +5v lorsque les tensions sur les lignes de puissance sont stabilisées
- PSU_ON : Reliez cette ligne au GND pour mettre en marche l’alimentation
- +5v « standby » : +5v pour l’électronique de contrôle (cette ligne est toujours à +5v que l’alimentation soit en marche ou non)

Concernant les puissances admissibles sur chaque ligne, voici ce qui est noté sur mon alimentation :

+3v3 @ 9A, +5v @ 16A, +12v @ 4A … c’est vraiment pas mal !
C’est largement au dessus de la plupart des alimentations d’atelier du commerce

–

Étape 3, démontage et décorticage :

C’est le moment de tout démonter, niark niark niark ]:)

/!\ STOP /!\

Avant de démonter une alimentation d’ordinateur (ou quoi que ce soit relié au secteur) :
- Vérifiez que l’alimentation est débranché
- Vérifiez que les condensateurs de l’alimentation ne sont pas chargés (laissez l’alim débranchée au moins 48h pour être sûr)
- Reliez PSU_ON et GND, cela finira de décharger les condensateurs de l’alimentation (au cas ou)
- Utilisez des gants en tissu, l’acier non ébavuré ça coupe et ça peut faire très mal !

PS: si vous n’êtes pas capable de comprendre ce que est noté sur le gros sticker jaune ci dessus, il serait préférable de trouver une autre idée de bricolage

–

Let’s go !

Première série de vis enlevée.

Deuxième série de vis enlevée, les choses ce précisent.
Hoho ! Un jolie ventilateur en vue !

Le capot est ouvert, on peut déjà voir les radiateurs, les transformateurs/bobinages et la carte de contrôle de l’alimentation.

Gros plan sur le circuit de l’alimentation.
Évitez de mettre vos doigts là dedans, le gros condensateur au centre et son collègue emballé dans du plastique jaune sur la droite ne sont pas vos amis

Remarque: amateurs de colle chaude vous allez être content … hummm délicieusement dégueulasse …
On appréciera tout particulièrement la self sur la droite qui est collée au radiateur avec cette *bip* de colle blanchâtre.

Démontage du circuit, on se retrouve avec un méli-mélo de câbles, une led qui pendouille et un connecteur secteur en vrac …
Va falloir faire un peu de ménage dans tout ça

Gros plan sur le circuit de contrôle de l’alimentation.
On peut voir le connecteur pour le ventilateur et un câble reliant un capteur de température (monté sur le radiateur) et le circuit.

Pourquoi un capteur de température ?
En cas de surcharge les mosfets chauffent, le radiateur chauffe et le circuit de contrôle coupe donc l’alimentation.
Si vous vous attendiez à un truc « propre » faudra repasser un autre jour

–

Étape 3, opération pince coupante :

Histoire de rendre les choses plus simple pour travailler, j’ai :
- coupé les connecteurs pour garder juste les fils,
- enlevé TOUTES ces petites saloperie de serre-câble,
- nettoyer le ventilateur et enlevé plusieurs décennies de poussière …

J’ai ensuite dessoudé tout les câbles de puissance, pour ne conserver que les câbles de contrôle / faible puissance.
Concernant les câbles de puissance ils seront remplacés plus tard par du « gros » câble pour tableau électrique qui pourra facilement tenir les +16 ampères.

–

Étape 4, premières « améliorations » :

J’ai remplacé le fusible 5A directement soudé au pcb par une douille à fusible « standard » (à vis).
Le jour ou il faudra changer le fusible je serai bien content d’avoir ajouté cette douille

Juste pour la petite histoire, le fusible d’origine était « tout simplement » soudé au pcb … impossible à remplacer en cas de problème … super !
J’ai aussi re-câblé la led (qui sert de témoin d’alimentation) sur des fils plus long.

–

Étape 4, agencement des connecteurs en vue de la mise en place dans un nouveau boitier :

Pour la face arrière je vais pas me casser la tête, j’ai prévu de placer le fusible au dessus du connecteur secteur comme dans la plupart des alimentations d’atelier.

Le ventilateur sera à l’arrière et enverra l’air vers l’extérieur, je ferai des trous sur le dessus du boitier pour l’entrée d’air.
Le circuit risque de bouffer un peu de poussière avec le temps, il faudra peut être envisager de mettre un filtre sur l’entrée d’air …

Concernant la face avant, les choses sont encore à l’état de plans.
J’envisage quelque chose dans ce gout là :

Avec un montage qui ressemblerait à ça :

(admirez un peu mes talents de dessin sous paint ^^ »)

–

Prochaine étapes :
- câblage du contrôleur + partie analogique sur plaque à essais
- montage du contrôleur + lcd
- code arduino + test
- boitier + test final

Comme précisé dans l’introduction, je publierai la suite de ce projet dés que j’aurai les divers composants, pour le moment patience

Classé dans:Corrigé, projet Tagged: diy, madeinfr

aucun rétrolien

Fabien B.

Mardi, juillet 10 2012

[DIY] Ampli audio stéréo pour VS10xx

Par Fabien B. le Mardi, juillet 10 2012, 15:44 - Planet

Bonjour tout le monde !

Aujourd’hui j’ai le plaisir de vous faire découvrir les plans de mon ampli audio miniature, fait maison bien sûr.

Je tient à préciser que je n’ai pas réinventer la roue, mon schéma est en grande partie (pour ne pas dire en totalité) basé sur les travaux de sonelec-musique :
http://www.sonelec-musique.com/electronique_realisations_ampli_casque_001.html

Je me suis d’une certaine manière contenté de faire le routage / typon du schéma proposé en y apportant une modification mineur.

–

Le schéma :

Remarque sur le schéma : Comme me l’as fait remarquer une de mes lecteurs il y a une erreur de calcul au niveau de C1 / C2.
Il ne s’agit pas de condensateurs 3.3nF mais bien de condensateurs 3.3µF !
Aprés (re)calcul du filtre passe haut j’ai décider de mettre des condensateurs C1 / C2 de 1µF ce qui correspond le mieux avec la fréquence basse du VS10xx (15Hz).
Désolé pour cette erreur stupide sur la puissance de 10 …

Le montage est composé :
- d’une masse virtuelle qui « transforme » la tension +9v d’une pile « standard », en une alimentation -4v5 / +4v5 différentielle,
- d’une protection hardware pour le chipset VS10xx,
- d’un montage amplificateur opérationnel + push-pull pour l’amplification du signal.

Remarque :
Je n’est pas inclut de protection anti ESD, je part du principe que celle ci est déjà intégré dans la breakout VS10xx utilisé (dans mon cas un breakout VS10xx de sparkfun).
De même je pars du principe que le montage anti ESD + liaison à la masse de GBUF est aussi intégré dans la breakout VS10xx.

Important : La broche GND du connecteur « LINE » doit être relié à la broche AGND du VS10xx pas à la broche GBUF !

La masse virtuelle fourni l’alimentation +/- 4.5v nécéssaire au bon fonctionnement de l’amplificateur opérationnel (ici un TL082 pour avoir un bon rendu audio), qui se charge d’amplifier le signal audio.
Le montage push-pull à transistor vient ensuite fournir la puissance nécéssaire pour controler des hauts parleurs de 8 ohms directement en sortie.

Vous remarquerez qu’il y a deux séries d’entrées, une avant et une âpres le filtre de protection pour le chipset VS10xx.
Cela permet d’utiliser le montage avec une breakout VS10xx aussi bien qu’avec un lecteur mp3 classique.

Note : J’aurai pu utiliser des 2N2222 / 2N2907 à la place des BC547 / BC557 pour avoir plus de puissance en sortie, mais l’alimentation n’aurai pas suivit.

Concernant l’amplification elle est d’environ x10 (+20dB) au maximum comme le précise sonelec-musique.
Le rendu des aigüe et des basses est très bon (vu le prix / taille du montage bien sur), c’est équivalent à un lot de mini enceinte usb « low cost ».

–

Le routage :

–

Prévisualisation 3D de la carte :

–

Le typon :

–

L’implémentation des composants :

–

Le résultat final :

Face avant :

Face arrière :

Oui je sait c’est pas très propre !
–

Le montage en fonctionnement :

–

L’entrée ligne relié à un lecteur MP3 (pas fait de photo avec la breakout VS10xx … oups) :

Un câble audio a malheureusement perdu la vie pour servir de connecteur jack vers SIL-3, son sacrifice restera gravé dans nos cœurs

–

La sortie connecté au hauts parleurs :

J’aime beaucoup utiliser des pinces croco
(Non sérieusement il faut que je me fasse un câble SIL3 vers jack femelle, les pinces croco ça va 2 minutes mais après c’est chiant …)

Voila voila, tous à vos fers à souder

Classé dans:projet Tagged: diy, madeinfr