Discussion :

[erwannoo]

Bonjour,

Je teste la communication entre 1 raspberry et 1 arduino mega 2560.
Avec ces 2 codes, codes d'exemple j'ai des résultats satisfaisants, démontrant bien que les 2 équipements sont bien cablés.

voici les codes :
python pour raspberry:

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/env python3
import serial
import time
 
if __name__ == '__main__':
	ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
	ser.reset_input_buffer()
	while True:
		ser.write(b"Hello from Raspberry Pi!\n")
		line = ser.readline().decode('utf-8').rstrip()
		print(line)
        time.sleep(1)

pour arduino:

Code Arduino :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void setup() {
	Serial.begin(9600);
	}
 
void loop() {
	if (Serial.available() > 0) {
		String data = Serial.readStringUntil('\n');
		Serial.print("You sent me: ");
		Serial.println(data);
	}
	}

Le truc c'est que maintenant je veux transmettre une variable; data = 65000 par exemple, mais je n'y arrive pas, et comme l'arduino à déjà sont usb d'utilisé j'ai pas le moniteur et c'est encore plus difficile d'analyser ce qui se passe.
Merci pour votre aide.

[f-leb]

Salut,

Synchroniser le Pi (avec Python) et l'Arduino sur une transmission série n'est pas si évident.
Voir Communication Arduino - Python via le port série

Et si tu veux utiliser un 2ème port série : comment obtenir un deuxième port série sur Arduino Uno ?

[erwannoo]

Bonjour,

merci pour les infos, j'ai trouvé l'astuce de renvoyer vers le Raspberry les valeurs reçues par l'Arduino (ça se mort la queue !!), ça semble plutôt marcher.
J'ai donc gratté un peu sur ma problématique, et avec les codes suivants, j'arrive à envoyer des valeurs en utilisant une variable. Par contre coté Arduino, ça relie mais chiffre par chiffre. Comment puis faire pour reconstruire le nombre initial (porté par la variable) ?

code Raspberry :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/usr/bin/env python3
import serial
import time
 
if __name__ == '__main__':
	ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
	ser.reset_input_buffer()
	while True:
                data = 6500
		ser.write(str(data).encode('utf-8'))                        # ici on envoie la valeur de la variable data
		line = ser.readline().decode('utf-8').rstrip()             # ici on affiche les valeurs reçues par l'arduino et renvoyée au raspberry
		print(line)
        time.sleep(1)

Code Arduino :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void setup() {
  Serial.begin(9600);
}
 
void loop() {
  if (Serial.available() > 0) {
      int data = Serial.read() - '0';
      Serial.println(data);
     }
}

Et quand je lance les codes, le résultat (visible sur le Raspberry) est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
6
5
0
0
6
5
0
0
6
5
0
0

ce qui n'est pas déconnant !!

[erwannoo]

Bon, après relecture de tout ça, je me dis que je suis trop bête... car effectivement coté Raspberry je convertis mon nombre en string, mais coté arduino le code original était déjà prêt pour récupérer du string !!!!!

Donc je pense que ça devrait aller en mixant les différents postes..

Sauf si vous pensez qu'il y a des améliorations à faire !!

[Auteur]

Bonsoir,

côté python termine ta chaîne par un caractère spécial comme le \n par exemple. Comme l'a fait remarqué f-leb, dans ton code Python, n'oublie pas d'initialiser ton Arduino avec un setDTR et ajoute une tempo pour attendre la fin de l'initialisation de la carte. Le Mega 2560 est un peu plus lent que le UNO pour s'initialiser.

Côté Arduino utilise la fonction Serial.readBytesUntil

Code Arduino :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
int BUF_SIZE = 32;
size_t n;
char *pch;
char buf[BUF_SIZE];
String strData;
int intData:
 
//................
 
if (Serial.available) 
{
    n = Serial.readBytesUntil('\n', buf, BUF_SIZE);
    if (n > 0)
    {
          pch = strtok(buf, ",");        
          strData = pch;
          intData = strData.toInt(); 
          //......
    }
}

[erwannoo]

Bonjour,

il y a un truc que je n'arrive pas a m'expliquer.. pour avec le code suivant :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/usr/bin/env python3
import serial
import time
 
if __name__ == '__main__':
	ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
	ser.reset_input_buffer()
	while True:
                data = 6500
		ser.write(str(data).encode('utf-8')+b"\n")                        # ici on envoie la valeur de la variable data
		line = ser.readline().decode('utf-8').rstrip()             # ici on affiche les valeurs reçues par l'arduino et renvoyée au raspberry
		print(line)
        time.sleep(1)

j'arrive à utiliser / piloter correctement l'Arduino mais pas lorsque je simplifie le code en enlevant la ligne de relecture ??

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python3
import serial
import time
 
if __name__ == '__main__':
	ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)
	while True:
                data = 6500
		ser.write(str(data).encode('utf-8')+b"\n")                        # ici on envoie la valeur de la variable data
        time.sleep(1)

Faut-il ajouter une ligne de fin de transmission ?? ou quelquechose du genre ? Merci pour votre aide.

