Projet CanBus Sheild avec entrées analogiques

[bauvaisis]

Bonjour a tous,

Je suis plutôt novice dans l'utilisation arduino mais on s'y fait assez rapidement , il me manque cependant beaucoup d'infos malgré mes recherches et lectures de tutos / cours.

Je vous présente mon projet : J'ai un arduino uno avec module can sheild. J'ai un montage de voiture sur table (compteur, pédale accélérateur etc) . Mon but premier étant d’émettre des trames CAN afin de réveiller le compteur et l'allumer sur table. J'ai réussi cette première étape , grâce à 2 trames. Ensuite je cherche à commander les aiguilles du compteur directement à l'aide de trames supplémentaires. J'ai réussi à contrôler l'aiguille RPM parfaitement avec des trames "statiques" donc telle valeur en entrée = valeur affiché.

La dernière étape où je bloque c'est que j'aimerais maintenant rajouter une entrée analogique qui corresponds à la pédale accélérateur (qui est ni plus ni moins qu'un potentiomètre à 2 pistes dissociés qui fonctionnent en meme temps : channel A et B) . J'ai utilisé la sortie 5 V et ground du can shield afin d'alimenter la pédale et la sortie variable connecté en A0 .

J'aimerais un coup de main sur l'écriture du programme afin de faire varier mon aiguille de RPM en fonction de la position de la pédale !

Les valeurs de ma pédale dans le data vont de 0x00 0x00 = 0RPM jusqu'à 0x00 0x7D = valeur MAXI

et lorsque j'alimente ma pédale en 5V j'ai pour 0% d'appui une sortie A0 = 0.755V et 100% appui A0= 3,885V

Donc en gros j'ai besoin d'un coup de main pour envoyer une trame avec mon data contenant 0x00 0x00 lorsque j'ai A0=0.755V et des valeurs linéaires proportionnelles jusqu'à la valeur maxi 0x00 0x7D lorsque A0 atteint 3,885V !

si quelqu'un a une idée ou un conseil à me donner je suis preneur

merci beaucoup pour votre aide et votre temps

bonne journée !

[hbachetti]

Utilise la fonction map().

0.755V : l'ADC devrait mesurer 1023÷5×0,775 = 158
3.885V : l'ADC devrait mesurer 1023÷5×0,775 = 794

int adc = analogRead(A0);
int valeur = map(adc, 158, 794, 0, 0x7D);

[bauvaisis]

Waouw génial merci beaucoup hbachetti ! J'essaye celà ce weekend ! Je tiendrai informé si ca a bien fonctionné

Merci encore !

[bauvaisis]

bonjour a tous,

je reviens aux nouvelles ! J'ai effectué mon montage sur table, alors je suis arrivé à obtenir une infime variation de l'aiguille grace au mouvement de la pédale, je ne suis pas loin du but mais il me manque une "commande" ou une "fonction"

En gros pour expliquer au complet : La valeur du RPM (8000 par exemple) est multiplié par 4 = 32000 ensuite converti en HEXA : 7D00

il faut que j'inverse les bytes pour obtenir 00 7D dans ma trame finale CAN.

J'ai tenté de swaper la position des 2 bytes comme cela mais je n'arrive pas à faire fonctionner cette trame ... si quelqu'un a une idée

merci d'avance

void loop() 



{
 

int adc = analogRead(A0);
int RPM = map(adc, 225, 838, 0, 8000);
int RPM4 = RPM * 4;
int RPMhex = Serial.print(RPM4, HEX);

int DataByte[1] = {RPMhex};
int DataParts[1] = {DataByte[1] >> 8};
int DataParts[2] = {DataByte[1] & 0xff};

 // send data:  id = 0x00, standrad frame, data len = 8, stmp: data buf
 
unsigned char msg1[4] = {0x07, 0x87, 0x00, 0x80};
unsigned char msg2[4] = {0xC1, 0x05, 0x07, 0x00};
unsigned char msg3[8] = {0x09, 0x22, DataParts[1], DataParts[2], 0x22, 0x00, 0x22, 0x22};



 CAN.sendMsgBuf(0x2C5, 0, 4, msg1);
 delay(16);                       // send data per 16ms

 CAN.sendMsgBuf(0x3C0, 0, 4, msg2);
 delay(32);                       // send data per 32ms

 CAN.sendMsgBuf(0x280, 0, 8, msg3);
 delay(10);                       // send data per 10ms

}


// END FILE

[hbachetti]

int RPMhex = Serial.print(RPM4, HEX);

NON.
Serial.print retourne le nombre d'octets écrits sur la ligne série.

Et un tableau commence à ZÉRO.

void setup()
{
  Serial.begin(115200);
  unsigned rpm4 = 32980;
  Serial.println(rpm4, HEX);
  byte data[2];
  data[0] = rpm4 & 0xff;
  data[1] = rpm4 >> 8;
  Serial.println(data[0] , HEX);
  Serial.println(data[1] , HEX);
}

void loop()
{
}

[bauvaisis]

Salut

Super , je comprends mieux ! merci pour le méga coup de pouce rapide Je vais tester celà tout de suite

[bauvaisis]

Bon y'a du mieux mais c'est pas encore ca! l'aiguille bouge sur une bonne moitié de plage puis revient à 0.

j'ai essayé de repartir à 0 comme tu m'a conseillé avec ceci :

void loop()
{

  int adc = analogRead(A0);
  int RPM = map(adc, 225, 838, 0, 8000);
  int RPM4 = RPM * 4;
  Serial.println(RPM4, HEX);
  
  byte data[2];
  data[0] = RPM4 & 0xff;
  data[1] = RPM4 >> 8;
  
  
unsigned char msg1[4] = {0x07, 0x87, 0x00, 0x80};
unsigned char msg2[4] = {0xC1, 0x05, 0x07, 0x00};
unsigned char msg3[8] = {0x09, 0x22, data[1], data[0], 0x22, 0x00, 0x22, 0x22};



  CAN.sendMsgBuf(0x2C5, 0, 4, msg1);
  delay(16);                       // send data per 16ms

  CAN.sendMsgBuf(0x3C0, 0, 4, msg2);
  delay(32);                       // send data per 32ms

  CAN.sendMsgBuf(0x280, 0, 8, msg3);
  delay(10);                       // send data per 10ms

}

Le soucis c'est que je ne savais pas comment utiliser les valeurs data[0] et data[1] donc j'ai du tout placer dans void loop, car sinon il ne connaissait pas les valeurs
...

Je vais essayer d'autres idées en attendant

merci !

[hbachetti]

Pour l'instant tu envoies poids fort en premier puis poids faible.

Savoir si c'est ce qu'il faut faire, à toi de le savoir.

[bauvaisis]

Dans ma trame CAN il faut que le poids fort viennent après le poids faible.

Exemple pour les 8000RPM x 4 = 32000 (décimale) = 7D00 (HEX) . Je dois envoyer 00 sur le 3eme BYTE de ma trame et 7D sur me 4eme BYTE.

Je pense avoir mal interprété le code : data[1] = rpm4 >> 8;

C'est donc lui le poids fort car il déplace la lecture de 8 bits (1byte) afin d'afficher le poids fort si je comprends bien?

Je test après en inversant data[0] et data[1]

merci

EDIT : J'ai bien inversé les positions DATA 1 et 0 mais cela ne fonctionne toujours pas correctement

J'ai repris mes branchements et mesures et une chose que j'ai oublié de prendre en compte c'est que la résistance variable de la pédale est inversée (valeur maxi résistance = pédale au repos = RPM 0) et le contraire lorsque la pédale est appuyé.

Alors que dans la fonction map , il considère que la petite valeur résistance => afficher 0 RPM.

Donc la j'ai bel et bien 8000 RPM affiché au repos avec ce code. C'est un bon début. Il manque juste une "inversion" vers le début de script proche de la ligne lecture Analog A0.

Ca va le faire

[hbachetti]

C'est donc lui le poids fort car il déplace la lecture de 8 bits (1byte) afin d'afficher le poids fort si je comprends bien?

Oui.

Effectivement ça va le faire.

[bauvaisis]

Petit retour, tout fonctionne parfaitement maintenant !!! c'est génial !!

J'ai du inverser la disposition des donnés dans la fonction map afin de prendre en compte "l'inversion" de résistance suivant le mouvement.

Un grand grand merci a toi pour ton aide précieuse hbachetti

[hbachetti]

Bonne suite

[bauvaisis]

C'est gentil, a toi aussi