Code Arduino DUE

[Tfou57]

Merci de ta réponse , je suis tes conseils et je repart donc du code INO X-PID de Sirnoname

En n’utilisant pas le plugin X-PID de X-SIM, comment met-on au point le PID ?
A l’aveugle, sans une comparaison visuel de la consigne et du réalisé ?

Ai-je bien compris ?: :?:
- Sans EEPROM, pas de possibilité de tracer la courbe du plugin X-PID d’X-Sim
- Sans EEPROM, la seule possibilité de faire reconnaitre la carte Arduino Due est par l’USO
- « fonction SendFirmwareVersion » sert à la détection du plugin X-PID
- « fonction SendFirmwareVersion » ne sert pas à la détection par USO

Pour adapter « fonction SendFirmwareVersion » , il faut tromper le Plugin Dll d’X-Sim en lui faisant croire que une carte Arduino Uno est branchée ?
Où trouve-t-on le « FirmwareVersion » des cartes ? (après une recherche durant cet matinée , je n’ai pas trouvé de piste de départ)

Mon premier but est de faire reconnaitre la carte Due par X-Sim
1)a) Je pense donc dans un premier temps dé greffer du code X-SIM de Sirnoname les parties se référant à l’EEPROM
Pour supprimer l’usage de l’EEPROM du code de X-PID de Sirnoname, il suffit de mettre // devant chaque ligne se référant à l’EEPROM
(pour passer les commandes en commentaires) ou Est-ce plus subtile ?

1)b) Je dois donc définir dans le code Arduino de la Due, tous les paramètres normalement saisis dans la page de configuration du plugin X-PID.

1)c) adapter « fonction SendFirmwareVersion » , mais comment ?

Les opérations 1)a), b) et c) suffit-elles pour la reconnaissance de la carte Arduino Due par X-PID d' X-Sim ?

2) Par la suite, quand ma connaissance du code Arduino aura évoluée, je pense reprendre ces lignes pour les adapter pour utiliser la
mémoire Flash ou SRAM

Avec l’EEPROM , si j’ai bien compris, c’est la page de configuration du plugin X-PID qui envoie à Arduino Uno des paramètres saisis dans X-Sim afin de modifier les réactions du PID ….

[Wanegain]

tu as mal compris

L'EEPRom sert à sauvegarder les infos.

X-Sim va envoyer une commande à l'Arduino et l'Arduino doit interpréter la commande en envoyant une réponse. C'est comme ça que l'Arduino est reconnue par le plugin dans X-Sim. Autrement dit, même un microcontrôleur non Arduino peut être reconnue pas X-Sim. Vérifie que dans Interface Settings tu as bien coché (uniquement) USB XPID. Normalement si c'est bien reconnu tu devrais voir apparaitre 2 interfaces de sortie.

Pour calibrer un PID, le meilleure solution c'est d'utiliser une courbe (passer par le plugin USB XPID) sinon tu fais à vue de nez... Si tu n'as pas l'EEPRom pour sauvegarder les valeurs, tu peux toujours les noter quelque part et les mettre dans le code car les valeurs qui sont dans le code avant d'être sauvegardées une première fois dans l'EEPRom sont les valeurs par défaut.

Le gros avantage d'utiliser le plugin USB XPID par rapport à l'USO, c'est que l'Arduino communique avec X-Sim ! Ce qui veut dire que tu peux visualiser des données dans X-Sim et ainsi faire une analyse et des réglages bien plus précis que par l'USO où tu ne vois rien (à part ajouter un écran LCD - qu'il faut coder).

Vérifie dans la fonction void setup() que tu as bien Serial.begin(9600); sans les // devant !

[Tfou57]

Merci de ta patience,
Je suis un peu long à comprendre …

