[eshapeoko] Moteurs commandés

(Pour commencer, voir ici l’annonce du projet)

J’ai commandé ce matin les 4 moteurs pas à pas nécessaires à ma CNC. Et des micro-switches fin de course.

Ce sont des modèles au format NEMA23, plus gros que les moteurs de reprap au format NEMA17. Cette image montre la différence:

Moteurs Nema17 / Nema23
Moteurs Nema17 / Nema23

L’intérêt supplémentaire, c’est que les moteurs de Makerslide sont des modèles 400 pas par tour, ce qui est une très bonne chose pour la résolution de la machine. En général, on ne trouve que des 200 pas par tour.

J’ai aussi choisi les drivers que j’utiliserai pour les piloter. Ce sera les modules Pololu DRV8825, capables de fournir 2 ampères (la datasheet parle même de 2.5A, pas mal!). Ils peuvent aussi fonctionner en micro-step 1/32, ce qui fait 12800 pseudo-pas par tour! Je ne pense pas que le système mécanique qui y sera attaché soit aussi précis!

Je commence aussi à réfléchir au design électronique. Je me doute que ces bestiaux vont chauffer (c’est d’ailleurs incroyable qu’on arrive à faire passer autant de courant dans un aussi petit composant !), donc j’ai déja prévu de les plaquer coté composants sur une plaque de cuivre ou un bon radiateur en alu (avec de la graisse thermique), qui servira de fond de boitier pour la carte électronique. En ajoutant des parois sur le bord du radiateur, j’aurai ainsi une boite fermée.

J’ai dépensé, tout compris, et après conversion, un total de 150,68 euros. Je suivrai le budget de près!

Voir l’annonce du projet

 

 

Pourquoi Openmakersdaily va changer de nom

Quand, il y a un an, j’ai décidé de faire un blog présentant mes bricolages, il a fallu lui trouver un nom “intelligent”, ou au moins, intéressant. J’ai cherché pendant longtemps une combinaison de mots liés à mon domaine pour en faire une expression sympa: ambiance open source, makers, et travail régulier avec “daily”, un peu comme un journal.

J’ai donc choisi Openmakersdaily, un mot valise composé de 3 mots, 6 syllabes, et 15 lettres, qui correspondait à un ensemble de domaines “com-net-org” encore libre. Je n’ai pas pensé à twitter à ce moment, et j’ai eu une double chance, que ce nom soit libre, et qu’il soit juste pas trop long pour que je puisse m’en servir sur twitter.

Mais je dois avouer que je ne suis qu’à moitié satisfait de ce nom. Avec le recul, je le trouve bien trop long, difficile à prononcer et à retenir, et surtout composé exclusivement de mots anglais alors que mon objectif est de bloguer en français. Mais il avait pour mérite d’exprimer mes objectifs avec ce blog, alors je l’ai utilisé.

Maintenant que j’ai un peu de recul, et surtout depuis que mon activité a pris un petit peu d’ampleur (en grande partie grâce à twitter et quelques rencontres), je trouve que ce nom est de plus en plus difficile à porter:

– Qu’est ce que tu fais?
– Je suis bloggueur en électronique!
– Ha, bien, c’est quoi ton blog?
– Openmakersdaily point org!
– OpenmaQUOI?

Cela s’est produit plusieurs fois et a fini par me convaincre que ce nom n’est pas ce qu’on peut faire de mieux.

Depuis quelques jours donc, j’ai décidé de trouver un nouveau nom. Pas facile, il devait être court, original, disponible sur le web, et représenter les activités que je décris. Toute combinaison de mot aboutissait à quelque chose de trop long, restait les sigles: OMD, ok, mais c’est pas très représentatif. C’est encore plus difficile de trouver un sigle intelligent qui se prononce bien. On n’invente pas “GNU” tous les jours.

