Archives par mot-clé : Atmel

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/).

Arduino Due 32bits

Arduino Due (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/11/arduino_due_in_hand NULL.jpg)J’ai regardé ailleurs un instant et je suis passé à côté de la nouvelle… L’équipe Arduino (http://arduino NULL.cc) a enfin annoncé officiellement le nouvel Arduino Due 32 bits. Tout comme le Stellaris LaunchPad (http://xv4y NULL.radioclub NULL.asia/2012/10/02/a-letroit-avec-un-arduino-ou-un-launchpad/) ou d’autres plateformes de développement tel que le Maple (http://leaflabs NULL.com/devices/maple/), il utilise un micro-contrôleur construit sur une architecture ARM Cortex 32 bits au lieu des plus simples plateformes 8 bits d’Atmel.

Le processeur choisi est un SAM3X8E à 84 MHz de chez Atmel qui suit l’architecture Cortex M3 (le Stellaris LaunchPad est un Cortex M4F, plus puissant) avec 512Ko de Flash et 96Ko de SRAM. Comme points forts du nouveau circuit on peut citer :

  • Des performances accrues et 54 entrées/sorties numériques
  • La disponibilité d’un port USB hôte en plus du port USB programmateur pour y connecter des périphériques
  • 12 CAN (ADC) sur 12 bits permettant un taux théorique maximum de 1000ks/s (contre 15ks/s pour l’Arduino 8 bits)
  • 2 CNA (DAC) sur 12 bits intégrés permettant une sortie audio
  • Une compatibilité avec les shield existant s’ils sont conçus à partir de la révision R3 car l’Arduino Due utilise une logique 3,3V (contre 5V pour l’Arduino)
  • Une portabilité assez facile du code prévu pour les ATMega vers les nouveaux Cortex M3
  • Un connecteur JTAG/SWD pour le déboguage

La version béta 1.5 de l’IDE Arduino est disponible mais demande encore un peu de travail pour être considérée comme stable. La platine Arduino Due est annoncée à 49$ US. C’est un peu plus cher que le Maple et 10 fois le prix du Stellaris Launchpad au passage. La disponibilité réelle n’est pas encore connue.

Une dernière remarque, comme beaucoup de circuits du même acabit, l’Arduino Due est en 3,3V et peut souffrir si vous lui envoyez des signaux 5V. L’intensité totale transmise sur le broches du circuit est aussi beaucoup plus faible que sur d’autres micro-contrôleurs plus robustes (AVR, MSP430, PIC). Tout dépend de vos usages, mais pour de la commande de moteurs ou des circuits simples, se lancer tout de suite vers l’Arduino Due peut ne pas être un bon choix…

Spectroscope Audio avec Arduino

[GTranslate]

Si vous souhaitez réaliser ce montage, je propose sur ma boutique en ligne un kit facile à monter contenant tous les composants nécessaires avec la carte micro-contrôleur préprogrammé (http://xv4y NULL.radioclub NULL.asia/boutique/?slug=product_info NULL.php&products_id=29).

Arduino Spectrum Scope FFT XV4Y (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/10/100_3300 NULL.jpg)Je vous l’avais dit, c’est une petite idée qui me trottait dans la tête depuis quelques temps et j’ai enfin pu la mettre en application. Le montage (ou plutôt le programme car de montage il y en a peu) que vous propose affiche le spectre d’un signal audio de 150 Hz à 3150 Hz en vous donnant le niveau maxi et la bande de fréquence où celui-ci se trouve. Ce n’est pas un analyseur de spectre à proprement dit, puisqu’il utilise la Transformée de Fourier Rapide (http://fr NULL.wikipedia NULL.org/wiki/Transformée_de_Fourier_rapide) à point fixe sur des entiers. En pratique ça fait la même chose…

Le but, c’est de faire joli et d’impressionner les filles d’aider l’opérateur télégraphie à ajuster son VFO pour se caler sur la fréquence de la station reçue (faire le battement nul, quoi).

Pour le réaliser, vous avez besoin :

  1. d’un Arduino avec ATMega168 ou ATMega328,
  2. Arduino Spectrum Scope FFT XV4Yd’un écran LCD 16×2 avec contrôleur Hitachi HD44780 ou compatible
  3. de fils et cavaliers en bon nombre
  4. d’une capacité de 10µF/16V (valeur non critique) avec le point froid (le “-“) sur l’entrée A0 de l’Arduino pour coupler l’audio de votre récepteur au montage
  5. du programme que je mets à disposition ci-dessous que vous allez compiler et télécharger dans l’Arduino

Je vais être franc, je n’ai pas beaucoup écrit de lignes de code pour faire ce programme et je me suis basé sur des librairies existantes. Mon talent (si j’en ai un) est de faire que ça marche! Toutes les références de librairies sont indiquées dans les sources et je vous conseille de vous reporter à leurs documentations respectives.

Arduino Spectrum Scope FFT générateur BF NE555 XV4Y (http://xv4y NULL.radioclub NULL.asia/wp-content/uploads/2012/10/100_3298 NULL.jpg)Les niveaux audio attendus sont entre 0 et 5V (ceux de l’ADC de l’Arduino). Vous pouvez changer l’échelle d’affichage en fonction de ce que vous mettez en entrée. Par exemple, la sortie audio fixe du port ACC du TS-590s donne 1,2V maximum, donc je mettrais le paramètre MAX_AUDIO à 256. Pour mes essais (et les photos), j’ai fait un petit montage générateur BF à base de NE555 (http://electroniccircuitsforbeginners NULL.blogspot NULL.com/2009/12/tone-generator-circuit NULL.html). Celui-ci fourni un beau signal carré plein d’harmoniques qui fait très beau sur l’afficheur!

Ce programme est libre d’utilisation et de modification dans le cadre de la licence GNU GPL v3 (http://www NULL.gnu NULL.org/licenses/gpl NULL.html). Toute inclusion dans un produit commercial ou un kit de composant est sujette à autorisation préalable de l’auteur (moi) et au respect des licences des autres librairies. J’apprécie tous commentaires ou toutes idées d’amélioration!

/*
Arduino HAM Audio Spectrum v1.01
By Yannick DEVOS - XV4Y
http://xv4y.radioclub.asia/

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

====
This program act as an audio Spectrum scope for the low frequency range
It is aimed at help HAM operators to "zero beat" a CW station

You just need to feed some audio (5V peak) into Analog Input 0 of an Arduino board and connect an LCD display.

The display is on a 16x2 LCD Display with HD44780 compatible driver, use the traditional 4 bits interface on pins 12,11,5,4,3,2
It as a graphical display for 20 spectrum bands and also display the numbers for the highest received signal and its band
Frequency is displayed in 20 150 Hz band between 150Hz and 3150Hz

In order to compile this program with Arduino 1.0.1, you will need to install 3 libraries :
- New LiquidCrystal
https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/Home
- LCDBitmap
http://arduino.cc/playground/Code/LCDBitmap
- Fixed FFT lib for Arduino 1.0
http://code.google.com/p/neuroelec/downloads/detail?name=ffft_library_for_Arduino_1.0.zip&can=2&q=

It is based on various works, please see below.

====
Revision history :
v1.00    2012-10-10
         First release
v1.01    2012-10-11
         Adding the F_STEP parameter and explaining how to change the sample rate    

====
This Example acquire analog signal from A0 of Arduino, and Serial out to Processing application to visualize.
Tested with preamplified audio data. Take a look at http://www.youtube.com/watch?v=drYWullBWcI

Analog signal is captured at 9.6 KHz, 64 spectrum bands each 150Hz which can be change from adcInit()
Load the this file to Arduio, run Processing application.

Original Fixed point FFT library is from ELM Chan, http://elm-chan.org/works/akilcd/report_e.html
A way to port it to the Arduino library and most demo codes are from AMurchick http://arduino.cc/forum/index.php/topic,37751.0.html
Processing app is based on codes from boolscott http://boolscott.wordpress.com/2010/02/04/arduino-processing-analogue-bar-graph-2/

====
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/>
*/

#include <stdint.h>
#include <ffft.h>
#include <Wire.h>
#include <LiquidCrystal.h>
#include <LCDBitmap.h>

// Here a few things that yoy may want to change

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);  // You can change this settings to your convenance, please see the library documentation

LCDBitmap bitmap(&lcd, 0, 0);

#define  IR_AUDIO  0    // ADC channel to capture
#define  F_STEP    150  // Width of the frequency bands in Hertz. This constant is only for display. To actually change the
                        // the size of the bands you have to change the FFT_N constant in ffft.h.
                        // 64 gives 300Hz (6300Hz displayed), 128 gives 150Hz (3150Hz displayed), 256 gives 75Hz.
                        // More samples means slower execution. Values higher than 256 do not seem to work. SRAM exhaustion ?
#define  MAX_AUDIO 512  // The maximum audio level you're expecting (for scaling), 5V is 1023
#define  OFFSET    1    // Spectrum band offset for display, first band has a lot of 50Hz hum so we skip it
#define  REFR_RATE 10   // Rate for refreshing the numerical display

// There are no user settings that you can modify here below

volatile  byte  position = 0;
volatile  long  zero = 0;
volatile  int   val, j, max_i, max_val, refresh;

byte graph[20];

int16_t capture[FFT_N];			/* Wave captureing buffer */
complex_t bfly_buff[FFT_N];		/* FFT buffer */
uint16_t spektrum[FFT_N/2];		/* Spectrum output buffer */

void setup() {
  lcd.begin(16,2);
  lcd.home ();

  adcInit();
  adcCalb();

  lcd.clear();
  bitmap.begin();
}

void loop() {
   if (position == FFT_N) {
     fft_input(capture, bfly_buff);
     fft_execute(bfly_buff);
     fft_output(bfly_buff, spektrum);

     max_val = max_i = 0;

     for (byte i = 0; i < 21; i++) {                 // We are capturing more (64 bands) than we can actually display (only 20)...
        j = i+OFFSET;
        val = map(spektrum[j],0,MAX_AUDIO,0,16);   // Scaling for display, only 16 dots high
        graph[i] = val;
        if (spektrum[j]>max_val) {          // Save the higher values for further display it
          max_val = spektrum[j];            // The value
          max_i = j;                        // Its band
        }
     }

    // Here we draw the graph
    bitmap.barGraph(20, graph, ON, UPDATE);

    // Here we display the highest numerical value but not each cycle because it flickers
    refresh++;
    if (refresh == REFR_RATE) {
      lcd.setCursor ( 4, 0 );
      lcd.print("Max F:    ");
      lcd.setCursor ( 10, 0 );
      lcd.print((max_i+1)*F_STEP);
      lcd.setCursor ( 14, 0 );
      lcd.print("Hz");
      lcd.setCursor ( 4, 1 );        // go to the next line
      lcd.print("Value:    ");
      lcd.setCursor ( 10, 1 );
      lcd.print(max_val*5);
      lcd.setCursor ( 14, 1 );
      lcd.print("mV");
      refresh = 0;
    }
    position = 0;
  }
}

// free running ADC fills capture buffer
ISR(ADC_vect) {
  if (position >= FFT_N)
    return;

  capture[position] = ADC + zero;
  if (capture[position] == -1 || capture[position] == 1)
    capture[position] = 0;

  position++;
}

void adcInit() {
  /*  REFS0 : VCC use as a ref, IR_AUDIO : channel selection, ADEN : ADC Enable, ADSC : ADC Start, ADATE : ADC Auto Trigger Enable, ADIE : ADC Interrupt Enable,  ADPS : ADC Prescaler  */
  // free running ADC mode, f = ( 16MHz / prescaler ) / 13 cycles per conversion 
  ADMUX = _BV(REFS0) | IR_AUDIO; // | _BV(ADLAR); 
//  ADCSRA = _BV(ADSC) | _BV(ADEN) | _BV(ADATE) | _BV(ADIE) | _BV(ADPS2) | _BV(ADPS1) //prescaler 64 : 19231 Hz - 300Hz per 64 divisions
  ADCSRA = _BV(ADSC) | _BV(ADEN) | _BV(ADATE) | _BV(ADIE) | _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0); // prescaler 128 : 9615 Hz - 150 Hz per 64 divisions, better for most music
  sei();
}

void adcCalb() {
  lcd.setCursor ( 0, 0 );        // go to the next line
  lcd.print("FFFT Spectrum");
  lcd.setCursor ( 0, 1 );        // go to the next line
  lcd.print("Calibration");
  long midl = 0;
  // get 2 meashurment at 2 sec
  // on ADC input must be NO SIGNAL!!!
  for (byte i = 0; i < 2; i++) {
    position = 0;
    delay(200);
    midl += capture[0];
    delay(200);
  }
  zero = -midl/2;
}

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.

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.