Archives par mot-clé : MSP430

Balise WSPR autonome avec MSP430 – suite

Générateur balise autonome WSPR LaunchPad MSP430 (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/09/100_3289 NULL.jpg)

[GTranslate]

J’ai retravaillé un peu sur ma balise WSPR autonome (http://xv4y NULL.radioclub NULL.asia/2012/05/11/balise-autonome-wspr-avec-msp430/) construite autour de l’émetteur QRSS de G0UPL/G0XAR (http://www NULL.hanssummers NULL.com/qrsskit NULL.html). D’une part j’ai mis le montage “au propre” sur un circuit imprimé de prototype, d’autre part j’ai implémenté la commande de polarisation du PA ce qui permet de ne pas être en émission constamment et de n’envoyer la séquence WSPR qu’une fois sur quatre de manière aléatoire par exemple.

Le code du générateur lui-même a été optimisé pour générer une séquence de test durant  la phase d’attente de synchronisation de l’horloge. Cela permet de vérifier que les différentes valeurs binaires sont envoyées avec la bonne excursion en fréquence (6Hz au total) et que la fréquence de travail désirée est bien la bonne. La durée de chaque valeur est de 5 secondes, plus longue que durant la séquence WSPR, ce qui facilite les réglages.

Générateur balise autonome WSPR LaunchPad MSP430 deux platines séparées (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/09/100_3290 NULL.jpg)Après quelques cafouillages dus à une erreur de câblage, les 3 premières soirées ont été très concluantes. Les reports sur 30 mètres viennent de Thaïlande, des Philippines, du Japon et d’Australie (environ 6000km). Avec les 90mW de la balise de G0UPL c’est tout ce que je peux espérer de mieux surtout à cette saison. En modifiant le circuit du PA j’en ai profité pour remplacer le 2N7000 par un Bs170. Le 2N7000 chauffait anormalement même s’il n’a jamais failli. Avec le Bs170, la dissipation autorisée est plus importante et il ne chauffe plus du tout… Je vais donc essayer d’augmenter la tension d’alimentation de l’´émetteur pour atteindre 9V et les 200mW en émission. J’espère que cela ne posera pas de difficultés pour l’oscillateur et l’étage buffer qui ne seront plus à leur point de fonctionnement optimal, sinon il me faudra charcuter un peu le circuit et ajouter un régulateur supplémentaire.

Reports WSPR 30m 29 septembre 2012 (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/10/WSPR_balise_MSP430 NULL.jpg)Il me reste encore quelques petits détails à régler sur le code micro-contrôleur mais je publierai l’ensemble des informations (y compris le schéma) sur une page dédiée d’ici quelques semaines. En attendant n’hésitez pas à me poser des questions si vous en avez.

Futurs projets pour micro-contrôleurs

Ecran LCD 16x2 (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/09/LCD16_2 NULL.jpg)Ce n’est pas pour tout de suite mais je commence à me gratter la tête pour de nouveaux projets autour de mon Arduino (vais-je en acheter un deuxième ?) ou de mon LaunchPad.

Je viens de recevoir un écran LCD 16×2 commandé à très bon prix sur eBay (http://www NULL.ebay NULL.com/itm/1pcs-1602-16x2-HD44780-Character-LCD-Display-Module-LCM-blue-blacklight-New-/251155458075?pt=LH_DefaultDomain_0&hash=item3a7a08281b). Le vendeur basé à Hong Kong s’étant montré très bien, je lui ai commandé un capteur de température et d’humidité (http://www NULL.ebay NULL.com/itm/1pcs-DHT11-Digital-Humidity-Temperature-Sensor-/251056594544?pt=LH_DefaultDomain_0&hash=item3a74239e70), un ensemble émetteur-récepteur 433 MHz (http://www NULL.ebay NULL.com/itm/1pcs-433Mhz-RF-transmitter-and-receiver-kit-Arduino-project-/261041100836?pt=LH_DefaultDomain_0&hash=item3cc7431824) et un convertisseur port USB vers signaux RS232/TTL (http://www NULL.ebay NULL.com/itm/1pcs-PL2303-USB-RS232-TTL-Converter-Adapter-Module-/251082091781?pt=LH_DefaultDomain_0&hash=item3a75a8ad05). Avec les trois premiers, j’aimerai bien essayer de monter un petit capteur météo à distance autour d’un ATTiny8 par exemple. Un Arduino ferait la collecte des résultats et l’affichage sur le LCD. Ensuite le micro-ordinateur viendrait récupérer des points de mesure une fois par jour pour faire des stats… Le convertisseur pour port USB c’est au passage, histoire de pouvoir faire tourner des micro-contrôleurs de manière indépendante.

L’écran LCD me servirait aussi pour un autre projet, celui de faire un analyseur de spectre Audio (par FFT) pour brancher sur le transceiver. Rien de révolutionnaire mais avoir un affichage centré autour de 600 Hz pourrait être une aide intéressante pour se caler sur le bon signal en CW. Je n’ai pas une très bonne oreille et parfois dans le feu de l’action en entendant un indicatif rare je ne me cale pas bien. Je n’ai jamais perdu de QSO à cause de cela mais ce n’est pas très poli pour l’autre opérateur… Plusieurs projets construits autour d’un Arduino existent sur ce sujet dont celui-ci qui me plaît bien (http://lusorobotica NULL.com/index NULL.php?topic=2985 NULL.0).

Video analyseur de spectre audio Arduino (http://www NULL.youtube NULL.com/watch?v=Zpz8XP4go3U)

Ici un autre mais je comprends moins bien le polonais que le portugais (http://www NULL.youtube NULL.com/watch?v=Bn6BIfr_UgY)

Manip électronique compatible Winkeyer avec Arduino sur base K3NG

K3NG contest keyer par XV4Y (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/09/100_3275 NULL.jpg)Ca y est, j’ai enfin fini de monter le petit circuit de mon manipulateur électronique compatible Winkeyer. En fait de circuit il s’agit en gros d’un transistor et de quelques résistances et condensateurs : pas de quoi casser trois pattes à une diode. le plus gros du travail est fait par le micro-contrôleur de la platine Arduino-Nano, et le code qui tourne sur celui-ci est écrit par K3NG (http://sourceforge NULL.net/projects/k3ngarduinocwke/).

Il y a quelques mois mes essais s’étaient avérés infructueux et je n’arrivais pas à avoir un fonctionnement stable du circuit. Avec les dernières versions du logiciel tout semble réglé et j’ai compilé un binaire qui fonctionne parfaitement bien. J’ai toutefois noté que certaines combinaisons de fonctionnalités (activées à la compilation par des #define) sont instables ou ne se compilent tout simplement pas. Faites des tests en ajoutant progressivement des fonctionnalités si vous trouvez que cela ne marche pas comme vous l’attendez.  Le blog de K3NG étant indisponible depuis le Viêt-Nam en ce moment je n’ai pu lui communiquer mes remarques…

Comme vous pouvez le voir sur la photo j’ai fait une implémentation minimaliste du circuit. En fait je compte l’utiliser uniquement en conjonction avec le logiciel de N1MM pour envoyer les numéros de série durant les concours. La grande majorité des composants sont de récupération (les touches et le buzzer piezo viennent d’un vieux téléphone Panasonic) et comme j’avais la place j’ai ajouté trois touches et le connecteur pour le manip. J’ai fait un petit calcul rapide du coût de ce circuit et en comptant comme composant le plus cher l’Arduino Nano 3.0 de Gravitech (http://www NULL.gravitech NULL.us/arna30wiatp NULL.html) à 35 USD (port non inclus), on arrive à environ 50 USD pour un manipulateur plutôt haut de gamme. Bien entendu, si on souhaite ajouter l’écran LCD (j’attends un LCD 16×2 commandé pas cher sur eBay (http://www NULL.ebay NULL.com/itm/New-1602-16x2-Character-LCD-Display-Module-HD44780-Controller-blue-blacklight-/300777230298?_trksid=p4340 NULL.m1850&_trkparms=aid%3D222002%26algo%3DSIC NULL.FIT%26ao%3D1%26asc%3D11%26meid%3D2126416898780744236%26pid%3D100011%26prg%3D1005%26rk%3D1%26)) et le connecteur pour clavier PS/2, le prix peut monter un peu. A noter que K1EL propose maintenant le WKUSB-Lite (http://k1el NULL.tripod NULL.com/WKlite NULL.html) pour 38 USD (+10 USD de port), ce qui est prix franchement attractif même sans le boîtier ou les boutons.

Arduino Nano clone

En faisant cette recherche je suis tombé sur des clones d’Arduino Nano vendus sur eBay (http://www NULL.ebay NULL.com/itm/Nano-V3-ATmega328P-Free-Mini-USB-Cable-Arduino-compatible-/320983464502?pt=LH_DefaultDomain_0&hash=item4abc1afa36) à moins de 10 USD port inclus. Fabriqués en Chine (soit) en vendus à Hong Kong (bien sûr) ils semblent copier à 100% et parfois améliorer un peu le design de Gravitech (http://www NULL.ebay NULL.com/itm/Meduino-Nano-Enchancement-Arduino-Compatible-3-3-5V-adjustable-16MHz-MEGA328-/150889585154?pt=LH_DefaultDomain_0&hash=item2321b85a02). Comme il n’y a rien de sorcier dans celui-ci et que le code du bootloader Arduino est disponible librement, ces alternatives sont tout à fait viable techniquement. Avec un prix divisé par quatre, il est difficile de résister… Je me disais justement qu’avoir un Arduino supplémentaire pour quelques projets que j’ai en tête et dont je vous parlerai bientôt pourrait être utile, car même le LaunchPad et son MSP430 devraient être bloqués sur ma balise WSPR (http://xv4y NULL.radioclub NULL.asia/2012/05/11/balise-autonome-wspr-avec-msp430/) qui aura mon attention dans les semaines qui viennent.

J’ai lu sur des forums que certains de ces clones à bas prix ne marchaient pas. Il semblerait surtout que ce soit comme d’habitude le contrôle qualité qui est défaillant. Certaines soudures sont mal faites ou des ponts électriques involontaires existent entre des broches de l’ATMega328. Si vous êtes un peu bricoleur, cela ne vous effrayera pas, sinon préférés tout de même le modèle original de Gravitech…

Toujours sur le même thème, on peut utiliser avec un Arduino ou un Launchpad l’écran LCD d’un Nokia 5110 (http://www NULL.ebay NULL.com/itm/84-48-LCD-Module-White-backlight-adapter-pcb-for-Nokia-5110-/140730843931?pt=LH_DefaultDomain_0&hash=item20c436431b). Il est plus souple d’utilisation qu’un traditionnel 16×2 caractères et se trouve pour juste un peu plus cher. Le contrôleur n’est pas le même mais les librairies se trouvent facilement que ce soit pour les AVR ou le MSP430. Par contre, adapter le code de K3NG pour cet écran pourrait demander un peu de travail…

Bibliothèque RTC pour le MSP430

[GTranslate]

Le micro-contrôleur MSP430G2553 de Texas Instruments livrés avec le LaunchPad dispose de tout le nécessaire pour en faire une horloge temps-réel (RTC). Il suffit de lui connecter un quartz 32KHz et de le programmer convenablement.

TI donne les librairies en assembleur utilisable avec leur environnement de développement. Pour Energia, une nouvelle librairie était nécessaire, je me suis donc attelé à sa conception.

Rien de révolutionnaire, mais ça peut servir à d’autres. C’est sur cette librairie qu’est basée ma balise autonome WSPR que je compte proposer en semi-kit d’ici peu (certainement à mon retour de vacances début juillet). D’origine la dérive en fréquence est de l’ordre du Hertz pour 24 heures (20ppm) ce qui suffit pour une nuit de transmission WSPR, mais peut-être ajustée avec un condensateur variable pour corriger la fréquence du quartz.

Le fichier d’en-têtes (sRTCsec.h) :

/*
 sRTC.h - Library for adding simple RTC capabilities using MSP430 hardware
 By Yannick DEVOS (XV4Y) - 2012

///////////////////////////////// How to use the lib

 * Create an instance of the object

 RealTimeClock myClock;

 * In order to have this RTC library working you should add this code to the end of your main program :

 interrupt(TIMER1_A0_VECTOR) Tic_Tac(void) {
	myClock.Inc_sec();		      // Update secondes
 };

 * Enjoy the clock reading the RTC_sec, RTC_min, RTC_hr variables

 */

// ensure this library description is only included once
#ifndef RTCsec_h
#define RTCsec_h

// library interface description
class RealTimeClockSec
{
	// user-accessible "public" interface
public:
	RealTimeClockSec(void);
	void Set_Time(char hr, char mins, char secs);
    char RTC_sec; // This how you read the time, by reading the vars
    char RTC_min;
    char RTC_hr;
	void Inc_sec(void); // This methode should be invoked by an Interrupt call (see top of the file comment)
	// A few private methods
private:
	void Inc_min(void);
	void Inc_hr(void);
};

#endif

Le code par lui-même (sRTCsec.cpp) :

/*
 sRTC.h - Library for adding simple RTC capabilities using MSP430 hardware
 By Yannick DEVOS (XV4Y) - 2012
 */

// include this library's description file
#include <sRTCsec.h>
#include <legacymsp430.h>

// Constructor /////////////////////////////////////////////////////////////////

RealTimeClockSec::RealTimeClockSec(void)
{
	RTC_sec = 0;
	RTC_min = 0;
	RTC_hr = 0;

	WDTCTL = WDTPW | WDTHOLD; // Kill watch-dog

	BCSCTL1 = DIVA_3;        // Clock = ACLK / 8
	BCSCTL3 |= (LFXT1S_0 | XCAP_3);        // Internal 12.5pF cap for 32KHz crystal

	TA1CCTL0 = CCIE;             //  CCR0 interupt activated
	TA1CCR0 = 4096-1;               // 4096 ticks of 32KHz XTal = 1 second => CCR0 counts N+1
	TA1CTL = TASSEL_1 | ID_3 | MC_1;  // Clock for TIMER 1 = ACLK, By 8 division, up front

};

// Methods /////////////////////////////////////////////////////////////////

void RealTimeClockSec::Inc_sec(void) {
	RTC_sec = RTC_sec + 1;		      // Update seconds
	if (RTC_sec == 60) {
		RTC_sec=0;
		Inc_min();
	};
};

void RealTimeClockSec::Inc_min(void) {
	RTC_min = RTC_min + 1;		      // Update minutes
	if (RTC_min == 60) {
		RTC_min=0;
		Inc_hr();
	};
};

void RealTimeClockSec::Inc_hr(void) {
	RTC_hr = RTC_hr + 1;		      // Update hours
	if (RTC_hr == 24) {
		RTC_hr=0;
	};
};

void RealTimeClockSec::Set_Time(char hrs=0, char mins=0, char secs=0) {
	if ((hrs>=0 && hrs <24) && (mins>=0 && mins<60) && (secs>=0 && secs<60)) {
		RTC_hr = hrs;	// Set time to values given in parameters
		RTC_min = mins;
		RTC_sec = secs;
	};
};

Avec un exemple (testé sous Energia 005a) c’est plus facile à comprendre :

#include &lt;sRTCsec.h&gt;
#include &lt;legacymsp430.h&gt;
#include &lt;TimerSerial.h&gt;

TimerSerial mySerial;
RealTimeClockSec myRTC;

  int ledState = LOW;

void setup() {
  pinMode(2, OUTPUT);

  // This is to close the serial output so you are able to upload a new sketch to the LaunchPad
  pinMode(5, INPUT_PULLUP),
  attachInterrupt(5,fin,LOW);

  mySerial.begin();

};

// The LED1 will blink each exact second and the time will be printed to the serial port
void loop() {
  if ((myRTC.RTC_sec % 2)==0 && ledState== HIGH) {
  ledState = LOW;
  mySerial.print(myRTC.RTC_min, DEC);
  mySerial.print(":");
  mySerial.println(myRTC.RTC_sec, DEC);
  digitalWrite(2, ledState);
  };

  if ((myRTC.RTC_sec % 2)==1 && ledState== LOW) {
  ledState = HIGH;
  mySerial.print(myRTC.RTC_min, DEC);
  mySerial.print(":");
  mySerial.println(myRTC.RTC_sec, DEC);
  digitalWrite(2, ledState);
  };
};

void fin() {
  mySerial.end();
};

interrupt(TIMER1_A0_VECTOR) Tic_Tac(void) {
	myRTC.Inc_sec();		      // Update secondes
};

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.