Dans 2 de tes posts réponses, tu me dis :
« Pour que l'arduino soit reconnue par X-Sim il faut qu'il donne sa version lorsque X-Sim la lui demande (fonction SendFirmwareVersion) »
« Autrement dit, même un microcontrôleur non Arduino peut être reconnue pas X-Sim ».
Si un microcontrôleur non Arduino peut être reconnu pas X-Sim, alors le FirmewareVersion ne définit pas le FirmeWare de l’Arduino Due, que défini-il ?
Où trouve-t-on le « FirmwareVersion » des cartes ? ( je n’ai toujours pas trouvé de piste)

Le dialogue entre X-Sim et Arduino et Arduino est dans le « void setup() » ?

Sans EEPROM, X-PID peut tracer donc la courbe position consigne / position réalisée, seule la saisie des paramètres ne peut pas être saisie dans la fenêtre de configuration et je dois les définir directement dans le code de l’Arduino Due

Je commence à modifier le code X-PID de Sirnoname :
- Pour mettre en commentaire toutes les zones concernant l’EEPROM
- Définition des paramètres X-PID directement en dur par le code INO
- Adaptation de I/O de l’Arduino Uno par ceux de l’Arduino Due

[Wanegain]

C'est une fonction écrite dans le code de Sirnoname qui envoie la version c'est pour ça que tu ne trouveras rien et surtout que tous les microcontrôleurs sont compatibles

Code: Select all

void SendFirmwareVersion()
{
   Serial.write('X');
   Serial.write('-');
   Serial.write('P');
   Serial.write('I');
   Serial.write('D');
   Serial.write(' ');
   Serial.write(48+firmaware_version_mayor);
   Serial.write('.');
   Serial.write(48+firmware_version_minor);
}


[Tfou57]

Merci pour toutes ces informations de base

Maintenant à moi de me former au code Arduino et de bosser un peu !

[Wanegain]

Pas de soucis !

Je pense que tu trouveras quand même plus d'infos sur le forum RFR qu'ici (surtout en français )

[Tfou57]

Bonjour,
Depuis que j’ai les Arduino Due , je suis plusieurs de tes posts :
- [TUTO]Arduino + Sabertooth + X-Sim, Pour ceux qui hésitent...
- Un autre très similaire au niveau du titre, que je ne citerais pas car il traite d'Arduino avec un autre logiciel ! ……
- Programmation Arduino

J’abuse, il me vient encore quelques questions

En entête de son code X-PID INO Sirnoname met en commentaire
“X-Sim PID ……….Target is a Arduino UNO R3 but should work on all Arduino with Atmel 328, Arduinos with an FTDI serial chip need a change to lower baudrates of 57600”

1) Qu’est-ce qui différencie dans le code INO Arduino with Atmel 328 et le code processeur de la Due qui est un ATMEL AT91SAM3X8E à part les I /O propres à chaque cartes ?
Y-a-t-il quelque part dans X-PID.DLL une reconnaissance d'un Atmel 328. Si cela est le cas , comment faire l'adaptation ?


Je ne comprends pas des synthases du protocole d'entrée de commande présent en début du code INO de X-PID de Sirnoname
Command input protocol (always 5 bytes, beginning with 'X' character and ends with a XOR checksum)
Protocole d'entrée de commande (toujours 5 octets, commençant par « X » de caractère et se termine par une somme de contrôle XOR)
Exemple :
'X' 8 H L C Set motor 2 D Derivative value to High and Low value
'X' 200 0 0 C Send back over serial port both analogue feedback raw values

'X' : Toujours 'X'
8 H L ou 200 0 0 = 5 octets ? , ils correspondent à quoi ?
C = Toujours C pour somme de contrôle XOR ( je suppose !)

2) Puis-je avoir une petite piste de tutorial à ce propos….? Pour comprendre leurs significations ?

[Wanegain]

Je n'ai pas regardé X-pid.dll et je ne pense pas qu'il détecte le processeur. Comme je te l'ai dit, il vérifie le code qui est dans l'Arduino en envoyant une commande à l'Arduino et si l'Arduino répond avec le bon numéro de version, alors il créé automatiquement 2 sorties.

