besoin d'un guide

Bonjour, J'ai depuis quelque temps un besoin que je n'arrive pas a résoudre avec des interrupteurs (et oui la veille école), et j'ai découverts Arduino. qui pourrait me semble t il résoudre mon problème. J'ai donc un récupérer un NANO V3, et j'ai installé le soft qui va bien., j'ai uploader un prog fourni avec le soft, ca charge, j'ai donc fait un grand pas.... Mon objectif n'étant pas d'apprendre le langage d'ARDUINO, c'est pas trop ma tasse de thé, mais juste résoudre un besoin ponctuel. Je pense que des bouts de codes doivent trainer ca et là, il suffirait de les couper/coller.

Explication du besoin: J'ai besoin de faire 5 fonctions (F1, F2....F5), et chaque fonction va piloter 8 relais suivant une table de vérités que j'ai établie: F1 > 11000011 F2 > 00110011 F3 > 00110000 .....etc quand je serai faire pour un , la suite je devrai m'en sortir.

Je souhaite dans un premier temps, faire defiler les fonctions simplement avec deux touches UP/DW, et dans un second temps, cerise sur le gâteau, j'ai vu qu'on pouvait mettre un LCD, et là, je voudrais pouvoir afficher: Fonction 1, Fonction 2.......

Si vous pouviez m'aider svp, pour me donner les librairies sur lesquelles je dois travailler pour gérer ces fonctions, si du code existe déjà, sa m'éviterai de partir dans tous les sens.

Merci pour votre support, et qui sait, j'y prendrai peut être gout :cold_sweat:

Salut,

gogole est ton ami, et des codes d’exemple, il y en a des tonnes! ne serait-ce que dans l’IDE, fichier/exemples, tu vas trouver de quoi t’amuser!

Le langage arduino n’est en fait que du langage C / C++. donc il faut apprendre le langage C!

Je le mets là: :P Le début doit être bon; l'idée générale est bonne. Mais quand les experts vont débarquer ici, il va y avoir des cris, et même des coups de feu. ]:) ]:D Je suis vraiment curieuse de voir en quoi ils vont transformer les goto. :P

byte pins[8] = {  2, 3, 4, 5, 6, 7, 8, 9};  // declare les 8 pins de sortie
byte i=0;
byte index=0;
// Ici il faudrait déclarer les labels "moins"; "plus" et "F1"; "F2"...EXT
// Mais quand les experts vont débarquer ici les labels vont voooler cui cui cui....
// Et les "goto" aussiiiii!
// iLs vont te transformer tout ça en fonctions, et ça va être bô.

void setup()
{
  for( i=0; i<8; i++) pinMode(pins[i], OUTPUT); //pins mise en sortie
  for( i=0; i<8; i++) pinMode(pins[i], LOW);
   pinMode (10, INPUT_PULLUP); // pin mise en entree
   pinMode(11, INPUT_PULLUP); // 
    pinMode(10, HIGH); // pin d'entree mise à "1"
   pinMode(11, HIGH);    
}
void loop(){
    if (digitalRead(10) == 0){ goto moins;} //tant que pin(10) ou pin(11) pas =0 ça tourne
    if (digitalRead(11) == 0){ goto plus;}    
    delay(100);
}
  moins:
  if (index==0){ 
    index=5
  }
  index=index-1
  if (index==1){ goto F1;}
  if (index==2){ goto F2;}
  if (index==3){ goto F3;}
  if (index==4){ goto F4;}
  if (index==5){ goto F5;} 
  //
  plus:
  if (index==6){ 
    index=1
  }
  index=index+1
  if (index==1){ goto F1;}
  if (index==2){ goto F2;}
  if (index==3){ goto F3;}
  if (index==4){ goto F4;}
  if (index==5){ goto F5;} 
  //
  F1: // fonction N°1
  pinMode(pins(2), HIGH); // F1
  pinMode(pins(2), HIGH); 
  pinMode(pins(2), LOW); 
  pinMode(pins(2), LOW); 
  pinMode(pins(2), LOW); 
  pinMode(pins(2), LOW); 
  pinMode(pins(2), HIGH); 
  pinMode(pins(2), HIGH); 