[erwannoo]

en fait je me suis rendu compte qu'au dessus d'un certain delai : ici 1 seconde, le code qui pilote l'arduino fonctionne bien. En dessous il ne répond pas, et je ne sais pas expliquer pourquoi... c'est en train de me rendre fou !! les tests de communication que j'ai fait dans la nuit ont hyper bien fonctionné, a une vitesse assez rapide, et la quand je l'ajoute avec mes fonctions ça bloque... si vous avez une petite idée, je suis preneur. Merci.

code raspberry qui doit juste envoyer les data a l'arduino :

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#!/usr/bin/env python
#executer avec python3
#voir si besoin de reseter le buffer
 
import epics
import time
import serial
data = 0
val = 1
 
p = epics.PV('TL_AN_Input_1:3/TL_AN_Input_1_Pin:12:AN/Voltage_Channel') #pour tests
 
def calcul_ocr1a():
        val = p.get()
        print (val)
        if (val != 0):
                if (val<4.1666):
                        data = round(159552000/(val*648*1024*0.99667))
                        print ("Raspberry transmit OCR1A = ", data)
                        ser.write(str(data).encode('utf-8')+b"\n")
                        time.sleep(1)
 
                else:
                        data = round(159552000/(val*648*0.99667))
                        print ("Raspberry transmit OCR1A = ", data)
                        ser.write(str(data).encode('utf-8')+b"\n")
                        time.sleep(1)
 
 
        else:
                print ("variable = 0")
 
 
if __name__ == '__main__':
        ser = serial.Serial('/dev/ttyACM0', 115200)
        while True:
                calcul_ocr1a()

et le code de l'arduino, qui ne fait que recevoir ces datas (pas de communication de retour vers le raspberry) :

Code Arduino :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
// code arduino slave sur COM6 port USB droit
// communication avec Raspberry en USB
 
#define SIGNAL1 12						          // ici on definit les sorties qui generent les signaux carres
#define SIGNAL2 10						          // ici on definit les sorties qui generent les signaux carres
#define SIGNAL3 8						            // ici on definit les sorties qui generent les signaux carres
#define SIGNAL4 6						            // ici on definit les sorties qui generent les signaux carres
 
unsigned char prescaler = 0b00001101;   // variable d'ajustement du prescaler en fonction de la valeur de frequence
int valeur = 2420;                    // frequenceInt 
 
void setup () {
  Serial.begin(115200);
  pinMode (SIGNAL1, OUTPUT);
  pinMode (SIGNAL2, OUTPUT);
  pinMode (SIGNAL3, OUTPUT);
  pinMode (SIGNAL4, OUTPUT);  
 
  // ============================================================================
  // Paramétrage du timer1, pour qu'il déclenche une interruption, à chaque fois que sa valeur sera égale à celle qu'on aura indiqué dans  OCR1A  
  // ============================================================================
  noInterrupts();                 // On désactive les interruptions, pour commencer
  TCCR1A = 0b00000000;            
  //TCCR1B = 0b00001001;            // TCCR1B = 0b00001001 pour desactiver prescaler  et  TCCR1B = 0b00001101 pour prescaler = 1024
  TIMSK1 = 0b00000010;
 
  bitSet(TIMSK1, OCIE1A);         // On met le bit OCIE1A à 1 (contenu dans le registre TIMSK1)
 
  // Enfin, on met le compteur à zéro, on entre la valeur déclenchant l'interruptionet on réactive les interruptions
  TCNT1 = 0;            // Mise du timer1 à zéro
  interrupts();         // Et, on ré-active les interruptions
}
 
 
// ======================
// Routine d'interruption
// ======================
ISR(TIMER1_COMPA_vect) {
  digitalWrite (SIGNAL1, !digitalRead(SIGNAL1));
  digitalWrite (SIGNAL2, !digitalRead(SIGNAL2));
  digitalWrite (SIGNAL3, !digitalRead(SIGNAL3));
  digitalWrite (SIGNAL4, !digitalRead(SIGNAL4));  
  TCCR1B = prescaler;
  OCR1A = valeur;			// mise à jour de la valeur OCR1A en fonction de la valeur envoyée par arduino 
 
}
 
// =================
// Boucle principale
// =================
void loop () 
{
  //while (!Serial.available());                         // ici on regarde si qqechose vient de l USB
  valeur = Serial.readStringUntil('\n').toInt();
  if (valeur<2430) {
    prescaler = 0b00001101;
    }
  else {
    prescaler = 0b00001001;
    }
}

[erwannoo]

J'ai donc recodé le programme python du raspberry en supprimant la fonction, en gardant la relecture de la valeur de l'arduin mais j'ai supprimé le .rstrip de la ligne.
Maintenant ça fonctionne plutôt bien, même avec un rafraichissement de 0,05 s.

Je n'ai pas très bien compris pourquoi ça plantait. Si quelqu'un peut m'éclairer sur le sujet, merci.
J'ai regardé la methode rstrip, ok, mais est-ce que cela peut expliquer la latence ??