Archives de mars, 2013

Bonjour à tous !

Alors aujourd’hui je vous propose de faire communiquer un MSP430 et une Arduino par une liaison sans-fil à base de NRF24l01+.

Nrf24L01, késako ?

Ces modules de communication sont très intéressants pour plusieurs raisons :

* Le prix : à moins de 3€ sur ebay par module, on peut imaginer créer tout un réseau pour presque rien.
* Ce sont des transceivers : à la fois émetteur et récepteur.
* 2,4 ghz : ça élimine beaucoup d’interférences.
* 128 canaux et plusieurs canaux de réception par module : ça permet d’avoir plusieurs émetteurs pour un seul récepteur sans risquer de collision.
* Plusieurs fonctions directement implémentées : ré-émission automatique, CRC (checksum) …
* Portée : 100m en champs libre, 20 m en intérieur (après ça dépend des murs et du débit). Pour 12€ il existe des modules avec amplificateur de puissance, pas testé mais la portée est annoncée à 1000 mètres.
* La consommation (le point qui m’intéresse, vous après verrez pourquoi 😉 ) : à fond ils bouffent 12mA et à la plus faible puissance on tombe à 8 mA. Mais ce n’est pas tout, il utilise la technologie Shockburst qui consiste lors d’une émission à émettre toutes les trames d’un coup. Autrement dit, si on communique à 10 kbits par seconde avec le module alors il va « accumuler » les données, et une fois qu’on lui demande de transmettre il envoi tout d’un coup, ce qui réduit au maximum la consommation. Enfin on peut les mettre en veille, la consommation tombe alors à moins de 1µA (mais le SPI est toujours actif !). Le réveil est assez rapide (<130µs).

Bref ils ont de quoi convaincre ! Datasheet : http://www.nordicsemi.com/kor/Products/2.4GHz-RF/nRF24L01P

Un doc en anglais, une sorte de synthèse commentée de la datasheet qui m’a pas mal aidé (attention cependant elle traite des modules pas « + ») : http://www.diyembedded.com/tutorials/nrf24l01_0/nrf24l01_tutorial_0.pdf

Comparé à la version « + » il n’y a surtout que quelque registres qui changent.

Si vous voulez plus d’infos et/ou vous limiter au cas de l’arduino, je vous recommande les articles de M. Skywodd : http://skyduino.wordpress.com/2012/01/20/tutoriel-arduino-mirf-v2-nrf24l01/ http://skyduino.wordpress.com/2012/02/01/arduino-transmission-valeur-analogique-par-nrf24l01/

Alors pourquoi interfacer un MSP430 et un Nrf ?

Et bien comme vous l’avez vu, la consommation est particulièrement optimisée, et c’est également la spécialité des MSP430 (et en plus les deux utilisent du 3,3V). Prenons un exemple simple : une sonde de température ambiante. On n’a pas besoin de prendre la température toutes les secondes, seulement une mesure toute les 10 secondes, voire une toute les minutes. Et voilà le principe de fonctionnement :

1) Réveil du MSP430 et du NRF24L01+.

2) Acquisition de la température.

3) Emission radio vers la base.

4) On rendort tout le monde pendant 10 sec.

Les étapes 1) 2) et 3) prennent environ 200 µs. Donc pendant la très grande majorité du temps, la consommation est inférieure à 2µA, et pendant 200µs elle reste très modérée : 400µA du NRF + 400µA pour un MSP430 à 1mhz. L’émission consomme 12 mA mais pendant 10-20 µs.

J’ai fait un essai avec une émission toutes les 2 secondes, alimenté par un condensateur goldcap 5F. Ca a tenu 2 jours, ce qui me donnait une consommation de ~10µA. Avec un pile bouton 200 mAh, ce montage pourrait tenir : 200 000 / 10 / 24 / 365 = 2,3 an ! Et à 0,5 hz de fréquence ! Imaginez si vous greffez un panneau solaire ou si on passe à une émission par minute … Les applications sont quasi infinies !

Allez, assez de théorie place à la pratique !

