Forums LR PRESSE

Où il est question de trains, petits et grands

  • Advertisement

Conseil sur faisabilité de mon projet

Toutes les discussions sur l'Arduino !

Modérateur: MOD

Re: Conseil sur faisabilité de mon projet

Publié: Lun 13 Avr 2015, 11:10 
2-3 remarques sur le code :
- le delay pendant 10s veut dire que pendant 10s ton ordi n'a aucune prise sur l'arduino qui commande les trains, si ils veulent se rentrer dedans, ils le feront.
- sur le code en lui-même, la vitesse des trains est commandée si je lis bien par la variable vitesse dont la limite entre 1 sens et l'autre est 125 mais aussi que cette vitesse est le PWM de l'analog du moteur. Si je comprends bien, la machine va plus vite dans un sens que dans l'autre et aussi que le chgt de sens et de vitesse peut être très rapide.
- ton while aussi bloque l'exécution du prog et tes trains pourront rentrer tranquillement en collision si des données arrivent sur la ligne série en continu.

Tout cela si je lis correctement ton prog.

Sur mon module analogique, je compte aussi utiliser l'ordi mais comme un potentiomètre, avec des boutons + et - comme sur une gaugemaster.
Une variable vitesse varie selon ce plus et moins entre -255 et 255, le sens de la loco est fait par le signe et la valeur absolue définit la vitesse. Voila pour mon truc si cela peut aider d'autres.
Guillaume22
Papotier
 
Messages: 138
Inscrit le: Dim 29 Sep 2013, 09:20

Re: Conseil sur faisabilité de mon projet

Publié: Lun 13 Avr 2015, 21:54 
merci pour ces remarques pertinente
- le délais de 10s est provisoire pour les essais
- très juste pour la limite de 125(au lieu de 250)entre la marche avant et arrière
c' est la seule solution que j' ai trouvé car je n'arrive pas a interpréter le signe +- avec la commande série (je débute avec l' arduino :? )
- il faut que je regarde de plus prêt la fonction while

mon objectif final étant de gérer la vitesse et le sens à partir d'un PC
Le chemin est encore long et semé d' embûches
SYLTRAIN80
 
Messages: 29
Inscrit le: Mar 24 Fév 2015, 10:47
Echelle pratiquée: HO - N
Prénom: Sylvain

Re: Conseil sur faisabilité de mon projet

Publié: Sam 02 Mai 2015, 23:36 
Bonsoir,
je suis toujours sur mon projet, et j 'essaie de travailler sur le transfert de trame via USB entre le logiciel UTS et arduino
J' arrive a faire croire au logiciel qu 'il est connecté à la carte électronique de UTS et lui faire envoyer la trame de données (55 octets de 8 bits).
du coté arduino grâce a un écran lcd de 2 *16 je peux vérifier qu' elle arrive bien.
J' ai besoin d' aide car je ne sais pas la lire pour affecter la valeur de chaque octet reçu a une variable que je pourrais utiliser plus tard dans le programme arduino
Voici la structure de la trame tel qu' elle est décrite par l 'auteur du logiciel:

Le diagramme de transfert de trame en V3.x est le suivant :

Dans le cadre d'un échange de trames complètes, le PIC renvoi un caractère tous les deux caractères reçus.
Émission de 55 octets et réception de 25 octets simultanément.

Tableau d'échange temporel d'une trame complète (exemple pour la carte n° 1) :

