Archives de catégorie : Micro-contrôleurs

Les micro-contrôleurs de type AVR, Arduino, MSP430, LaunchPad, PIC, PICAXE…

Portage de MICROPYTHON sur TeXAS INSTRUMENTS LM4F120 (Stellaris LaunchPad)

J’ai un petit côté nostalgique en ce moment et j’avais envie de retrouver les plaisirs simples des micro-ordinateurs des années 80: un interpréteur simple (type BASIC) en ligne de commande. J’avais dans mes fonds de tiroir une carte Stellaris LaunchPad de Texas Instruments qui est construite autour d’un micro-contrôleur bien plus puissant que nos vénérables Amstrad CPC, Thomson MO5, Sinclair ZX ou Matra Alice 90 (dans mon cas). Il ne me restait plus qu’à trouver un projet autour de son CPU Cortex M4 32 bits avec 64Ko de RAM et 256Ko de mémoire flash.

MicroPython remplit parfaitement la mission: simple d’accès, tournant sur des micro-contrôleurs et aussi parfaitement évolutif. Python est aussi bien plus propre et puissant que le BASIC. Seul problème: les “versions” (portages) actuellement disponible ne tournaient pas sur la carte que j’avais à ma disposition. Comme l’architecture (ARM v8 32bits) était déjà supportée, en principe le travail ne serait que minime.

Capture écran MicroPython sur Stellaris LaunchPad
Capture ecran Micropython sur Stellaris LaunchPad

J’avais réussi mon premier objectif (ligne de commande) depuis quelques semaines mais je voulais aussi implémenter un minimum de fonctionnalité, et surtout le faire proprement. Le plus dur a été de comprendre la philosophie de MicroPython et comment faire un code qui soit utile pour tous. Ce soir, j’ai eu la grande satisfaction de publier sur GitHub mon premier “commit” avec un code relativement bien documenté et propre et qui utilise les fonctions de base de la carte (LED tricolore et boutons pression).

Tout est disponible publiquement ici: https://github.com/zl4yy/micropython

Maintenant je voudrais implémenter des fonctions plus évoluées comme les bus I2C et SPI, les ports USB, etc. Entre temps j’ai découvert un autre projet similaire mais sur une version plus vieille de MicroPython. J’ai l’intention de m’en inspirer et de réutiliser une partie du code (qui est open source) mais l’auteur a fait quelques choix différents qu’il me faudra contourner.

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

Prototype kit Balise WSPR DDS XV4Y (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/12/100_3339 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 NULL.asia/docs/). 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
    http://xv4y.radioclub.asia/

    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
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You can download a copy of the GNU General Public License at <http://www.gnu.org/licenses/>
*/

// Here modify to your taste or needs

#define PTT_key          P2_2
#define ANALOG_BUTTONS   A5
#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);

  myDDS.begin();
  
   
  pinMode(ANALOG_BUTTONS, INPUT);

  myScreen.begin();
  myScreen.setBacklight(1);
    
  myScreen.setFont(1);
  myScreen.text(0, 0, "sVFO");
  myScreen.text(0, 2, "AD9850");
  myScreen.setFont(0);
  myScreen.text(0, 4, "v1.00 - XV4Y");
  myScreen.text(0, 5, "Init...");
  
  delay(1000);
  
  myDDS.reset();
  
  myDDS.SetFrequency( frequency_A, 0, false );

  digitalWrite( PTT_key, LOW );

};

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

void loop() {
    myScreen.clear();
    myScreen.setBacklight(1);
    myScreen.setFont(1);
    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 );
    };

    myScreen.setFont(0);
    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
        break;
#endif

      } 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
        break;
#endif

      } 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"
            freq_select++;
            if (freq_select > 14) freq_select = 0;
            if (vfo == 1) frequency_B = frequencies[freq_select]; else frequency_A=frequencies[freq_select];
            multiplier--;
            break;
          };
        };
        multiplier++;
        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;
            multiplier++;
            break;
          };
        };
        multiplier--;
        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;
          };
        };
        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;
        break;
      };
    }

};


//******************************************************************
// 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;
  }
}

Le Raspberry Pi Zero pour seulement 5 USD

