Christian Py F5HOD

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

• Sa taille physique est standardisée.

• Un nombre impressionnant de cartes filles sont
disponibles (Shield).
• Un prix très bas (25€)

• 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.
 • Arduino pro

• Arduino UNO

• Arduino UNO R3

• Arduino LEONARDO

• Arduino Mini
• Arduino Mega 2560

• Arduino ADK Android

• Arduino DUE
et bien d’autres platines …
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

16 KB (ATmega168) or 32 KB (ATmega328) dont

Mémoire Programme Flash
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

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

16 KB (ATmega168) or 32 KB (ATmega328) dont

Mémoire Programme Flash
Mémoire SRAM (mémoire volatile)
Mémoire EEPROM (mémoire non volatile)
Vitesse d’horloge
2 KB sont utilisés par le bootloader
1 KB (ATmega168) ou 2 KB (ATmega328)
512 bytes (ATmega168) ou 1 KB (ATmega328)
16 MHz
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
40 mA
(5V)
Intensité maxi disponible par broche E/S (3.3V) 50 mA
16 KB (ATmega168) or 32 KB
Mémoire Programme Flash (ATmega328) dont 2 KB sont utilisés par
le bootloader
Mémoire SRAM (mémoire volatile) 1 KB (ATmega168) ou 2 KB (ATmega328)
512 bytes (ATmega168) ou 1 KB
Mémoire EEPROM (mémoire non volatile)
(ATmega328)
Vitesse d’horloge 16 MHz
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
40 mA
(5V)
Intensité maxi disponible par broche E/S (3.3V) 50 mA
32 KB (ATmega32u4) dont 4 KB sont
Mémoire Programme Flash
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
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
40 mA
(5V)
Intensité maxi disponible par broche E/S (3.3V) 50 mA
16 KB (ATmega168) dont 2 KB sont
Mémoire Programme Flash
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
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
40 mA
(5V)
Intensité maxi disponible par broche E/S (3.3V) 50 mA
256 KB dont 8 KB sont utilisés par le
Mémoire Programme Flash
bootloader
Mémoire SRAM (mémoire volatile) 8 KB
Mémoire EEPROM (mémoire non volatile) 4 KB
Vitesse d’horloge 16 MHz
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
130 mA
I/O
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
 AREF
Tension de Port SPI
référence D10 – D13
analogique Entrées / sorties digital D0 – D13 Port série
D0 – D1

Port USB de programmation

et permet d’alimenter
l’Arduino. Max 500ma
Port ISP

Port I2C
A4 – A5

Entrée DC 7-12 v
2,1 mm

Alimentation Entrées Analogiques A0 – A5

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

I2C : A4 (SDA), A5 (SCL)

 AREF
Tension de
référence Port SPI *
analogique Port série
D10 – D13
D0 – D1
Port I2C*
D14 – D19
A20 – A21

Entrées / sorties digital

D0 – D13

Port USB de programmation

et permet d’alimenter
l’Arduino. Max 500ma Port ISP*

Entrées / sorties digital

D22 – D53

Entrée DC 7-12 v
2,1 mm

Alimentation Entrées Analogiques A0 – A11

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

I2C : A20 (SDA), A21 (SCL)

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

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 023

http://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
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 !
void setup() { Cette exemple est le
minimum de code
// insérer votre code ici nécessaire pour
démarrer votre
} ARDUINO !

void loop() {

// insérer votre code ici dans la boucle

}
 La fonction

Dans ce code se trouvent deux fonctions.

Les fonctions sont en fait des portions de code.
void setup() {

// insérer votre code ici

}

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:

Les fonctions permettent de segmenter le code afin de - patte 2 en sortie, état haut ?
- OK
créer des modules . Elles doivent être implantées en - timer 3 à 15 millisecondes ?
dehors des fonctions spéciales loop et setup ! - OK
...
Void test ()
{ Pour les appeler :
Code
}
Void test ();
 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.

void loop(){

// insérer votre code ici

}

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

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

// cette ligne est inactif dans le programme

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 :

Int X = 4;
Voilà les types de variables les plus répandus :

Valeurs
Quel nombre il
Type stocke ?
maximales du Nombre sur X bits Nombre d'octets
nombre stocké

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

-2 147 483 648 à

long entier
+2 147 483 647
32 bits 4 octets

char entier -128 à +127 8 bits 1 octets

-3.4 x 10^{38}à
float décimale
+3.4 x 10^{38}
32 bits 4 octets

-3.4 x 10^{38}à
double décimale
+3.4 x 10^{38}
32 bits 4 octets
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 :
Valeurs
Quel nombre il Nombre sur X
Type maximales du Nombre d'octets
stocke ? bits
nombre stocké
entier non
unsigned char 0 à 255 8 bits 1 octets
négatif
entier non
unsigned int 0 à 65 535 16 bits 2 octets
négatif
entier non 0 à 4 294 967
unsigned long 32 bits 4 octets
négatif 295
Une des particularités du langage Arduino:

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

Valeurs
Quel nombre il Nombre sur X
Type maximales du Nombre d'octets
stocke ? bits
nombre stocké
entier non
byte 0 à 255 8 bits 1 octets
négatif
entier non
word 0 à 65535 16 bits 2 octets
négatif
entier non
boolean 0à1 1 bits 1 octets
négatif
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

Boolean variable = FALSE;

Boolean variable = TRUE;

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

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