Pour le protocole d'entrée :

le plugin commences toujours par envoyer un 'X' qui va se traduire par un début de commande :
Je vais t'expliquer la fonction SerialWorker qui lit les données venant du PC :

void SerialWorker()
{
while(Serial.available()) tant que des données du PC sont disponibles
{
if(buffercount==-1) si buffercount = -1
{
buffer = Serial.read(); Lecture des données venant du PC, caractère par caractère (8bits)
if(buffer != 'X'){buffercount=-1;}else{buffercount=0;} Si mon caractère est un X, alors buffercount = 0 sinon buffercount = -1
}
else Cas où buffercount est différent de -1
{
buffer = Serial.read(); on lit le prochain caractère
commandbuffer[buffercount]=buffer; on le sauvegarde dans la liste commandbuffer
buffercount++; on incrémente de 1 buffercount
if(buffercount > 3) si buffercount > 3 qui veut dire que l'on a toutes les données de la commande (4 octets)
{
if(CheckChecksum()==true){ParseCommand();}else{errorcount++;} le dernier caractère (C) envoyé est un checksum (XOR), on vérifie que les données ne sont pas erronées et si c'est le cas on lance la fonction ParseCommand qui va interpréter les infos, sinon on supprime la commande
buffercount=-1;on remet buffercount à -1 pour la prochaine commande
}
}
}
}

Pour ce qui est des 5 octets de la commande, si après le 'X', tu as 1 (par exemple), alors tu envois la commande du moteur 1. H et L sont les données envoyées sur 2 octets (valeur haute et valeur basse) mais ramenées à 10bits pour correspondre aux valeurs mesurées sur les potentiomètres...

Je ne sais pas si j'ai été clair...

Pour bien comprendre un code Arduino, il faut toujours commencer par la fonction void loop() qui est la fonction principale. A partir de là tu suis les fonctions (qui renvoient souvent à d'autres fonctions...), tu devrais mieux comprendre par la suite !

[Tfou57]

Merci de ta réponse et des annotations lignes par ligne et du temps passé à me répondre.

MERCI pour ton conseil
« Pour bien comprendre un code Arduino, il faut toujours commencer par la fonction void loop() qui est la fonction principale. A partir de là tu suis les fonctions (qui renvoient souvent à d'autres fonctions...) »
Je n’avais pas ce reflexe , ce B.A. - BA du déchiffrage d’un code Arduino .
C'est vrai en procédant ainsi le déchiffrage est plus aisé !

Je suis preneur de toutes les astuces de base afin de prendre les bonnes habitudes.
Actuellement , je zappe de tutoriel en forum Arduino pour essayer de comprendre tronçon de code par tronçon.

Tu baignes et tu domines la programmation, je n’ai pas tes connaissance en programmation
Pour ma part tout est nouveau , novice dans ce domaine, c’est vraiment un case tête de comprendre !
Cela prend du temps , je ne suis pas pressé , c'est tellement enrichissant !

Cela commençais bien, je confondais bits et octets, j’ai tout à apprendre !
« Pour ce qui est des 5 octets de la commande, si après le 'X', tu as 1 (par exemple), alors tu envoies la commande du moteur 1.
H et L sont les données envoyées sur 2 octets (valeur haute et valeur basse) »
Valeur haute = « H » ? = 1 mot de 8bits ?
Valeur basse = « L » ? = 1 mot de 8 bits ?

Il va me falloir vraiment beaucoup de temps pour comprendre et adapter le code X-Pid de Sirnoname.

[Wanegain]

Effectivement le code n'est pas le plus simple pour commencer, surtout qu'il y a des techniques très spéciales pour gagner en performances...

Pour débuter, le mieux c'est de comprendre les exemples fournis avec le logiciel...

H et L sont des mots de 8 bits. En fait tu es limité à 8 bits par la communication série. Pour obtenir un mot de 10 bits il faut donc l'envoyer en 2 parties H (high) et L (low).