Raspberry Pi Zero (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2015/11/Pi-Zero-Features-Graphic-Small NULL.jpg)La fondation Raspberry Pi vient d’annoncer le lancement d’une version minimaliste de leur célèbre carte ordinateur embarqué nommée Raspberry Pi Zero. Pour un prix de seulement 5$, ce circuit de la moitié de la taille d’une carte de crédit embarque le même processeur Broadcom BCM2835 que la carte originale mais cadencé à 1 GHz ce qui apporte des performances améliorées de 40%. La mémoire vive est de 512Mo et les entrées-sorties sont réduites avec un port HDMI, deux ports micro-USB et un lecteur de carte micro-SD. Le connecteur “standard” de 40 broches pour les entrées-sorties GPIO est présent, ainsi que des broches permettant une sortie vidéo composite.

Merci à Ars Technica pour l’information (http://arstechnica NULL.com/gadgets/2015/11/pi-zero-a-full-raspberry-pi-for-just-4/).

Un analyseur de réseau très simple à base d’AD9850 et Arduino Nano

G4NQX Analyseur de réseau AD9850 Arduino Nano (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2015/10/ddstop NULL.jpg)Rob G4NQX a réalisé un analyseur de réseau scalaire très peu coûteux autour de quelques modules faciles à trouver : un DDS AD9850 et un Arduino Nano (http://rheslip NULL.blogspot NULL.co NULL.uk/2015/08/the-simple-scalar-network-analyser NULL.html). La détection de puissance est faite par un circuit à échelle logarythmique AD8307 et un petit ampli tampon est nécessaire pour augmenter un peu le signal de l’AD9850. La partie logiciel PC pour le contrôle et affichage logiciel est écrite en Python à partir d’une idée originale de PA2OHH.

La plupart des OM n’ayant pas besoin d’analyseur vectoriel, ce montage peut tout à fait faire l’affaire pour vos mesures jusque 30 MHz. Pour plus de détails reportez-vous à l’article en anglais.

 

ARM Radio par I2PHD : un récepteur SDR 8-900KHz à échantillonnage direct

ARM Radio par I2PHD réception Europe 1 (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2015/07/arm_radio_europe1 NULL.jpg)Alberto de I2PHD est l’excellent concepteur du logiciel WinRAD qui a servi de base à HDSDR (http://xv4y NULL.radioclub NULL.asia/2014/12/20/reception-ads-b-et-decouverte-de-ma-clef-rtl-sdr/) (WinRAD HD), très connu des amateurs de radio SDR I/Q et RTL-SDR, ainsi que d’Argo (http://xv4y NULL.radioclub NULL.asia/2012/05/27/nouvelle-version-build-140-dargo-par-i2phd/), logiciel de QRSS. Depuis quelques temps il avait commencé à se pencher sur l’écriture de codes SDR pour les processeurs ARM Cortex M.

Il vient juste de participer à un concours de créations de circuits autour des micro-contrôleurs ARM et partage en ligne le design et le code source de son projet ARM Radio (http://www NULL.sdradio NULL.eu/weaksignals/code/ARM_Radio NULL.pdf). Au niveau matériel, la volonté est celle de la simplicité puisqu’il n’y a quelques composants en dehors de la carte STM32F429 Discovery qui intègre déjà un écran tactile LCD. Le convertisseur ADC intégré au micro-contrôleur réalise la numérisation du signal qui est ensuite traité numériquement par le Cortex M4 à 200 MHz. A noté que ce dernier disposant d’unité SIMD Neon, les performances sont excellentes.

ARM Radio par I2PHD schéma bloc de principe (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2015/07/I2PHD_ARM_Radio_schema_principe NULL.png)A noter que si la réception d’Europe 1 sur le grandes ondes ne vous paraît pas une application intéressante, l’intérêt de ce projet est qu’il peut être adapté à n’importe quelle bande de fréquence avec l’ajout d’un premier étage de conversion HF et que le code source étant ouvert vous pourrez implémenter n’importe quelle démodulation.

C.H.I.P. : Un ordinateur embarqué (style Raspberry-Pi) pour 9$

CHIP board AllWinner A13 (Ars Technica) (http://arstechnica NULL.com/information-technology/2015/05/move-over-raspberry-pi-this-startup-is-building-a-9-computer/)Selon Ars Technica, la startup américaine Next Thing travaille sur un équivalent du Rasperry Pi mais pour un prix plancher de 9 USD (http://arstechnica NULL.com/information-technology/2015/05/move-over-raspberry-pi-this-startup-is-building-a-9-computer/). C’est en fait un “à-côté” d’un projet existant, mais ils se sont dit qu’ils pourraient en faire profiter la communauté et ont placé le projet sur KickStarter où il a rencontré un succès énorme avec plus de 627 000$ levés à ce jour depuis 12 000 contributeurs. Les lots de productions prévus pour décembre 2015 sont bientôt épuisés et les commandes arrivent pour ceux de janvier 2016!

Cette carte beaucoup plus petite que la plupart de ses consoeurs embarquement un CPU AllWinner A13 à 1GHz (simple-coeur Cortex A8 et GPU Mali400) , 512Mo de RAM et 4Go de Flash pour la mémoire de masse. Elle intègre WiFi et Bluetooth ainsi qu’une sortie vidéo composite en plus du port USB habituel. Avec un adaptateur, vous pouvez aussi brancher un écran HDMI ou VGA.

PocketCHIP AllWinner A13 (Ars Technica)Des compléments sont disponibles avec le PocketC.H.I.P. qui le transforme en mini-tablette (plutôt au format GameBoy) avec écran tactile 4,3″ 470×272, batterie 3000mAh, mini clavier à membrane, connecteurs GPIO… Le paquet comprenant un Pocket CHIP et une carte CHIP est disponible pour les contributions à partir de 49$.

A noter qu’à part pour les USA où la livraison est à 5$, c’est 20$ de frais de port, ce qui limite un peu l’intérêt pour les paquets les moins chers…

Nouveau micro-contrôleur Atmel avec une autonomie sur piles mesurées en dizaines d’années

Atmel SAM L21 (Photo Ars Technica) (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2015/04/atmel-640x427 NULL.jpg)Atmel a annoncé il y a quelques jours une nouvelle famille de circuits intégrés basés sur une architecture ARM Cortex M0. L’objectif visé par les nouveaux micro-contrôleurs SAM L21 (http://www NULL.atmel NULL.com/products/microcontrollers/arm/sam-l NULL.aspx) est une consommation extrêmement basse de l’ordre de la dizaine d’années. On parle de consommations situées entre 35µA/MHz en fonctionnement et 200nA en veille profonde. C’est environ 4 fois mieux que les meilleurs circuits actuels en utilisation, et le gain en veille profonde est encore plus important. En effet, alors qu’habituellement on se contente d’éteindre l’horloge interne des circuits, les SAM L21 permettent de complètement déconnecter certaines parties du circuit-intégré tout en permettant aux autres de continuer à communiquer, réduisant ainsi les pertes par fuites à presque zéro.

Cette nouvelle puce dispose d’un coeur Cortex M0 32 bits à 42 MHz, jusqu’à 256Ko de mémoire Flash, jusqu’à 32Ko de mémoire SRAM et jusqu’à 8Ko d’une autre mémoire SRAM spéciale qui reste alimentée même dans le mode veille le plus profond. En plus des périphériques habituellement trouvé dans les MCU (ADC et DAC 12bits, GPIO, USB, I2C, SPI, UART…) qui sont paramétrables, le L21 dispose de la gestion d’interface tactiles, d’un circuit spécial pour le chiffrement AES et d’un Générateur de Nombres Aléatoires Véritables (TRNG, True Random Number Generator). Ceci la rend donc parfaitement adapté pour les systèmes embarqué et les commandes à distance sécurisées.

L’article d’origine provient d’Ars Technica (http://arstechnica NULL.com/information-technology/2015/03/new-arm-powered-chip-aims-for-battery-life-measured-in-decades/).

Le Raspberry Pi 2 avec processeur quadricoeur est arrivé! [MAJ]

Trois ans après lancé la démocratisation de l’informatique embarquée, la Fondation Raspberry (http://www NULL.raspberrypi NULL.org) renouvelle sa plateforme matérielle tout en gardant le même prix de 35$. Le Raspberry Pi 2 est dès à présent disponible en volume chez les revendeurs habituels.

Raspberry Pi 2 (Ars Technica) (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2015/02/Pi2ModB1GB_2 NULL.jpg)Plus qu’une mise à jour comme la dernière version B+, le Raspberry Pi 2 (http://www NULL.raspberrypi NULL.org/raspberry-pi-2-on-sale/) est une vraie évolution sans remettre en cause les bases matérielles. Le format de la carte reste le même et la consommation électrique est toujours contenue. Je vous laisse consulter les détails sur l’article d’Ars Technica qui m’a informé de la nouveauté (http://arstechnica NULL.com/information-technology/2015/02/raspberry-pi-2-arrives-with-quad-core-cpu-1gb-ram-same-35-price/). En résumé, voici ce qui change par rapport au modèles B et B+ qu’il remplace :

  • Processeur Broadcom BCM2836 (CPU plus puissant, même GPU)
  • CPU quadri-core Cortex A7 à 900 MHz avec jeu d’instruction ARMv7
  • 1 Go de RAM (partagée avec la vidéo)
  • 4 ports USB et carte MicroSD (comme sur le B+)

Mon avis personnel, c’est qu’une des limitations de performance va maintenant venir de la mémoire de masse. Les cartes SD ne sont pas les périphériques les plus rapides et intégrer une mémoire de type eMMC pour la base de l’OS aurait été intéressant. De plus, en milieu humide (ou dans un pays tropical), les contacts des cartes SD peuvent s’oxyder et provoquer des faux-contacts à long terme.

Mise à jour à propos des performances : Le processeur BCM2836 du nouveau RPi2 utilise des coeurs Cortex A7 à 900 MHz (cadence maximale de 1,1 GHz). Cela représente un bon en avant par rapport au modèle précédent, mais reste bien en deçà d’une carte comme la Radxa Rock (http://xv4y NULL.radioclub NULL.asia/2014/11/18/ordinateur-embarque-radxa-rock-2-avec-cpu-rk3288-quadri-core-a-18ghz/) dont le RK3188 utilise des coeurs Cortex A9 plus performants et qui plus est cadencés à 1,6 GHz. Un banc d’essai disponible ici donne quelques points de comparaison intéressants (http://www NULL.trustedreviews NULL.com/raspberry-pi-2-review-power-and-performance-page-2). Par ailleurs, la capacité à tirer parti des 4 coeurs disponible dépendra des applications et de la façon dont elles ont été écrites. Pour avoir suivi les échanges concernant le développement de WSJT-X par exemple, le faire tourner sur plusieurs coeurs grace à OpenMP n’apporte que 25% de gain en moyenne, et n’utilise que deux coeurs partiellement chargés.

La grande nouveauté (mis à part le CPU beaucoup plus puissant) c’est bien évidemment le jeu d’instruction ARMv7. En effet, le précédent Pi utilisait un jeu d’instruction ARMv6 ce qui limitait les possibilités de systèmes d’exploitation. De nouvelles images de Raspbian seront bientôt disponible supportant les deux générations de carte. Surtout, c’est Ubuntu et Windows 10 qui font leur apparition. Il semblerait que la Fondation Raspberry et Microsoft aient travaillé de manière rapprochée ces 6 derniers mois pour faire fonctionner l’OS grand public et il sera disponible gratuitement. Microsoft sent le vent tourner dans le domaine de l’informatique embarquée (http://dev NULL.windows NULL.com/en-us/featured/Windows-Developer-Program-for-IoT) et souhaite rattraper son retard à tout prix.

Le modèle A reste inchangé pour l’entrée de gamme à 20$, même si une mise à jour mineure est  prévue dans les mois qui viennent, certainement pour passer la RAM à 512 Mo. Les modèles B et B+ restent aussi disponibles pour les utilisateurs professionnels qui ont besoin de stabilité (ça fera plaisir à certains). Le choix de garder le même GPU est intéressant car le Raspberry est un des rares ordinateurs embarqués à disposer des pilotes Linux pour ce dernier. A noter toutefois que s’il permet de lire des vidéos compressées en HD, il devrait marquer le pas pour les définitions 4k face aux nouveaux GPU.

La CubieBoard 4 CC-A80 octo-core disponible à 125$

CubieBoard 4 CC-A80 (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2015/01/unnamed_2048x2048 NULL.jpg)Ca y est, la plus puissante des cartes pour informatique embarquée est maintenant disponible à la commande pour le prix de 124,9 USD (http://store NULL.r0ck NULL.me/collections/home-slide/products/cubieboard4-cc-a80-high-performance-mini-pc) au lieu de 159 USD. Elle est livrée avec les câbles USB, un boîtier acrylique minimaliste et l’antenne WiFi, mais pas l’alimentation (prévoir 4A sous 5V). Cette nouvelle itération de la CubieBoard a des caractéristiques impressionnantes :

  • Processeur AllWinner A80 (http://www NULL.allwinnertech NULL.com/en/clq/processora/A80 NULL.html) gravés en 28nm, 8 coeurs ARM Cortex en architecture BIG.little (4x A15 à 2,0GHz et 4x A7 à 1,3GHz), GPU PowerVR 64 coeurs G6230.
  • 2 Go de RAM, 8Go de Flash eMMC (extensible à 64 Go), lecteur de carte micro-SD
  • 1 port Ethernet Gigabit, Wifi bi-bande 2,4/5 GHz, Bluetooth 4
  • 4 ports USB 2.0 host, 1 port USB 3.0 OTG, UART, JTAG, i2c, récepteur IR
  • Entrées et sorties audio, port HDMI 1.4 et VGA

Vous allez me dire, tant de puissance dans le AllWinner A80 (http://blog NULL.imgtec NULL.com/powervr/allwinner-ultraocta-a80-processor-packs-powervr-series6-gpu-64-cores) pour quoi faire ? Là est la question… D’autant que répartir la charge sur 8 coeurs CPU (dont on ne sait pas quelle type de topologie BIG.little ils utilisent) n’est pas facile. De plus, le pilote du GPU PowerVR (très puissant au demeurant) n’est pas rendu disponible pour Linux. Cela veut dire qu’en dehors d’une utilisation avec la version d’Android livrée avec la carte, vous pouvez l’oublier.

Carte APU par PC Engines à processeur AMD G T40E : haute performance pour routeurs ou applications embarquées

Je suis tombé sur ce produit conçu et fabriqué en Suisse un peu par hasard en travaillant sur un nouveau projet que j’ai autour de OpenWRT (http://xv4y NULL.radioclub NULL.asia/2014/03/13/installer-openwrt-sur-un-routeur-tp-link-wr941nd/).

APU1D PC Engines (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2015/01/apu1c1 NULL.jpg)Les cartes APU de PC Engines sont construites autour de processeur x86 64 bits AMD G Series T40E (http://www NULL.pcengines NULL.ch/apu1d NULL.htm), elles prennent la suite de la série ALIX (http://www NULL.pcengines NULL.ch/alix NULL.htm) (AMD Geode LX700 et LX800). Les processeurs AMD G Series (http://www NULL.amd NULL.com/en-us/products/embedded/processors/g-series) T40E disposent de deux coeurs “Bobcat” à 1 GHz et d’un processeur graphique performant, et sont utilisés dans la Gizmo Explorer (http://xv4y NULL.radioclub NULL.asia/2013/10/13/comparatif-entre-les-ordinateurs-embarques-x86-gizmo-explorer-kit-amd-et-minnowboard-intel/)  (http://xv4y NULL.radioclub NULL.asia/2013/10/13/comparatif-entre-les-ordinateurs-embarques-x86-gizmo-explorer-kit-amd-et-minnowboard-intel/)par exemple. Le but n’étant pas de lui faire exécuter des jeux vidéos mais des calculs mathématiques pour du chiffrement de VPN par exemple. L’intérêt de ces processeurs par rapport aux processeurs ARM qu’on trouve dans les Raspberry Pi, Radxa Rock ou CubieBoard, c’est d’une part qu’ils exécutent nativement du code x86 comme tout PC lambda, et qu’ils disposent de systèmes d’entrées-sorties de haute volée, avec la possibilité par exemple de disposer de ports Gigabit Ethernet, d’un connecteur SATA…

La carte APU1D4 par exemple, offre 4 Go de RAM, 3 ports Gigabit Ethernet, 2 ports miniPCIe, 1 port m-SATA, 2 ports USB et des entrées-sorties GPIO, I2C et UART habituelles. Le prix est de net5501 routeur AMD Geode145€ HT chez Calexium (http://store NULL.calexium NULL.com/fr/cartes-meres-pc-engines-alix-apu/350-apu-1c-amd-g-t40e-double-coeur-1-ghz NULL.html). Vous pouvez faire fonctionner cette carte avec les variantes de Linux ou BSD les plus courantes, mais aussi Windows XP ou FreeDOS. Cela-dit, ce type de matériel donnera tout son potentiel comme routeur sous OpenWRT ou avec d’autres variantes très légères de Linux comme Linaro ou une Debian minimaliste installée sur mesure.

Si vous cherchez plus de connectivité réseau mais moins de puissant CPU, regardez du côté des net5501 de Soekris (http://soekris NULL.com/products/net5501 NULL.html), là encore le matériel est très intéressant et permet d’envisager des projets de routeur sur mesure, à l’abris des yeux et des oreilles de la NSA ou des espions chinois.