//F2:
........excétéra...téra...
}

je me suis amusé à programmer un petit truc , je sais pas si c'est ce que tu veux, en plus je ne suis pas un expert en prog et ça fait même pas une semaine que je joue avec une arduino uno ...

const byte tb=5; // nombre de "fonction"
const int up = 10; // numéro de la broche du bp up
const int down=11; // numéro de la broche du bp down
const int pin=2; // numéro de la première sortie

byte F[tb+1]; // tableau qui contiendra la programation des "fonctions"
int pos; // numéro de la "fonction" à envoyer sur les sorties
boolean arup; // bit pour l'anti rebond de la touche up
boolean ardown; // bit pour l'anti rebond de la touche down

void setup() {

  // on configure les 8 broches de 0 à 7 en sortie
  for (int p = pin; p < pin+8; p++)  {
    pinMode(p, OUTPUT);      
  }
  pinMode(up, INPUT);  // la broche 10 pour Up
  pinMode(down, INPUT);  // la broche 11 pour down
  // programmation des "fonctions" :
  // il suffit de changer les 1 et les 0 pour chaque "fonction"
  F[1]=0b11000011 ;  // 0b est obligatoire pour écrire en binaire
  F[2]=0b00110011 ;  // le bit de gauche à droite du b est relié à la broche 7
  F[3]=0b00110000 ;  // le bit de droite à la fin est relié à la broche 0
  F[4]=0b00001111 ;
  F[5]=0b11111111 ;

  pos=1; // la "fonction 1" sera active au démarage
}

void loop() {

  // on passe en revue les 8 sorties et on active la sortie suivant le tableau
   for (int p = 0; p < 8; p++) digitalWrite(p+pin,bitRead(F[pos], p)); 
    
  // si on appuis sur up on change de "fonction" en incrémentant pos
  if (digitalRead(up) and pos < tb) {if (!arup){ pos++; arup=1;}
  } else arup=0; // arup bloque le changement tant qu'on n'a pas relaché le bouton up
  
  // si on appuis sur duwn on change de "fonction" en décrémentant pos
  if (digitalRead(down) and pos > 1) {if (!ardown){ pos--; ardown=1;} 
  } else ardown=0;// ardonw bloque le changement tant qu'on n'a pas relaché le bouton down

}

j'ai mis "fonction" entre guillemets dans les com car setup() ou loop() sont elles de vraie fonctions

Bonjour Il serait intéressant d'utiliser un registre à décalage 74HC595 (pour sortir les 8 bits) suivi ULN2003 (pour commander des relais ). Surtout si on veut plus tard ajouter un afficheur LCD: on risque d'être à court de pins de sorties de l'Arduino. A+

Carolyne: Je suis vraiment curieuse de voir en quoi ils vont transformer les goto. :P

Tu es vraiment incurable. Avec toi c'est "le Basic ou la mort". Les goto se remplacent par des appels de fonctions. tu remplaces goto F1 par funcF1(). Et tu mets le code des fonctions dans une fonction. Même en Basic quand on ne code pas avec les pieds c'est ce que l'on fait.

lve123: Il serait intéressant d'utiliser un registre à décalage 74HC595 (pour sortir les 8 bits) suivi ULN2003 (pour commander des relais ). Surtout si on veut plus tard ajouter un afficheur LCD: on risque d'être à court de pins de sorties de l'Arduino.

8 relais + 2 bouton + un LCD ça rentre (16 pins)

pour la prog :

#define BoutonUP 11
#define BoutonDOWN 12