Et puis je me suis dit: pourquoi ne pas mettre en avant le fait que je suis radioamateur? Ce hobby représente en fait un grand nombre des valeurs que je décris. Effectivement, je n’ai pas décidé de devenir radioamateur sans raison, c’est une activité qui me convient plutôt bien:

  • les radioamateurs sont les plus anciens makers du monde. Il ne faut pas oublier que le radio-amateurisme a été inventé vers 1900 pour permettre à des particuliers “intéressés” de pratiquer les techniques de la radio, tout justes découvertes par Marconi et compagnie, avec un but éducatif et personnel, à l’inverse des premières sociétés de radiocommunication (comme la Société Française de Radiotéléphonie: SFR, ça vous dit quelque chose?). Ceux-ci ont commencé à radiobricoler dans leur coin, puis au moment où l’Etat a voulu règlementer les télécommunications, ces gens sont allé, un par un, faire valoir leur droit à l’auto-éducation et négocier des autorisations personnelles au Ministère des Postes. L’Etat a toujours accepté et a rapidement fait inscrire ces autorisations dans les lois, à coté des communications de l’Armée et des Entreprises. Les autres pays ont rapidement suivi le mouvement avec l’ONU et la mise en place de l’ITU. C’est une des premières reconnaissances officielles d’un mouvement de fabrication personnelle. Aujourd’hui les Radioamateurs sont reconnus “d’utilité publique” grâce à leur capacité de mise en place d’un réseau de communication indépendant et robuste en cas de catastrophes naturelles.
  • Dans le cadre de mon activité de radioamateur, je fabrique aussi des choses intéressantes qui méritent d’être présentées ici, et je participe à des super projets, ce qui sera intéressant à décrire, et en même temps, les radioamateurs ne sont pas en permanence branchés sur leur micro et leur antenne: Le radioamateurisme est plutot une ambiance, une manière de vivre amicale, qui met en avant la communication et les réalisations personnelles; c’est exactement compatible avec l’objectif de mon blog maker.
  • Mon indicatif radio, F4GRX, fournit un nom court, prononçable, original, et unique que je peux utiliser tel quel pour un site. Je l’ai déja: http://www.f4grx.net, mais il n’est pas activé. Le F initial représente directement la France, exactement comme les indicatifs des avions.

Bref, vous l’avez compris, openmakersdaily.org va devenir f4gr.net. Le site actuel restera en place comme une redirection, et les anciennes URL resteront valides grâce à un petit coup de config htaccess, en suivant bien les conseils de google pour déménager un site.

Pendant un moment, j’avais décidé de ne pas me présenter en tant que radioamateur pour ne pas être “catégorisé”, mais après tout, tant pis pour ceux qui me catégoriseront, un radioamateur se doit d’avoir un esprit ouvert et comme je l’ai déja dit, c’est juste un bricoleur avec un droit d’émettre, donc c’est un bricoleur avant tout. D’ailleurs je pense à l’instant que cela me donnera peut être l’occasion de faire des interviews de radioamateurs intéressants.

Je suis maintenant à l’écoute de vos avis et questions afin que je complète ces explications.

[Projet] Ma future CNC / imprimante 3D

Bon, les circuits pour le module NFC sont partis chez SeeedStudio, merci à eux pour leur efficacité et leur bon service: ils se rappellent encore qu’ils ont oublié de me livrer un truc il y a un an, et vont me l’ajouter gratos à ma commande!

En attendant, j’ai un peu de temps libre. Dans les transports, au lieu de jouer à Kicad, je vous pouvoir avancer la rédaction de mon guide pour débuter en électronique, et je vais aussi démarrer mon grand projet de fond, celui qui donnera le sens à la vie, à l’univers, et au reste.

Je vais me monter une imprimante 3D.

Non, une CNC.

Non, en fait, j’arrive pas à choisir.

Donc ce sera les deux.

Je vais prendre une eShapeoko. C’est une plate forme peu chère, très robuste, et assez universelle. Vu sa construction, je n’aurai pas de difficulté à la reconvertir à l’envie, en CNC ou en imprimante 3D, je n’aurai qu’à remplacer la “broche” par un extrudeur, et ajouter un hot plate.

Je me fais pas d’illusions, j’ai vu plein de gens à l’Electrolab passer leur soirées sur les réglages, je sais qu’il y aura beaucoup de travail.

Mais bon, je me dis qu’avec mes ambitions de bricolage, avoir un moyen de production rapide à la maison n’est pas un luxe. Je vais choisir toutes les options de la eShapeoko qui garantissent le maximum de robustesse, avec l’objectif d’usiner du bois (medium) et peut être de l’aluminium (même si c’est lent).

