ARDUINO

?C’est quoiChristian Py F5HOD

Les modules Arduino™ sont des plates-formes de prototypage micro contrôlées "open-source" spécialement conçues pour les artistes, les

concepteurs ou les hobistes.

Programmables via un langage proche du "C" (disponible en libre téléchargement), les modules Arduino™ peuvent fonctionner de façon autonome.

• Sa taille physique est standardisée.

• Un prix très bas (25€)

• Un nombre impressionnant de cartes filles sont disponibles (Shield).

• Elle est très facilement programmable en langage dérivé du #C.

• La liberté, elle définit de façon assez concise l'esprit de l'Arduino.

• Le logiciel : gratuit et open source, développé en Java, dont la simplicité d'utilisation relève de savoir cliquer sur la souris.

• Le matériel : cartes électroniques dont les schémas sont en libre circulation sur internet.

Différents models :

• Arduino UNO

• Arduino UNO R3

• Arduino LEONARDO

• Arduino DUE

• Arduino pro

• Arduino Mini

et bien d’autres platines …

• Arduino Mega 2560

• Arduino ADK Android

ARDUINO UNODimensions : 53 mm x 68 mm

Microcontrôleur ATmega328

Tension de fonctionnement 5V

Tension d'alimentation (recommandée) 7-12V

Tension d'alimentation (limites) 6-20V

