Archives par mot-clé : arduino

Balise autonome WSPR avec MSP430

[GTranslate]

Ces derniers jours je me suis amusé un peu à programmer le LaunchPad de TI avec Energia. Le but étant de voir si du code Arduino (AVR ATMega) était facilement portable sur le MSP430.

Capture port série Balise WSPR MSP430 XV4Y (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/05/Capture-Balise-WSPR-MSP430 NULL.jpg)La réponse est oui, si le code est propre (pas toujours facile) et s’il n’utilise pas des librairies non encore portée sur Energia (ce qui va diminuer avec le temps). En pratique je suis parti d’un morceau de code de F4GKA/VA2GKA (http://www NULL.itsrainingelephants NULL.com/2012/04/29/wspr-30m-ready/#comments) et d’un autre de DH3JO (http://wsprnet NULL.org/drupal/node/1342) pour faire une balise WSPR autonome. Le code est fonctionnel mais n’a pas encore été testé sur l’air. Cerise sur le gâteau, il est “rétroportable” sur Arduino car il suffit de changer les numéros de broches.

J’ai encore un peu de travail autour de cela, mais pour les curieux voici les résultats de quelques heures de réflexion ce matin. Il me faut maintenant connecter cela sur la balise QRSS du kit de G0UPL / G0XAR et voir comment cela se comporte en particulier du point de vue dérive de la synchronisation dans le temps. Contrairement à mon Arduino Nano le LaunchPad n’est pas équipé d’origine d’un quartz mais j’ai ce qu’il faut sous la main.

Au passage la modification du kit balise QRSS peut se faire comme l’a fait IW1QLH avec une échelle R-2R (http://www NULL.iw1qlh NULL.net/index NULL.php/projects-hardware-mainmenu-66/99-qrp/115-qrss-beacon).

Le fichier pour Energia/Arduino est disponible au téléchargement (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/05/WSPR_autonome_XV4Y NULL.txt). Attention, il faudra renommer le fichier en .ino au lieu du .txt (WordPress n’aime pas les .ino)

/* WSPR Static Generator for MSP430G2553
* Code for Energia 005a</code>

* By Yannick DEVOS - XV4Y - May 2012
* Free for HAM Radio usage

* Based on VA2GKA Guenael Jouchet code for sending
* Based on DH3JO Martin Nawrath for WSPR sequence encoding

*
* Internal clock of MSP430 could be not stable enough, try a Crystal
* Start the circuit on the second 0 of an odd minute

* Ouput on 2 bits PinA and PinB
* Mirror on LED1 and LED2 du LaunchPad for testing
* Output to Serial for testing
* Using an R-2R ladder it makes the G0UPL/G0XAR beacon frequency shift
*/

#include// Comment on Arduino, replace mySerial by Serial everywhere

#define wsprPinA 7
#define wsprPinB 6
#define LEDPinA 14
#define LEDPinB 2
#define StartBtn 5

const char SyncVec[162] = {
1,1,0,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,1,0,0,1,0,1,1,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,
1,1,0,0,1,1,0,1,0,0,0,1,1,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,1,1,0,0,0,1,1,0,1,0,1,0,
0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,1,1,0,1,1,0,0,1,1,0,1,0,0,0,1,1,1,0,0,0,0,0,1,0,1,0,0,1,1,0,0,0,0,
0,0,0,1,1,0,1,0,1,1,0,0,0,1,1,0,0,0
};

const char call[] = "XV4Y ";
const char locator[] = "OK20";
const byte power = 20;

int i;
char symbol;

int ii,bb;

byte c[11]; // encoded message

byte sym[170]; // symbol table 162
byte symt[170]; // symbol table temp
unsigned long n1; // encoded callsign
unsigned long m1; // encodes locator

TimerSerial mySerial; // Comment on Arduino

//******************************************************************
// Defining pins mode
// Encoding the WSPR sequence

void setup() {
mySerial.begin(); // Comment on Arduino
pinMode(wsprPinA, OUTPUT); // Change for Arduino/AVR
pinMode(wsprPinB, OUTPUT); // Change for Arduino/AVR
pinMode(LEDPinA, OUTPUT); // Change for Arduino/AVR
pinMode(LEDPinB, OUTPUT); // Change for Arduino/AVR
pinMode(StartBtn, INPUT_PULLUP); // INPUT for Arduino and put pin to HIGH
// digitalWrite(StartBtn, HIGH); // Don't use this on LaunchPad/MSP430

mySerial.print("\n\n\n*** MSP430 WPSR beacon \n");

encode_call();
mySerial.print("call: ");
mySerial.print(call);
mySerial.print(" ");
mySerial.print(n1,HEX);
mySerial.println(" ");

encode_locator();
mySerial.print("locator: ");
mySerial.print(locator);
mySerial.print(" ");
mySerial.print(m1 &lt;&lt; 2,HEX);
mySerial.println(" ");
for (bb=0;bb mySerial.print(c[bb],HEX);
mySerial.print(",");
}
mySerial.println("");
encode_conv();

mySerial.println("");

for (bb=0;bbmySerial.print(symt[bb],DEC);
mySerial.print(".");
if ( (bb+1) %32 == 0) mySerial.println("");
}
mySerial.println("");

interleave_sync();

mySerial.println("Channel symbols :");
for (bb=0;bb mySerial.print(sym[bb],DEC);
mySerial.print(".");
if ( (bb+1) %32 == 0) mySerial.println("");
}
mySerial.println("");

};

//******************************************************************
// Here starts the actual sequence sending

void loop() {
digitalWrite( wsprPinB, LOW );
digitalWrite( LEDPinB, LOW );

digitalWrite( wsprPinA, LOW );
digitalWrite( LEDPinA, LOW );
mySerial.println("*** Sequence sending delayed.");
mySerial.println("*** Press S2 to start now.");
i = 0;
while (i &lt; 9408) {
delay(1);
if (digitalRead(StartBtn)==LOW) {
i = 20000;
} else {
i++;
};

}

for (i = 0; i &lt; 170; i++) { symbol = sym[i]; mySerial.print(symbol%10, DEC); mySerial.print(" "); digitalWrite( wsprPinB, (symbol &gt;&gt; 1) );
digitalWrite( LEDPinB, (symbol &gt;&gt; 1) );

digitalWrite( wsprPinA, (symbol &amp; 1) );
digitalWrite( LEDPinA, (symbol &amp; 1) );
delay(682.667);
};
mySerial.println("\n *** End of sequence");
};

/* Functions declaration
* This code by DH3JO
* KHM 2009 / Martin Nawrath
* Kunsthochschule fuer Medien Koeln
* Academy of Media Arts Cologne
*/

//******************************************************************
void encode() {
encode_call();
encode_locator();
encode_conv();
interleave_sync();
};
//******************************************************************
// normalize characters 0..9 A..Z Space in order 0..36
char chr_normf(char bc ) {
char cc=36;
if (bc &gt;= '0' &amp;&amp; bc = 'A' &amp;&amp; bc &gt; 20;
t1=n1;
c[1]= t1 &gt;&gt; 12;
t1=n1;
c[2]= t1 &gt;&gt; 4;
t1=n1;
c[3]= t1 &lt;&lt; 4; } //****************************************************************** void encode_locator(){ unsigned long t1; // coding of locator m1=179-10*(chr_normf(locator[0])-10)-chr_normf(locator[2]); m1=m1*180+10*(chr_normf(locator[1])-10)+chr_normf(locator[3]); m1=m1*128+power+64; // merge coded locator and power into message array c[] t1=m1; c[3]= c[3] + ( 0x0f &amp; t1 &gt;&gt; 18);
t1=m1;
c[4]= t1 &gt;&gt; 10;
t1=m1;
c[5]= t1 &gt;&gt; 2;
t1=m1;
c[6]= t1 &lt;&lt; 6;

}
//******************************************************************
// convolutional encoding of message array c[] into a 162 bit stream
void encode_conv(){
int bc=0;
int cnt=0;
int cc;
unsigned long sh1=0;

cc=c[0];

for (int i=0; i &lt; 81;i++) {
if (i % 8 == 0 ) {
cc=c[bc];
bc++;
}
if (cc &amp; 0x80) sh1=sh1 | 1;

symt[cnt++]=parity(sh1 &amp; 0xF2D05351);
symt[cnt++]=parity(sh1 &amp; 0xE4613C47);

cc=cc &lt;&lt; 1;
sh1=sh1 &lt;&lt; 1;
}

}

//******************************************************************
byte parity(unsigned long li)
{
byte po = 0;
while(li != 0)
{
po++;
li&amp;= (li-1);
}
return (po &amp; 1);
}

//******************************************************************
// interleave reorder the 162 data bits and and merge table with the sync vector
void interleave_sync(){
int ii,ij,b2,bis,ip;
ip=0;

for (ii=0;iibis=1;
ij=0;
for (b2=0;b2 &lt; 8 ;b2++) { if (ii &amp; bis) ij= ij | (0x80 &gt;&gt; b2);
bis=bis &lt;&lt; 1;
}
if (ij &lt; 162 ) {
sym[ij]= SyncVec[ij] +2*symt[ip];
ip++;
}
}
}

Premiers pas avec le LaunchPad de TI

Texas Instruments LaunchPad Value kit MSP430 (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/05/100_3157 NULL.jpg)J’ai reçu mes deux kits LaunchPad il y a quelques jours. Oui, deux, car une première commande qui s’était conclue par une erreur du serveur web a quand même abouti. A 4,30$ le bout je n’ai pas annulé la commande… Au passage, livraison en temps record par Fedex avec 4 jours ouvrés, la douane ne semble même pas avoir ouvert le paquet.

La présentation est beaucoup plus valorisante que celle de l’Arduino Nano qui m’était tombé entre les mains il y a un an. Belle boîte, câble USB, petits autocollants, connecteurs… rien ne manque. Bonne nouvelle aussi, les micro-contrôleurs livrés sont équipés de respectivement 16ko (MSP430G2553) et 8ko (MSP430G2452), beaucoup mieux que les 1 et 2ko indiqués sur le site web lors de la commande. Détail pratique : la platine du Launchpad est équipée de petits patins en mousse permettant de la poser sur un bureau sans problèmes.

IDE Energia pour LaunchPad sous OS X (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/05/Energia_Launchpad NULL.jpg)J’ai commencé à jouer un peu avec ce circuit en utilisant l’IDE Energia. Ce dernier étant un fork d’Arduino, la prise en main est rapide. Le fait de se retrouver avec un langage similaire (inspiré de Wiring/Processing) aide aussi beaucoup. Par contre le manque de documentation ou du moins l’absence d’homogénéité de celle-ci est pénalisante. Contrairement à la plateforme Arduino pas de définition matériel précise et le brochage n’est pas évident à connaître car il change suivant la version du processeur. Les terminologies utilisées me paraissent un peu obscures mais c’est peut-être une histoire de temps pour trouver les docs.

En tous cas, le fait de pouvoir programmer facilement le micro-contrôleur et ensuite implanter le CI autonome dans un circuit ouvre de nouvelles possibilités.

Petit ajout : La version d’Energia que j’utilise est la 005a, mais celle sur laquelle travaille les développeur est la 006. Pas mal de travail entre les deux, en particulier sur le nommage des broches. L‘exemple disponible en ligne pour utiliser la sonde thermomètre ne fonctionne pas tel que car la broche P1.3 qui lit le contact PUSH2 semble en état instable. Elle permet en tous cas de voir que les broches sont accessibles tout simplement par le numéro sur le boîtier, mais il faut alors se plonger dans les datasheet… D’autres exemples sont en ligne mais sont prévus pour la 006, et je n’ai pas trop envie de me mettre à compiler moi-même le logiciel.

Convertisseur port USB vers port parallèle Centronics

Convertisseur USB parallèle - dos PCB (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/05/ul-16i2 NULL.jpg)Au passage, pour ceux qui utilisent encore des interface de programmation à port parallèle pour leurs PIC, AVR ou autres micro-contrôleurs, voici un petit convertisseur à réaliser soit même pour un coût tout à fait modique (http://www-user NULL.tu-chemnitz NULL.de/~heha/bastelecke/Rund%20um%20den%20PC/USB2LPT/ul-16 NULL.en NULL.htm). Attention, il semblerait qu’il soit trop lent pour une imprimante par contre…

Les micro-contrôleurs MSP430 de Texas Instruments

Microcontrôleur MSP430 de chez TI (http://www NULL.ti NULL.com/lsds/ti/microcontroller/16-bit_msp430/overview NULL.page)Je vous ai déjà pas mal parlé d’Arduino et de la famille des micro-contrôleurs AVR de chez Atmel. D’autres solutions existent comme les célèbres PIC de MicroChip dont est dérivée la plateforme PICAXE. En me penchant sur le travail de Steve KD1JV, j’ai vu qu’il avait fait le choix d’utiliser des produits de la série MSP430 de chez TI (http://msp430 NULL.com/). Ceux-ci ayant une consommation extrêmement basse (0,1 µA en veille profonde), le choix est plus qu’indiqué pour les transceiver ultra-portable QRP de Steve.

Gamme Value MSP430G2xx

Je ne vais pas me lancer dans une comparaison détaillée des deux architectures. Elles sont à la fois très différentes en terme de choix techniques, et très similaires en terme d’application sur le terrain. Le nombre de modèles et de version de circuits est très grand en particulier chez Texas Instruments et une comparaison face à face est difficile entre AVR et MSP430. En pratique, tout dépendra de vos besoins et de vos contraintes.

Texas Instruments LaunchPad (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/04/300px-LaunchPad_wireframe NULL.png)Pour ce qui nous concerne nous, les amateurs et hobbyistes, je considérerai deux points importants : le coût et la simplicité de mise en oeuvre. Du point de vue coût, une grosse société comme TI peut faire très fort car elle propose sa plateforme de développement LaunchPad (http://www NULL.ti NULL.com/tool/msp-exp430g2) a un coût ridiculement bas : 4,30$ port compris! Les micro-contrôleurs aujourd’hui fournis avec le kit sont peut-être limités, mais c’est aussi 5 fois moins cher qu’un Arduino. Pour ce prix vous avez entre les mains :

  • La platine de développement MSP-EXP430G2 (avec port USB)
  • un microcontrôleur M430G2211 (16 MHz,  2ko de Flash, 128o RAM, 10 entrées-sorties GPIO, un timer 16-bit, WDT, BOR, Comparator A+)
  • un microcontrôleur M430G2231 (16 MHz, 2ko de Flash, 128o RAM, 10 entrées-sorties GPIO, un timer 16-bit, WDT, BOR, un port USI (I2C/SPI), 8 canaux ADC 10 bits)
  • un quartz 32,768 KHz à souder soit même sur la platine en cas de besoin d’une horloge précise
  • Deux jeux de connecteurs
  • Un câble USB
  • Des autocollants TI Launchpad

Pour la simplicité d’utilisation, je vais vous avouer que je n’ai pas encore reçu mon kit LaunchPad donc ce que vous donne est de seconde main. L’environnement de développement de Texas Instrument tourne sous Windows uniquement et semble faire l’unanimité autour de son manque d’ergonomie et de sa complexité de mise en oeuvre. Des tiers ont développé des extensions logiciels pour programmer les MSP430 depuis XCode (Mac OS X) ou Ubuntu, mais l’aide de TI semble limitée. Si on regarde du côté des produits officiels de Atmel, ils sont peut-être bons mais pas gratuits. Par contre la communauté d’utilisateurs est importante et de nombreux outils libres de très bonne qualité existent. Il y a bien entendu Arduino, qui pour moi est la véritable porte d’entrée à l’AVR et qui propose un excellent environnement de développement multiplateforme et une communauté très active. Les platines Arduino me semble aussi mieux conçues et plus évolutive, mais cela est subjectif et peut se régler avec un peu de travail. Un fork de l’IDE Arduino pour le MSP430 semble disponible…

En conclusion le match est très serré. Vu le coût d’une plateforme LaunchPad, je vous conseille vivement d’en commander une et de vous faire votre avis par vous-même… Un wiki très détaillé sur LaunchPad (http://processors NULL.wiki NULL.ti NULL.com/index NULL.php?title=MSP430_LaunchPad_(MSP-EXP430G2)) est disponible avec les liens vers les environnements de développement disponibles.

Balise WSPR autonome avec Arduino chez W3PM

Hier j’ai laissé tourné WSPR sur 30 mètres pour voir si la propagation était revenue à un niveau correct sur cette bande. Cela m’a aussi permis de valider les performances de l’OCF Dipole sur le 30 mètres où en principe elle ne devrait pas fonctionner…

Réception WSPR 19 mars 2012 sur 30m (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/03/WSPR_19mars2012_30m NULL.jpg)En lisant la partie “blog” du site WSPRnet.org (http://wsprnet NULL.org/) je suis tombé sur un OM qui parlait d’une balise autonome WSPR autour d’un Arduino. Intéressé, j’ai creusé un peu et j’ai trouvé une mine d’information sur le site de W3PM (http://www NULL.knology NULL.net/~gmarcus/). Cet OM a fait un excellent travail autour de WSPR en concevant des émetteur-récepteur mais aussi en utilisant des Arduino Uno et Arduino MEGA pour piloter un DDS. Il a aussi conçu le même style de générateur WSPR pour la platine QRSS de G0UPL/G0XAR (http://xv4y NULL.radioclub NULL.asia/2010/08/16/kit-balise-qrss/) mais sur un micro-contrôleur PIC. C’est cette dernière qui m’intéresse le plus mais je n’ai pas de PIC.

J’avoue que pour l’instant je n’ai pas encore eu l’occasion de regarder en détails comment me servir de toutes ces infos. Je me pencherai sur ce projet courant mai. Générer une séquence WSPR “manuellement” est possible car K1JT fournit le petit programme adéquat. Il faut ensuite moduler correctement la fréquence pour un shift de 1 à 3 Hz (positif et négatif, 4 symboles en tout). La difficulté pour les transmissions de séquences WSPR étant de devoir être calé à la seconde près sur les minutes paires sinon aucune trame n’est décodée… Une horloge asservie à un GPS résout le problème, mais je n’en ai pas. W3PM semble utiliser aussi un récepteur de signaux WWBV (disponible à bas prix) mais ça ne marchera pas très bien hors des USA.

A noter que F4GKA (http://www NULL.itsrainingelephants NULL.com/2012/03/04/fabrication-dun-mept/) s’intéresse aussi à ce problème et utilise lui une échelle de 4 résistance comme DAC pour piloter la varicap (une LED sur la balise de G0UPL).

Dernière chose, voici k6HX qui a construit une balise SSTV à partir d’un Arduino (http://brainwagon NULL.org/2009/07/23/success-robot36-encoder-works/). Bon, en fait il génère un fichier son (WAV) sur PC et l’Arduino en déclenche la lecture sur l’AudioShield… mais il y a de l’idée.

BeagleBoard, Raspberry Pi et autres PC embarqués pour les radioamateurs

L’arrivée du Rapsberry Pi (http://www NULL.raspberrypi NULL.org/) a fait beaucoup parlé de cette famille de PC « embarqués ». Les 10 000 premières unités produites ont été précommandées par au moins 200 000 clients ! Un point sur ce qu’ils sont réellement et leur intérêt pour les radioamateurs me paraît nécessaire.

Raspberry Pi (http://img1 NULL.lesnumeriques NULL.com/news/23/23602/rapsberry-pi-mini-pc-35 NULL.jpg)Nous commencerons par les plus anciens de la famille des BeagleBoard (http://beagleboard NULL.org/), projet totalement ouvert, plus destinés à être des « plateformes de développement » selon leurs auteurs et qui sont appuyés par Texas Instrument cherchant ici à développer l’usage de ses processeurs. L’architecture étant ouverte, un industriel peut ensuite produire une série taillée sur mesure de la plateforme correspondant exactement à ses besoins et réduisant les coûts.

Le Rapsberry Pi est plus un produit pour geeks et se veut vendu en masse. Plus fermé conceptuellement, il offre aussi moins de possibilités pour le concepteur du matériel de bidouiller.
Le dernier de la famille, dont nous ne parlerons pas c’est le Cotton Candy (http://www NULL.fxitech NULL.com/products/) : Un PC au format Clé USB plutôt puissant (il embarque un processeur Cortex A9 et 1 Go de RAM) n’offrant en fait aucune vraie entrée-sortie.

Tout d’abord les caractéristiques.

BeagleBoard-xMBeagleBoard originale

  • 125 $
  • Texas Instrument OMAP3530 à 720 MHz (ARM Cortex A8) = 1200 MIPS
  • Processeur graphique PowerVR SGX530
  • DSP TMS320C64x+ pour vidéo HD ou divers traitement du signal (SDR)
  • 128 Mo RAM, 256 Mo Flash
  • Bus I2C/SPI, GPIO, RS-232, JTAG
  • Connecteur USB et USB-on-the-go, lecteur carte MMC/SD
  • Entrée-sortie audio stéréo
  • Sortie DVI et S-Video
  • OS : Android, Ubuntu, WinCE, RISC OS, Symbian…autres Linux

BeagleBoard-xM (différences avec le BeagleBoard original) :

  • 149 $
  • Texas Instrument OMAP3530 à 1 GHz
  • 512 Mo RAM, pas de Flash intégrée
  • Ethernet 10/100
  • Port caméra
  • Lecteur MicroSD (jusque 4 Go)
  • Sortie HDMI (plus de DVI)

Pandaboard ES

PandaBoard ES

  • 182$
  • Texas Instrument OMAP4460 à 1,2 GHz (ARM Cortex A9 bicoeur)
  • Processeur graphique PowerVR SGX540 à 384 MHz
  • DSP TMS320C64x
  • 1 Go de RAM, pas de Flash intégrée
  • Lecteur carte SD (SDHC jusque 32 Go)
  • Ethernet 10/100, Wifi et Bluetooth
  • Bus I2C/SPI, GPIO, RS-232, JTAG
  • Port caméra, Connecteur DSI pour écran LCD
  • USB et USB-on-the-go
  • Sortie DVI et HDMI
  • OS : Android, Ubuntu et RISC OS

Raspberry Pi

  • 35$
  • Broadcom 2763 à 700 MHz (ARM1176JZF-S)
  • 256 Mo RAM
  • Sortie audio stéréo (pas d’entrée)
  • Ethernet 10/100
  • Bus I2C/SPI, GPIO
  • Connecteur DSI pour écran LCD
  • OS : Debian, Fedora, RISC OS
    (l’architecture ARMv6 n’est pas supportée par Ubuntu ou Android)

En faisant une petite recherche sur le web on se rend vite compte que peu de projets tournant sur ces plateformes ont trait au radioamateurisme. Ceci pour plusieurs raisons.

Tout d’abord une grande partie des applications que nous utilisons (cahier de trafic, cluster, modes numériques…) a besoin d’une interface homme-machine (un écran, un clavier en résumé) et ceci n’est pas inclus dans les produits ci-dessus. Le coût au premier abord paraît faible mais quand on y ajoute un écran on arrive vite à celui d’un PC portable premier prix.

SDR2Go avec UHFSDR

Ensuite, pour faire de ces systèmes un contrôleur de radio type SDR, se présentent rapidement deux écueils. Le premier c’est l’absence d’entrée-sortie à grande vitesse (le plus rapide étant le bus USB) pour accéder directement aux données d’un ADC comme sur le HPSDR. Les Beagleboard embarquent bien une entrée-sortie audio stéréo (soient 2 DAC et 2 ADC) mais les circuits sont de piètre qualité, loin des besoins d’une vrai radio SDR. Le deuxième c’est la difficulté pour programmer le DSP embarqué dans ces systèmes. Contrairement à ce qui existe sur d’autres plateformes dédiées au traitement du signal (comme celles utilisées sur le SDR2Go (http://www NULL.qsl NULL.net/k5bcq/Kits/Kits NULL.html) ou le SDRCube (http://www NULL.sdr-cube NULL.com/)), ici tout est à faire ou presque, et cela rebute pas mal de développeurs (voir le portage de GNU Radio sur Beagleboard (http://www NULL.opensdr NULL.com/node/17)).

Quand on regarde bien, le vrai but de ces produits n’est pas de fournir un système polyvalent mais surtout une plateforme « multimédia » comme le sont les smartphones avec qui ils partagent la plupart des composants micro-processeur en tête. Ok ils disposent d’entrées-sorties supplémentaires pour les adeptes de la bidouille, mais celles dont nous aurions besoin !

Un peu après avoir publié cet article j’ai lu un message sur la liste Knight QRSS qui suggérait que ce type de PC embarqué pourrait être parfait pour servir de Grabber QRSS. C’est une application que je n’avais pas envisagé. Seule la PandaBoard a suffisamment de puissance pour servir de décodeur WSPR par contre. A moins de porter les algorithmes de K1JT sur le DSP, mais c’est une autre paire de manches.

Et Arduino ?

En guise de conclusion, comment ces produits se comparent-ils à un Arduino (http://www NULL.arduino NULL.cc/) ? Tour d’abord en terme de performances brutes l’Arduino est largement derrière. Le processeur de l’ArduinoMega est à 16 MHz, 8ko de SRAM, 256Ko de Flash, pas de DSP, pas de circuits vidéos… rien à voir. C’est vrai qu’un Arduino est aussi puissant qu’un ordinateur familial des années 80, et qu’il peut déjà faire pas mal de choses.

La vraie force de l’Arduino c’est d’automatiser des tâches nécessitant beaucoup d’interactions électriques ou électroniques : commandes des relais (pour une balise, un manipulateur CZ) , capturer des valeurs (fréquencemètre, Wattmètre), piloter un bus I2C. Ecrire un tel code sur un Arduino est très simple et permet de concevoir un matériel autonome, fiable, très simple, consommant peu d’énergie et peu coûteux à produire en série si besoin. L’environnement de développement (IDE) de l’Arduino permet de concevoir un tel code en quelques minutes.

Bien entendu, on peut faire la même chose avec un BeagleBoard dont les entrées-sorties GPIO et I2C sont accessibles par des commandes du shell Linux. Honnêtement, c’est un peu utiliser un marteau-pilon pour enfoncer une punaise, et si on veut faire des choses complexes on va sentir le besoin d’un vrai environnement de développement et d’un langage dédié. De plus dupliquer le circuit sera difficile et coûteux et la complexité du matériel (et du logiciel) augmente le risque de panne.

Programmer un micro-contrôleur Atmel ATtiny avec un Arduino (MAJ)

[GTranslate]

Il y a plus d’un an j’avais monté un kit balise QRSS (MEPT QRSS pour être exact) de G0UPL (http://xv4y NULL.radioclub NULL.asia/2010/08/16/kit-balise-qrss/). Hans livre le micro-contrôleur ATTiny13 du kit programmé à l’avance avec l’indicatif que vous lui demandez, or le mien a changé entretemps!

Arduino utilisé comme ISP pour reprogrammer un ATTiny13

J’avais donc en tête de reprogrammer celui-ci avec le bon indicatif. C’est facilement faisable avec une platine Arduino programmée pour agir en tant qu’ISP (In System Programmer). Une condition cependant, que les Fuse-bits ne soient pas programmés car dans ce cas un programmateur à tension élevée est nécessaire pour tout remettre à zéro. Hans et Steve m’ont confirmé que ce n’était pas le cas pour leur micro-contrôleur.

Je ne vais pas vous faire un guide pas-par-pas ici, plusieurs tutoriaux sont disponibles sur internet et mieux documentés. Je vais plutôt vous dire où trouver les informations. A noter que j’utilise un Macintosh, mais les grandes lignes restent les mêmes.

Liste des ingrédients :

  • La dernière version de l’IDE de l’Arduino (http://arduino NULL.cc/en/Main/Software).
  • Le pack de développement CrossPack pour AVR (http://www NULL.obdev NULL.at/products/crosspack/index NULL.html) qui permettra de compiler le code vers un binaire AVR avec XCode et installera aussi AVRDude permettant de communiquer avec le microcontrôleur de chez Atmel.
  • Un Arduino avec ATMega328, une plaque d’essais, des câbles, des jumpers et un condensateur (à mettre entre la pin RESET et la masse de l’Arduino.
Recette :
  • Lancer l’IDE Arduino, ouvrir le sketch Arduino ISP des exemples, le programmer dans l’Arduino.
  • Créer un projet dans XCode, copier le code du keyer QRSS (http://www NULL.hanssummers NULL.com/images/stories/qrsskeyer/beacon NULL.c) et le compiler.
  • Câbler l’Arduino et l’ATTiny de telle façon à raccorder les masses et +5V des deux circuits ensembles. Connecter les broches 10, 11, 12 et 13 de l’Arduino respectivement aux broches 1 (RST), 5 (MOSI), 6 (MISO),7 (SCK) de l’ATTiny13. (Voir photo un peu plus haut)
  • Ouvrir une fenêtre du terminal (shell) et récupérer l’ancien binaire (voir capture ci-dessous,cliquez pour élargir).Récupération du binaire du précédent programme dans la Flash de l'ATTiny13 avec AVRDude (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/01/Download-binaire-ATTiny13-XV4TUJ NULL.jpg)
  • Programmer l’ATTiny avec le fichier .hex généré par XCode (voir capture ci-dessous, cliquez pour élargir).Envoi du binaire du nouveau programme dans la Flash de l'ATTiny13 avec AVRDude (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/01/Upload-binaire-ATTiny13-XV4Y NULL.jpg)

Ca marche, ma balise envoie maintenant le bon indicatif (voir plus bas pour la mise à jour). Je n’ai plus qu’à procéder au réalignement périodique de la fréquence car celle-ci bouge un peu (50Hz c’est beaucoup en QRSS) avec les changements de saison et de température moyenne.

Mon but était de reprogrammer un ATTiny13 (http://futurlec NULL.com/Atmel/ATTiny13V NULL.shtml) avec le code source de G0UPL/G0XAR. Celui-ci est dans le langage C spécifique à ce micro-contrôleur, et avec le template AVR de XCode ont produit un binaire (fichier .hex) en code machine pour celui-ci. La flash sur l’ATTiny13 et de 1Ko, le binaire fait 664o.

Si vous disposez d’ATTiny45 ou ATTiny85, (http://futurlec NULL.com/Atmel/ATTiny85 NULL.shtml) ceux-ci ayant plus de mémoire, une autre possibilité existe si vous souhaitez créer vos propres programmes. En effet, le projet Arduino-Tiny (http://code NULL.google NULL.com/p/arduino-tiny/) a pour but de porter le noyau Arduino sur ATTiny. Ceci permet d’utiliser l’environnement de développement (IDE) d’Arduino et son langage plus évolué. Toutes les commandes ne sont pas utilisables car certaines sont propres au micro-contrôleur ATMega (http://futurlec NULL.com/Atmel/ATMEGA328P-AU NULL.shtml) des Arduino. Toutefois, pour un bon nombre de projets simples (balise (http://xv4y NULL.radioclub NULL.asia/2011/07/01/balise-cw-a-base-de-micro-controleur-arduino/), manipulateur électronique (http://xv4y NULL.radioclub NULL.asia/2011/12/09/arduino-manipulateur-cw-de-numero-de-serie-pour-concours/)…) cela permet de réduire de le coût et de simplifier le circuit.

Mise à jour : Contrairement à ce que je pensais au début même si la programmation du micro-contrôleur se passait bien aucune “manipulation” n’était effectuée par la balise, le signal restait fixe mais variait à cause du changement de température…

Je prends contact avec Stephen et Hans qui me donne deux informations. D’abord la fréquence à indiquer dans le Makefile pour la compilation est 9 600 000 Hz, car les ATTiny ont été programmés avec les fuse-bytes indiquant une horloge de 9,6 Mhz et pas de prescaling par le diviseur-par-8. Ensuite un petit bogue réside dans leur code qui ne compile plus sur les nouvelles versions de WinAVR (qui utilise avr-libc comme Crosspack). Après quelques recherches (je ne suis pas très doué en programmation), le code est corrigé et compile maintenant parfaitement. La version mise à jour du code devrait être disponible chez G0UPL, n’hésitez pas à me contacter pour plus de détails.

Arduino : un manipulateur CW complet

J’ai fait un petite mise à jour du code de mon manipulateur électronique pour concours (http://xv4y NULL.radioclub NULL.asia/2011/12/09/arduino-manipulateur-cw-de-numero-de-serie-pour-concours/). L’envoi plus rapide du 599 était en fait trivial, mais j’étais passé à côté la fois dernière. Deux minutes ce matin et l’affaire était jouée.

Par contre je m’étais fixé comme prochaine étape de réaliser un manipulateur électronique émulant un Winkeyer de K1EL (http://k1el NULL.tripod NULL.com/WKUSB NULL.html). Non pas que je voulais l’améliorer ou même le copier car les produits de K1EL et en particulier le Winkeyer me paraissent extrêmement complets et d’un rapport qualité/prix imbattable. Seul le MasterKeyer de HamGadgets (http://www NULL.hamgadgets NULL.com/index NULL.php?main_page=product_info&cPath=21&products_id=106&zenid=gdc9eut0dq79n4uvr3nmlj7sk7) est peut-être mieux doté, mais il est aussi plus cher. En fait c’est le côté pédagogique de la chose qui m’intéressais. Je voulais juste émuler la transmission d’une chaîne simple pour pouvoir utiliser le logiciel de log de N1MM (http://n1mm NULL.hamdocs NULL.com/tiki-index NULL.php?page=HomePage) lors des concours.

Schéma manipulateur CW Arduino (http://radioartisan NULL.wordpress NULL.com/arduino-cw-keyer/)Je me suis donc mis à la recherche sur Google de mots clefs comme “K1EL winkeyer protocole” pour me rendre compte que d’autres avait eu la même idée et surtout trouver cette article (http://radioartisan NULL.wordpress NULL.com/arduino-cw-keyer/). Je n’ai pas encore lu le code et encore moins testé son fonctionnement, mais la liste des fonctionnalité et la description sont impressionnantes. Ca va beaucoup plus loin que ce que je n’avais jamais pensé faire et ça rivalise avec beaucoup de produits commerciaux.

Je ne pense pas utiliser le code tel quel. Si j’ai vraiment besoin d’un manipulateur électronique externe complet, le Winkeyer comprend tous les composants, le boîtier, les connecteurs… pour à peine plus que le prix d’un Arduino. Par contre je vais jeter un oeil au code et je ne dis pas que je l’essayerai quand même en particulier pour tâter un peu de la manipulation Ultimatic.

Arduino : Manipulateur CW de numéro de série pour concours

Avec l’ARRL 10M contest qui s’approche je me suis dit qu’il serait de bon ton de me remuer l’arrière-train pour enfin programmer ce manipulateur électronique spécial numéro de série pour les concours. Cet article fait suite à celui-ci sur une balise CW à partir du micro-contrôleur Arduino (http://xv4y NULL.radioclub NULL.asia/2011/07/01/balise-cw-a-base-de-micro-controleur-arduino/).

La majorité de nos transceivers actuels intègrent un manipulateur électronique à mémoire, mais peu embarquent la possibilité d’envoyer les “reports” ou plutôt les numéros de série durant les concours.

J’ai donc fait un petit programme sur Arduino qui vient combler ce manque. La plateforme matérielle et la base du code seront décrites dans le prochain numéro de Radioamateur Magazine (http://www NULL.malibrairienumerique NULL.fr/librairie/). Ce montage viendra sur la prise “straight key” de votre émetteur ou en parallèle de la sortie de votre manipulateur électronique externe si celui-ci ne fait pas les numéros de série.

Je vous mets le code brut de fonderie sur cette page, à vous de l’adapter. Il fonctionne mais il lui manque encore à mon goût la possibilité d’envoyer plus vite de 599 que le numéro de série en lui-même. J’ai finalement ajouté cette fonctionnalité en quatre lignes de codes, et c’est propre. Il manque encore la possibilité de dépasser le numéro de série de 999 et mettre ou non les zéros devant. Cela dit je ne pense pas m’éterniser plus sur ce code depuis que j’ai découvert ce dont je parle ici (http://xv4y NULL.radioclub NULL.asia/2011/12/14/arduino-un-manipulateur-cw-complet/). Les commentaires devraient vous aider à comprendre le code et l’adapter.

Apparemment le code source s’affiche mal, vous trouverez un fichier texte du code source sur ce lien (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2011/12/CW_Contest1 NULL.txt).

// Générateur de reports pour concours (contests) 599+numéro de série
// Vitesse variable par potentiomètre entrée A0, commande transistor pin D12 et LED pin D13
// Lecture des commandes par 3 broches 6, 7 et 8
// Codage de l'alphabet par Hans Summers G0UPL et Stephen Farthing G0XAR

// Version 0.9
// 09/12/2011 par Yannick DEVOS XV4Y

// Définition de l'alphabet sous forme binaire
// 0 = dot, 1 = dash
const int A	=	0b11111001;
const int B	=	0b11101000;
const int C	=	0b11101010;
const int D	=	0b11110100;
const int E	=	0b11111100;
const int F	=	0b11100010;
const int G	=	0b11110110;
const int H	=	0b11100000;
const int I	=	0b11111000;
const int J	=	0b11100111;
const int K	=	0b11110101;
const int L	=	0b11100100;
const int M	=	0b11111011;
const int N	=	0b11111010;
const int O	=	0b11110111;
const int P	=	0b11100110;
const int Q	=	0b11101101;
const int R	=	0b11110010;
const int S	=	0b11110000;
const int T	=	0b11111101;
const int U	=	0b11110001;
const int V	=	0b11100001;
const int W	=	0b11110011;
const int X	=	0b11101001;
const int Y	=	0b11101011;
const int Z	=	0b11101100;
const int _SPC	=       0b11101111;
const int _0	=	0b11011111;
const int _1	=	0b11001111;
const int _2	=	0b11000111;
const int _3	=	0b11000011;
const int _4	=	0b11000001;
const int _5	=	0b11000000;
const int _6	=	0b11010000;
const int _7	=	0b11011000;
const int _8	=	0b11011100;
const int _9	=	0b11011110;
const int _BRK	 =      0b11010010;
const int _WAIT  =	0b10000000;

// Format du message : 1er nombre = longueur, Caractères utilisent les constantes pour une équivalence binaire
const int msg[] = {10, T, _1, _2, _3, _4, _5, _6, _7, _8, N}; // Chiffres seulement avec abbréviations pour 0 et 9

// Attribution des broches
const byte inUP = 8;    // Broche 8 pour incrémenter les numéros de série
const byte inRPT = 7;   // Broche 7 pour répéter les numéros de série
const byte inDWN = 6;   // Broche 8 pour décrémenter les nuémros de série

// Réglages par défaut
const byte nbRepetition = 2;

// Déclaration et initilisation des variables
byte msgIndex = 1;
byte inc_bit = 8;
byte character = _SPC;
boolean start = false;
byte seqIndex = 8; // On démarre trop haut pour ne pas initialiser la lecture de suite
int sequence = 0;
byte repetition = 0;
int vitesse = 100;

byte key = 0;
byte etat = 0;

void setup()  {
  // on declare La patte 13 (LED intégrée) comme sortie
  pinMode(13, OUTPUT);
  // on declare les pattes inUP, inRPT et inDWN (Entrée numérique) comme entrées et on met en place la résistance de pull-up
  pinMode(inUP, INPUT);
  digitalWrite(inUP, HIGH);
  pinMode(inDWN, INPUT);
  digitalWrite(inDWN, HIGH);
  pinMode(inRPT, INPUT);
  digitalWrite(inRPT, HIGH);
  // Initilisation du générateur de nombres aléatoires avec la lecture d'une patte non connectée
  randomSeed(analogRead(A2));
} 

// Ici le micro-controleur bouclera indéfiniement
void loop()  { 

  if (repetition

 

Balise CW à base de micro-contrôleur Arduino

Ca fait un petit moment que je pensais écrire une suite à l’article de vulgarisation autour de la platine Arduino que j’avais fait pour Radioamateur Magazine. Je ne présente plus le concept Arduino si ce n’est en disant que c’est une plateforme complète (matériel, IDE, librairies…) qui permet de développer simplement et rapidement des circuit autour de micro-contrôleurs Atmel MegaAVR.

Balise CW à partir d'une platine Arduino Nano (http://capheda NULL.files NULL.wordpress NULL.com/2011/06/100_3005 NULL.jpg)Je voulais montrer une application simple de l’usage d’un micro-contrôlleur dans le cadre d’une activité radioamateur. Sans partir dans l’accès à des circuits externes comme un écran LCD qui tout en restant simple alourdissent le code et limite la compréhension pour le débutant, il restait peu de possibilités pratiques : un manipulateur Iambic ou une balise CW. Finalement c’est sur le deuxième projet que je me suis reporté sur le deuxième car j’avais un besoin propre pour des essais de propagation sur 80m et 40m que je veux faire en automne.

En avant-première voici le code (très simple) et une photo du montage. A noter que pour le codage de l’alphabet Morse je me suis inspiré du code fait par Hans G0UPL et Steve G0XAR pour le contrôleur de la balise QRSS (http://www NULL.hanssummers NULL.com/qrsskeyer NULL.html). C’est de loin le plus élégant et le plus efficace que j’ai vu. Une description complète et didactique accompagnée d’un code dûment commenté suivra dans un prochain numéro de Radioamateur Magazine dès que j’aurai eu le temps d’écrire un article au propre…

// Balise CW Arduino
// Vitesse variable par potentiomètre entrée A0, commande transistor pin D12 et LED pin D13
// 29/06/2011 par Yannick DEVOS XV4Y
// Codage de l'alphabet par Hans Summers G0UPL et Stephen Farthing G0XAR

// Définition de l'alphabet sous forme binaire
// 0 = dot, 1 = dash
const int A	=	0b11111001;
const int B	=	0b11101000;
const int C	=	0b11101010;
const int D	=	0b11110100;
const int E	=	0b11111100;
const int F	=	0b11100010;
const int G	=	0b11110110;
const int H	=	0b11100000;
const int I	=	0b11111000;
const int J	=	0b11100111;
const int K	=	0b11110101;
const int L	=	0b11100100;
const int M	=	0b11111011;
const int N	=	0b11111010;
const int O	=	0b11110111;
const int P	=	0b11100110;
const int Q	=	0b11101101;
const int R	=	0b11110010;
const int S	=	0b11110000;
const int T	=	0b11111101;
const int U	=	0b11110001;
const int V	=	0b11100001;
const int W	=	0b11110011;
const int X	=	0b11101001;
const int Y	=	0b11101011;
const int Z	=	0b11101100;
const int _SPC	=       0b11101111;
const int _0	=	0b11011111;
const int _1	=	0b11001111;
const int _2	=	0b11000111;
const int _3	=	0b11000011;
const int _4	=	0b11000001;
const int _5	=	0b11000000;
const int _6	=	0b11010000;
const int _7	=	0b11011000;
const int _8	=	0b11011100;
const int _9	=	0b11011110;
const int _BRK	 =      0b11010010;
const int _WAIT  =	0b10000000;

// Format du message : 1er nombre = longueur, Caractères utilisent les constantes pour une équivalence binaire
const int msg[] = {26, X, V, _4, Y, _BRK, B, _SPC, X, V, _4, Y, _BRK, B, _SPC, _1, _0, W, _SPC, P, S, E, _SPC, R, P, T, _WAIT};

const long intervalle = 60000; // (60 secondes ou 1 minute entre chaque transmission)

// Déclaration et initilisation des variables
byte msgIndex = 1;
byte inc_bit = 8;
byte character = _SPC;
boolean start = false;

int vitesse = 100;

byte key = 0;
byte etat = 0;
long dern_trans = 0;
long maintenant = 0;

void setup()  { 
  // on declare les pattes 12 (transistor) & 13 (LED intégrée) comme sorties
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
} 

void loop()  { 

  msgIndex = 1;

  while (msgIndex < msg[0]+1) {
    vitesse = 50 + round(analogRead(A0)/8);

    character = msg[msgIndex];

    inc_bit = 8;

    if (character == _SPC) {
        delay (9*vitesse); //
        inc_bit = 0;
    }
    if (character == _WAIT) {
        while (maintenant < (dern_trans + intervalle)) {
          maintenant = millis();
          delay (100);
        };
        dern_trans = millis();
        inc_bit = 0;
    }

    while (inc_bit) {

      etat = bitRead(character,inc_bit-1);

      if (start) {
        if (etat)
          key=3;
        else
          key=1;

        while (key) {
          digitalWrite(12, HIGH);
          digitalWrite(13, HIGH);
          delay (vitesse);
          key--;
        }

        digitalWrite(12, LOW);
        digitalWrite(13, LOW);
        delay (vitesse);
      }

      if (!etat && !start) start=true;

      inc_bit--;

    }
    delay (2*vitesse);

    start = false;
    msgIndex++;

  }

}