Je compte aussi la mettre à disposition de mes amis makers qui auraient des besoin d’impression 3D. On verra quand ce sera en “production”, mais ça me plairait de filer un coup de main aux potes.

Voici ce que je vais prendre dès que j’aurai reçu mon sponsoring d’anniversaire (:D) :

  • kit eshapeoko avec options: double axe x, double drive y, longueur étendue, perçages nema23
  • 4 moteurs nema23
  • driver moteurs, 1 arduino pour grbl
  • Peut être que j’utiliserai un raspberry pi pour le pilotage.
  • pour la broche, je sais pas encore. J’ai une petite perçeuse qui doit aller pour le bois avec une alim suffisante.
  • une table de travail de 50×60 en bois épais, avec 4 pieds en cornières acier, et des étagères intermédiaires pour ranger les accessoires
  • un capot en plexi pour éviter de mettre de la poussière partout. Et un adaptateur pour l’aspirateur…

Ca me permettra de découper et percer des plaques de MDF, c’est l’objectif numéro 1.

Ensuite on passera à l’objectif numéro 2, l’impression 3D, ça me demandera d’investir dans différents accessoires:

  • hotplate
  • extrudeur adaptable à l’emplacement de la broche. Là, je sais que je pourrai compter sur les copains de l’Electrolab.

Bref, tout un programme!
J’ai déja des tonnes d’idées supplémentaires: broche plus puissante pour travailler l’alu, bloc de démultiplication pour améliorer la résolution des déplacements. Il m’en viendra d’autres!

Bien entendu, je décrirai ici l’avancement de mon projet. Au boulot!

[Projet] Module NFC

Le NFC, c’est une technique de communication sans contact, qui est utilisée pour les cartes de transport et autres cartes CB sans contact. Le signal est modulé à une fréquence de 13,56 MHz, ce qui est une bande “ISM” comme le 2.4 GHz ou le 433.92 MHz. En dehors du NFC, cette bande sert aux machines à plasma en physique, semiconducteurs, etc.

J’ai remarqué qu’il existait peu de lecteurs NFC hackables et abordables.

Le seul que je connaisse est le OpenPCD, basé sur un chip lecteur NFC de NXP. Ce projet implémente un lecteur de cartes sans contact dont le micrologiciel est fait pour expérimenter.

Je suis récemment tombé sur le circuit de Texas Instruments TRF7970A, qui, non seulement, est capable de fonctionner comme le circuit de NXP (lecteur de carte, ou “initiator” en langage NFC), mais également en mode “peer to peer” et “target” (émulation de carte). C’est un composant ridiculement petit (QFN) mais facilement disponible. Malgré sa petite taille pénible à souder, il mérite qu’on s’y intéresse. Un kit d’évaluation est disponible auprès de TI, mais 1) j’aime pas les kits d’évaluation et 2) c’est cher (49 ou 99 dollars). Donc je vais faire ma propre carte.

En suivant toutes les docs de référence fournies par TI, j’ai été capable de développer ma propre carte d’évaluation, au format 5×5 cm.

La première carte est une antenne adaptée munie de son circuit d’adaptation d’impédance: Les valeurs des composants seront à calculer selon des formules (magiques pour les débutants) après avoir caractérisé l’inductance de l’antenne. Je reviendrai sur ces calculs plus tard.

Schéma antenne
Schéma antenne

Le dessin de l’antenne est basé sur un design NXP à plusieurs tours qui permet d’avoir les deux fils de sortie de l’antenne du même côté.

Circuit de l'antenne
Circuit de l’antenne

La deuxième carte est le “lecteur” proprement dit, qui porte un autre circuit d’adaptation d’impédance, le circuit TRF, et une connexion SPI vers un microcontroleur Tiva C, le successeur du Stellaris qui se trouve sur la carte Stellaris Launchpad. Voici quelques caractéristiques techniques:

  • Front-end NFC Texas Instruments TRF7970A
  • Connecteur coaxial UFL pour l’antenne
  • Microcontroleur ARM Cortex M4 Tiva C Series TM4F123
  • 256k de flash
  • 32k de RAM
  • Port USB (OTG non câblé, donc seulement device)
  • Port I2C
  • UART
  • Port JTAG sur header 10 points (pinout ARM standard)
  • 20 GPIO disponibles sur header au pas de 2.54mm
  • Alimentation 5V, par USB ou externe