http://www.siteduzero.com/sciences/tutoriels/arduino-pour-bien-
commencer-en-electronique-et-en-programmation
Structure
Fonctions de base Variables et constantes Fonctions
Ces deux fonctions sont obligatoires dans tout Les variables sont des expressions que vous Entrées/Sorties Numériques
programme en langage Arduino : pouvez utilisez dans les programmes pour •pinMode(broche, mode)
•void setup() stocker des valeurs, telles que la tension de •digitalWrite(broche, valeur)
•void loop() sortie d'un capteur présente sur une broche •int digitalRead(broche)
Structures de contrôle analogique. Entrées analogiques
•if Constantes prédéfinies •int analogRead(broche)
•if...else Les constantes prédéfinies du langage Arduino Sorties "analogiques" (génération d'impulsion)
•for sont des valeurs particulières ayant une •analogWrite(broche, valeur) - PWM
•switch case signification spécifique. Entrées/Sorties Avancées
•while •HIGH | LOW •tone()
•do... while •INPUT | OUTPUT •noTone()
•break •true | false •shiftOut(broche, BrocheHorloge, OrdreBit, valeur)
•continue A ajouter : constantes décimales prédéfinies •unsigned long pulseIn(broche, valeur)
•return Expressions numériques Temps
Syntaxe de base •Expressions numériques entières •unsigned long millis()
•; (point virgule) Types des données •unsigned long micros()
•{} (accolades) Les variables peuvent être de type variés qui sont •delay(ms)
•// (commentaire sur une ligne) décrits ci-dessous. •delayMicroseconds(us)
•/* */ (commentaire sur plusieurs lignes) Synthèse des types de données Arduino Math
Opérateurs arithmétiques •boolean •min(x, y)
•= (égalité) •char •max(x, y)
•+ (addition) •byte •abs(x)
•- (soustraction) •int •constrain(x, a, b)
•* (multiplication) •unsigned int •map(valeur, toLow, fromHigh, toLow, toHigh)
•/ (division) •long •pow(base, exposant)
•% (modulo) •unsigned long •sq(x)
Opérateurs de comparaison •float (nombres à virgules) •sqrt(x)
•== (égal à) •double (nombres à virgules) Trigonométrie
•!= (différent de) •Les chaînes de caractères •sin(rad)
•< (inférieur à) •Les tableaux de variables •cos(rad)
•> (supérieur à) •void (fonctions) •tan(rad)
•<= (inférieur ou égal à) Conversion des types de données Nombres randomisés (hasard)
•>= (supérieur ou égal à) •char() •randomSeed(seed)
Opérateurs booléens •byte() •long random(max)
•&& (ET booléen) •int() •long random(min, max)
•|| (OU booléen) •long() Communication
•! (NON booléen) •float() •Serial
Opérateurs composés Référence
•++ (incrémentation) •Code ASCII (à finir)
•-- (décrémentation) (à revoir)
•+= (addition composée)
•-= (soustraction composée)
•*= (multiplication composée)
•/= (division composée)
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é.

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érique
Sur 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 de lecture de la tension sur une broche analogique:
const int potar = 0; // le potentiomètre, branché sur la broche analogique 0
int valeurLue; //variable pour stocker la valeur lue après conversion
float 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);
}
Le schéma :
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
}
Exemple de lecture de la tension sur une broche analogique et d’écriture sur un port numérique :

//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);
}
Suite du code

Le schéma :
Exemple de lecture de la tension sur une broche analogique et d’écriture sur un port numérique :
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);
Suite du code
break;

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

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

Fin du code

Le schéma :
Afficheur LCD:
Le branchement
L'afficheur LCD utilise 6 à 10 broches de
Le schéma :
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
 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).
 É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€.
 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.
 Oscar, DJ0MY

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

 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.
 M0XPD

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

Module
AD9850 DDS
Disponible sur EBay
 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
 EasyVR

Matériels nécessaire:

• La platine EasyVR pour Arduino.

• L’Arduino.

EasyVR Arduino Libraries

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

EasyVR Commander

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

 Matériels nécessaire:
RJ45

• La platine Ethernet pour Arduino

• L’Arduino.

Ethernet Arduino Libraries

Le code: ( le début )
Les librairies

#include <SPI.h>
#include <Ethernet.h>
Micro SD
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
Pour y stocker
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; les pages internet

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);
 Matériels nécessaire :

• La platine E/S pour Arduino.

Le code: • La carte relais.

#define Relais_ON 0 • L’Arduino.

#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()
{ AC250V 10A, AC150V 10A; DC30V 10A , DC28V 10A.
//-------( Initialise les relais en position repos)---- Dimension: environ 5 x 3.8 x 1.7cm Existe en
1-2-4-8
digitalWrite(Relais_1, Relais_OFF); Relais
void loop()
digitalWrite(Relais_2, Relais_OFF); {
digitalWrite(Relais_3, Relais_OFF);
digitalWrite(Relais_4, Relais_OFF);
digitalWrite(Relais_1, Relais_ON); // Relais en fonction
//---( Broches en sortie )----
delay(2000); // attendre 2secondes
pinMode(Relais_1, OUTPUT);
pinMode(Relais_2, OUTPUT);
pinMode(Relais_3, OUTPUT); digitalWrite (Relais_1, Relais_OFF); // Relais au repos
pinMode(Relais_4, OUTPUT);
delay(4000); // attendre 4 secondes
delay(2000); // attendre 2 secondes
} }
}
Christian Py F5HOD