Alors sachez que je me suis pas mal débattu avec ce trio … Car il y a quelques paramètres qui diffèrent entre les deux librairies, et le problème c’est qu’on bosse en aveugle : tant que tous les paramètres ne sont pas bons, il n’y a pas de communication et le debug est pour ainsi dire quasi-impossible … Bref voici le code côté MSP430 (lib = https://github.com/spirilis/msprf24) :

#include <msp430.h>
#include "msprf24.h"
#include "nrf_userconfig.h"

char addrTX[]={'t','e','s','t','2'};

char buf[]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; // trame exemple

int main(void) {

WDTCTL = WDTPW + WDTHOLD;
BCSCTL2 = SELM_0 + DIVM_0 + DIVS_0;

if (CALBC1_1MHZ != 0xFF) {
DCOCTL = 0x00;
BCSCTL1 = CALBC1_1MHZ; /* Set DCO to 1MHz */
DCOCTL = CALDCO_1MHZ;
}

BCSCTL1 |= XT2OFF + DIVA_3;
BCSCTL3 = XT2S_0 + LFXT1S_0 + XCAP_0;
TA0CCTL0 = CM_0 + CCIS_0 + OUTMOD_0 + CCIE; // configuration du timer à 1 s
TA0CCR0 = 4095;
TA0CTL = TASSEL_1 + ID_0 + MC_1;

UCB0CTL1 |= UCSWRST; // configuration du SPI
UCB0CTL0 = UCMSB + UCMST + UCMODE_0 + UCSYNC;
UCB0CTL1 = UCSSEL_2 + UCSWRST;
UCB0BR0 = 64;
UCB0BR1 = 6;
UCB0CTL1 = ~UCSWRST;

P1DIR|=BIT0;

rf_crc=RF24_EN_CRC|RF24_CRCO; // CRC active, 16-bit
rf_addr_width=5; // On utilise une adresse de 5 bytes
rf_speed_power=RF24_SPEED_2MBPS|RF24_POWER_0DBM; // vitesse 1MBPS et puissance max
rf_channel=1;

msprf24_init();

msprf24_set_pipe_packetsize(0,16); // payload de 16 byte sur le pipe 0
msprf24_open_pipe(0,1); // ouverture du pipe avec Auto-Acknowledgement

w_tx_addr(addrTX); // configuration adresse émission
w_rx_addr(0,addrTX); // configuration adresse réception idem à celle de transmission
                      // pour permettre la réception de l'ACK

msprf24_standby(); // module en veille (pas endormi)

while(1){

if(msprf24_is_alive()) { // fait clignoter la LED rouge sur launchpad si
	P1OUT^=BIT0; // le nrf est bien connecté
}else{
	P1OUT&=!BIT0;
}

LPM3; // on endort

w_tx_payload(16,buf); // on charge le FIFO avec le tableau buf
msprf24_activate_tx(); // émission
msprf24_get_irq_reason(); // récupère les alertes du NRF
while(!(rf_irq && RF24_IRQ_TX)) msprf24_get_irq_reason(); // tant que la transmission n’est pas finie, on boucle
msprf24_irq_clear(RF24_IRQ_TX); // on efface les flags d’alerte

}

}

#pragma vector=TIMER0_A0_VECTOR
__interrupt void TIMER0_A0_ISR_HOOK(void) {
LPM3_EXIT;
}

+

Modification du nrf_userconfig.h : en haut il y des constantes suivant la fréquence de fonctionnement, il suffit de décommenter la partie qui vous correspond et de commenter les autres et en bas la partie hardware pour définir où sont brancher les pins CE, CSN et IRQ si vous l’utilisez. J’avoue j’ai pas approfondi le code plus que ça, et il n’est pas optimisé. Il y a surement des lignes que je pourrai virer, mais ils m’avaient tellement fait galérer ces modules que j’en avez marre xD

Comme je vais reprendre ce principe bientôt, je publierai une mise à jour 😉

Côté Arduino :

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

void setup(){
  Serial.begin(9600);
  ConfigMirf();

  Serial.println("Listening...");
}

void loop(){

  if( Mirf.dataReady()){

    byte data[Mirf.payload];
    Mirf.getData(data);

    for (int i=0;i<16;i++){
      Serial.print(data[i]);
      Serial.print(" ");
    }
Serial.println(" ");

  }

}

void ConfigMirf(){

  Mirf.spi = &MirfHardwareSpi;
  Mirf.cePin=8;
  Mirf.csnPin=7;

  Mirf.init();

  Mirf.setRADDR((byte *)"2tset");
  Mirf.setTADDR((byte *)"1tset");
  Mirf.payload = 16;
  Mirf.config();

}

+

Modification du fichier Mirf.h : en effet chose étonnante les créateur de cette lib n’ont pas créé de fonction directe pour modifier la gestion de la CRC … Il faut modifier cette ligne en haut :


#define mirf_CONFIG ((1<<EN_CRC) | (1<<CRCO) ) // CRC active 2 bytes, correspond ici avec le code du MSP 430

#define mirf_CONFIG ((1<<EN_CRC) | (0<<CRCO) ) // CRC active 1 byte

#define mirf_CONFIG ((0<<EN_CRC) | (0<<CRCO) ) // CRC désactivée

Alors vous aurez peut-être noter les petites différences :

* Les adresses ne sont pas dans le même ordre.

* Les canaux sont décalé de 1 (MSP = de 1 à 128, Arduino = de 0 à 127)

Alors après bien sur vous pouvez remplir buf avec ce que vous voulez. A noter également qu’ici je n’ai pas géré la mise en sommeil du Nrf, seulement celle du MSP, mais c’est très facile, il suffit de faire :


msprf24_powerdown(); // endort

msprf24_standby(); // réveil, nécessite 130µs d’après la datasheet

Pour recevoir côté MSP430, en gardant les paramètres du précédent code :


msprf24_get_irq_reason();

if(rf_irq && RF24_IRQ_RX) {

msprf24_irq_clear(RF24_IRQ_RX);

r_rx_payload(16,buf);

}

Bon la du coup ça reste assez simpliste au niveau des fonctionnalités, mais débroussaillé tout ça m’a pris un temps fou vu ces quelques différences foireuses dures à débusquer … Mais ça fait déjà le principal : envoyer et recevoir des données. Je n’ai pas été très explicite dans le code, si vous comprenez pas n’hésitez pas je compléterais 😉

Enjoy !

EDIT 12/06/13 : suite à des problèmes d’un lecteur j’ai repris mon code et trouvé quelques erreurs. En fait il y a quelque chose qui m’échappe avec le registre EN_AA qui permet l’activation de l’auto-acknowledgment. Il s’agit d’une fonction qui permet à l’émetteur de confirmer que son message a bien été reçu. Je ferai un peu plus de test demain mais je pense avoir trouvé. En tout cas j’ai édité les codes de l’articles qui fonctionnent avec un launchpad équipé d’un G2553 et une Arduino nano (ou Uno et compagnie c’est pareil, testé sur Mega également, il suffit d’adapter les n° de pins).

Une remarque également : la librairie Arduino utilise le pipe 1 pour recevoir car apparemment c’est le pipe 0 qui reçoit les ACK, ce qui permet de le garder libre. C’est pourquoi sur le MSP430 il faut configurer le pipe 0 avec la même adresse que celle utilisée pour l’envoi, une façon de reconnaître la provenance de l’ACK et d’éviter tout conflit.

 

EDIT n°2 13/06/13 : deux points : j’ai approfondi le coup de l’auto-acknowledgment. Il faut également que ce paramètre soit synchronisé sur les deux parties ! Par défaut le nrf l’a d’activé, donc si on ne précise pas côté Arduino, il faut utiliser sur le MSP430 :

msprf24_open_pipe(0,1);

+

Il faut mettre d’adresse du destinataire en réception sur le pipe 0.

Si on ne veut pas d’ACK, dans ce cas on désactive côté arduino avec :

Mirf.configRegister(EN_AA,0); // ACK disabled

+

Côté MSP :

msprf24_open_pipe(0,0);

Second point le câblage. Bon côté Arduino y’a pas de mystère je pense. Côté MSP :

MISO P1.6
MOSI P1.7
SCK P1.5
CE P2.4
CSN P2.3

Attention, CE et CSN sont dépendants de ce que vous avez mis dans nrf_userconfig.h. Pour avoir cette config j’ai :


/* CSN SPI chip-select */
#define nrfCSNport 2
#define nrfCSNportout P2OUT
#define nrfCSNpin BIT3

/* CE Chip-Enable (used to put RF transceiver on-air for RX or TX) */
#define nrfCEport 2
#define nrfCEportout P2OUT
#define nrfCEpin BIT4
Publicités

Bonjour à tous !

Ça faisait quelques semaines que le projet me trottait dans la tête, j’ai décidé de passer à l’acte : construire un fraiseuse CNC.

Qu’est-ce que c’est ?

Une CNC c’est en gros, une perceuse pilotée par des moteurs pas-à-pas.  Ça permet sans aucune connaissance en menuiserie et autres artisanats de matériaux de fabriquer des pièces au dixième de millimètre.
Il vous suffit de faire un tour sur Youtube et vous verrez à quoi ça ressemble et ce qu’on peut faire avec.

Problème principal : c’est cher. L’entrée de gamme (hors électronique)  tourne autour de 200€ grand mini, mais ça grimpe très vite, la plupart du temps c’est mini 500€.

Mais quel intérêt pour un DIYer ?

Fabriquer des façades de boitier ultra propres et engravées, des bâtis moteur, des supports, des pancartes, de graver des PCB et de les percer … Bref la encore c’est l’imagination la principale limite.

Ma mienne

Le cahier des charges dans mon cas était le suivant :

– Un coût très bas (<100 euros hors électronique).
– Une fabrication qui nécessite le moins d’outils possible pour que chacun puisse la faire sans être fraiseur-tourneur depuis 20 ans …
– Des matériaux et pièces facilement trouvables.
– Une fabrication la plus simple possible, en minimisant les coupes notamment (moins de coupes = moins de chances de ne pas être aligné)
– Pas de contrainte sur la vitesse de fraisage. Je suis un DIYer, pas un pro 😉
– Le plus open-source possible.
– Capable de travailler de l’alu (en basse vitesse s’il faut).

Afin de remplir le dernier point, je suis parti sur une défonceuse. Pourquoi ? Vitesse de rotation (3500-22000 tr/min pour la mienne), et mécanique prévue pour les mouvements latéraux.
Et oui, les perceuses par exemple sont prévues pour des mouvements axiaux et on peut flinguer les roulements très vite et vive le jeu … J’ai pris celle de Brico-dépôt : 20€, 1000W et vitesse réglable !

Du coup ça implique un certain poids à prendre en compte dans le design. Le design justement : pour le guidage, j’ai choisi des glissières de tiroir. Le système de guidage, c’est souvent ce qui coûte un bras. Après recherche, c’est chez « l’entrepôt du bricolage » que j’ai trouvé mon bonheur : prix et qualité (enfin quand c’est neuf). Et elles vont dans les deux sens, alors que chez Mr Bricolage elles ne vont que dans un sens, ce qui limite l’amplitude de mouvement.

Pour le choix du matériau de base, je suis parti sur du médium : « solide » et prix contenu. Je mets des guillemets parce que c’est rigide, mais comme c’est de la poudre de bois compactée, ça s’effrite facilement. Alors comme des planches de 2m c’est chiant à transporter, j’ai cherché des plaques plus petites (en plus si j’ai pas à découper en largeur c’est une grosse partie des coupes en moins, et droite qui plus est). Mais souvent, ça douille … Spéciale dédicace à Casto ! Et chez Mr Bricolage ils ont des planches de 120×60 pour 13€, et les 60 cm c’est ce que j’avais prévu 😉

Après tergiversation, je suis arrivé à ça :

3D_2 3D_1

Alors j’ai la chance d’avoir un papa pas mal équipé niveau bricolage ! Scie à ruban et perceuse à colonne notamment. En fait j’ai pas eu besoin d’un matos ultra évolué, et tout ce que j’ai eu à faire est réalisable avec du matos encore plus simple (scie sauteuse ou circulaire par exemple). Et une perceuse à colonne, ça démarre à 50€ et ici ça suffit.

Les photos (en vrac) :

_DSC7956 _DSC7955 ???????????????????????????????????? ???????????????????????????????????? ???????????????????????????????????? ???????????????????????????????????? ???????????????????????????????????? _DSC7944 ???????????????????????????????????? ???????????????????????????????????? ???????????????????????????????????? ???????????????????????????????????? ???????????????????????????????????? ????????????????????????????????????

Le vrai défi ça a été de tout couper/percer en prévision de l’alignement … Donc quand on peut, coller les pièces ensemble et faire un trou, comme ça après montage c’est forcement aligné 😉

J’ai choisi un montage cheville/encollage (surtout pour l’esthétique à vrai dire …) mais à refaire j’utiliserais de la bonne vieille vis (sans oublier les avants-trous néanmoins).

Pour les déplacements, ça sera une tige filetée avec des bagues qui serve en temps normale à les relier avec des moteurs pas-à-pas surporter grâce à des entretoises comme celles qu’on trouve dans les PC. Photos au prochain épisode.

Pour la défonceuse, il faut bricoler un peu ! Il faut virer toutes les parties métalliques pour alléger et by-passer le bouton poussoir (sur une défonceuse la mise en marche n’est pas verrouillable, en tout cas sur celle la) :

IMG_1318 IMG_1317 IMG_1316

Un peu de gaine thermo et hop tout propre 🙂 Au passage j’ai changé la prise « classique » pour compacter un peu.

J’ai pas pris de photo mais la variation de vitesse se fait via un bête gradateur. Pas impossible que j’en rajoute un piloter par l’Arduino plus tard … 🙂

Bilan des dépenses (pour le moment)

– Bois 3 x planches = 3 x 13 = 39€ Mr Bricolage
– Roulements x 3 = 3 x 1 = 3€ Ebay (moi je les ai récup sur des moteurs 230V usagés, y’en a chez Décathlon aussi)
– tige filetée x 2 = 2 x 2 = 4€ Brico dépôt
– Glissières = 9 + 5 + 5 = 19€ Entrepôt du bricolage
– boulons cylindriques = 3 x 2 = 6€ Brico dépôt
– Chevilles bois = 3€ Brico dépôt
– Colle à bois = 4€
– Défonceuse = 20€ Brico dépôt
= 98€ Objectif complete !

Côté électronique (et oué quand même)

Pour l’électronique j’ai beaucoup réfléchi : il faut savoir que piloter des CNC nécessite de maîtriser parfaitement le temps réel. Et oui si les moteurs ne sont pas parfaitement synchro ça fait un ovale au lieu d’un rond … Et apparemment (la ça dépasse mes compétences) Windows est une vraie daube dans le domaine (merci aux trolleurs de linuxiens de s’abstenir :p).

De plus, on trouve très peu de freeware pour piloter une CNC sur cet OS. Enfin dernier problème : les électroniques de pilotage utilisent pour la très grande majorité le port LPT, qui tend à disparaître.
Bref côté DIY tout ça c’est pas jojo. Et la du coup, pourquoi pas utiliser une Arduino non d’un chien ? Et nous y voila ! Mais avant le détail la théorie : pour fabriquer une pièce il faut tout d’abord dessiner sa pièce en 3D (typiquement en open source, freeCAD).

Ensuite il faut convertir cette objet en 3D en G-Code. Le G-code est le langage universel : grosso modo c’est un fichier texte qui dit « axe des X bouge de 200 mm à 5mm/min, axe des Z … » chaque ligne correspondant à une étape. Donc la il faut un autre logiciel pour réaliser cette étape (faut que j’étudie les solution open source la).

Et enfin il faut convertir ce texte en pilotage réel. Et la, soit on utilise encore un autre soft (certains logiciels rassemblent toutes ces fonctions, la plupart coutent plus cher que l’appareil … je dis pas que c’est volé bien au contraire, mais pour un DIYer ça fait bizarre) qui va piloter le LPT (le LPT se comportant alors comme des simples sortie digitales) ou bien on passe un microcontrôleur sur lequel on streamer le G-code.

Cette dernière solution présentent d’énormes avantages : plus de problème de temps réel, le µC est parfait pour ça, USB, et enfin multi-plateforme (et oui les Apple-ien, jusqu’à présent ils l’avaient dans l’os dans le domaine !)

Deux solutions existent alors :

– GRBL : un excellent article dessus  http://www.civade.com/post/2011/06/15/piloter-une-CNC-avec-Arduino-GRBL-moteurs-pas-a-pas
Cette solution me pose un problème : il faut mettre les mains dans le cambouis, il faut passer par AVR Studio si on veut essayer de comprendre et/ou modifier le code … Bref c’est pas user-friendly et j’ai pas le temps pour le moment d’apprendre un autre environnement.

– Librairie RepRap : http://reprap.org/wiki/G-code   ahaaaaa !! La ça me plaît 🙂 Une vraie lib Arduino ! J’ai pas approfondi à fond mais ça semble correspondre à mes attentes. Pour l’instant je mets ça de côté, je verrais quand tout le hardware sera opérationnel afin de pouvoir vraiment tester mais il semble déjà que les développeurs ont pensé à utiliser une carte SD … Donc même pas besoin de PC 🙂

Sur ebay on trouve pour 30-40 euros des cartes à base de TB6560 :

$T2eC16ZHJGoE9nuQgj-zBQGKJLWCfQ~~60_12

On en trouve beaucoup de bleu, apparemment elles sont pas terribles … Alors que les rouges corrigent la plupart des défauts. Celle la en plus a un port pour une télécommande manuelle. Même si j’aurais pu hacker directement le LPT, je voulais garder les deux si jamais en cas de problème je devais me rabattre sur des solutions plus « traditionnelles ». Hier j’ai réussi a comprendre qui fait quoi sur ce port car aucune doc n’est dispo (WTF?!) et le marquage sur le PCB est totalement faux … Mais ça a l’air de fonctionner, au prochain épisode je vous montrerai ça et les systèmes de guidages 😉

Bilan 

C’est quand même pas simple … Beaucoup d’heures de travail, beaucoup de recherches … Ça coûte cher ces bestioles mais on se dit que c’est pas du luxe parce quand on doit le faire soi-même il faut s’attendre à cravacher. J’espère qu’à la fin de l’aventure je vous aurez donné toutes les clés pour que ça soit beaucoup plus simple pour vous, j’étudie déjà d’autres solutions pour un bâti certes plus cher (et encore) mais beaucoup plus facile à monter.

EDIT : suite des aventures ici