Archives par mot-clé : arduino

Code source ultra-simpliste pour Arduino/MSP430 d’un VFO à AD9850/AD9851

Prototype kit Balise WSPR DDS XV4Y (http://xv4y NULL.radioclub NULL.jpg)Dans un commentaire Sylvain F6GGX m’a demandé après ce bout de code. Il était disponible gratuitement dans la boutique mais comme j’ai désactivé cette dernière il a disparu du site…
Voici donc le code source d’un VFO très simpliste à base de AD9850/AD9851 qui utilise les librairies que j’ai écrites ou adaptées (http://xv4y NULL.radioclub Honnêtement je pense pas que ce code soit très utile, rien de particulièrement compliqué et l’ergonomie à 4 boutons n’est pas super. C’est utile en dépannage avec le kit balise WSPR que je produisais mais c’est tout. Le code est écrit pour Energia sur MSP430, le porter sur Arduino (ATMega328) ne devrait poser aucun problème.

/* Simple VFO with DDS for MSP430G2553
 * Code for Energia 009
 * By Yannick DEVOS - XV4Y - March 2013

    Copyright 2012-2013 Yannick DEVOS under GPL 3.0 license
    Any commercial use or inclusion in a kit is subject to author approval

 * Agile Frequency generation using AD9850/9851 DDS
 * Output to Nokia 5110 compatible LCD
 * Check if P2_2 has changed state and switch VFO (like when PTT is pressed to operate split)

Usage for short press of buttons :
- Up / Down      increase or decrease the frequency following the choosen digit
- Left / Right   increase or decrease the digit
- OK             validate the frequency and send it to the DDS
Long press of buttons :
- Left           Set the current VFO to the next band bottom frequency
- Right          VFO A = VFO B
- OK             Switch between VFO A and VFO B

Revision history :
v1.00    2013-03-18
         First release

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
GNU General Public License for more details.

You can download a copy of the GNU General Public License at <>

// Here modify to your taste or needs

#define PTT_key          P2_2
#define AUTO_VALID       // Uncomment if you want the DDS frequency to be udapted automatically after each value change

#define DEFAULT_FREQ    8            // Value 8 in Frequencies array is 14000000
// Here under don't touch anything unless you know what you do

#include <legacymsp430.h>
#include <AD9850.h> // Library for AD9850 control by MSP430

#include <LCD_5110.h>

              // Frequencies (1 Hz precision) you can select
const unsigned long int frequencies[] = {
  137000, 471000, 501000, 1830000, 3500000, 5200000, 7000000, 10100000,
  14000000, 18068000, 21000000, 24890000, 28000000, 50000000, 70000000};
const byte Analog_Noise = 5;    // Margins for reading analog buttons

boolean   vfo=0, saved_PTT;  // VFO A or B and PTT input state
char      multiplier, aff_multiplier, freq_select=DEFAULT_FREQ;
unsigned  long int frequency_A=frequencies[DEFAULT_FREQ], frequency_B=frequencies[DEFAULT_FREQ], debounce;

char chaine_txt[6] = {' ', ' ', ' ', ' ', ' ', 0x00};

AD9850 myDDS (P1_0, P1_1, P1_2, P1_4);  // Call the AD9850 Library, AD9850 pins for CLOCK, LOAD, DATA and RESET
//AD9850 myDDS (P1_1, P1_2, P1_0, P1_4);  // Call the AD9850 Library, AD9851 pins for CLOCK, LOAD, DATA and RESET

LCD_5110 myScreen(P2_3,    // Chip Select *
         P1_6,    // Serial Clock *
         P2_5,    // Serial Data *
         P2_4,    // Data/Command *
         NULL,    // Reset *
         P1_7,    // Backlight
         NULL);  // Push Button 0

// Defining pins mode and initializing hardware

void setup() {
  pinMode(PTT_key, INPUT_PULLUP);


  myScreen.text(0, 0, "sVFO");
  myScreen.text(0, 2, "AD9850");
  myScreen.text(0, 4, "v1.00 - XV4Y");
  myScreen.text(0, 5, "Init...");
  myDDS.SetFrequency( frequency_A, 0, false );

  digitalWrite( PTT_key, LOW );


// Here starts the actual sequence sending

void loop() {
    if (vfo == 0) {
      myScreen.text(0, 0, "VFO A");
      myDDS.SetFrequency( frequency_A, 0, false );
    } else {
      myScreen.text(0, 0, "VFO B");
      myDDS.SetFrequency( frequency_B, 0, false );

    display_freq (frequency_A, 3);
    display_freq (frequency_B, 5);

    while (read_buttons()==5 || read_buttons()==4 || read_buttons()==2) delay(10); // Debounce except for UP/DWN

    while (1) {
      // Update the frequencies display
      if (multiplier > 5) {
        aff_multiplier = multiplier + 2;
      } else if (multiplier > 2) {
        aff_multiplier = multiplier + 1;
      } else {
        aff_multiplier = multiplier;
      myScreen.text(0, 4, "          ");
      if (vfo == 0) {
        myScreen.text(9-aff_multiplier, 4, "^");
      } else {
        myScreen.text(9-aff_multiplier, 4, "v");
      display_freq (frequency_A, 3);
      display_freq (frequency_B, 5);
      // Read the analog buttons input
      if(read_buttons()==1) {            // Up we increase frequency
        delay(200);  // Debounce
        if (vfo == 0) {
          frequency_A = frequency_A + powf(10,(float)multiplier);
        } else {
          frequency_B = frequency_B + powf(10,(float)multiplier);
#if defined AUTO_VALID

      } else if (read_buttons()==3) {    // Down we decrease frequency
        delay(200);  // Debounce
        if (vfo == 0) {
          frequency_A = frequency_A - powf(10,(float)multiplier);
        } else {
          frequency_B = frequency_B - powf(10,(float)multiplier);
#if defined AUTO_VALID

      } else if (read_buttons()==2) {    // Left we increase multiplier
        debounce = millis();
        while (read_buttons()==2) {  //Debounce
          if ((millis()-debounce)>1000) {  // Long press we do "Band UP"
            if (freq_select > 14) freq_select = 0;
            if (vfo == 1) frequency_B = frequencies[freq_select]; else frequency_A=frequencies[freq_select];
        if (multiplier > 7) multiplier = 7;

      } else if (read_buttons()==4) {    // Right we decrease multiplier
        debounce = millis();
        while (read_buttons()==4) {  //Debounce
          if ((millis()-debounce)>1000) {  // Long press we do VFO A=B
            if (vfo == 1) frequency_A = frequency_B; else frequency_B=frequency_A;
        if (multiplier < 0) multiplier = 0;

      } else if (read_buttons()==5) {    // OK we go out
        debounce = millis();
        while (read_buttons()==5) {  //Debounce
          if ((millis()-debounce)>1000) {  // Long press we switch VFO A/B
            if (vfo == 1) vfo=0; else vfo=1;
        break;   // Short press we just leave the loop so the frequency is transmitted to the AD9850

      // Check if we are transmitting split (momentaneous VFO A->B switch)
      if (saved_PTT != digitalRead(PTT_key)) {
        saved_PTT = digitalRead(PTT_key);
        if (vfo == 1) vfo=0; else vfo=1;


// Display the frequency
void display_freq (unsigned long freq, char ligne) {
  myScreen.text(10, ligne, " Hz ");
  chaine_txt[5] = 0x00;
  chaine_txt[4] = 0x30 + (((freq)/1)%10);
  chaine_txt[3] = 0x30 + (((freq)/10)%10);
  chaine_txt[2] = 0x30 + (((freq)/100)%10);
  chaine_txt[1] = '.';
  chaine_txt[0] = 0x30 + (((freq)/1000)%10);
  myScreen.text(5, ligne, chaine_txt);
  chaine_txt[5] = 0x00;
  chaine_txt[4] = 0x30 + (((freq)/10000)%10);
  chaine_txt[3] = 0x30 + (((freq)/100000)%10);
  chaine_txt[2] = '.';
  chaine_txt[1] = 0x30 + (((freq)/1000000)%10);
  chaine_txt[0] = 0x30 + (((freq)/10000000)%10);
  myScreen.text(0, ligne, chaine_txt); 

// Display a 2 digits number
void display_number (byte number, char column, char ligne) {
  chaine_txt[2] = 0x00;
  chaine_txt[1] = 0x30 + (number%10);
  chaine_txt[0] = 0x30 + ((number/10)%10);
  myScreen.text(column, ligne, chaine_txt);

// Return a button value depending on the analog reading
byte read_buttons () {
  int value = analogRead(ANALOG_BUTTONS);
  if ( value<(1+Analog_Noise) ) {
    return 1;
  } else if ( value<(78+Analog_Noise) ) {
    return 2;
  } else if ( value<(146+Analog_Noise) ) {
    return 3;
  } else if ( value<(205+Analog_Noise) ) {
    return 4;
  } else if ( value<(255+Analog_Noise) ) {
    return 5;
  } else {
    return 0;

3 projets QRP par VU2ESE

VU2ESE - Amplificateur linéaire 25W IRF510 (http://xv4y NULL.radioclub NULL.jpg)Farhan VU2ESE, auteur des BITX (http://xv4y NULL.radioclub et MINIMA (http://xv4y NULL.radioclub, nous avait récemment fait part de ses expérimentations autour d’une boîte d’accord QRP (http://xv4y NULL.radioclub

Ces derniers jours il a envoyé sur quelques listes de diffusion l’adresse d’un nouveau site web où il partage trois autres projets (http://hfsignals NULL.blogspot NULL.html) assez innovants :

  • SWEEPERINO (http://hfsignals NULL.blogspot NULL.html), un générateur de signal / wobulateur / ROSmètre construit autour d’un Arduino, d’un Si570 et d’un détecteur de signal W7ZOI à base d’AD8307.
  • Un amplificateur linéaire 25W bi-bandes 20/40 mètres (http://hfsignals NULL.blogspot NULL.html) à base d’IRF510, pour 2W en entrée et alimentation 30V.
  • Les détails du BITX40 (http://hfsignals NULL.blogspot NULL.html) dont le kit a été distribué à la Hamfest India.

Décodeur de télégraphie autonome avec Arduino

Nicola Cimmino - Décodeur CW Arduino (http://xv4y NULL.radioclub NULL.png)Merci à Raj VU2ZAP d’avoir partagé ce lien. Le projet de décodeur Morse de Nicola Cimmino est très intéressant à plusieurs titres.

Tout d’abord il utilise peu de composants et le principal est un micro-contrôleur Arduino. Ensuite le code est entièrement disponible en licence GNU. Et finalement sa documentation est très didactique et complète même s’il manque un schéma du circuit d’amplification audio qui aurait pu être utile.

Pour l’instant le code attend un signal 700 Hz et une vitesse autour de 13 wpm, mais chacun est libre d’améliorer le code source pour l’adapter à ses besoins.

La vidéo ci-dessous en montre le fonctionnement.

Vidéo décodeur CW Arduino Nicola Cimmino

Un TNC en mode KISS économique construit avec un Arduino [MAJ MicroModem MicroAPRS]

Il y a quelques années de cela, 99% de mon activité radio tournait autour du packet et du TCP/IP au travers de l’AX25. J’étais un des premiers dans la région lilloise à utiliser Linux (alors avec des kernels 1.2.x recompilés puis 1.3.x qui intégrait l’AX25 dans le source) pour le réseau packet-radio local. J’utilisais principalement une carte HDLC opto-scc avec un Z8530 qui pilotait des TCM3105. J’avais aussi construit avec mes petits doigts inhabiles un clone du TNC-2 en kit d’origine hollandaise (je crois) qui a du finir sa carrière chez F6IWQ Jean-Claude.

Aujourd’hui, puisqu’il n’y a personne autour de moi en VHF et au-delà, je regarde tout cela avec pas mal de distance, mais j’en reste pas moins curieux. Les choses ont bien évoluée depuis les coûteux TNC (http://en NULL.wikipedia de chez Kantronics, AEA (PK-232) ou PacComm (le Tiny-2 de F1GUM) très riches mais complexes. La grande mode est à l’APRS puisqu’avec Internet s’envoyer des messages par BBS interconnectées via des liens à 9600bps (merci G3RUH (http://www NULL.amsat NULL.html)) pour les plus riches n’est pas excitant.

J’avoue que je ne me suis pas intéressé à cette technologie, car je n’en vois pas trop l’intérêt dans ma situation. Toutefois j’ouvre l’oeil aux différents matériels et en particulier aux constructions OM et solutions open-source. Plusieurs TNC et circuits APRS étaient déjà parus en utilisant des micro-contrôleurs PIC comme celui de WB8WGA paru dans QEX ici amélioré (http://www NULL.enide ou le TNC-X avec port USB (http://www NULL.tnc-x ou encore le Mini-TNC de Fox Delta (http://www NULL.foxdelta NULL.htm). Par contre je n’avais rien trouvé autour des micro-contrôleurs AVR et de l’Arduino, sauf un projet de KI4MCW avorté car l’environnement Arduino souffre de trop de latences.

TNC Arduino (http://xv4y NULL.radioclub NULL.png)Heureusement, il y a quelques jours je suis tombé sur ce projet de TNC en mode KISS sur Arduino Nano (ATMega 328) (http://www NULL.mobilinkd qui va ravir les adeptes de la construction OM. Le code source est disponible sur GitHub, et on peut voir que son concepteur a utilisé BertOS (système temps-réel) pour résoudre les problèmes de latence. La programmation doit se faire AVRdude qui va “flasher” le binaire. Le concepteur propose aussi un TNC alimenté par batterie avec connexion Bluetooth pour être piloté directement par le téléphone (http://store NULL.mobilinkd

Je ne compte pas réaliser ce circuit, mais si vous prenez le temps de faire le montage, merci de m’informer de vos résultats!

Suite à une information de F8BXI, voici les liens vers MicroModem et MicroAPRS, deux codes librement disponibles écrits avec BertOS pour des Arduino qui implémentent un modem AX-25 AFSK 1200bps et un node APRS.

Nouveautés chez QRP-Labs (G0UPL)

Synthetiseur Si5351 à OCXO QRP Labs G0UPL (http://xv4y NULL.radioclub NULL.jpg)L’annonce de ces nouveautés datent d’en fait il y a près d’une semaine mais je n’ai pas eu le temps d’en parler. Hans G0UPL va ajouter quelques produits à sa boutique dans les jours qui viennent.

  • Tout d’abord un boîtier en aluminium anodisé noir, pré-découpé pour le kit complet balise Ultimate III (http://www NULL.qrp-labs NULL.php?route=product/product&product_id=77), avec la place pour toutes les options (filtre de bande, GPS…). Le prix de 20$ (plus port de 10$) est très correct.
  • Un module enfichable pour Arduino Uno qui reprend toutes les fonctionnalités du kit Ultimate III mais sans LCD et boutons (que vous pouvez ajouter vous-même). Cela permettra à ceux qui le veulent de développer eux-même leur logiciel de balise ou de générateur de fréquence en bénéficiant d’une plateforme matérielle performante et à prix raisonnable.
  • Prototype Synthetiseur OCXO G0UPL (http://xv4y NULL.radioclub NULL.jpg)Le plus important, c’est un kit synthétiseur de fréquence avec Si5351A et référence 10MHz à OCXO (http://www NULL.hanssummers NULL.html). Le but de ce kit est de remplacer avantageusement les modules chinois avec AD9850. Ceux-ci sont devenus impossibles à approvisionner et présentaient des limites en terme de performance et d’utilisation. Le nouveau kit devrait couvrir de 8 KHz à 160 MHz avec une stabilité de l’ordre de 0,1ppm à chaud, ce qui est excellent!

Le dernier kit est vraiment intéressant et pourra prendre la place dans les kits QRSS Ultimate III existant après une mise à jour du firmware. Avec le module Arduino, cela ouvre la possibilité de construire des générateurs de fréquence très stable jusque 160 MHz.

Un quatrième projet et quant à lui retardé, c’est celui d’un récepteur QRSS comme compagnon au kit balise. Hans cherchait une solution technique innovante mais ses tentatives autour de la démodulation méthode Weaver se sont avérées décevante.

Un Wattmètre-ROSmètre open-source par TF3LJ / VE2LJX

Wattmètre ROSmètre opensource TF3LJLoftur TF3LJ a lancé un projet très intéressant, celui de construire un appareil de mesure essentiel à tout radioamateur : un Wattmètre – ROSmètre. Son projet présente l’intérêt d’être ouvert à tous et d’utiliser un firmware écrit avec l’IDE Arduino. Du point de vue matériel, il utilise un micro-contrôleur Teensy 2+, des amplificateurs logarithmiques AD8307 et un écran 4×20 avec contrôleur compatible HD44780. A noter qu’au choix les ADC 10bits interne du micro-contrôleur ou des ADC externe 12-bits AD7991 d’Analog Device peuvent être utilisés. Le firmware les détecte automatiquement.

Les caractéristiques sont les suivantes :

  • Mesures allant du µW au KW et de 200Hz à 50 MHz
  • Mesures du ROS précises pour des niveaux de puissance aussi bas que 1mW
  • Double bargraph avec 100 niveaux chacuns
  • Affichage rémanent du niveau le plus haut pour une lecture de puissance crête-à-crête (PEP)
  • Lecture puissance instantanée, moyenne et en pointe (100ms)
  • Lecture puissance crête-à-crête (PEP) avec durée de 1s, 2,5s ou 5 secondes
  • Alarme ROS trop élevé pour des seuils de 1.5:1 à 4:1
  • Seuil de puissance réglable pour l’alarme ROS
  • Echelle automatique pour la lecture du mW au KW (auto-ranging)
  • Echantillonnage pour la mesure à 200 Hz
  • Connexion par port série virtuel via USB
  • Navigation et configuration par menu “tourner et pousser”
  • Calibrage par rapport à une source connue de puissance
  • Alimentation par 5V/200mA par le port USB (via un chargeur mural ou le PC)
  • Résolution maximale de 0,025dB (ADC 12bits avec référence à 2,6V)
  • Mode économiseur d’écran avec message personnalisable

Une version PDF prête à imprimer du manuel de construction est disponible en ligne.

Le MINIMA : nouveau transceiver par VU2ESE Farhan

Schéma du MINIMA par VU2ESE (http://xv4y NULL.radioclub NULL.png)Farhan de VU2ESE, le père du Bitx, vient d’annoncer son nouveau projet sur la liste Bitx : le MINIMA (http://www NULL.phonestack NULL.html). C’est encore une fois un projet très original du point de vue de l’architecture et des choix techniques réalisés. Une initiative à saluer!

Sans lister les caractéristiques que vous trouverez sur le site du projet (http://www NULL.phonestack NULL.html), le MINIMA est un transceiver QRP BLU/CW à couverture générale avec une puissance de sortie de 1W et une ergonomie simplifiée (un bouton). Voici les principaux points innovants à retenir :

  • Utilisation du Si570 comme oscillateur local.
  • Utilisation d’un ATMega328 (Arduino Nano) comme micro-contrôleur avec un afficheur LCD 16×2. Le code source est disponible librement.
  • Fréquence intermédiaire de 20 MHz avec des quartz d’horloge d’ordinateur.
  • Topologie de filtres originale pour le premier étage (front-end).
  • Mélangeur KISS utilisant deux JFET J310 pilotés par l’OL (et non le signal).
  • Utilisation de transistors courants 2N3904/2N3906 pour tous les étages d’amplification et de mélange, y compris pour la BF.
  • Transmission CW générée par audio.

Selon Farhan, le MINIMA est un des transceivers les plus simples à réaliser et à utiliser. Son architecture le rend très tolérant et donc facile à mettre au point, tout en gardant des performances intéressantes et un bon confort d’utilisation.

Je gardais l’info sous le coude suivant la volonté de Farhan car celui-ci souhaitait mettre en place une liste de diffusion avant de rendre l’information publique. La nouvelle ayant déjà été reprise SolderSmoke et (http://www NULL.radioamateur je publie cet article…

Arduino Tre avec processeur ARM et Arduino Galileo avec processeur Intel Quark [MAJ]

Arduino Tre (http://xv4y NULL.radioclub NULL.png)Après avoir innové et rendu accessible à un large public le développement de programmes pour micro-contrôleurs, la fondation Arduino se met dans les pas du Raspberry Pi. Elle vient d’annoncer l’Arduino Tre une carte conçue en partenariat avec BeagleBoard et qui embarque un processeur de la famille Cortex A8 d’ARM (un TI Sitara AM335x à 1GHz) ainsi qu’un micro-contrôleur AVR à ses côtés (un ATMega32U4 comme celui de l’Arduino Due) (http://arduino A noter que le Sitara AM335x est le même que celui de la BeagleBone Black, ce qui garanti le support des mêmes distributions Linux et d’un support matériel accru. La disponibilité est annoncée pour le printemps 2014 et de prix officiel pour l’instant. L’Arduino Yún (avec routeur Ethernet/WiFi sous OpenWRT/Linux intégré) (http://store NULL.arduino NULL.php?main_page=product_info&products_id=313) étant à 52€, on peut spéculer que le prix du Tre devrait être du même ordre de grandeur dans les 70€.

Intel Galileo Arduino (http://xv4y NULL.radioclub NULL.jpg)Autre annonce, celle d’une carte avec processeur Intel x86, l’Intel Galileo conçue en collaboration avec la fondation Arduino. Elle embarque un processeur SoC Quark X1000 à 400MHz qui reprend l’architecture de la famille Atom et qui devrait avoir des performances supérieures aux meilleurs représentants de la famille Cortex Mx d’ARM, mais pour des caractéristiques de consommation inconnue. La disponibilité est annoncée pour fin Novembre et le prix sous les 60$. Cette carte est aussi capable de faire tourner un système d’exploitation Linux.

MAJ : Après avoir étudié de plus l’architecture du Quark X1000, lui trouve beaucoup de similarité avec celle du i486DX… (http://www NULL.hardware NULL.html)

Merci à Ars Technica pour les deux infos (ici (http://arstechnica et ici (http://arstechnica

Nouvelle version de l’IDE Energia

Logo Energia (http://xv4y NULL.radioclub NULL.png)La dernière information de la série MSP430 c’est la disponibilité au téléchargement d’une nouvelle version de l’environnement de développement Energia (http://energia (basé sur l’application Arduino). Celle-ci corrige plusieurs bogues et apporte des améliorations diverses, mais surtout, elle ajoute le support de la nouvelle carte LaunchPad MSP430F5529 (http://xv4y NULL.radioclub annoncée récemment. Cette concomitance des deux annonces montre que la collaboration entre Texas Instruments et l’équipe qui développe Energia est plutôt efficace. Deux autres nouveautés importantes à noter dans l’application sont le support du BoosterPack Wi-Fi CC3000 et du BoosterPack Anaren AIR (communication sans-fil).

Texas Instruments lance le nouveau LaunchPad MSP430F5529

La première mouture du LaunchPad MSP430 de chez Texas Instruments utilise dans ses dernières versions des micro-contrôleurs MSP430G2452 et MSP430G2553. De la gamme Value, ils ont le gros avantage d’être en boîtier DIL, ce qui permet de les intégrer facilement à des projets externes à la carte LaunchPad. Ils sont aussi bon marché (en grosse quantité). La plus grosse de leur lacune concerne la capacité mémoire, principalement avec la SRAM limitée à 512o et la Flash à 16Ko. Pour de nombreux projets ça va, mais gérer des chaînes de caractères pour l’affichage sur un écran LCD peut rapidement devenir très compliqué. Mon contrôleur de balise à DDS pour WSPR/QRSS (http://xv4y NULL.radioclub arrive d’ailleurs à la limite de Flash et de SRAM ce qui m’empêche d’y intégrer de nouvelles fonctionnalités. Ceci est en partie compensé par le fait qu’on peut le reprogrammer très facilement via le port USB.

LaunchPad MSP430F5529 source (http://xv4y NULL.radioclub NULL.jpg)Il y a quelques jours, Texas Instruments a annoncé un nouveau produit avec le LaunchPad MSP430F5529 (http://www NULL.43oh proposé à 12,9$ et qui vient redistribuer les cartes dans la gamme de cartes expérimentales LaunchPad. En effet, cette fois-ci plus question de boîtier DIL, le circuit MSP430F5529 est un CMS soudé définitivement sur le carte, mais c’est nécessaire pour ce type de puce et c’est déjà le cas pour les cartes LaunchPad C2000 Piccolo (http://xv4y NULL.radioclub, LaunchPad Hercules (http://xv4y NULL.radioclub et LaunchPad Tiva C (Stellaris (http://xv4y NULL.radioclub Il reprend d’ailleurs la disposition des connecteurs 40 broches de ceux-ci ce qui permet d’utiliser les mêmes Booster Packs. Aussi, comme plusieurs de ses grand-frères, il dispose d’un port USB attaché au micro-contrôleur et non plus simplement au circuit de Programmation/Debug. Ceci vous permet de concevoir des périphériques USB comme par exemple un circuit qui va chercher des informations sur un serveur web et les “tapes” au clavier sur une autre machine (quelqu’un se reconnaît-il dans la foule?).

Tout le détail est disponible sur ici (http://www NULL.43ohà (http://www NULL.43oh et encore là (http://www NULL.43oh, mais voici ce qu’il faut en retenir :

  • Port USB 2.0 connecté directement au micro-contrôleur
  • Processeur cadencé à 25MHz (contre 16MHz pour le G2553)
  • 128Ko de Flash et 8Ko de SRAM (c’est beaucoup)
  • Convertisseur analogique-numérique 12bits SAR
  • Convertisseur de tension DC-DC pour disposer facilement de 5V et 3,3V via l’USB

Texas Instruments met à disposition les outils de développement et les librairies y compris pour concevoir des périphériques USB de classes CDC, HID et MSC. Vous pouvez tout aussi bien choisir de programmer ce circuit via l’Environnement Energia qui reprend la syntaxe Arduino. Les premières impressions que livre “spirillis” (membre très actif de la communauté sont très positives même si quelques limitations sont notées et que TI travaille pour les lever. Une bonne nouvelle c’est que la section USB comporte 2Ko de RAM que vous pouvez utiliser conjointement aux 8Ko de la mémoire principale si vous n’activez pas l’USB. Autre point intéressant, à la livraison le LaunchPad est programmé avec une démo qui le fait agir comme périphériques HID (un clavier) et comme mémoire de masse simultanément. Cela ouvre la porte à pas mal d’applications!