Schéma frontend NFC
Schéma frontend NFC

Et le circuit:

PCB Frontend NFC
PCB Frontend NFC

J’ai réussi à me débrouiller pour avoir très peu de pistes coté cuivre, du coup le plan recouvre tout le dessous du circuit. La majorité des pistes vertes que vous voyez relient tous les points de masse, pour m’assurer que je n’en oublie aucun. En réalité, toutes ces pistes seront noyées dans le plan de masse. J’utilise cette technique pour m’assurer que mon plan de masse est en un seul morceau.

Dans la semaine qui vient, je vais envoyer ces deux circuits chez SeeedStudio, je pense en faire au moins dix, peut être plus. Si avoir ces circuits vous intéresse, signalez vous, je n’utiliserai pas les 10 donc contre une petite obole, je pourrai vous envoyer un jeu de circuits. Mais je ne les donnerai pas, je connais trop de projets qui finissent par prendre la poussière sur l’étagère…

Niveau réalisation, il y a un TQFP (pas trop dur) et un QFN. Il vaut mieux souder ça à l’air chaud, mais ça doit aussi être possible au fer très fin.

Niveau logiciel, c’est complexe. Avant d’avoir un lecteur de cartes fonctionnel, il faudra du temps. Mais c’est possible, je n’ai aucun doute, surtout si je suis pas tout seul. On peut imaginer de la communication avec les téléphones NFC du moment. Les possibilités sont infinies, Internet est vaste, et plein de docs.

Pour les libs bas niveau, je pense partir de ce que j’ai déja développé pour la carte Stellaris Launchpad, ma librairie FreeStella, qui permet d’initialiser le CPU et de faire fonctionner l’uart. Cette lib n’a aucune dépendance, elle permet le développement “bare metal” à partir du vecteur de boot de l’ARM. Elle ne se base pas sur le TivaWare / StellarisWare, et elle est publiée avec une licence très permissive.

Je vous tiens au courant, et en attendant, parlez moi de vos idées. Qu’est ce qu’on va bien pouvoir faire de cool avec ce projet?

[Mini Tuto] Travailler en virgule fixe

Suite à discussions avec @skywodd du blog skyduino, qui parlait avec délectation des calculs en virgule fixe, j’ai décidé de faire un petit point sur le sujet pour montrer que c’est pas si difficile que ça.

Ce post va concerner le langage C.

A l’origine: la virgule flottante

En C, quand on veut traiter des nombres à virgule, on va utiliser des variables de type float ou double. Ces types de données gèrent les nombres à virgule avec une notation “signe-mantisse-exposant”, c’est à dire en format “scientifique. En maths on a plutot l’habitude des nombres en base 10, par exemple 1,27 x 10^3. En informatique, on utilise la base 2, c’est aussi le cas dans les float/double.

Quand le compilateur C rencontre des expressions flottantes, il y a 2 possibilités:

  • soit le CPU cible est équipé d’un FPU (floating point unit) matériel, et dans ce cas le compilateur peut générer des instructions assembleur qui font appel à ce fpu.
  • soit le CPU n’en est pas équipé, et les instructions correspondantes sont implémentées par de longues routines écrites en assembleur, pour gcc c’est libm qui s’en occupe. (thx Skywodd, pas libgcc)

Dans la plupart des micro-contrôleurs embarqués de type PIC ou AVR (ou même ARM non cortex M4) il n’y a pas de FPU, du coup les opérations en flottant, si elles sont supportées par le compilateur, sont à éviter pour des raisons de performances.

Problèmes en virgule flottante

Parfois on veut gérer directement des grandeurs physiques, comme quand on écrit le code pour un accéléromètre, un appareil de mesure de tension/courant, etc.

La méthode “triviale” est de passer en float.

Regardons le code suivant:

#define REF_VOLTAGE (float)5.0 //valeur de la tension de référence
#define CONV_MAX 2048 //valeur max de mesure pour un convertisseur 12 bits (exemple)

unsigned short conv = adc_read(); //lire le résultat de la conversion, c'est un entier