Broches E/S numériques 14 (dont 6 disposent d'une sortie PWM)

Broches d'entrées analogiques 6

Intensité maxi disponible par broche E/S (5V) 40 mA

Intensité maxi disponible par broche E/S (3.3V) 50 mA

Mémoire Programme Flash16 KB (ATmega168) or 32 KB (ATmega328) dont 2 KB sont utilisés par le bootloader

Mémoire SRAM (mémoire volatile) 1 KB (ATmega168) ou 2 KB (ATmega328)

Mémoire EEPROM (mémoire non volatile) 512 bytes (ATmega168) ou 1 KB (ATmega328)

Vitesse d’horloge 16 MHz

ARDUINO UNO R3Dimensions : 53 mm x 68 mm

Microcontrôleur ATmega328

Tension de fonctionnement 5V

Tension d'alimentation (recommandée) 7-12V

Tension d'alimentation (limites) 6-20V

Broches E/S numériques 14 (dont 6 disposent d'une sortie PWM)

Broches d'entrées analogiques 6

Intensité maxi disponible par broche E/S (5V) 40 mA

Intensité maxi disponible par broche E/S (3.3V) 50 mA

Mémoire Programme Flash16 KB (ATmega168) or 32 KB (ATmega328) dont 2 KB sont utilisés par le bootloader

Mémoire SRAM (mémoire volatile) 1 KB (ATmega168) ou 2 KB (ATmega328)

Mémoire EEPROM (mémoire non volatile) 512 bytes (ATmega168) ou 1 KB (ATmega328)

Vitesse d’horloge 16 MHz

ARDUINO PRODimensions : 53 mm x 68 mm

Microcontrôleur ATmega328

Tension de fonctionnement 5V

Tension d'alimentation (recommandée) 7-12V

Tension d'alimentation (limites) 6-20V

Broches E/S numériques 14 (dont 6 disposent d'une sortie PWM)

Broches d'entrées analogiques 6

Intensité maxi disponible par broche E/S (5V)

40 mA

Intensité maxi disponible par broche E/S (3.3V) 50 mA

Mémoire Programme Flash16 KB (ATmega168) or 32 KB (ATmega328) dont 2 KB sont utilisés par le bootloader

Mémoire SRAM (mémoire volatile) 1 KB (ATmega168) ou 2 KB (ATmega328)

Mémoire EEPROM (mémoire non volatile) 512 bytes (ATmega168) ou 1 KB (ATmega328)

Vitesse d’horloge 16 MHz

ARDUINO LEONARDO32 bytes Dimensions : 53 mm x 68 mm

Microcontrôleur ATmega32u4

Tension de fonctionnement 5V

Tension d'alimentation (recommandée) 7-12V

Tension d'alimentation (limites) 6-20V

Broches E/S numériques 20 (dont 7 disposent d'une sortie PWM)

Broches d'entrées analogiques 12

Intensité maxi disponible par broche E/S (5V)

40 mA

Intensité maxi disponible par broche E/S (3.3V) 50 mA

Mémoire Programme Flash 32 KB (ATmega32u4) dont 4 KB sont utilisés par le bootloader

Mémoire SRAM (mémoire volatile) 2,5 KB (ATmega32u4)

Mémoire EEPROM (mémoire non volatile) KB (ATmega32u4)

Vitesse d’horloge 16 MHz

ARDUINO PRO miniDimensions : 33 mm x 18 mm

Microcontrôleur ATmega168

Tension de fonctionnement 3,3V ou 5V

Tension d'alimentation (recommandée) 3.35 -12 V (3.3V model)

5 - 12 V (5V model)

Broches E/S numériques 14 (dont 6 disposent d'une sortie PWM)

Broches d'entrées analogiques 6

Intensité maxi disponible par broche E/S (5V)

40 mA

Intensité maxi disponible par broche E/S (3.3V) 50 mA

Mémoire Programme Flash 16 KB (ATmega168) dont 2 KB sont utilisés par le bootloader

Mémoire SRAM (mémoire volatile) 1 KB (ATmega168)

Mémoire EEPROM (mémoire non volatile) 512 bytes (ATmega168)

Vitesse d’horloge 8 MHz

ARDUINO MEGADimensions : 53 mm x 101 mm

Microcontrôleur ATmega2560

Tension de fonctionnement 5V

Tension d'alimentation (recommandée) 7-12V

Tension d'alimentation (limites) 6-20V

Broches E/S numériques 54 (dont 15 disposent d'une sortie PWM)

Broches d'entrées analogiques 16

Intensité maxi disponible par broche E/S (5V)

40 mA

Intensité maxi disponible par broche E/S (3.3V) 50 mA

Mémoire Programme Flash 256 KB dont 8 KB sont utilisés par le bootloader

Mémoire SRAM (mémoire volatile) 8 KB

Mémoire EEPROM (mémoire non volatile) 4 KB

Vitesse d’horloge 16 MHz

ARDUINO DUEPossibilité de brancher une souriset un clavier USB Dimensions : 53 mm x 101 mm

Microcontrôleur AT91SAM3X8E

Tension de fonctionnement 3.3 V

Tension d'alimentation (recommandée) 7-12V

Tension d'alimentation (limites) 6-20V

Broches E/S numériques 54 (dont 12 disposent d'une sortie PWM)

Broches d'entrées analogiques 12

Intensité maxi disponible toutes broche I/O

130 mA

Intensité maxi disponible par broche E/S (3.3V) 800 mA

Mémoire Programme Flash 512 KB (application)

Mémoire SRAM (mémoire volatile) 96 KB

Vitesse d’horloge 84 Mhz

Description des broches: UNO

Entrées / sorties digital D0 – D13 Port série D0 – D1

Port SPI D10 – D13

Port I2C A4 – A5

Entrées Analogiques A0 – A5

Alimentation

Entrée DC 7-12 v

2,1 mm

Port USB de programmation et permet d’alimenter l’Arduino. Max 500ma

Port ISP

AREFTension de référence

analogique

SPI :Interface Série pour périphérique D10 : /SS D11 : MOSI D12 : MISO et D13 : SCLK.

I2C : A4 (SDA), A5 (SCL)

Description E/S : ATMEGA 328

Description E/S : MEGA

Entrées / sorties digital D0 – D13

Port sérieD0 – D1

D14 – D19

Port SPI *D10 – D13

Port I2C*A20 – A21

Entrées Analogiques A0 – A11 Alimentation

Entrée DC 7-12 v

2,1 mm

Port USB de programmation et permet d’alimenter l’Arduino. Max 500ma

Port ISP*

AREFTension de référence

analogique

SPI :Interface Série pour périphérique D10 : /SS D11 : MOSI D12 : MISO et D13 : SCLK.

I2C : A20 (SDA), A21 (SCL)

Entrées / sorties digital D22 – D53

ISP : In-System Programmer (reprogrammation de l’Arduino)

Logiciel pour la programmation :Disponible pour Windows , Linux et Mac.

Le logiciel va vous permettre de programmer la carte Arduino, par la prise USB,De créer des sketchs.

Le logiciel gratuit est disponible à cette adresse:

En français :www.mon-club-elec.fr/mes_telechargements/arduino-0018-fr.zip

Page officielle (En Anglais) : v 023http://arduino.cc/en/Main/Software

ATTENTION les extensions de fichier sont différentes selon les versions:

< 1.0.0 ont pour extensions .PDE> 1.0.0 ont pour extensions .INO

ATTENTION ELLES NE SONT PAS COMPATIBLES ENTRE ELLES,

Espace de développement Intégré (EDI) Arduino

Les boutons :

En cliquant sur le bouton qui permet de transférer votre programme dans l’Arduino, le logiciel vérifie la bonne syntaxe. Si une seule erreur est détectée, il vous faut la corriger ! Avant de pouvoir la transférer !

Le terminal : Il permet d’interagir avec la platine ARDUINO

La programmation :

void setup() {

  // insérer votre code ici}

void loop() {

  // insérer votre code ici dans la boucle   }

Cette exemple est le minimum de code

nécessaire pour démarrer votre

ARDUINO !

La programmation :

La fonction

Dans ce code se trouvent deux fonctions. Les fonctions sont en fait des portions de code.

Cette fonction setup() est appelée une seule fois lorsque le programme commence. C'est pourquoi c'est dans cette fonction que l'on va écrire le code qui n'a besoin d'être exécuté une seule fois. On appelle cette fonction : "fonction d'initialisation". On y retrouvera la mise en place des différentes sorties et quelques autres réglages. C'est un peu le check-up de démarrage. Imaginez un pilote d'avion dans sa cabine qui fait l'inventaire:

void setup() {

  // insérer votre code ici}

- patte 2 en sortie, état haut ?- OK- timer 3 à 15 millisecondes ?- OK...

Void test (){Code }

Les fonctions permettent de segmenter le code afin de créer des modules . Elles doivent être implantées en dehors des fonctions spéciales loop et setup !

Pour les appeler :

Void test ();

La programmation :

Une fois que l'on a initialisé le programme il faut ensuite créer son "cœur", autrement dit le programme en lui même.

C'est donc dans cette fonction loop() où l'on va écrire le contenu du programme. Il faut savoir que cette fonction est appelée en permanence, c'est-à-dire qu'elle est exécutée une fois, puis lorsque son exécution est terminée, on la ré-exécute encore et encore. On parle de boucle infinie.

void loop(){

  // insérer votre code ici}

La programmation :

Les points virgules

Les points virgules terminent les instructions. Si par exemple je dis dans mon programme : « appelle la fonction couperDuSaucisson »  je dois mettre un point virgule après l'appel de cette fonction.

LiquidCrystal_I2C lcd(0x27,20,4);

NewSoftSerial mySerialGsm(RxGsmPin,TxGsmPin); // Set Arduino pin 7 and 8 as softserial (RX-TX)

NewSoftSerial mySerialVoice(RxVoicePin,TxVoicePin);

NewSoftSerial mySerialBluetooth(RxBluetoothPin,TxBluetoothPin);

La programmation :

Les accolades

Les accolades sont les "conteneurs" du code du programme. Elles sont propres aux fonctions, aux conditions et aux boucles. Les instructions du programme sont écrites à l'intérieur de ces accolades.

void setup() {

  // insérer votre code ici}

La programmation :

// cette ligne est inactif dans le programme

Les commentaires

Pour finir, on va voir ce qu'est un commentaire. Ce sont des lignes de codes qui seront ignorées par le programme. Elles ne servent en rien lors de l'exécution du programme.

La programmation :

Int X = 4;

Définir une variable

Si on donne un nombre à notre programme, il ne sait pas si c'est une variable ou pas. Il faut le lui indiquer. Pour cela, on donne un type aux variables. Oui, car il existe plusieurs types de variables ! Par exemple la variable "x" vaut 4 :

La programmation :

Type Quel nombre il stocke ?

Valeurs maximales du nombre stocké

Nombre sur X bits

Nombre d'octets

int entier -32 768 à +32 767 16 bits 2 octets

long entier-2 147 483 648 à +2 147 483 647

32 bits 4 octets

char entier -128 à +127 8 bits 1 octets

float décimale-3.4 x 10^{38}à +3.4 x 10^{38}

32 bits 4 octets

double décimale-3.4 x 10^{38}à +3.4 x 10^{38}

32 bits 4 octets

Voilà les types de variables les plus répandus :

La programmation :Si à présent notre variable "x" ne prend jamais une valeur négative(-20, -78, ...), alors on utilisera un type non-signé.

C'est à dire, dans notre cas, un char dont la valeur n'est plus de -128 à +127, mais de 0 à 255.

Voici le tableau des types non signés, on repère ces types par le mot unsigned (de l'anglais : non-signé) qui les précède :

TypeQuel nombre il stocke ?

Valeurs maximales du nombre stocké

Nombre sur X bits

Nombre d'octets

unsigned charentier non négatif

0 à 255 8 bits 1 octets

unsigned intentier non négatif

0 à 65 535 16 bits 2 octets

unsigned longentier non négatif

0 à 4 294 967 295

32 bits 4 octets

La programmation :

TypeQuel nombre il stocke ?

Valeurs maximales du nombre stocké

Nombre sur X bits

Nombre d'octets

byteentier non négatif

0 à 255 8 bits 1 octets

wordentier non négatif

0 à 65535 16 bits 2 octets

booleanentier non négatif

0 à 1 1 bits 1 octets

Une des particularités du langage Arduino:

Est qu'il accepte un nombre plus important de types de variables.

La programmation :

Les variables booléennes:

Sont des variables qui ne peuvent prendre que deux valeurs :ou VRAI ou FAUX.

Elles sont utilisées notamment dans les boucles et les conditions

Int variable = LOW;Int variable = HIGH;

Le langage Arduino accepte aussi une troisième forme d'écriture (qui lui sert pour utiliser les broches de sortie du microcontrôleur) :

Boolean variable = FALSE;Boolean variable = TRUE;

http://www.siteduzero.com/sciences/tutoriels/arduino-pour-bien-commencer-en-electronique-et-en-programmation

L’adresse du site ou je me suis documenté est très bien expliqué.

Les références :StructureFonctions de baseCes deux fonctions sont obligatoires dans tout programme en langage Arduino : •void setup() •void loop() Structures de contrôle•if •if...else •for •switch case •while •do... while •break •continue •return Syntaxe de base•; (point virgule) •{} (accolades) •// (commentaire sur une ligne) •/* */ (commentaire sur plusieurs lignes) Opérateurs arithmétiques•= (égalité) •+ (addition) •- (soustraction) •* (multiplication) •/ (division) •% (modulo) Opérateurs de comparaison•== (égal à) •!= (différent de) •< (inférieur à) •> (supérieur à) •<= (inférieur ou égal à) •>= (supérieur ou égal à) Opérateurs booléens•&& (ET booléen) •|| (OU booléen) •! (NON booléen) Opérateurs composés•++ (incrémentation) •-- (décrémentation) (à revoir) •+= (addition composée) •-= (soustraction composée) •*= (multiplication composée) •/= (division composée)

Variables et constantesLes variables sont des expressions que vous pouvez utilisez dans les programmes pour stocker des valeurs, telles que la tension de sortie d'un capteur présente sur une broche analogique. Constantes prédéfiniesLes constantes prédéfinies du langage Arduino sont des valeurs particulières ayant une signification spécifique. •HIGH | LOW •INPUT | OUTPUT •true | false A ajouter : constantes décimales prédéfinies Expressions numériques•Expressions numériques entières Types des donnéesLes variables peuvent être de type variés qui sont décrits ci-dessous.

Synthèse des types de données Arduino •boolean •char •byte •int •unsigned int •long •unsigned long •float (nombres à virgules) •double (nombres à virgules) •Les chaînes de caractères •Les tableaux de variables •void (fonctions) Conversion des types de données•char() •byte() •int() •long() •float() Référence•Code ASCII (à finir)

FonctionsEntrées/Sorties Numériques•pinMode(broche, mode) •digitalWrite(broche, valeur) •int digitalRead(broche) Entrées analogiques•int analogRead(broche) Sorties "analogiques" (génération d'impulsion)•analogWrite(broche, valeur) - PWM Entrées/Sorties Avancées•tone() •noTone() •shiftOut(broche, BrocheHorloge, OrdreBit, valeur) •unsigned long pulseIn(broche, valeur) Temps•unsigned long millis() •unsigned long micros() •delay(ms) •delayMicroseconds(us) Math•min(x, y) •max(x, y) •abs(x) •constrain(x, a, b) •map(valeur, toLow, fromHigh, toLow, toHigh) •pow(base, exposant) •sq(x) •sqrt(x) Trigonométrie•sin(rad) •cos(rad) •tan(rad) Nombres randomisés (hasard)•randomSeed(seed) •long random(max) •long random(min, max) Communication•Serial

Les libraires :

Pour faciliter l ’élaboration d’une application, il existe des librairies pour chaque interface. Ce sont des micros programmes.

Exemple :

La librairie pour lire ou écrire sur une carte SD.

//Include all the libraries necessary for FAT32#include <byteordering.h>#include <fat.h>#include <FAT16.h>#include <fat_config.h>#include <partition.h>#include <partition_config.h>#include <sd-reader_config.h>#include <sd_raw.h>#include <sd_raw_config.h>

Ces librairies se déclarent en début de programme, elles doivent êtres téléchargées depuis le net et copiées au paravent dans le dossier arduino/libraries/

Ps: à chaque ajout de librairies, l’interface doit être relancé.

La programmation :

Lire la tension sur une broche analogique:

Un truc très sympa avec Arduino, c'est que c'est facile à prendre en main. Et ça se voit une fois de plus avec l'utilisation des convertisseurs numérique -> analogique ! En effet, vous n'avez qu'une seule nouvelle fonction à retenir : analogRead() !

analogRead();

Cette fonction va nous permettre de lire la valeur lue sur une entrée analogique de l'Arduino. Elle prend un argument et retourne la valeur lue :

•L'argument est le numéro de l'entrée analogique à lire (explication ci-dessous)•La valeur retournée (un int) sera le résultat de la conversion analogique-numériqueSur une carte Arduino Uno, on retrouve 6 CAN. Ils se trouvent tous du même côté de la carte, là où est écrit "Analog IN" :

Exemple :Exemple de lecture de la tension sur une broche analogique:

const int potar = 0; // le potentiomètre, branché sur la broche analogique 0int valeurLue; //variable pour stocker la valeur lue après conversionfloat tension; //on convertit cette valeur en une tension void setup(){    //on se contente de démarrer la liaison série pour visualiser la valeur     Serial.begin(9600);} void loop(){    //on convertit en nombre binaire la tension lue en sortie du potentiomètre    valeurLue = analogRead(potar);     //on traduit la valeur brute en tension (produit en croix)    tension = valeurLue * 5.0 / 1024;         //on affiche la valeur lue sur la liaison série    Serial.print("valeurLue = ");    Serial.println(valeurLue);         //on affiche la tension calculée    Serial.print("Tension = ");    Serial.print(tension,2);    Serial.println(" V");         Serial.println(); //on saute une ligne entre deux affichages    delay(500); //on attend une demi-seconde pour que l'affichage ne soit pas trop rapide}

Le schéma :

Exemple :

//définition des broches utilisée (vous êtes libre de les changer)const int led_verte = 9;const int led_bleue = 10;const int led_rouge = 11; int compteur_defilement = 0; //variable permettant de changer de couleur  void setup(){   //définition des broches en sortie   pinMode(led_rouge, OUTPUT);   pinMode(led_verte, OUTPUT);   pinMode(led_bleue, OUTPUT);} void loop(){   couleur(compteur_defilement); //appel de la fonction d'affichage   compteur_defilement++; //incrémentation de la couleur à afficher   if(compteur_defilement > 6) compteur_defilement = 0; //si le compteur dépasse 6 couleurs    delay(500);}

Le schéma :

Suite du code

Exemple de lecture de la tension sur une broche analogique et d’écriture sur un port numérique :

Exemple :

void couleur(int numeroCouleur){   switch(numeroCouleur)   {      case 0 : //rouge         analogWrite(led_rouge, 0); //rapport cyclique au minimum pour une meilleure luminosité de la LED                                    //qui je le rappel est commandée en "inverse"                                    //(0 -> LED allumée ; 255 -> LED éteinte)         analogWrite(led_verte, 255);         analogWrite(led_bleue, 255);         break;      case 1 : //vert         analogWrite(led_rouge, 255);         analogWrite(led_verte, 0);         analogWrite(led_bleue, 255);         break;      case 2 : //bleu         analogWrite(led_rouge, 255);         analogWrite(led_verte, 255);         analogWrite(led_bleue, 0);         break;      case 3 : //jaune         analogWrite(led_rouge, 0);         analogWrite(led_verte, 0);         analogWrite(led_bleue, 255);         break;     

Le schéma :

Suite du code

Exemple de lecture de la tension sur une broche analogique et d’écriture sur un port numérique :

Exemple :

 case 4 : //violet         analogWrite(led_rouge, 0);         analogWrite(led_verte, 255);         analogWrite(led_bleue, 0);         break;      case 5 : //bleu ciel         analogWrite(led_rouge, 255);         analogWrite(led_verte, 0);         analogWrite(led_bleue, 0);         break;      case 6 : //blanc         analogWrite(led_rouge, 0);         analogWrite(led_verte, 0);         analogWrite(led_bleue, 0);         break;      default : //"noir"         analogWrite(led_rouge, 255);         analogWrite(led_verte, 255);         analogWrite(led_bleue, 255);         break;   }}

     

Le schéma :

Fin du code

Exemple de lecture de la tension sur une broche analogique et d’écriture sur un port numérique :

Exemple:

Le schéma :

Afficheur LCD:Le branchementL'afficheur LCD utilise 6 à 10 broches de données ((D0 à D7) ou (D4 à D7) + RS + E) et deux d'alimentations (+5V et masse). La plupart des écrans possèdent aussi une entrée analogique pour régler le contraste des caractères. Nous brancherons dessus un potentiomètre de 10 kOhms.Les 10 broches de données peuvent être placées sur n'importe quelles entrées/sorties numériques de l'Arduino. En effet, nous indiquerons ensuite à la librairie LiquidCrystal qui est branché où.Le montage à 8 broches de données

Exemple:Afficheur LCD:

Comme écrit plus tôt, nous allons utiliser la librairie "LiquidCrystal". Pour l'intégrer c'est très simple, il suffit de cliquer sur le menu "Import Library" et d'aller chercher la bonne.

Une ligne #include "LiquidCrystal.h" doit apparaitre en haut de la page de code (les prochaines fois vous pourrez aussi taper cette ligne à la main directement, ça aura le même effet). Ensuite, il ne nous reste plus qu'à dire à notre carte Arduino où est branché l'écran (sur quelles broches) et quelle est la taille de ce dernier (nombre de lignes et de colonnes).

Nous allons donc commencer par déclarer un objet (c'est en fait une variable évoluée, plus de détails dans la prochaine partie) lcd, de type LiquidCrystal et qui sera global à notre projet.

La déclaration de cette variable possède plusieurs formes LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7) où rs est le numéro de la broche où est branché "RS", "enable" est la broche "E" et ainsi de suite pour les données.•LiquidCrystal(rs, enable, d4, d5, d6, d7) (même commentaires que précédemment

Ensuite, dans le setup() il nous faut démarrer l'écran en spécifiant son nombre de colonnes puis de lignes. Cela se fait grâce à la fonction begin(cols,rows).

Exemple:Écran LCD:

Le code:

 #include "LiquidCrystal.h" //ajout de la librairie //Vérifier les broches !LiquidCrystal lcd(11,10,9,8,7,6,5,4,3,2); //liaison 8 bits de données

void setup(){    lcd.begin(16,2); //utilisation d'un écran 16 colonnes et 2 lignes    lcd.write("Salut les OMs !"); //petit test pour vérifier que tout marche} void loop() {

}

     

Comme vous pouvez le voir, le code est très simple, quelques ligne suffisent pour afficher du texte !

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

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é) étant à 52€, on peut spéculer que le prix du Tre devrait être du même ordre de grandeur c’est à dire dans les 70€.

Arduino TRE: Printemps 2014

Nouveauté à

venir

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.

Arduino Galileo : Novembre 2013

Nouveauté à

venir

Le nanoKeyer peut être utilisé comme un keyer autonome ou connecté via le port USB de votre ordinateur avec votre logiciel favori.

Au moyen du microprogramme de K3NG il peut aussi être utilisé en autonome en y ajoutant un CLAVIER-PS2.

NANOKEYER:

Oscar, DJ0MY

http://www.cqdx.ru/ham/do-it-yourself/the-nanokeyer-is-an-arduino-nano-based-cw-contest-keyer/

Arduino DDS Shield:

M0XPD

http://m0xpd.blogspot.co.uk/2013/02/arduino-dds-shield.html

AD9850 DDS

Module

Disponible sur EBay

Arduino EAGLE:http://www.semageek.com/un-librarie-eagle-pour-creer-un-shield-arduino-facilement/

Plus besoin de vous présenter le célèbre logiciel de conception électronique Eagle de Cadsoft, ni le kit Arduino.

Voici un outil qui tombe à pic pour ceux qui souhaitent développer leur propre design de shield pour les kits Arduino, une librairie pour Eagle qui contient la base pour créer un nouveau shield.

https://github.com/adafruit/Adafruit-Eagle-Library

Librairie Eagle

La reconnaissance vocale :

https://acapela-box.com/AcaBox/index.php

EasyVR

EasyVR Commander

EasyVR Arduino Libraries

Matériels nécessaire:

• La platine EasyVR pour Arduino.

• L’Arduino.

Les logiciels :

Il permet de programmer la carte , en l'occurrence:

• Insérer les mots reconnues par la voix.

• Apprendre la reconnaissance vocale (par comparaison) .

• Insérer les mots pour la synthèse vocale.

Convertit les textes en fichiers audio reconnus par la carte

Client ou Serveur Ethernet :

Ethernet Arduino Libraries

Matériels nécessaire:

• La platine Ethernet pour Arduino

• L’Arduino.

 #include <SPI.h>#include <Ethernet.h>

// Enter a MAC address and IP address for your controller below.// The IP address will be dependent on your local network:

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

IPAddress ip (192,168,1,177);

// Initialize the Ethernet server library// with the IP address and port you want to use // (port 80 is default for HTTP):

EthernetServer server(80);

Le code: ( le début )

RJ45

Micro SD

Les librairies

Pour y stocker les pages internet

La carte relais :Matériels nécessaire :

• La platine E/S pour Arduino.

• La carte relais.

• L’Arduino.#define Relais_ON 0#define Relais_OFF 1

#define Relais_1 2 // Arduino Digital E/S numéro de la broche #define Relais_2 3 #define Relais_3 4 #define Relais_4 5

void setup() {//-------( Initialise les relais en position repos)----

digitalWrite(Relais_1, Relais_OFF); digitalWrite(Relais_2, Relais_OFF); digitalWrite(Relais_3, Relais_OFF); digitalWrite(Relais_4, Relais_OFF);

//---( Broches en sortie )----

pinMode(Relais_1, OUTPUT); pinMode(Relais_2, OUTPUT); pinMode(Relais_3, OUTPUT); pinMode(Relais_4, OUTPUT); delay(2000); // attendre 2 secondes}

Le code:

Existe en1-2-4-8Relais

AC250V 10A, AC150V 10A; DC30V 10A , DC28V 10A. Dimension: environ 5 x 3.8 x 1.7cm

void loop() {

digitalWrite(Relais_1, Relais_ON); // Relais en fonction

delay(2000); // attendre 2secondes

digitalWrite (Relais_1, Relais_OFF); // Relais au repos

delay(4000); // attendre 4 secondes

}}

ARDUINO

Christian Py F5HOD

FIN