Bonjour 
,
mais je l'ai mon code! J'ai même la conduite. En plus, j'aime pas le chocolat... 
.
Je pensais que le message d'erreur suffisait pour avoir une idée de la panne. Enfin, c'est comme ça dans les Rolls-Royce. En même temps, j'ai pas de Rolls-Royce.
Alors voilà le code en question:
Entête:
#ifndef DOMINO_H
#define DOMINO_H
#include "Arduino.h"
class Domino
{
private:
void pinStatus();
public:
Domino();
~Domino();
void begin(int Bauds);
void connect();
void pwm(byte Pin);
void onOff(byte Pin);
};
#endif
Code proprement dit:
#include "Domino.h"
Domino::Domino() //Constructeur
{
}
int Tableau[20]; //Tableau d'état des sorties: -1 pour l'état HIGH, -2
//pour l'état LOW, entre 0 et 255 pour la valeur PWM
byte Reception; //Stockage de l'octet entrant
String Message = ""; //Messages entrants et sortants
boolean FlagReception = false; //
//Méthode privée
void pinStatus() /*Renvoie au programme appelant, sur sa demande, l'état des
broches de la carte, inactif (-3) haut (-1), bas (-2) ou valeur PWM ([0..255]),
ce qui lui permet de savoir si la broche est utilisée ou non, et si oui, si
elle est utilisée en sortie standard ou PWM et de connaître son état.
*/
{ //
if (FlagReception == true)
{
String Status = "";
if (Message == "status") //Si demande du status des pins
{
for (byte i=0; i<=19; i++)
{
Status += Tableau[i];
Status += ";";
}
Serial.print(Status);
delay(1);
FlagReception = false;
}
}
}
//Méthodes publiques
void Domino::begin(int Bauds) //<<constructeur>>
{
for (byte i=0; i<=19; i++) //Initialisation du tableau
{
Tableau[i] = -3; //Pin non utilisée en sortie, Onoff ou PWM
}
Serial.begin(Bauds); //Initialise le port série à la vitesse "Bauds"
}
void Domino::connect()
{
Message = "";
while (Serial.available() > 0) //Tant qu'il reste un octet dans le buffer
{
FlagReception = true; //On positionne l'indicateur de réception
Reception = Serial.read(); //On l'extrait vers "Reception"
Message += char(Reception); //On construit la chaine "Message"
delay(10);
}
if (FlagReception == true) Serial.flush(); //On vide le tampon par précaution
pinStatus();
}
void Domino::onOff(byte Pin) //Commuter la sortie "Pin" entre les états haut et bas
/*Au premier passage dans la fonction, c'est à dire à la mise sous tension de la carte
ou à sa réinitialisation, la valeur "Tableau" de toutes les sorties est initialisée à
-3 par la méthode "begin". On teste donc la valeur "Tableau" de la sortie "Pin" donnée
en argument ce qui permet de configurer la broche correspondante en sortie (OUTPUT),
chose que l'utilisateur n'aura donc pas à faire, puis on lui affecte la valeur "Tableau"
-2 qui correspond à l'état "LOW". Cette action n'aura lieu qu'une fois, à la mise en
service, et correspond donc bien à une initialisation dans le "setup()". Elle permet
au programme appelant, par l'intermédiaire de la méthode "Status()", de connaître la
configuration de la broche et sa valeur, pour traitement.
Le code de la méthode proprement dit sera, quant à lui, effectué à chaque appel de la
méthode et aura pour action de commuter la sortie correspondante à l'état haut (-1) ou à
l'état bas (-2) en fonction de la commande reçue.
Cette commande est une chaine de la forme "BtnxOn" ou "BtnxOff" où x représente le
numéro (Pin) de la sortie traitée: Par exemple, la réception de la chaine "Btn4On"
indiquera à la carte qu'elle doit passer la sortie 4 à l'état haut.
*/
{
if (Tableau[Pin] == -3) //Initialisation de la sortie "Pin" en sortie standard
{ //Code exécuté une seule fois, au premier passage dans la fonction
pinMode(Pin,OUTPUT);
Tableau[Pin] = -2; //Valeur LOW
}
if (FlagReception == true)
{ //Code exécuté à chaque passage lors de la réception d'un message
String TempStr = "Btn";
TempStr += byte(Pin);
TempStr += "On" ;
if (Message == TempStr)
{
digitalWrite(Pin,HIGH); //Met à l'état haut la Pin correspondante
Tableau[Pin] = -1; //Renseigne le tableau d'état des sorties (voir déclaration)
Serial.print(Message); //Renvoi l'état de la Pin pour maj de la led du bouton
FlagReception = false;
delay(1);
}
else
{
TempStr = "Btn";
TempStr += byte(Pin);
TempStr += "Off" ;
if (Message == TempStr)
{
digitalWrite(Pin,LOW); //Met à l'état haut la Pin correspondante
Tableau[Pin] = -2; //Renseigne le tableau d'état des sorties (voir déclaration)
Serial.print(Message); //Renvoi l'état de la Pin pour maj de la led du bouton
delay(1);
FlagReception = false;
}
}
}
}
void Domino::pwm(byte Pin) //Envoie une valeur comprise entre 0 et 255 sur la sortie "Pin"
/*Voir les explications pour la méthode "onOff(byte Pin)", qui sont indentiques mises à
part les valeurs qui, ici, PWM oblige, varieront de 0 à 255.
Ici, la chaine de commande est de la forme "PWMx;y" où x représente la sortie traitée et
où y représente la valeur PWM que la carte devra "écrire" sur cette sortie. La sortie
sélectionnée devra, bien sûr, être une sortie PWM valide. Par exempe, la réception du
message "PWM10;123" demandera à la carte d'écrire la valeur 123 sur la sortie 10, c'est
à dire mettre à l'état haut cette sortie selon le rapport cyclique 123/255.
*/
{
if (Tableau[Pin] == -3) //Initialisation de la sortie "Pin" en sortie PWM
{ //Code exécuté une seule fois, au premier passage dans la fonction
pinMode(Pin,OUTPUT);
Tableau[Pin] = 0; //Valeur PWM
}
if (FlagReception == true)
{ //Code exécuté à chaque passage lors de la réception d'un message
String Bouton = Message.substring(0, Message.indexOf(";")); //Récupère l'entête
String Valeur = Message.substring(Message.indexOf(";") +1 ); //Récupère le valeur
String TempStr = "PWM"; //Construit la chaine d'entête correspondant à "Pin"
TempStr += byte(Pin); //pour comparaison avec l'entête reçue
if (Bouton == TempStr) //Si le test est positif, on traite
{
int Longueur = Valeur.length()+1; //Manipulation destinée à convertir la chaine
char CarVal[Longueur]; //"Valeur" de type "String" en une valeur entière
Valeur.toCharArray(CarVal, Longueur); //"Val" de type "int", pour contourner l'absence
int Val = atoi(CarVal); //d'une fonction du genre "String.toInt("123")"
analogWrite(Pin, Val);
Tableau[Pin] = Val;
FlagReception = false;
}
}
}
Exemple pratique:
#include "Domino.h"
Domino Dom; //Instanciation
byte led5 = 5; //Déclarations
byte led10 = 10;
byte led13 = 13;
void setup()
{
Dom.begin(9600); //Initialisations
}
void loop()
{
Dom.pwm(led5);
Dom.pwm(led10);
Dom.onOff(led13);
}
Après téléversement, si ça fonctionne, il suffit d'envoyer, à l'aide du terminal Arduino, un message sous forme de chaine du type "BtnxOn" ou "BtnxOff" avec x représentant le numéro de broche de 2 à 19 (les broches 0 et 1 étant réservées pour la liaison série), pour, d'une part, recevoir l'accusé-réception sur le terminal sous la forme d'une chaine identique à celle envoyée, et d'autre part, d'allumer ou d'éteindre la (les) diode(s) raccordées aux sorties utilisées à titre d'exemple.
Pour les sorties "PWM", le message à envoyer est du type "PWM;x" où x représente un entier compris entre 0 et 255. En fonction de la valeur envoyée, la diode éventuellement raccordée brillera plus ou moins. Il n'y a pas d'accusé-réception sur le terminal.
J'utilise la version 1.0.5-r2 de l'IDE Arduino sous Windows 7.
Je travaille avec une carte Arduino UNO.
Par contre, je ne connais pas l'age du capitaine 
.
En espérant que ces précisions suffiront,
cordialement,
naute.
,
. Ce sont, bien sûr, des notions de base, mais si on ne les a pas...