float voltage = conv / CONV_MAX * REF_VOLTAGE; //règle de trois!

//maintenant on a une tension

Ce code est mauvais : il commence par faire une division, puis une multiplication. Selon les compilateurs, ça peut être grave, car si CONV_MAX n’est pas converti en flottant, la division produira toujours un résultat zéro: Eh oui, le résultat de cette division sera toujours compris entre zéro et un! Nous pouvons apporter une correction pour éviter cela:

float voltage = conv / (float)CONV_MAX * REF_VOLTAGE;

C’est moins mauvais… Cette fois c’est la précision qui en prend un coup. L’erreur d’arrondi dûe à la précision limitée de la division va être multipliée par REF_VOLTAGE, le résultat sera peu précis. On peut faire mieux de cette manière:

float voltage = (float)(conv * REF_VOLTAGE) / (float)CONV_MAX;

Cette fois, on  va diviser un plus grand nombre, et les erreurs d’arrondis seront minimales.

Maintenant, étudions le problème des performances, en essayant de se passer des nombres flottants.

L’optimisation: la virgule fixe

Dans beaucoup de cas en informatique embarquée, on veut pouvoir gérer des nombres dont les variations sont limitées, c’est à dire qu’on n’a pas besoin de gérer des exposants très différents. C’est le cas par exemple lorsqu’on gère la tension issue d’un convertisseur analogique numérique.

Dans ce cas, le convertisseur va générer un nombre de quelques bits, par exemple 8 à 16 bits. Le résultat de la conversion est un entier, et la plupart du temps cette information suffit.

Remarquons que la plupart des nombres à virgules simples peuvent s’écrire comme une fraction. Évidemment ce n’est pas le cas de tous les nombres, mais dans le cadre de la précision limitée qui nous intéresse, c’est le cas. Exemple: 1,23 = 123/100

On peut décider de fixer ce dénominateur et de le rendre implicite: on ne l’écrit plus. Cela nous permet de travailler avec des entiers “plus grands”.

Si je choisis par exemple 100, tous les nombres ayant deux chiffres après la virgule peuvent s’écrire comme des entiers:

  • 1,23 => 123
  • 4,67 => 467
  • 1,5473 => 155

J’ai choisi une convention de virgule fixe à deux chiffres après la virgule, ce qui en réalité, signifie que je travaille avec des nombres 100 fois plus grands que la réalité.

Si on transpose ceci dans le domaine de l’informatique, il faut faire les choses intelligemment. On ne va plus utiliser des puissances de dix, mais des puissances de deux, car c’est le système naturel de comptage de l’ordinateur. L’avantage, c’est que les multiplications et les divisions se transforment en décalages. Exemples:

* pour multiplier par 16, je décale vers la gauche de 4 bits.
* pour diviser par 32, je décale vers la droite de 5 bits.

Avec cette idée, je ne vais plus utiliser des nombres ayant deux chiffres après la virgule, mais de nombres ayant N bits après la virgule. Pas de panique, ça veut dire qu’au lieu de multiplier mes valeurs par 10,100,1000, je vais les multiplier par 16,32,…1024, etc.

Cela ne change rien au résultat: cela veut juste dire que je travaille avec des valeurs N fois plus grandes que le résultat souhaité.

Dans la plupart des cas en embarqué, on va travailler avec des nombres à virgule fixe de 16 (short) ou 32 (long) bits.

On choisit ensuite le nombre de bits après la virgule. Cela permet de définir une grande quantité de formats:

  • le format 8.8 code les nombres sur 16 bits, avec un dénominateur de (1<<8) = 256, il reste 8 bits pour la partie entière, ce qui permet de coder les nombres de 0 à 255 avec une précision de 1/256, ou de -128 à 127 si on garde le signe
  • le format 12.4 permet de coder de 0 à 4095 (12 bits entiers) avec une précision de 1/16
  • etc… etc…

Donc 5,0 volts flottants, si je le traduis en entier ça fait 5 volts, en format 8.8 ça fait (5<<8)+0 = (5*256) = 1280, et en format 12.4, ça fait (5*16) = 80
Si vous lisez 80 en format 12.4, ça fait en réalité: (80/16) = 5