Voici la trame complète de 55 octets envoyée du PC au PIC :
1 0x01 ; Octet de sélection de la carte (0x01 pour la carte n°1, 0x11 pour la carte n°2, 0x21 pour la carte n°3, 0x31 pour la carte n°4)
2 0x08 ; Octet de commande d'échange de trame complète entre le PC et le PIC
3 pwm_r0 ; Valeur de la vitesse sur le canton 0 (= 0 à 63)
4 pwm_r1 ; // 1
5 pwm_r2 ; // 2
6 pwm_r3 ; // 3
7 pwm_r4 ; // 4
8 pwm_r5 ; // 5
9 pwm_r6 ; // 6
10 pwm_r7 ; // 7
11 pwm_r8 ; // 8
12 pwm_r9 ; // 9
13 pwm_r10 ; // 10
14 pwm_r11 ; // 11
15 pwm_r12 ; // 12
16 pwm_r13 ; // 13
17 pwm_r14 ; // 14
18 pwm_r15 ; // 15
19 pwm_s0_7 ; Valeur sens de déplacement 1 bit par canton n° 0 à 7
20 pwm_s8_15 ; Valeur sens de déplacement 1 bit par canton n° 8 à 15
21 out_out3 ; Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])
22 out_out4 ; // 8 à 15 (IC15-ULN2008 [1])
23 out_out5 ; // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)
24 out_out21 ; Valeur des bits des sorties 40 à 47 (ULN2008 [2])
25 out_out22 ; // 48 à 55 (ULN2008 [2])
26 out_out23 ; // 56 à 63 (ULN2008 [2])
27 out_out24 ; // 64 à 71 (ULN2008 [2])
28 out_out25 ; // 72 à 79 (ULN2008 [2])
29 led_on0 ; Leds 00-07 allumées (1bit = une led)
30 led_on1 ; Leds 12-19 allumées ( bit = 1 = on )
31 led_on01 ; Leds 08-11 et 20-23 allumées
32 led_on2 ; Leds 24-31 allumées
33 led_on3 ; Leds 36-43 allumées
34 led_on23 ; Leds 32-35 et 43-47 allumées
35 led_cl0 ; Leds 00-07 clignotantes (1bit = une led)
36 led_cl1 ; Leds 12-19 clignotantes ( bit = 1 = cli)
37 led_cl01 ; Leds 08-11 et 20-23 clignotantes
38 led_cl2 ; Leds 24-31 clignotantes
39 led_cl3 ; Leds 36-43 clignotantes
40 led_cl23 ; Leds 32-35 et 43-47 clignotantes
41 led_in0 ; Leds 00-07 clignotant inversé (1bit = une led)
42 led_in1 ; Leds 12-19 clignotant inversé ( bit = 1 = inv)
43 led_in01 ; Leds 08-11 et 20-23 clignotant inversé
44 led_in2 ; Leds 24-31 clignotant inversé
45 led_in3 ; Leds 36-43 clignotant inversé
46 led_in23 ; Leds 32-35 et 43-47 clignotant inversé
47 srv_0 ; Valeur de consigne du servo n° 0
48 srv_1 ; Valeur de consigne du servo n° 1
49 srv_2 ; Valeur de consigne du servo n° 2
50 srv_3 ; Valeur de consigne du servo n° 3
51 srv_4 ; Valeur de consigne du servo n° 4
52 ruf1 ; LIBRE réservé utilisation future
53 ruf2 ; LIBRE réservé utilisation future
54 ruf3 ; LIBRE réservé utilisation future. Pour le PIC c'est le dernier octet de la trame. Le prochain octet 0x00 est traité comme une commande "Nulle".
55 0x00 ; Octet de fin pour resynchroniser la prochaine trame si nécessaire (Si perte d'un octet pendant le transfert).

Le dernier octet 0x00 n'est pas traité par le PIC. Il est traité comme un octet de commande 0x00 et le PIC l'ignore.
Cela sert si l'on perd un octet pendant le transfert (53 octets reçu au lieu de 54). Le PIC reçoit l'octet 0x00 comme dernier octet d'échange. La trame est bien sûr erronée, mais le PIC a bien fini le transfert d'une trame complète et
repasse en attente d'un octet de commande. Le prochain octet reçu sera donc bien traité comme un octet de commande.

En retour le PIC renvoi une trame de 25 octets vers le PC.

1 0x83 ; Octet de réponse à la réception de l'octet 0x01, 0x11, 0x21 ou 0x31
2 can_r0 ; Valeur lue sur l'entrée analogique (0) ( = 0 à 255 )
3 can_r1 ; // (1)
4 can_r2 ; // (2)
5 can_r3 ; // (3)
6 can_r4 ; // (4)
7 in_in1 ; Valeurs des bits des 40 entrées (75HCT165 [2]) V3
8 in_in2 ; //
9 in_in3 ; //
10 in_in4 ; //
11 in_in5 ; //
12 det_i1 ; Un bit par canton, = 1 si le canton est occupé
13 det_i2 ; //
14 ruf11 ; LIBRE réservé utilisation future
15 det_i1m ; Un bit par canton, le passage à l'état 1 est mémorisé
16 det_i2m ; Tous ces Octets sont effacés par la lecture de ces registres.
17 mat_in0 ; 4bits d'entrées colonne INA + ligne IN3 à IN0 + 4 bits mémorisation des
18 mat_in1 ; // INB + ligne IN3 à IN0 états, effacés par
19 mat_in2 ; // INC + ligne IN3 à IN0 la lecture de ces
20 mat_in3 ; // IND + ligne IN3 à IN0 registres.
21 mat_in4 ; // INE + ligne IN3 à IN0
22 mat_in5 ; // INF + ligne IN3 à IN0
23 mat_in6 ; // ING + ligne IN3 à IN0
24 mat_in7 ; // INH + ligne IN3 à IN0
25 mat_in8 ; // INI + ligne IN3 à IN0


Nota:
certains octet correspondent à des valeurs variable et pour d' autre a chaque bits de l' octet correspond un état de variable si j'ai bien compris (1 octet pour 2 états(0 ou 1) de 8 variables (entrée ou sortie))
je ne connais pas la technique a utiliser pour l affectation des valeurs
ex:
3 eme octet = pwm_r0
4 eme octet = pwm_r1
ect .....

Existe t' il un tuto ,une explication ou un modèle pour ce type d' opération ?
SYLTRAIN80
 
Messages: 29
Inscrit le: Mar 24 Fév 2015, 10:47
Echelle pratiquée: HO - N
Prénom: Sylvain

Re: Conseil sur faisabilité de mon projet

Publié: Dim 03 Mai 2015, 10:50 
Bonjour,

Pour manipuler les bits, il y a des infos ici : http://www.locoduino.org/spip.php?article70
Avatar de l’utilisateur
jlb
Fécond
 
Messages: 667
Inscrit le: Jeu 04 Oct 2012, 16:38
Echelle pratiquée: N
Prénom: Jean-Luc

Re: Conseil sur faisabilité de mon projet

Publié: Dim 03 Mai 2015, 15:41 
Merci je regarde a ça
SYLTRAIN80
 
Messages: 29
Inscrit le: Mar 24 Fév 2015, 10:47
Echelle pratiquée: HO - N
Prénom: Sylvain

Re: Conseil sur faisabilité de mon projet

Publié: Lun 04 Mai 2015, 11:12 
jlb a écrit:Bonjour,

Pour manipuler les bits, il y a des infos ici : http://www.locoduino.org/spip.php?article70

Bonjour

Pour des accès "simples" on peut aussi utiliser des structures :
Code: Tout sélectionner
// declaration
struct {
   boolean a:1; // bit     
   boolean b:1; // bit         
   boolean c:1; // bit
   boolean d:1; // bit       
   boolean e:1; // bit       
   boolean f:1; // bit       
   boolean g:1; // bit       
   boolean h:1; // bit       
} bits;
// utilisations
bits.e=true; if (bits.b) ...

Si on veut aussi faire un accès global on peut utiliser une union en plus :
Code: Tout sélectionner
// declaration
union {
  byte octet; // acces global
  struct { // acces bit par bit
   boolean a:1; // bit     
   boolean b:1; // bit         
   boolean c:1; // bit
   boolean d:1; // bit       
   boolean e:1; // bit       
   boolean f:1; // bit       
   boolean g:1; // bit       
   boolean h:1; // bit       
  };
} bits_ou_octet;
// utilisations
  bits_ou_octet.e=true;    // acces a un bit
  bits_ou_octet.octet=123; // acces global

Pierre
Avatar de l’utilisateur
Pierre59
Papotier
 
Messages: 144
Inscrit le: Dim 07 Mars 2010, 10:17
Localisation: Villeneuve d'Ascq (59650)
Âge: 74
Echelle pratiquée: HO
Club: Lille Modélisme

Re: Conseil sur faisabilité de mon projet

Publié: Mer 20 Mai 2015, 17:06 
Bonjour à tous
je reviens vers vous car j' ai besoins de votre aide.
j' ai fais une petite carte selon le shema vu sur site :
http://www.train35.com/commande_moteur.html

Image

sur lequel j' ai ajouté la possibilité d' asservissement de la vitesse

Image

la carte fonctionne seule et l' exemple du logiciel pour la fcem aussi, mais pour l instant je le laisse de cote car je ne sais pas l' adapter avec un xref variable.

Image

Mon soucis vient de la lecture de la liaison avec le logiciel.
Pour mes essais j' essaie le lire la variable pwm_r0 et la renvoyer la commande de pwm sur la sortie d3
la liaison entre le logiciel et la carte ne plante pas mais la commande de la valeur ne fonctionne pas
Je pense que mon problème vient de la lecture du type de l' octet hex ,dec

voici mon embryon de code
Code: Tout sélectionner
byte pwm_r0 = 0; //Valeur de la vitesse sur le canton 0 (= 0 à 63)
byte pwm_r1 = 0; // 1
byte pwm_r2 = 0; // 2
byte pwm_r3 = 0; // 3
byte pwm_r4 = 0; // 4
byte pwm_r5 = 0; // 5
byte pwm_r6 = 0; // 6
byte pwm_r7 = 0; // 7
byte pwm_r8 = 0; // 8
byte pwm_r9 = 0; // 9
byte pwm_r10 = 0; // 10
byte pwm_r11 = 0; // 11
byte pwm_r12 = 0; // 12
byte pwm_r13 = 0; // 13
byte pwm_r14 = 0; // 14
byte pwm_r15 = 0; // 15
byte pwm_s0_7 = 0; //Valeur sens de déplacement 1 bit par canton n° 0 à 7
byte pwm_s8_15 = 0; //Valeur sens de déplacement 1 bit par canton n° 8 à 15
byte out_out3 = 0; //Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])
byte out_out4 = 0; // 8 à 15 (IC15-ULN2008 [1])
byte out_out5 = 0; // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)
byte out_out21 = 0; // Valeur des bits des sorties 40 à 47 (ULN2008 [2])
byte out_out22 = 0; // 48 à 55 (ULN2008 [2])
byte out_out23 = 0; // 56 à 63 (ULN2008 [2])
byte out_out24 = 0; // 64 à 71 (ULN2008 [2])
byte out_out25 = 0; // 72 à 79 (ULN2008 [2])
byte led_on0 = 0; //Leds 00-07 allumées (1bit = une led)
byte led_on1 = 0; //Leds 12-19 allumées ( bit = 1 = on )
byte led_on01 = 0;// Leds 08-11 et 20-23 allumées
byte led_on2 = 0; //Leds 24-31 allumées
byte led_on3 = 0;// Leds 36-43 allumées
byte led_on23 = 0; //Leds 32-35 et 43-47 allumées
byte led_cl0 = 0; //Leds 00-07 clignotantes (1bit = une led)
byte led_cl1 = 0; //Leds 12-19 clignotantes ( bit = 1 = cli)
byte led_cl01 =0; //Leds 08-11 et 20-23 clignotantes
byte led_cl2 = 0; //Leds 24-31 clignotantes
byte led_cl3 = 0; //Leds 36-43 clignotantes
byte led_cl23 = 0; //Leds 32-35 et 43-47 clignotantes
byte led_in0 = 0; //Leds 00-07 clignotant inversé (1bit = une led)
byte led_in1 = 0; //Leds 12-19 clignotant inversé ( bit = 1 = inv)
byte led_in01 = 0; //Leds 08-11 et 20-23 clignotant inversé
byte led_in2 = 0; //Leds 24-31 clignotant inversé
byte led_in3 = 0; //Leds 36-43 clignotant inversé
byte led_in23 = 0; //Leds 32-35 et 43-47 clignotant inversé
byte srv_0 = 0; //Valeur de consigne du servo n° 0
byte srv_1 = 0; //Valeur de consigne du servo n° 1
byte srv_2 = 0; //Valeur de consigne du servo n° 2
byte srv_3 = 0; //Valeur de consigne du servo n° 3
byte srv_4 = 0; //Valeur de consigne du servo n° 4
byte ruf1 = 0; //LIBRE réservé utilisation future
byte ruf2 = 0; //LIBRE réservé utilisation future
byte ruf3 = 0;
byte octet = 0;// fin de trame

void setup() {
  analogWrite(3,0);
  Serial.begin(38400);
  }

void loop()
{
  // if there's any serial available, read it:
while (Serial.available() > 0) {
       octet = Serial.read ();// lire un premier caractère
       
          if (octet = (0x01))
              Serial.write (0x83);
           

    // clear the screen
   byte pwm_r0 = (Serial.read()); //Valeur de la vitesse sur le canton 0 (= 0 à 63)

     analogWrite(3,pwm_r0/63*255);
             

   byte pwm_r1 = (Serial.read()); // 1

   



  byte pwm_r2 =( Serial.read()); // 2


  byte pwm_r3 = (Serial.read()); // 3

  byte pwm_r4 = (Serial.read()); // 4

  byte pwm_r5 = (Serial.read()); // 5

  byte pwm_r6 = (Serial.read()); // 6


  byte pwm_r7 = (Serial.read()); // 7
 

  byte  pwm_r8 = (Serial.read()); // 8


  byte  pwm_r9 = (Serial.read()); // 9

  byte pwm_r10 = (Serial.read()); // 10


  byte  pwm_r11 =( Serial.read()); // 11

  byte  pwm_r12 = (Serial.read()); // 12


  byte  pwm_r13 = (Serial.read()); // 13

  byte pwm_r14 = (Serial.read()); // 14


  byte pwm_r15 = (Serial.read()); // 15

pwm_s0_7 = Serial.read(); //Valeur sens de déplacement 1 bit par canton n° 0 à 7

         
pwm_s8_15 = Serial.read(); //Valeur sens de déplacement 1 bit par canton n° 8 à 15

out_out3 = Serial.read(); //Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])


out_out4 = Serial.read(); // 8 à 15 (IC15-ULN2008 [1])


out_out5 = Serial.read(); // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)


out_out21 = Serial.read(); // Valeur des bits des sorties 40 à 47 (ULN2008 [2])

out_out22 = Serial.read(); // 48 à 55 (ULN2008 [2])

out_out23 = Serial.read(); // 56 à 63 (ULN2008 [2])


out_out24 = Serial.read(); // 64 à 71 (ULN2008 [2])

out_out25 = Serial.read(); // 72 à 79 (ULN2008 [2])

led_on0 = Serial.read(); //Leds 00-07 allumées (1bit = une led)


led_on1 = Serial.read(); //Leds 12-19 allumées ( bit = 1 = on )


led_on01 = Serial.read();// Leds 08-11 et 20-23 allumées

led_on2 = Serial.read(); //Leds 24-31 allumées

led_on3 = Serial.read();// Leds 36-43 allumées


led_on23 = Serial.read(); //Leds 32-35 et 43-47 allumées


led_cl0 = Serial.read(); //Leds 00-07 clignotantes (1bit = une led)

led_cl1 = Serial.read(); //Leds 12-19 clignotantes ( bit = 1 = cli)

led_cl01 = Serial.read(); //Leds 08-11 et 20-23 clignotantes

led_cl2 = Serial.read(); //Leds 24-31 clignotantes

led_cl3 = Serial.read(); //Leds 36-43 clignotantes

led_cl23 = Serial.read(); //Leds 32-35 et 43-47 clignotantes

led_in0 = Serial.read(); //Leds 00-07 clignotant inversé (1bit = une led)


led_in1 = Serial.read(); //Leds 12-19 clignotant inversé ( bit = 1 = inv)


led_in01 = Serial.read(); //Leds 08-11 et 20-23 clignotant inversé

led_in2 = Serial.read(); //Leds 24-31 clignotant inversé

led_in3 = Serial.read(); //Leds 36-43 clignotant inversé


led_in23 = Serial.read(); //Leds 32-35 et 43-47 clignotant inversé

srv_0 = Serial.read(); //Valeur de consigne du servo n° 0

srv_1 = Serial.read(); //Valeur de consigne du servo n° 1

srv_2 = Serial.read(); //Valeur de consigne du servo n° 2


srv_3 = Serial.read(); //Valeur de consigne du servo n° 3


srv_4 = Serial.read(); //Valeur de consigne du servo n° 4


ruf1 = Serial.read(); //LIBRE réservé utilisation future

ruf2 = Serial.read(); //LIBRE réservé utilisation future

ruf3 = Serial.read();

octet = Serial.read ();
   



     }               
    }
 


je pense le problème vient du code , si vous pouvez m' apporter votre aide, elle sera la bienvenue car je tourne un peu en rond :evil:
SYLTRAIN80
 
Messages: 29
Inscrit le: Mar 24 Fév 2015, 10:47
Echelle pratiquée: HO - N
Prénom: Sylvain

Re: Conseil sur faisabilité de mon projet

Publié: Mer 20 Mai 2015, 17:44 
Bonjour,

Effectivement le (un ?) problème vient du code.

le
Code: Tout sélectionner
if (octet = (0x01))
affecte 0x01 à octet. Je pense que tu voulais comparer. Il faut donc utiliser ==
Code: Tout sélectionner
octet = 0x01
est toujours vrai car 0x01 est différent de 0

Ensuite, tu fais une succession de read sur la ligne série alors qu'il n'y a sans doute rien. Il faudrait attendre avant chaque read qu'une octet soit disponible. Le mieux est de faire une fonction qui attend avant de lire. Comme ceci :

Code: Tout sélectionner
byte waitAndRead()
{
  while (Serial.available() == 0); // attend un octet au moins
  return Serial.read();
}


et remplacer tous tes
Code: Tout sélectionner
Serial.read()
par
Code: Tout sélectionner
waitAndRead()


Tu peux alors supprimer la boucle while.

Côté matériel, il manque la diode roue libre, les transistors vont souffrir. Ta lecture de FCEM est sans aucune protection, le micro risque de griller, Il faut impérativement mettre une diode schottky entre A0 et 5V de manière à ce que si la tension en A0 excède 5V, ça part dans l'alim. De même, il faut une diode schottky entre A0 et la masse de manière à ce que si la tension en A0 descend en dessous de 0, ça parte vers la masse.
Avatar de l’utilisateur
jlb
Fécond
 
Messages: 667
Inscrit le: Jeu 04 Oct 2012, 16:38
Echelle pratiquée: N
Prénom: Jean-Luc

Re: Conseil sur faisabilité de mon projet

Publié: Mer 20 Mai 2015, 18:33 
Merci beaucoup,
tous semble facile et évident lorsque je vous lis
Mes débuts en c++ sont laborieux car je pars de très loin mais il faut de je persiste pour mener mon projet à terme
SYLTRAIN80
 
Messages: 29
Inscrit le: Mar 24 Fév 2015, 10:47
Echelle pratiquée: HO - N
Prénom: Sylvain

Re: Conseil sur faisabilité de mon projet

Publié: Mer 20 Mai 2015, 19:04 
est ce que waitAndRead() est une fonction ? car elle ne colore pas comme Serial.read() quand je la saisie
SYLTRAIN80
 
Messages: 29
Inscrit le: Mar 24 Fév 2015, 10:47
Echelle pratiquée: HO - N
Prénom: Sylvain

Re: Conseil sur faisabilité de mon projet

Publié: Mer 20 Mai 2015, 19:18 
Il faut que tu mettes la fonction waitAndRead dans ton sketch. C'est normal qu'elle ne se colore pas car elle ne fait pas partie des bibliothèques Arduino.
Avatar de l’utilisateur
jlb
Fécond
 
Messages: 667
Inscrit le: Jeu 04 Oct 2012, 16:38
Echelle pratiquée: N
Prénom: Jean-Luc

Re: Conseil sur faisabilité de mon projet

Publié: Mer 20 Mai 2015, 19:44 
ok je comprends mieux
SYLTRAIN80
 
Messages: 29
Inscrit le: Mar 24 Fév 2015, 10:47
Echelle pratiquée: HO - N
Prénom: Sylvain

Re: Conseil sur faisabilité de mon projet

Publié: Mar 14 Juil 2015, 22:20 
bon après de multiples essais je bloque toujours sur ma lecture de trame
voici mon dernier code et je ne comprends pas ou ça pèche
Code: Tout sélectionner
byte pwm_r0 = 0; //Valeur de la vitesse sur le canton 0 (= 0 à 63)
byte pwm_r1 = 0; // 1
byte pwm_r2 = 0; // 2
byte pwm_r3 = 0; // 3
byte pwm_r4 = 0; // 4
byte pwm_r5 = 0; // 5
byte pwm_r6 = 0; // 6
byte pwm_r7 = 0; // 7
byte pwm_r8 = 0; // 8
byte pwm_r9 = 0; // 9
byte pwm_r10 = 0; // 10
byte pwm_r11 = 0; // 11
byte pwm_r12 = 0; // 12
byte pwm_r13 = 0; // 13
byte pwm_r14 = 0; // 14
byte pwm_r15 = 0; // 15
byte pwm_s0_7 = 0; //Valeur sens de déplacement 1 bit par canton n° 0 à 7
byte pwm_s8_15 = 0; //Valeur sens de déplacement 1 bit par canton n° 8 à 15
byte out_out3 = 0; //Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])
byte out_out4 = 0; // 8 à 15 (IC15-ULN2008 [1])
byte out_out5 = 0; // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)
byte out_out21 = 0; // Valeur des bits des sorties 40 à 47 (ULN2008 [2])
byte out_out22 = 0; // 48 à 55 (ULN2008 [2])
byte out_out23 = 0; // 56 à 63 (ULN2008 [2])
byte out_out24 = 0; // 64 à 71 (ULN2008 [2])
byte out_out25 = 0; // 72 à 79 (ULN2008 [2])
byte led_on0 = 0; //Leds 00-07 allumées (1bit = une led)
byte led_on1 = 0; //Leds 12-19 allumées ( bit = 1 = on )
byte led_on01 = 0;// Leds 08-11 et 20-23 allumées
byte led_on2 = 0; //Leds 24-31 allumées
byte led_on3 = 0;// Leds 36-43 allumées
byte led_on23 = 0; //Leds 32-35 et 43-47 allumées
byte led_cl0 = 0; //Leds 00-07 clignotantes (1bit = une led)
byte led_cl1 = 0; //Leds 12-19 clignotantes ( bit = 1 = cli)
byte led_cl01 =0; //Leds 08-11 et 20-23 clignotantes
byte led_cl2 = 0; //Leds 24-31 clignotantes
byte led_cl3 = 0; //Leds 36-43 clignotantes
byte led_cl23 = 0; //Leds 32-35 et 43-47 clignotantes
byte led_in0 = 0; //Leds 00-07 clignotant inversé (1bit = une led)
byte led_in1 = 0; //Leds 12-19 clignotant inversé ( bit = 1 = inv)
byte led_in01 = 0; //Leds 08-11 et 20-23 clignotant inversé
byte led_in2 = 0; //Leds 24-31 clignotant inversé
byte led_in3 = 0; //Leds 36-43 clignotant inversé
byte led_in23 = 0; //Leds 32-35 et 43-47 clignotant inversé
byte srv_0 = 0    ; //Valeur de consigne du servo n° 0
byte srv_1 = 0    ; //Valeur de consigne du servo n° 1
byte srv_2 = 0    ; //Valeur de consigne du servo n° 2
byte srv_3 = 0    ; //Valeur de consigne du servo n° 3
byte srv_4 = 0    ; //Valeur de consigne du servo n° 4
byte ruf1 = 0     ; //LIBRE réservé utilisation future
byte ruf2 = 0     ; //LIBRE réservé utilisation future
byte ruf3 = 0     ; //LIBRE réservé utilisation future. Pour le PIC c'est le dernier octet de la trame. Le prochain octet 0x00 est traité comme une commande "Nulle".

byte octet = 0 ;
const char debtrame   = 0x08;
const char numecarte  = 0x83;
const char deteccarte = 0x01;
int octetReception=0; // variable de stockage des valeurs reçues sur le port Série (ASCII)
char caractereRecu=0; // variable pour stockage caractère recu
int compt=0; // variable comptage caractères reçus


void setup() {
 
analogWrite(9,0);
analogWrite(10,0);
analogWrite(11,0);


  // initialize the serial communications:
  Serial.begin(38400);
  }
byte WaitAndRead()
{
  while (Serial.available() == 0); // attend un octet au moins
  return Serial.read();
}
void loop()
{


   
   byte octet = WaitAndRead();
    if(octet ==(deteccarte)){
   
     
    Serial.write (0x83);

   

  byte octet = WaitAndRead();
  if(octet == (debtrame)){
   
  pwm_r0 = WaitAndRead(); //Valeur de la vitesse sur le canton 0 (= 0 à 63)
   analogWrite(9,(pwm_r0));

             
     
     
pwm_r1 = WaitAndRead(); //Valeur de la vitesse sur le canton 1 (= 0 à 63)
    analogWrite(10,(pwm_r1));
       

 
   Serial.write (0);
   

pwm_r2 = WaitAndRead(); //Valeur de la vitesse sur le canton 2 (= 0 à 63)
   analogWrite(11,(pwm_r2));
     


pwm_r3 = WaitAndRead(); //Valeur de la vitesse sur le canton 2 (= 0 à 63)
 
    Serial.write (0);

pwm_r4 = WaitAndRead(); //Valeur de la vitesse sur le canton 2 (= 0 à 63)

pwm_r5 = WaitAndRead(); // 5

   Serial.write (0);

pwm_r6 = WaitAndRead(); // 6

pwm_r7 = WaitAndRead(); // 7

   Serial.write (0);

pwm_r8 = WaitAndRead(); // 8

pwm_r9 = WaitAndRead(); // 9

   Serial.write (0);

pwm_r10 = WaitAndRead(); // 10

pwm_r11 = WaitAndRead(); // 11

   Serial.write (0);

pwm_r12 = WaitAndRead(); // 12

pwm_r13 = WaitAndRead(); // 13

  Serial.write (0);

pwm_r14 = WaitAndRead(); // 14

pwm_r15 = WaitAndRead(); // 15

   Serial.write (0);

pwm_s0_7 = WaitAndRead(); //Valeur sens de déplacement 1 bit par canton n° 0 à 7

pwm_s8_15 = WaitAndRead(); //Valeur sens de déplacement 1 bit par canton n° 8 à 15

   Serial.write (0);

out_out3 = WaitAndRead(); //Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])

out_out4 = WaitAndRead(); // 8 à 15 (IC15-ULN2008 [1])

  Serial.write (0);

out_out5 = WaitAndRead(); // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)

out_out21 = WaitAndRead(); // Valeur des bits des sorties 40 à 47 (ULN2008 [2])

  Serial.write (0);

out_out22 = WaitAndRead(); // 48 à 55 (ULN2008 [2])

out_out23 = WaitAndRead(); // 56 à 63 (ULN2008 [2])

  Serial.write (0);

out_out24 = WaitAndRead(); // 64 à 71 (ULN2008 [2])

out_out25 = WaitAndRead(); // 72 à 79 (ULN2008 [2])

  Serial.write (0);

led_on0 = WaitAndRead(); //Leds 00-07 allumées (1bit = une led)

led_on1 = WaitAndRead(); //Leds 12-19 allumées ( bit = 1 = on )

  Serial.write (0);

led_on01 = WaitAndRead();// Leds 08-11 et 20-23 allumées

led_on2 = WaitAndRead(); //Leds 24-31 allumées

  Serial.write (0);

led_on3 = WaitAndRead();// Leds 36-43 allumées

led_on23 = WaitAndRead(); //Leds 32-35 et 43-47 allumées

  Serial.write (0);

led_cl0 = WaitAndRead(); //Leds 00-07 clignotantes (1bit = une led)

led_cl1 = WaitAndRead(); //Leds 12-19 clignotantes ( bit = 1 = cli)

  Serial.write (0);

led_cl01 =WaitAndRead(); //Leds 08-11 et 20-23 clignotantes

led_cl2 = WaitAndRead(); //Leds 24-31 clignotantes

  Serial.write (0);

led_cl3 = WaitAndRead(); //Leds 36-43 clignotantes

led_cl23 = WaitAndRead(); //Leds 32-35 et 43-47 clignotantes

  Serial.write (0);

led_in0 = WaitAndRead(); //Leds 00-07 clignotant inversé (1bit = une led)

led_in1 = WaitAndRead(); //Leds 12-19 clignotant inversé ( bit = 1 = inv)

  Serial.write (0);

led_in01 = WaitAndRead(); //Leds 08-11 et 20-23 clignotant inversé

led_in2 = WaitAndRead(); //Leds 24-31 clignotant inversé

  Serial.write (0);

led_in3 = WaitAndRead(); //Leds 36-43 clignotant inversé

led_in23 = WaitAndRead(); //Leds 32-35 et 43-47 clignotant inversé

  Serial.write (0);

srv_0 = WaitAndRead(); //Valeur de consigne du servo n° 0

srv_1 = WaitAndRead(); //Valeur de consigne du servo n° 1

   Serial.write (0);

srv_2 = WaitAndRead(); //Valeur de consigne du servo n° 2

srv_3 = WaitAndRead(); //Valeur de consigne du servo n° 3

srv_4 = WaitAndRead(); //Valeur de consigne du servo n° 4

ruf1 = WaitAndRead(); //LIBRE réservé utilisation future

ruf2 = WaitAndRead(); //LIBRE réservé utilisation future

ruf3 = WaitAndRead(); //LIBRE réservé utilisation future. Pour le PIC c'est le dernier octet de la trame. Le prochain octet 0x00 est traité comme une commande "Nulle".

   
  } 
}   
}



toujours le message " perte de liaison avec la carte"

ral le bol je n'y comprend vraiment plus rien :cry:
SYLTRAIN80
 
Messages: 29
Inscrit le: Mar 24 Fév 2015, 10:47
Echelle pratiquée: HO - N
Prénom: Sylvain

Re: Conseil sur faisabilité de mon projet

Publié: Dim 30 Août 2015, 11:39 
Bonjour,

J'ai recadré ton sketch avec des indentations bien claires.
Cela ne change rien au programme, mais c'est plus lisible.

Puis j'ai supprimé les "byte octet" que j'ai simplement remplacé par "octet", en ne gardant la définition de octet dans les variables globales ("en haut").
Ce n'est jamais bon de définir les variables plusieurs fois.
Puis j'ai décalé la définition de WaitAndRead au dessus du setup.

Donc, jusque là, je n'ai rien fait de fondamental (sauf les byte octet)

En compilant avec un Uno, il ne trouve aucun problème.
Par contre, en compilant avec un DUE (j'ai cette chance), le compilateur trouve une ambiguïté :
Serial.write (0);
Il trouve assez bizarre d'envoyer un 0, et donc, pour lui, un entier (int), sur le bus série. On ne peut pas non plus mettre 0x00, pas plus compréhensible pour lui.
La seule chose qu'il comprenne, syntaxiquement, c'est Serial.write("0");

Mais je ne pense pas que ce soit ce que tu veuilles : tu voudrais certainement vider le bus série. Et ce n'est pas comme ça qu'on peut faire.
Le bus série envoie des infos en continu. Ce n'est pas comme une mémoire qu'on efface.
La fonction de jlb s'appelle justement WaitAndRead(), justement pour attendre la suite.

Code: Tout sélectionner
byte pwm_r0 = 0; //Valeur de la vitesse sur le canton 0 (= 0 à 63)
byte pwm_r1 = 0; // 1
byte pwm_r2 = 0; // 2
byte pwm_r3 = 0; // 3
byte pwm_r4 = 0; // 4
byte pwm_r5 = 0; // 5
byte pwm_r6 = 0; // 6
byte pwm_r7 = 0; // 7
byte pwm_r8 = 0; // 8
byte pwm_r9 = 0; // 9
byte pwm_r10 = 0; // 10
byte pwm_r11 = 0; // 11
byte pwm_r12 = 0; // 12
byte pwm_r13 = 0; // 13
byte pwm_r14 = 0; // 14
byte pwm_r15 = 0; // 15
byte pwm_s0_7 = 0; //Valeur sens de déplacement 1 bit par canton n° 0 à 7
byte pwm_s8_15 = 0; //Valeur sens de déplacement 1 bit par canton n° 8 à 15
byte out_out3 = 0; //Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])
byte out_out4 = 0; // 8 à 15 (IC15-ULN2008 [1])
byte out_out5 = 0; // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)
byte out_out21 = 0; // Valeur des bits des sorties 40 à 47 (ULN2008 [2])
byte out_out22 = 0; // 48 à 55 (ULN2008 [2])
byte out_out23 = 0; // 56 à 63 (ULN2008 [2])
byte out_out24 = 0; // 64 à 71 (ULN2008 [2])
byte out_out25 = 0; // 72 à 79 (ULN2008 [2])
byte led_on0 = 0; //Leds 00-07 allumées (1bit = une led)
byte led_on1 = 0; //Leds 12-19 allumées ( bit = 1 = on )
byte led_on01 = 0;// Leds 08-11 et 20-23 allumées
byte led_on2 = 0; //Leds 24-31 allumées
byte led_on3 = 0;// Leds 36-43 allumées
byte led_on23 = 0; //Leds 32-35 et 43-47 allumées
byte led_cl0 = 0; //Leds 00-07 clignotantes (1bit = une led)
byte led_cl1 = 0; //Leds 12-19 clignotantes ( bit = 1 = cli)
byte led_cl01 =0; //Leds 08-11 et 20-23 clignotantes
byte led_cl2 = 0; //Leds 24-31 clignotantes
byte led_cl3 = 0; //Leds 36-43 clignotantes
byte led_cl23 = 0; //Leds 32-35 et 43-47 clignotantes
byte led_in0 = 0; //Leds 00-07 clignotant inversé (1bit = une led)
byte led_in1 = 0; //Leds 12-19 clignotant inversé ( bit = 1 = inv)
byte led_in01 = 0; //Leds 08-11 et 20-23 clignotant inversé
byte led_in2 = 0; //Leds 24-31 clignotant inversé
byte led_in3 = 0; //Leds 36-43 clignotant inversé
byte led_in23 = 0; //Leds 32-35 et 43-47 clignotant inversé
byte srv_0 = 0    ; //Valeur de consigne du servo n° 0
byte srv_1 = 0    ; //Valeur de consigne du servo n° 1
byte srv_2 = 0    ; //Valeur de consigne du servo n° 2
byte srv_3 = 0    ; //Valeur de consigne du servo n° 3
byte srv_4 = 0    ; //Valeur de consigne du servo n° 4
byte ruf1 = 0     ; //LIBRE réservé utilisation future
byte ruf2 = 0     ; //LIBRE réservé utilisation future
byte ruf3 = 0     ; //LIBRE réservé utilisation future. Pour le PIC c'est le dernier octet de la trame. Le prochain octet 0x00 est traité comme une commande "Nulle".

byte octet            = 0 ;
const char debtrame   = 0x08;
const char numecarte  = 0x83;
const char deteccarte = 0x01;
int octetReception    = 0; // variable de stockage des valeurs reçues sur le port Série (ASCII)
char caractereRecu    = 0; // variable pour stockage caractère recu
int compt             = 0; // variable comptage caractères reçus

//------------------------ WaitAndRead --------------------------------
byte WaitAndRead()
{
  while (Serial.available() == 0); // attend un octet au moins
  return Serial.read();
}

//-------------------------- Setup ----------------------------------
void setup()
{     
  analogWrite(9,0);
  analogWrite(10,0);
  analogWrite(11,0);

  // initialize the serial communications:
  Serial.begin(38400);
}

//------------------------- Loop -------------------------------------
void loop()
{       

  byte octet = WaitAndRead();
  if(octet ==(deteccarte))
  {           
    Serial.write (0x83);
   
    byte octet = WaitAndRead();
    if(octet == (debtrame))
    {       
      pwm_r0 = WaitAndRead(); //Valeur de la vitesse sur le canton 0 (= 0 à 63)
      analogWrite(9,(pwm_r0));
   
      pwm_r1 = WaitAndRead(); //Valeur de la vitesse sur le canton 1 (= 0 à 63)
      analogWrite(10,(pwm_r1));         

      // Serial.write(0);
       
      pwm_r2 = WaitAndRead(); //Valeur de la vitesse sur le canton 2 (= 0 à 63)
      analogWrite(11,(pwm_r2));
     
      pwm_r3 = WaitAndRead(); //Valeur de la vitesse sur le canton 2 (= 0 à 63)
     
      // Serial.write(0);

      pwm_r4 = WaitAndRead(); //Valeur de la vitesse sur le canton 2 (= 0 à 63)
      pwm_r5 = WaitAndRead(); // 5

      // Serial.write(0);

      pwm_r6 = WaitAndRead(); // 6
      pwm_r7 = WaitAndRead(); // 7

      // Serial.write(0);

      pwm_r8 = WaitAndRead(); // 8
      pwm_r9 = WaitAndRead(); // 9

      // Serial.write(0);

      pwm_r10 = WaitAndRead(); // 10
      pwm_r11 = WaitAndRead(); // 11

      // Serial.write(0);

      pwm_r12 = WaitAndRead(); // 12
      pwm_r13 = WaitAndRead(); // 13

      // Serial.write(0);

      pwm_r14 = WaitAndRead(); // 14
      pwm_r15 = WaitAndRead(); // 15

      // Serial.write(0);

      pwm_s0_7  = WaitAndRead(); //Valeur sens de déplacement 1 bit par canton n° 0 à 7
      pwm_s8_15 = WaitAndRead(); //Valeur sens de déplacement 1 bit par canton n° 8 à 15

      // Serial.write(0);

      out_out3 = WaitAndRead(); //Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])
      out_out4 = WaitAndRead(); // 8 à 15 (IC15-ULN2008 [1])

      // Serial.write(0);

      out_out5  = WaitAndRead(); // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)
      out_out21 = WaitAndRead(); // Valeur des bits des sorties 40 à 47 (ULN2008 [2])

      // Serial.write(0);

      out_out22 = WaitAndRead(); // 48 à 55 (ULN2008 [2])
      out_out23 = WaitAndRead(); // 56 à 63 (ULN2008 [2])

      // Serial.write(0);

      out_out24 = WaitAndRead(); // 64 à 71 (ULN2008 [2])
      out_out25 = WaitAndRead(); // 72 à 79 (ULN2008 [2])

      // Serial.write(0);

      led_on0 = WaitAndRead(); //Leds 00-07 allumées (1bit = une led)
      led_on1 = WaitAndRead(); //Leds 12-19 allumées ( bit = 1 = on )

      // Serial.write(0);

      led_on01 = WaitAndRead();// Leds 08-11 et 20-23 allumées
      led_on2  = WaitAndRead(); //Leds 24-31 allumées

      // Serial.write(0);

      led_on3  = WaitAndRead();// Leds 36-43 allumées
      led_on23 = WaitAndRead(); //Leds 32-35 et 43-47 allumées

      // Serial.write(0);

      led_cl0 = WaitAndRead(); //Leds 00-07 clignotantes (1bit = une led)
      led_cl1 = WaitAndRead(); //Leds 12-19 clignotantes ( bit = 1 = cli)

      // Serial.write(0);

      led_cl01 = WaitAndRead(); //Leds 08-11 et 20-23 clignotantes
      led_cl2  = WaitAndRead(); //Leds 24-31 clignotantes

      // Serial.write(0);

      led_cl3  = WaitAndRead(); //Leds 36-43 clignotantes
      led_cl23 = WaitAndRead(); //Leds 32-35 et 43-47 clignotantes

      // Serial.write(0);

      led_in0 = WaitAndRead(); //Leds 00-07 clignotant inversé (1bit = une led)
      led_in1 = WaitAndRead(); //Leds 12-19 clignotant inversé ( bit = 1 = inv)

      // Serial.write(0);

      led_in01 = WaitAndRead(); //Leds 08-11 et 20-23 clignotant inversé
      led_in2  = WaitAndRead(); //Leds 24-31 clignotant inversé

      // Serial.write(0);

      led_in3  = WaitAndRead(); //Leds 36-43 clignotant inversé
      led_in23 = WaitAndRead(); //Leds 32-35 et 43-47 clignotant inversé

      // Serial.write(0);

      srv_0 = WaitAndRead(); //Valeur de consigne du servo n° 0
      srv_1 = WaitAndRead(); //Valeur de consigne du servo n° 1

      // Serial.write(0);

      srv_2 = WaitAndRead(); //Valeur de consigne du servo n° 2
      srv_3 = WaitAndRead(); //Valeur de consigne du servo n° 3
      srv_4 = WaitAndRead(); //Valeur de consigne du servo n° 4
      ruf1  = WaitAndRead(); //LIBRE réservé utilisation future
      ruf2  = WaitAndRead(); //LIBRE réservé utilisation future
      ruf3  = WaitAndRead(); //LIBRE réservé utilisation future. Pour le PIC c'est le dernier octet de la trame. Le prochain octet 0x00 est traité comme une commande "Nulle".     
    }
  }   
}




A suivre, donc.
J'y arriverai ... demain !
Avatar de l’utilisateur
groumfit
Papotier
 
Messages: 143
Inscrit le: Sam 25 Oct 2014, 11:25
Âge: 61
Prénom: Denis

Re: Conseil sur faisabilité de mon projet

Publié: Lun 31 Août 2015, 18:36 
Merci groumfit de te re-pencher sur mon problème.
J' ai mis des "Serial.write (0);" pour simuler des réponses au logiciel (détections de cantons) mais cela n' arrange rien au pb
je vais essayer d' expliquer la logique de lecture de trame que j' essaie d' écrire
( avec mes termes)

"SI" arduino reçoit 0x01
"alors" arduino répond 0x83

"alors"

"quand"arduino reçoit 0x08 (octet de commande d' échange de trame)
"alors" arduino lit les 52 octets suivant et les affecte à une variable

"quand "arduino reçoit 0x00 (octet de fin de trame)
"alors "on recommence depuis le début

je ne sais pas si cela est clair et si je peux traiter toutes les conditions avec "IF" ?
SYLTRAIN80
 
Messages: 29
Inscrit le: Mar 24 Fév 2015, 10:47
Echelle pratiquée: HO - N
Prénom: Sylvain

PrécédentSuivant

Retour vers Arduino

Qui est en ligne ?

Utilisateur(s) parcourant actuellement ce forum : Aucun utilisateur inscrit et 2 invité(s)