Bonjour,
je vais essayer de vous présenter de facon claire mon pb
Dans mon projet de commande de réseau de train a partir d' un PC et de carte Arduino
j' essaie de lire la trame de données du logiciel UTS (libre de droit)
http://www.la-tour.info/uts/uts_index.html
Mon but étant de d' utiliser le logiciel et de remplacer la carte électronique par une carte arduino MEGA qui communique avec plusieurs carte UNO (1 par canton)
La trame de sortie et décrite par l' auteur lui même :
Liaison PC-PIC
le PC envoi 55 octets et le PIC en renvoi 25 octets simultanément.
L'échange des données entre le PC et le PIC dure 14 msec. L'envoi des données se fait en une seule trame, ce qui facilitera le passage à une liaison usb si nécessaire.
Il est possible d'utiliser le logiciel UTS et de construire ses propres interfaces, si elles répondre aux spécifications ci-après.
De même, on pourrait utilise les cartes à PIC d'UTS avec un autre logiciel, si l'on peut modifier les commandes envoyées par cet autre programme de supervision de réseau.
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 .....
A partir de la j' ai écrit un petit programme sur UNO pour lire la trame , le logiciel détecte la carte électronique UTS et les leds rx et tx clignotent et la L s' allume en continue.
Jusque la tous semble fonctionner mais je n' arrive pas à exploiter par exemple les données reçues
pour pwm_r0 pour commander une led ou un moteur?
est ce que le pb vient de l' interprétation de la variable ?
voici mon semblant de code :
int pwm_r0 = 0; //Valeur de la vitesse sur le canton 0 (= 0 à 63)
int pwm_r1 = 0; // 1
int pwm_r2 = 0; // 2
int pwm_r3 = 0; // 3
int pwm_r4 = 0; // 4
int pwm_r5 = 0; // 5
int pwm_r6 = 0; // 6
int pwm_r7 = 0; // 7
int pwm_r8 = 0; // 8
int pwm_r9 = 0; // 9
int pwm_r10 = 0; // 10
int pwm_r11 = 0; // 11
int pwm_r12 = 0; // 12
int pwm_r13 = 0; // 13
int pwm_r14 = 0; // 14
int pwm_r15 = 0; // 15
int pwm_s0_7 = 0; //Valeur sens de déplacement 1 bit par canton n° 0 à 7
int pwm_s8_15 = 0; //Valeur sens de déplacement 1 bit par canton n° 8 à 15
int out_out3 = 0; //Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])
int out_out4 = 0; // 8 à 15 (IC15-ULN2008 [1])
int out_out5 = 0; // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)
int out_out21 = 0; // Valeur des bits des sorties 40 à 47 (ULN2008 [2])
int out_out22 = 0; // 48 à 55 (ULN2008 [2])
int out_out23 = 0; // 56 à 63 (ULN2008 [2])
int out_out24 = 0; // 64 à 71 (ULN2008 [2])
int out_out25 = 0; // 72 à 79 (ULN2008 [2])
int led_on0 = 0; //Leds 00-07 allumées (1bit = une led)
int led_on1 = 0; //Leds 12-19 allumées ( bit = 1 = on )
int led_on01 = 0;// Leds 08-11 et 20-23 allumées
int led_on2 = 0; //Leds 24-31 allumées
int led_on3 = 0;// Leds 36-43 allumées
int led_on23 = 0; //Leds 32-35 et 43-47 allumées
int led_cl0 = 0; //Leds 00-07 clignotantes (1bit = une led)
int led_cl1 = 0; //Leds 12-19 clignotantes ( bit = 1 = cli)
int led_cl01 =0; //Leds 08-11 et 20-23 clignotantes
int led_cl2 = 0; //Leds 24-31 clignotantes
int led_cl3 = 0; //Leds 36-43 clignotantes
int led_cl23 = 0; //Leds 32-35 et 43-47 clignotantes
int led_in0 = 0; //Leds 00-07 clignotant inversé (1bit = une led)
int led_in1 = 0; //Leds 12-19 clignotant inversé ( bit = 1 = inv)
int led_in01 = 0; //Leds 08-11 et 20-23 clignotant inversé
int led_in2 = 0; //Leds 24-31 clignotant inversé
int led_in3 = 0; //Leds 36-43 clignotant inversé
int led_in23 = 0; //Leds 32-35 et 43-47 clignotant inversé
int srv_0 = 0; //Valeur de consigne du servo n° 0
int srv_1 = 0; //Valeur de consigne du servo n° 1
int srv_2 = 0; //Valeur de consigne du servo n° 2
int srv_3 = 0; //Valeur de consigne du servo n° 3
int srv_4 = 0; //Valeur de consigne du servo n° 4
int ruf1 = 0; //LIBRE réservé utilisation future
int ruf2 = 0; //LIBRE réservé utilisation future
int ruf3 = 0;
int octet = 0;// fin de trame
void setup() {
pinMode(13, OUTPUT);
digitalWrite(13, LOW);
// initialize the serial communications:
Serial.begin(38400);
}
void loop()
{
if (Serial.available()) {
octet = Serial.read ();
if(octet == (0x01)){
Serial.write (0x83);}
octet = Serial.read ();
pwm_r0 = Serial.read(); //Valeur de la vitesse sur le canton 0 (= 0 à 63)
if (((pwm_r0,DEC)) == 0){
digitalWrite(13, LOW);}
else {digitalWrite(13, HIGH);}
pwm_r1 = Serial.read(); //Valeur de la vitesse sur le canton 0 (= 0 à 63)
Serial.write (0xF2);
pwm_r2 = Serial.read(); // 2
pwm_r3 = Serial.read(); // 3
pwm_r4 = Serial.read(); // 4
pwm_r5 = Serial.read(); // 5
pwm_r6 = Serial.read(); // 6
pwm_r7 = Serial.read(); // 7
pwm_r8 = Serial.read(); // 8
pwm_r9 = Serial.read(); // 9
pwm_r10 = Serial.read(); // 10
pwm_r11 = Serial.read(); // 11
pwm_r12 = Serial.read(); // 12
pwm_r13 = Serial.read(); // 13
pwm_r14 = Serial.read(); // 14
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();
}
}
Est ce que la lecture de cette trame est possible à exploiter pour la suite de mon projet ? 
Vos avis et votre aide me serais d' un grand secours car aprés de multiples essais je bloque sur ce point (le développement des PWM de canton ainsi de les capteur de présence avec des Arduino NANO sont presque au point (reste la gestion des FEM et surtout la communication du logiciel <-> MEGA et MEGA <-> NANO1 +NANO2 ect.....)
Je suis désespéré de ne pas comprendre ou est mon problème de lecture de la trame du logiciel
Moderator edit: code tags
une carte arduino MEGA qui communique avec plusieurs carte UNO (1 par canton)
Bonjour,
nous avions déjà un post de ce type, la question était de savoir comment synchroniser les pwm des arduino esclaves, pour éviter des accélérations intempestives quand la motrice est à cheval sur 2 cantons ...
Merci de votre info,
mais ma priorité actuellement et de traiter le problème de lecture de trame et de traitement des données lues pour pouvoir avancer dans mon projet .
La communication entre la Carte MEGA et les UNO sera dans un 2éme temps.
bonjour
D'accord avec pepe
quel est le ratio de l'intertrame rapporté à la durée de trame ?
j' ai essayé avec waitandread mais avec ce code la le logiciel ne reconnait plus la carte
int ledPin1 = 9;
int ledPin2 = 10;
int ledPin3 = 11;
int pwm_r0 = 0; //Valeur de la vitesse sur le canton 0 (= 0 à 63)
int pwm_r1 = 0; // 1
int pwm_r2 = 0; // 2
int pwm_r3 = 0; // 3
int pwm_r4 = 0; // 4
int pwm_r5 = 0; // 5
int pwm_r6 = 0; // 6
int pwm_r7 = 0; // 7
int pwm_r8 = 0; // 8
int pwm_r9 = 0; // 9
int pwm_r10 = 0; // 10
int pwm_r11 = 0; // 11
int pwm_r12 = 0; // 12
int pwm_r13 = 0; // 13
int pwm_r14 = 0; // 14
int pwm_r15 = 0; // 15
int pwm_s0_7 = 0; //Valeur sens de déplacement 1 bit par canton n° 0 à 7
int pwm_s8_15 = 0; //Valeur sens de déplacement 1 bit par canton n° 8 à 15
int out_out3 = 0; //Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])
int out_out4 = 0; // 8 à 15 (IC15-ULN2008 [1])
int out_out5 = 0; // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)
int out_out21 = 0; // Valeur des bits des sorties 40 à 47 (ULN2008 [2])
int out_out22 = 0; // 48 à 55 (ULN2008 [2])
int out_out23 = 0; // 56 à 63 (ULN2008 [2])
int out_out24 = 0; // 64 à 71 (ULN2008 [2])
int out_out25 = 0; // 72 à 79 (ULN2008 [2])
int led_on0 = 0; //Leds 00-07 allumées (1bit = une led)
int led_on1 = 0; //Leds 12-19 allumées ( bit = 1 = on )
int led_on01 = 0;// Leds 08-11 et 20-23 allumées
int led_on2 = 0; //Leds 24-31 allumées
int led_on3 = 0;// Leds 36-43 allumées
int led_on23 = 0; //Leds 32-35 et 43-47 allumées
int led_cl0 = 0; //Leds 00-07 clignotantes (1bit = une led)
int led_cl1 = 0; //Leds 12-19 clignotantes ( bit = 1 = cli)
int led_cl01 =0; //Leds 08-11 et 20-23 clignotantes
int led_cl2 = 0; //Leds 24-31 clignotantes
int led_cl3 = 0; //Leds 36-43 clignotantes
int led_cl23 = 0; //Leds 32-35 et 43-47 clignotantes
int led_in0 = 0; //Leds 00-07 clignotant inversé (1bit = une led)
int led_in1 = 0; //Leds 12-19 clignotant inversé ( bit = 1 = inv)
int led_in01 = 0; //Leds 08-11 et 20-23 clignotant inversé
int led_in2 = 0; //Leds 24-31 clignotant inversé
int led_in3 = 0; //Leds 36-43 clignotant inversé
int led_in23 = 0; //Leds 32-35 et 43-47 clignotant inversé
int srv_0 = 0; //Valeur de consigne du servo n° 0
int srv_1 = 0; //Valeur de consigne du servo n° 1
int srv_2 = 0; //Valeur de consigne du servo n° 2
int srv_3 = 0; //Valeur de consigne du servo n° 3
int srv_4 = 0; //Valeur de consigne du servo n° 4
int ruf1 = 0; //LIBRE réservé utilisation future
int ruf2 = 0; //LIBRE réservé utilisation future
int ruf3 = 0;
int octet = 0;// fin de tramevoid setup() {
// initialize the serial communications:
Serial.begin(38400);
}
byte WaitAndRead()
{
while (Serial.available() == 0); // attend un octet au moinsreturn Serial.read();
}
void loop()
{if (Serial.available()) {
octet = Serial.read ();
if(octet == (0x01)){Serial.write (0x83);}
int pwm_r0 = (WaitAndRead()); //Valeur de la vitesse sur le canton 0 (= 0 à 63)
int valpmw01 = (pwm_r0,DEC);
analogWrite(ledPin1,(valpmw01));int pwm_r1 = (WaitAndRead()); //Valeur de la vitesse sur le canton 1 (= 0 à 63)
int valpmw02 = (pwm_r1,DEC);
analogWrite(ledPin2,(valpmw02));Serial.write (0xF2);
int pwm_r2 = (WaitAndRead()); //Valeur de la vitesse sur le canton 2 (= 0 à 63)
int valpmw03 = (pwm_r2,DEC);
analogWrite(ledPin3,(valpmw03));pwm_r3 = Serial.read(); // 3
pwm_r4 = Serial.read(); // 4
pwm_r5 = Serial.read(); // 5
pwm_r6 = Serial.read(); // 6
pwm_r7 = Serial.read(); // 7
pwm_r8 = Serial.read(); // 8
pwm_r9 = Serial.read(); // 9
pwm_r10 = Serial.read(); // 10
pwm_r11 = Serial.read(); // 11
pwm_r12 = Serial.read(); // 12
pwm_r13 = Serial.read(); // 13
pwm_r14 = Serial.read(); // 14
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();
}
}
mais pourquoi ?
pb de vitesse ???
je ne peux pas te répondre Artouste car je n' ai pas les connaissances pour comprendre et répondre a ta question (je pense que c' est la vitesse de transmission de la trame)
si cela est utile voici ce que la doc precise:
En V3.x un octet 0x00 est ajouté en fin de trame pour fiabiliser la liaison série.
En V3.x la vitesse de la liaison est de 38400 bps. A cette vitesse, un caractère est envoyé toutes les 260 µsec.
A 20 Mhz, une instruction assembleur du PIC dure 4*1/20Mhz = 0,2 µsec.
La réception des caractères ne provoque pas d'interruption dans le PIC.
Le programme doit exécuter toutes les instructions de la boucle principale en moins de 250 µsec, soit en moins de 1250 instructions assembleur.
La V3.x grâce à répartition des charges réalisée en partie à chaque boucle, tient en moins de 900 instructions.
Pour de nouvelles évolutions, il reste donc du temps pour exécuter 350 instructions par boucle (A chaque fois que l'on passe dans 'it_timer').
Le programme du PC a été revu pour améliorer la fiabilité de la liaison PIC-PC. En cas de parasite, la liaison se resynchronise automatiquement sans intervention.
En débranchant le câble et en le rebranchant en moins de 10 secondes, le logiciel gère complètement cette coupure sans afficher de message d'erreur.
Au bout de trois essais en erreur, un message d'erreur s'affiche proposant une reprise ou un arrêt de la liaison, ce qui permet de rebrancher
un câble ou de remettre le montage sous tension. Il faut parfois réinitialiser cette liaison deux ou trois fois pour reprendre le dialogue entre le PC et le PIC, mais pas besoin de quitter le programme du PC.
La trame envoyée par le PC commence toujours par 0x01, 0x11, 0x21 ou x31 (0x01 pour la carte n°1) + 0x08 et fini par un 0x00 pour synchroniser la liaison si le PIC avait perdu un caractère.
En cas d'erreur de liaison, le programme réémet immédiatement une nouvelle trame depuis le PC.
Le pointeur 'FSR' est utilisé en interne par le PIC. Il permet de pointer sur un registre interne. Voir la déclaration de ces variables dans "873rs33.asm".
Par exemple si FSR = 0x20 et qu'on lit la valeur pointé par 'FSR', on trouve "pwm_r0" = Valeur de la vitesse sur le canton 0 (= 0 à 63).
CARDADR EQU 0 est une variable définie dans le programme assembleur. Au moment de la compilation du programme en ".hex", cette variable donne le n° de la carte à PIC.
Échanges PC-PIC : Le PC à l'initiative et envoi un octet de commande, suivi éventuellement d'octets de données :
0x00 Resynchronise la communication série avec le PC (Le PIC ne fait rien). Utilisé aussi à la fin de l'envoi d'une trame de X octets, pour compléter si nécessaire la trame.
si un octet a été perdu dans la transmission. En cas de coupure de liaison, le PC réinitialise la liaison en envoyant 60 fois l'octet 0x00.
0x01 La carte à "PIC n° 1 = CARDADR EQU 0" répond 0x83 est devient sélectionnée, les autres cartes sont désélectionnées.
0x11 La carte à "PIC n° 2 = CARDADR EQU 1" répond 0x83 est devient sélectionnée, les autres cartes sont désélectionnées.
0x21 La carte à "PIC n° 3 = CARDADR EQU 2" répond 0x83 est devient sélectionnée, les autres cartes sont désélectionnées.
0x31 La carte à "PIC n° 4 = CARDADR EQU 3" répond 0x83 est devient sélectionnée, les autres cartes sont désélectionnées.
0x02 + 0xZZ Met à jour le pointeur d'adresse 'FSR' de la carte à PIC sélectionnée avec la valeur 0xZZ.
0x03 + 0xZZ Ecrit la valeur 0xZZ dans le registre mémoire pointé par [FSR] de la carte à PIC sélectionnée. Ne touche pas au registre "FSR".
0x04 La carte à PIC sélectionnée retourne 0xZZ lu dans le registre mémoire pointé par [FSR]. Ne touche pas au registre "FSR".
0x05 + 0xZZ Incrémente le pointeur 'FSR' et écrit la valeur 0xZZ dans le registre mémoire pointé par [FSR] de la carte à PIC sélectionnée.
0x06 Incrémente le pointeur 'FSR' et retourne 0xZZ lu dans le registre mémoire pointé par [FSR] de la carte à PIC sélectionnée.
0x07 Incrémente le pointeur 'FSR' et retourne 0xZZ lu dans le registre mémoire pointé par [FSR] de la carte à PIC sélectionnée, puis efface dans le PIC le registre mémoire pointé par [FSR].
0x08 Transfère d'une trame complète (Écriture + Lecture simultanée) entre le PC et la carte à PIC sélectionnée.
Les octets de commande 0x02 à 0x07 sont envoyés par UTS depuis la page "Debug > Commande directe de la carte rs232" du programme UTS, quand on modifie un registre du PIC.
Cela permet de lire ou d'écrire dans un registre mémoire du PIC. Pour plus d'information, voir la table "ADRESSES DES VARIABLES" dans le programme assembleur ".asm".
En fonctionnement habituel, UTS n'envoie pas les commandes 0x02 à 0x07.
en suivant les instructions de pepe j' ai fait un essai de code
le logiciel reconnait la carte rx et tx clignotent
mais pas possible d interférer sur les pwm 1,2,3
donc toujours au même point 
int ledPin1 = 9;
int ledPin2 = 10;
int ledPin3 = 11;
int pwm_r0 = 0; //Valeur de la vitesse sur le canton 0 (= 0 à 63)
int pwm_r1 = 0; // 1
int pwm_r2 = 0; // 2
int pwm_r3 = 0; // 3
int pwm_r4 = 0; // 4
int pwm_r5 = 0; // 5
int pwm_r6 = 0; // 6
int pwm_r7 = 0; // 7
int pwm_r8 = 0; // 8
int pwm_r9 = 0; // 9
int pwm_r10 = 0; // 10
int pwm_r11 = 0; // 11
int pwm_r12 = 0; // 12
int pwm_r13 = 0; // 13
int pwm_r14 = 0; // 14
int pwm_r15 = 0; // 15
int pwm_s0_7 = 0; //Valeur sens de déplacement 1 bit par canton n° 0 à 7
int pwm_s8_15 = 0; //Valeur sens de déplacement 1 bit par canton n° 8 à 15
int out_out3 = 0; //Valeur des bits des sorties 1 à 7 (IC14-ULN2008 [1])
int out_out4 = 0; // 8 à 15 (IC15-ULN2008 [1])
int out_out5 = 0; // 16 à 23 (IC16-ULN2008 [1]) (Les sorties 24 à 39 sont reportées vers les leds)
int out_out21 = 0; // Valeur des bits des sorties 40 à 47 (ULN2008 [2])
int out_out22 = 0; // 48 à 55 (ULN2008 [2])
int out_out23 = 0; // 56 à 63 (ULN2008 [2])
int out_out24 = 0; // 64 à 71 (ULN2008 [2])
int out_out25 = 0; // 72 à 79 (ULN2008 [2])
int led_on0 = 0; //Leds 00-07 allumées (1bit = une led)
int led_on1 = 0; //Leds 12-19 allumées ( bit = 1 = on )
int led_on01 = 0;// Leds 08-11 et 20-23 allumées
int led_on2 = 0; //Leds 24-31 allumées
int led_on3 = 0;// Leds 36-43 allumées
int led_on23 = 0; //Leds 32-35 et 43-47 allumées
int led_cl0 = 0; //Leds 00-07 clignotantes (1bit = une led)
int led_cl1 = 0; //Leds 12-19 clignotantes ( bit = 1 = cli)
int led_cl01 =0; //Leds 08-11 et 20-23 clignotantes
int led_cl2 = 0; //Leds 24-31 clignotantes
int led_cl3 = 0; //Leds 36-43 clignotantes
int led_cl23 = 0; //Leds 32-35 et 43-47 clignotantes
int led_in0 = 0; //Leds 00-07 clignotant inversé (1bit = une led)
int led_in1 = 0; //Leds 12-19 clignotant inversé ( bit = 1 = inv)
int led_in01 = 0; //Leds 08-11 et 20-23 clignotant inversé
int led_in2 = 0; //Leds 24-31 clignotant inversé
int led_in3 = 0; //Leds 36-43 clignotant inversé
int led_in23 = 0; //Leds 32-35 et 43-47 clignotant inversé
int octet = 0;// fin de tramevoid setup() {
// initialize the serial communications:
Serial.begin(38400);
}void loop()
{if (Serial.available()) {
octet = Serial.read ();
if(octet == (0x01)){Serial.write (0x83);}
if (Serial.available()) {
int pwm_r0 = Serial.read (); //Valeur de la vitesse sur le canton 0 (= 0 à 63)
int valpmw01 = (pwm_r0,DEC);
analogWrite(ledPin1,(valpmw01));
}if (Serial.available()) {
int pwm_r1 = Serial.read (); //Valeur de la vitesse sur le canton 1 (= 0 à 63)
int valpmw02 = (pwm_r1,DEC);
analogWrite(ledPin2,(valpmw02));
}Serial.write (0xF2);
if (Serial.available()) {
int pwm_r2 = Serial.read (); //Valeur de la vitesse sur le canton 2 (= 0 à 63)
int valpmw03 = (pwm_r2,DEC);
analogWrite(ledPin3,(valpmw03));
}}
}
S'il te plait
mets tes codes entre balises code
ok excuse moi
est ce que veux que je l' ai re-poste ?
si oui le quel ?
SYLTRAIN80:
ok excuse moi
est ce que veux que je l' ai re-poste ?
si oui le quel ?
non , edite simplement tes messages en remplaçant les balise citations par les balises codes
Oui j' ai bien compris 
est ce que le complément d' informations du descriptif de trame apporte une réponse à ta question
"quel est le ratio de l' intertrame rapporté à la durée de trame ?"
SYLTRAIN80:
Oui j' ai bien compris
est ce que le complément d' informations du descriptif de trame apporte une réponse à ta question
"quel est le ratio de l' intertrame rapporté à la durée de trame ?"
Le ratio c'est tout simplement le rapport entre le nombre maximal theorique de trames pouvant etre emises en une seconde et le nombre de trames émises/secondes.
ex : si une trame dure 1ms tu peux au max en envoyer 1000 par seconde le ratio est de 1 (ou 100% d'occupation )
si tu en envoi 100 le ratio est de 10 (10% d'occupation)
Donc si j' ai compris la trame fait 55 octets de 8bits soit 440 bits
la vitesse de transmission est de 38400 bps donc 87.27 trames par secondes
SYLTRAIN80:
Donc si j' ai compris la trame fait 55 octets de 8bits soit 440 bits
la vitesse de transmission est de 38400 bps donc 87.27 trames par secondes
déjà si 55 X 8 ça fait bien 440 , en transmission serie 1 octet utile nécessite plus de 8 bits pour etre transmis :
il faut y associer les bits de start,parité et de stop 8)
Par confort (et cas les plus courants) l'habitude et de prendre 10 bits pour un octet 'utile'
à 38400 tu peux donc transmettre au mieux 69 trames/secondes.
Mais tout ça ne renseigne pas sur le nombre effectif de trame transmise par seconde , ce nombre est donc compris entre 0 et 69.
Ma question reste donc : où trouve t'on l'info du nombre de trames "utilies" transmises effectivement par seconde ( ce n'est pas la même chose que le nombre théorique possible" ?
la doc dit :
Liaison PC-PIC
le PC envoi 55 octets et le PIC en renvoi 25 octets simultanément.
L'échange des données entre le PC et le PIC dure 14 msec. L'envoi des données se fait en une seule trame, ce qui facilitera le passage à une liaison usb si nécessaire.
SYLTRAIN80:
la doc dit :
Liaison PC-PIC
le PC envoi 55 octets et le PIC en renvoi 25 octets simultanément.
L'échange des données entre le PC et le PIC dure 14 msec. L'envoi des données se fait en une seule trame, ce qui facilitera le passage à une liaison usb si nécessaire.
A mon "louchomètre de précision" 8) et sauf à m’être planté , je trouve un maxi de 48 "discussions"/secondes possibles.
S j'ai bien compris c'est le PC qui est initiateur (c'est lui qui envoie 55 octets et attend en retour 25 octets)
comment est géré "en demande le flux de trames" sur/par le PC ?
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) :
Nb d'octet TX RX Nb d'octet
emis reçus
1 0x01
83 1
1 0x08
2 0x24
3 0x52
F2 1
4 0x14
5 0x06
AC 2
6 0x79
7 0xA2
7E 3
8 0xBC
9 0x8F
... ... ... ...
... ... ... ...
45 0x10
46 0x8E
0 24
47 0x79
48 0x28
0 25
55 0x00
La doc dit "
En V3.x un octet 0x00 est ajouté en fin de trame pour fiabiliser la liaison série.
En V3.x la vitesse de la liaison est de 38400 bps. A cette vitesse, un caractère est envoyé toutes les 260 µsec. "
je pense donc que le pc envoie un flux de trame constant de 1 octet /260 µsec et que au bout de 55 octets il renvoie une nouvelle trame
l'octect n°1 0x01 etant l'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)
l' octet n°55 0x00 etant l'octet de fin pour resynchroniser la prochaine trame si nécessaire (Si perte d'un octet pendant le transfert).
la doc dit aussi "
Le PC à l'initiative et envoi un octet de commande, suivi éventuellement d'octets de données :
0x00 Resynchronise la communication série avec le PC (Le PIC ne fait rien). Utilisé aussi à la fin de l'envoi d'une trame de X octets, pour compléter si nécessaire la trame.
si un octet a été perdu dans la transmission. En cas de coupure de liaison, le PC réinitialise la liaison en envoyant 60 fois l'octet 0x00.
Ma question est ce que un UNO ou MEGA est capable de lire à cette vitesse et retranscrire la trame vers une autre liaison?
car je ne connais pas les capacititées de leurs microprocesseur comparés au PIC 16F873A 20/SP