Calculs en virgule fixe

C’est le même principe que pour les fractions, et dans notre cas elles sont déja réduites au même dénominateur D, celui qu’on a choisi. Un nombre en virgule fixe s’écrit <quelque chose>/D.

L’addition et la soustraction sont triviales, c’est la même chose que pour les entiers:

a/D + b/D = (a+b)/D

Il suffit donc de faire la somme de deux nombres en virgule fixe pour retrouver un nombre en virgule fixe dans le même format, sans autre chose à faire.

Pour la multiplication:

a/D * b/D = (a*b)/(D*D)

mais j’ai besoin de fractions dans lequel le dénominateur est toujours D. Je peux réécrire ce résultat en divisant en haut et en bas par D, ce qui ne change pas le résultat:

(a*b)/(D*D) = (a*b/D)/(D*D/D) = (a*b/D)/D

Le résultat de la multiplication de a et b est donc (a*b/D). En pratique, cela veut dire que chaque fois que vous multipliez deux nombres en virgule fixe dans le même format, il faut diviser ensuite le résultat par D. Comme on a dit que D était une puissance de deux, ça revient à un décalage.

Division: (a/D) / (b/D) = (a/D) * (D/b) = a/b = (a*D/b) /D

Vous me suivez? Pour retrouver un nombre dans le bon format, il faut donc multiplier par D après la division. Normal, c’est le réciproque de la multiplication!

Pour la comparaison, rien à signaler, on peut le faire directement, ce format ne change pas l’ordre des nombres entiers: a/D < b/D si et seulement si a < b .

Pour transposer un nombre flottant (ou entier) en format à virgule fixe, il suffit de le multiplier par D.

Pour transformer un nombre à virgule fixe en format flottant (ou en entier), il suffit de le diviser par D.

Conclusion

J’espère que ce petit aperçu vous aura clarifié les idées. En résumé, il s’agit de :

  • Choisir un dénominateur D assez grand pour la précision que vous souhaitez, celle ci vaudra 1/D. Pour avoir un avantage, il faut que D soit une puissance de 2.
  • Multiplier tous les nombres à manipuler par D, cela se fait par décalage à gauche.
  • L’addition et la soustraction se font avec des opérations normales sur les entiers.
  • La multiplication se fait comme pour les entiers, on divise ensuite par D en décalant à droite.
  • La division a/b se fait en prémultipliant a par D, puis en faisant une simple division entière par b.
  • La comparaison se fait comme pour les entiers

Et c’est tout!

Novena, le laptop open source de Bunnie Huang

Je ne présente plus Bunnie Huang, ce grand hacker et concepteur de matériel libre aux nombreuses réalisations importantes pour le monde du hacking. J’adore le fait qu’il vive pleinement son objectif d’améliorer le monde par la conception électronique.

En décembre, il nous avait présenté son projet courant, un laptop open source. Il faut bien réaliser la difficulté de ce projet: il ne s’agit pas d’un arduino, il faut être capable de comprendre le design complexe d’un appareil récent de haute technicité, en faire un schéma complet incluant des composants en boitier BGA, des bus parallèles haute bitesse à longueur controlée pour la DDR, des paires différentielles USB, SATA, LVDS, etc. C’est pas de la tarte. Tout ce petit monde doit rentrer dans une carte à au moins 4 couches si ce n’est plus.

Le projet a bien avancé. Pour vous en dire un peu plus, je vais maintenant lui passer le micro en vous présentant une traduction de l’article qu’il a publié aujourd’hui.


Nouvelles de Notre Laptop (aka Novena)

En décembre dernier, j’ai blogué à propos du fait que je construis un laptop ouvert. Le message a généré des centaines de commentaires, et j’ai été bien surpris de rencontrer tant d’intérêt.

Pour être honnête, ça m’a un peu dépassé. De plus, beaucoup de gens ne comprenaient pas ce que nous sommes en train de faire, ce qui se voyait aux suggestions du genre “mettez y un Core I7 et un bon GPU nVidia, vendez le pour moins de 1000 euros, et je l’achèterai”.

Plutôt que de tenter de convaincre tout Internet, ou de me laisser distraire par une campagne Kickstarter alors que le projet est très complexe et particulièrement risqué, j’ai décidé de rester discret et de me concentrer sur ce que je fais le mieux – hacker du hard.