const byte Fonction[] ={0b00000011,0b00001100,0b001100000,0b11000000,0b10000001}; //arbitraire
const byte Pins[] = {3,4,5,6,7,8,9,10}; // à adapter suivant branchement des relais 

int i,x;

void setup() {

for(i=0;i<8;i++){
pinMode(Pins[i],OUTPUT);
}

pinMode(BoutonUP,INPUT_PULLUP);
pinMode(BoutonDOWN,INPUT_PULLUP);

}

void loop() {

if(digitalRead(BoutonUP)==LOW || digitalRead(BoutonDOWN)==LOW) {

digitalRead(BoutonUP)==LOW?x++:x--;
if(x>5)x=0;
if(x<0)x=5;

for(i=0;i<8;i++) {

digitalWrite(Pins[i],(1&Fonction[x]>>i));

}

while(digitalRead(BoutonUP)==LOW || digitalRead(BoutonDOWN)==LOW); //tant qu'un bouton est appuyé

delay(50); // suppression des effets de rebond
}

}

à: fdufnews. Merci, c'est tout ce que je voulais savoir. :P Mais tu vois, ce qui manque, pour vulgariser le "C"; c'est un tuto, qui serait toutes les erreurs de syntaxe les plus courantes, et ce qu'elles génère comme message. Parce que perso, le débuggeur me sort des fois des trucs qui me laissent perplexe. Comme "constructor/destructor"... Je m'attends à me prendre un "Terminator" dans la face un de ces quatre. Il y a aussi les "types" qui ne sont pas de la bonne "ethnie"; il faut alors faire une analyse du génome; et va trouver un labo ouvert un Dimanche... à: B@tto. C'est beau !!! :P

Carolyne: à: fdufnews. Merci, c'est tout ce que je voulais savoir. :P Mais tu vois, ce qui manque, pour vulgariser le "C"; c'est un tuto, qui serait toutes les erreurs de syntaxe les plus courantes, et ce qu'elles génère comme message. Parce que perso, le débuggeur me sort des fois des trucs qui me laissent perplexe. Comme "constructor/destructor"... Je m'attends à me prendre un "Terminator" dans la face un de ces quatre. Il y a aussi les "types" qui ne sont pas de la bonne "ethnie"; il faut alors faire une analyse du génome; et va trouver un labo ouvert un Dimanche...