Donc malgré le manque de nouvelles par ici, le projet est toujours bien vivant et actif. Tous nos progrès ont pu être suivis via nos repository git et sur notre wiki. Il y a aussi un forum de discussion, même si je n’y passe qu’environ une fois par mois. Le déroulement de la mise sous tension de la carte et la matrice de validation des fonctionnalité se trouve ici, et la liste des modifications entre le prototype de validation électrique (EVT)  et le prototype de validation de la conception (DVT) est documentée ici. Nous nous sommes également amusés à écrire du code pour calibrer les délais de propagation sur le bus DDR3 pour quelques modules SO-DIMM.

NDT: Bunnie nomme “EVT” (engineering validation test) la version initiale de la carte, et “DVT” (Design validation test) la version révisée de la carte.

La version “trop long; rien lu” de ce qui se trouve dans le wiki est donc : la carte a subi une révision majeure et a reçu quelques améliorations qui, je le pense, ont véritablement affiné la vision que nous avons de ce projet.

Le FPGA

Pour moi, la présence du FPGA est un vrai point de différenciation, donc je l’ai boosté; la carte DVT intègre maintenant un plus gros FPGA, un Spartan 6 LX45, doté d’une alimentation améliorée. Je veux être capable d’utiliser le FPGA comme un coprocesseur, ainsi que pour l’acquisition de données; je lui ai donc ajouté un buffer de 2 Gbit de DDR3 (256 Mo), connecté par un bus à 800 Mtransferts/seconde sur 16 bits. Pour finir, je veux pouvoir brancher divers modules d’acquisition de données à haute vitesse, donc j’ai laissé tomber le connecteur Raspberry Pi et les E/S analogiques à basse vitesse; tout le bloc est remplacé par un simple connecteur d’extension à haute vitesse. Ce connecteur met à disposition 21 paires différentielles, ainsi que quelques lignes simples. C’est suffisant pour connecter deux ADC 8 bits à 500 Msps au FPGA, ce qui en fait un système d’acquisition particulièrement correct (NDT: permettant de faire du SDR très large bande, par exemple).

L’affichage

Pour moi, il est très important d’avoir beaucoup de pixels sur mon portable. Nous avons donc révisé l’interface LCD pour qu’elle soit facilement améliorable et remplaçable en utilisant des cartes d’adaptation en mezzanine. Le premier adaptateur que nous avons conçu permet de piloter un écran Retina. Nous utilisons maintenant un écran LG LP129QE de 12,85 pouces, d’une résolution de 2560 x 1700 pixels, (soit une densité de 239 PPI), avec des couleurs en 24 bits. Il est vraiment magnifique.

On voit ci-dessous à quoi ressemble la carte mezzanine. Le circuit flex fait sur mesure transfère un double bus LVDS de 24 bits, l’alimentation, le PWM pour le rétroéclairage, un bus I2C et USB. La carte contient un circuit convertisseur de LVDS vers DisplayPort, et elle se connecte à l’écran par ces nouveaux micro-câbles coaxiaux genre IPEX.

J’ai déja passé du temps sur le design industriel (NDT: la mise en boite!) mais je ne suis pas encore prêt à partager ces détails avec tout le monde; je dirai seulement que le boitier sera fait de cuir et d’aluminium, et qu’il est fait pour être ouvert, accessible, et facilement adaptable aux futures versions de la carte mère.

En attendant, nous développons sur le système dans un état “explosé”. L’image ci-dessous montre tous les composants essentiels connectés et en fonctionnement; le clavier/souris, LCD, disque dur, carte mère, le tout exécutant son propre environnement de développement. Le bureau affiché est un Ubuntu armhf de base avec notre propre noyau personnalisé, mais cette décision est loin d’être finale; nous testons un large choix de distributions pour vérifier leur compatibilité et leur praticité.

Le boîtier routeur

Beaucoup de gens ont montré de l’intérêt pour utiliser le Novena en tant que routeur sécurisé — pour beaucoup de gens du métier, l’ouverture du système est un argument déterminant. A cette fin, nous avons conçu un boitier de conversion qui permet d’intégrer la carte mère dans un design qui rappelle un routeur conventionnel.