Un peu de lecture pour toi (et d'autres) http://fr.openclassrooms.com/informatique/cours/apprenez-a-programmer-en-c https://www.rocq.inria.fr/secret/Matthieu.Finiasz/teaching/ENSTA/IN101%20-%20poly%20C.pdf Evidemment c'est "cours" sont orientés C (le vrai). Le "langage arduino" repose sur un sous-ensemble du C (et du C++) et il prend quelques libertés avec le standard dans le but de simplifier son l'utilisation par les profanes.

Concernant les messages retournés par le compilateur. Il n'y a qu'une règle à connaitre: L'erreur est sur la ligne indiquée OU SUR LES LIGNES PRECEDENTES. Ensuite faut chercher.

Un lien...Du lien...Des liens...Thank you man !

Bonsoir tous, Merci pour vos reponses respectives et vos exemples. Je vais interfacer tout ca ce weekend, essayer ce que vous m avez passe, et vous tiendrai au ju. Je retiens que ca tient dans le uno, c est deja pas mal. Pour super cinci, cest quoi le IDE?... et pour le C ca va une autre paire de manches, car a part ce besoin, j ai rien d autre, et de plus je ne suis pas un softeux... @@@@+++++

L'IDE, c'est la fenêtre qui s'ouvre quand tu double clique sur l'icone "Arduino.exe" (faut pas être préssé); fenêtre dans laquelle tu va coller le code l'orfèvrerie de B@tto. Que tu "téléversera" dans la carte; après l'avoir "sauver sous". Le fichier sera dans un dossier du même nom dans le dossier "Arduino" qui a été crée dans "tes documents" (Windoze), à l'installation. Note: Dans la fenêtre (IDE) d'Arduino, ( "Outils/portSérie") tu peux contôler que ton port est le même que dans: Clic droit sur poste de travail/Propriétés/Matériel/Gestionaire des périphériques/Ports(Com et LPT).(pour Windoze.) Note: Que si tu a autre chose de branché sur ton USB (ex: clé 3G ou autre qui tourne en tâche de fond, c'est à dire débranchée mais application non "quittée") tu peux avoir un pb de conflit.(c'est du vécu.)

Bonsoir,

mirage2000: Pour super cinci, cest quoi le IDE?... et pour le C ca va une autre paire de manches, car a part ce besoin, j ai rien d autre, et de plus je ne suis pas un softeux... @@@@+++++

IDE pour integrated development environment. Ou si tu préfères c'est arduino qui te permet d'écrire tes programmes. @+

Il me semble que dans le code de B@tto:
Dans la while le: (bouton) doit être: (boutonUp). Ou me trompe-je ?

Bonsoir,

Carolyne: Il me semble que dans le code de B@tto: Dans la while le: (bouton) doit être: (boutonUp). Ou me trompe-je ?

Oui et non, tu as le choix :grin: Si ton BP est câblé entre la pin et gnd alors actif à LOW Si ton BP est câblé entre la pin et +5V alors actif à HIGH Tout est une question de référentiel @+

"bouton" n'a pas été déclaré. "boutonUp" oui. Alors icare...On plane... :grin:

Carolyne: Il me semble que dans le code de B@tto: Dans la while le: (bouton) doit être: (boutonUp). Ou me trompe-je ?

Yes c'est corrigé ;)

Bonjour,

Carolyne: "bouton" n'a pas été déclaré. "boutonUp" oui. Alors icare...On plane... :grin:

C'était pour voir si tu suivais. Non, bien vue. @+

alors là chapo ! 8) L'appel du grale a été plus fort, j'ai pas pu attendre !!! j'ai câblé les leds, les bp, et j'ai chargé le code de Ohhhh mon B@ttoOOOO, et ça clignote, on se croirait dans une boite de nuit.... je vérifie tout cela calmement, maintenant que le pic d’adrénaline est passé.

Bon je re édité mon post: Ca fonctionne mais par contre je ne retrouve pas l'allumage des leds dans l'ordre des sorties, ca me parrait inversé? Ma FONCTION1 est 1 1 0 0 0 0 0 1 et ca correspond a D10 D9 D8 D7 D6 D5 D4 D3 normal ???

Question: si je voulais qu'au démarrage je vienne directement sur FONCTION1, car tout est a zero , on fait comment? merci encore pour votre patience et devouement

@+

mirage2000: Ca a l'air de fonctionner mais par contre je ne retrouve pas l'allumage des leds dans l'ordre des sorties, ca me parrait inversé? Ma premiére sequence est 1 1 0 0 0 0 0 1 et ca correspond a D10 D9 D8 D7 D6 D5 D4 D3 normal ???

Il faut reprendre les deux tableau du début :

const byte Fonction[] ={0b00000011,0b00001100,0b001100000,0b11000000,0b10000001};

== > ce sont les séquences, comme tu n'avais pas donné toutes les fonctions j'ai fait du pifomètre la, à toi d'éditer comme ça t'ira. Le principe c'est que les 0 et les 1 sont liés avec le deuxième tableau :

const byte Pins[] = {3,4,5,6,7,8,9,10};

Mais effectivement l'ordre est "inversé" (et oui tout est affaire de relativité ;) ). Si je prend la première fonction :

00000011 ==> 0 0 0 0 0 0 1 1 10 9 8 7 6 5 4 3 ==> ça donne pin 3 et 4 HIGH et tout les autres à LOW

Donc soit tu inverses l'ordre dans Pins[] soit dans Fonction[]