Le disque dur de 2,5 pouces donne une idée de l’échelle.

Le dessus est en aluminium anodisé, et la plupart des vis sont décoratives. Au départ, je voulais rappeler l’ambiance des monolithes noirs mystérieux et m’amuser à cacher les vis. A l’inverse, les vis sont maintenant présentées clairement, comme pour inviter l’utilisateur à les dévisser pour ouvrir l’objet. “Il n’y a rien de magique dans cette boite. Ouvrez moi et vous comprendrez.”

Ci dessus un routeur sans son couvercle et tous les ports connectés. Pour les partenaires avec qui je travaille, afin réduire les coûts, il est probable que nous ne câblerons que les les deux connecteurs ethernet, l’USB OTG et l’alimentation.

Le premier hack (Le Romulator)

Le Novena DVT a déja été mis à contribution pour nous aider dans nos projets de hacking. Nous avons implémenté un “romulator” grâce à la combinaison de l’interface haute vitesse, du FPGA et de la DDR3.

L’idée est d’émuler de la flash NAND en temps réel et en circuit, en utilisant le FPGA et la DDR3. Le FPGA émule fidèlement le circuit NAND, dont le contenu peut être visualisé et modifié en temps réel par le CPU i.MX6 — la DDR 3 a des tonnes de bande passante, et le macroblock DDR de Xilinx est configuré pour fournir 4 ports virtuels à la RAM. En plus, 16 Mo de DDR3 sont réservés à la capture du trafic NAND, comme un analyseur logique, ce qui nous permet d’explorer l’historique de transactions complexes, et de comprendre ce qui s’est passsé et ce qui a foiré.

Une petite carte en circuit imprimé flexible est directement branchée dans le connecteur d’extension haute vitesse. La carte est suffisamment fine pour être soudée directement sous un chip de flash pour une surveillance passive, ou directement sur la carte mère cible pour une émulation active.

D’autres cartes seront conçues pour ce port. Ma liste inclut une carte ADC rapide, des variantes pour l’acquisition de signaux digitaux, et des blocs PHY (transceivers) pour des bus standards tels que l’USB ou le HDMI.

Conclusion

Pour conclure, nous nous amusons bien à construire le portable que nous avons toujours voulu — il se situe maintenant entre un oscilloscope scriptable en python, un analyseur logique, et un laptop. Je pense qu’il va se révéler être un outil indispensable au hacking, particulièrement pour l’analyse de signaux qui demandent de conserver la synchronisation entre plusieurs couches de protocoles, des conditions de déclenchement complexe et/ou des stimuli en retour.

En ce qui concerne la question inévitable de la commercialisation, et pour combien… une fois que nous aurons terminé la construction du système (et “terminé” est très vague —  franchement, je pense que ce projet est continuellement en cours de développement et d’amélioration), je mettrai l’appareil à disposition d’acheteurs qualifiés. Parce qu’il est open source et un peu délicat à prendre en main, j’hésite à vendre ce projet à tous ceux qui ont juste besoin d’un laptop. Je m’inquiète des acheteurs qui ne comprennent pas que le mot “ouvert” nécessite aussi de mettre un peu la main à la pâte pour que tout fonctionne, et que les choses sont continuellement en développement. Ceci pourrait aboutir à un taux de retours important, ou à passer les quatres prochaines années de ma vie coincé à faire du support technique de base au lieu de faire du développement; aucune de ces deux options ne m’intéresse. Je pense donc que le formulaire d’achat sera un programme python ou javascript qu’il faudra modifier correctement et soumettre via github; ou alors je vendrai juste le kit de composants, ce qui ciblerait uniquement ceux qui savent où ils s’aventurent, et qui savent RTFM (lire le put…n de manuel). De manière très probable, le prix sera celui qu’on s’attend à payer pour un oscilloscope numérique qui restera des années dans le labo, pas pour un vulguaire “merdable” qui sera à la poubelle dans un an. Pensez à cet ordi comme un “bijou de famille”.

Enfin bref, voila le point d’avancement. Je repars hacker!


Le mot de la fin: Tout bien compris, merci Bunnie pour tout ce que tu fais pour la communauté des hackers. Je commence à économiser…