Commande d'une électrovanne danfoss PVEO

Bonjour,

Suite à mon précédent Post ou je récupère la position d'un joystick, Je voudrais utiliser cette valeur pour contrôler une électrovanne Danfoss PVEO.

D'après la documentation, l'électrovanne devrait être pilotable en PWM. Hors, je n'y arrive pas

J'utilise un MOSFET canal N, pour faire un signal PWM 12V, la tension moyenne équivaut à la tension analogique du joystick d'origine (tension analogique), mais l'électrovanne ne réagit pas.

Le joystick d'origine me fournit les tensiiosn suivante:
Neutre: 1/2 VIN (12 à 14V)
Dans une direction: de 1/2 VIN à VIN
Dans l'autre direction: de 1/2 VIN à 0V

L'intensité mesurée varie de 0.01 mA à -0.01 mA, donc vraiment faible.

J'essaye de faire un schéma de mon montage dès que possible.

D'avance, merci pour votre aide.

dans la doc ils disent aussi

The standard PVE, PVEA/M/H/S, can also be controlled by a pulse with modulated PWM signal

vous dites que vous avez une PVEO. supporte-t-elle le PWM?

sinon si vous avez un modèle compatible, ils disent aussi

Recommended PWM frequency for PVE
PVE type                 PWM frequency
PVEM                   [color=red]> 200 Hz[/color]
PVEA/H/S/U             [color=red]> 1 kHz[/color]

Vous avez regardé la fréquence en PWM de votre Arduino pour prendre une PIN adéquate en cas de PVEA/H/S/U?

Bonjour,

Il s'agit d'une PVEM et non d'une PVEO.

Je voudrais contrôler 3 électrovanne PVEM et 2 PVEO.
Les PVEO qui sont ON/OFF ne me posent pas de problème.

j'utilise la pin3 de l'arduino pour contrôler mon MOSFET (schéma ci dessous).
J'ai de gros doute quand à mon branchement, c'est mon premier montage de ce type.

Schéma.jpg

Pour info la fréquence que j'utilise est de 500 Hz, mesurée à l'oscilloscope, cela me semble être la fréquence standard de l'arduino.

Absolument.
Cela va t-il convenir à l'électrovanne ?

Selon la documentation, 200 Hz est la valeur minimale recommandée.

Le branchement vous semble t-il correcte?

J'ai remplacé le MOSFET par un 2N2222, cela ne change rien.

Peut être un MOSFET canal P? Une astuce pour le commander depuis une sortie PWM 5V de l'arduino?
J'ai des IRF 9510.

Peut être un MOSFET canal P

Non. Forcément canal N.
Le canal P serait adapté en commutation HIGH-SIDE.
L'IRL520 sur ton schéma est en LOW-SIDE.

IRF9510 : surdimensionné et canal P ne convient pas.
Un 2N7000 serait plus adapté.

Pour cet utilisation un 2N2222 ira très bien, même un petit BC547, mais la résistance R1 devra être placée entre pin3 et base.
Mais je suppose que tu t'en doutes ?

Le tout est de savoir ce qu'attend l'électrovanne : amplitude, impédance.

Voici les spécification technique pour la PVEM.

Pas sûr que cela fonctionne en PWM...

Techspec PVEM.jpg

A 12V l'entrée consomme 0.25mA.
Cela donne une résistance d'entrée de R3 = 48K.

Une résistance de pull-up R2 de 1K me semble OK.

Finalement j'ai mit un filtre passe bas sur la sortie PWM suivit d'un aop, de cette façon, j'ai un signal analogique satisfaisant.

Malgré tout, j'ai encore un problème. ces électrovanne sont alimentée par une source de courant non stabilisée entre 12V et 14V.

la tension commande est toujours fonction de la tension d'alimentation:
0.5*V Alim = neutre.

Quelle est la meilleure façon d'adapter mon circuit?

J'ai pensé à utiliser un régulateur de tension pour l'alimentation des électrovanne. Serait-ce une bonne solution?

Comment est alimenté l'AOP ?

Réguler du 12V en partant de 12V à 14V sera impossible.

Quel est exactement le problème ?

L'AOP est en amplificateur non inverseur, j'utilise 1 résistance fixe et un pot pour régler la tension de sortie.

L'alimentation de l'aop est 12v - 14v (batterie) = l'alimentation des électrovanne.

le signal de commande de l'électrovanne doit être proportionnelle à la tension d'alimentation:

si valim = 14V, 7v = tension de commande au neutre
si valim = 12v, 6v = tension de commande au neutre

la tension de sortie de l'AOP est proportionnelle à la tension d'entrée de la sortie de l'arduino (de 0 à 5v)

je me suis inspiré du montage suivant, je n'ai pas mit de filtre RC en sortie de l'AOP

les électrovanne commandent un bras à vérin hydraulique sur un véhicule à moteur.

si le moteur tourne, l'alternateur charge la batterie et la tension est de 14v.
il me faut une tension de 7v pour que le bras ne bouge pas

si la tension varie en fonction de la charge de la batterie, ... ex 12,5v
avec une tension de 7v, le bras va bouger tout seul.

A l'origine, ces électrovanne se commandent simplement par un joystick à potentiomètre (principe pont diviseur de tension)

Si l'alimentation de l'AOP est prise sur la batterie, ça devrait aller non à mon avis.

Non, la tension sortie de l'AOP ne varie pas en fonction de la tension d'alimentation. Elle varie en fonction de la tension d'entrée, en tout cas, de la façon dont je l'ai branché.

Tu as fait des essais de pilotage de la vanne ?

Avec une alim de laboratoir, j'ai beau faire varier la tension d'alimentation de l'AOP, la tension de sortie reste la même.

Par contre en changeant la valeur de la sortie pwm de l'arduino, je peut la faire varier.

voici mon code:

//-------------Variable joystick-----------------

int x_axis; //Variable valeur axe X
int y_axis; // Variable Valeur axe Y
int z_axis; //Variable valeur axe Z

//-----------Variable LIN BUS------------------
const byte sync_byte = 0x55;
const byte id_joystick = 0xA8;
const byte id_poignee = 0xE9;

//-------------Configuration pin ------------------
int pin_x_axis = 3;
int pin_y_axis = 5;
int pin_z_axis = 6;



//-----------Variable pour code--------------
byte data[12];
unsigned long linbusInterval = 3000; //Durée qui sépare 2 trames
unsigned long prevByteMicros = 0; //Moment réception message précédent
unsigned long curByteMicros = 0; //Moment actuel
boolean newData = false;
const byte numBytes = 15;
byte receivedBytes[numBytes];
byte numReceived = 0;



//--------------Config Arduino------------------
void setup() {
  Serial1.begin(19200);
  Serial.begin(115200);

  pinMode(pin_x_axis, OUTPUT);
}


//----------------Calcul du Checksumm-------------------------------------------
byte checksum(const uint8_t* message, char nBytes, uint16_t sum) {
  while (nBytes-- > 0) sum += *(message++); // Fait la somme des message

  while (sum >> 8) // renvoi le premier bit éventuel vers le bit de poids faible
    sum = (sum & 255) + (sum >> 8); //Inversion et ajout du 9e bit éventuel
  return (~sum);
}

//-------------------Lecture valeurs-----------------------------------------------
void parse_frame() {
  if (newData == true) {

    if (receivedBytes[2] == id_joystick) {
      x_axis = receivedBytes[3];
      y_axis = receivedBytes[5];
    }
    else if (receivedBytes[2] == id_poignee) {
      z_axis = receivedBytes[4];
    }

    newData = false;
  }
}


//-----------------Réception trames lin ------------------------------------------------

void getlin() {


  static boolean recvInProgress = false;
  static byte ndx = 0;
  int startmarker = 0x0;
  byte rb;

  while (Serial1.available() > 0 && newData == false) {
    curByteMicros = micros();
    if (curByteMicros - prevByteMicros >= linbusInterval) {
      recvInProgress = false;
      receivedBytes[ndx] = '\0';
      numReceived = ndx;
      ndx = 0;
      newData = true;
      //Serial.print (recvInProgress);
      //Serial.println();
    }
    prevByteMicros = curByteMicros;
    rb = Serial1.read();
    recvInProgress = true;

    if (recvInProgress == true) {
      receivedBytes[ndx] = rb;
      ndx++;
      if (ndx >= numBytes) {
        ndx = numBytes - 1;
      }
    }

  }
}


//--------------------Affichage trame sur moniteur série--------------------------------------

void showNewData() {
  if (newData == true) {
    for (byte n = 0; n < numReceived; n++) {
      Serial.print (receivedBytes[n], HEX);
      Serial.print (" ");
    }
    Serial.println();

    newData = false;
    //Serial.print(newData);
  }
}


//------------------------------Génération signal PWM-----------------------------------------------
void generatePWM() {
  byte x;
  byte y;
  byte z;
  x = map(x_axis, 0, 255, 47, 174);
  y = map(y_axis, 0, 255, 64, 191);
  z = map(z_axis, 0, 255, 64, 191);
  analogWrite(pin_x_axis, x);
  analogWrite(pin_y_axis, y);
  analogWrite(pin_z_axis, z);
}


//---------------Fonction loop------------------------
void loop() {
  getlin();
  parse_frame();
  generatePWM();




}

Il faudrait que je puisse faire varier:

 x = map(x_axis, 0, 255, 47, 174);

fonctionne pour 12v (j'ai 6v au neutre)

y = map(y_axis, 0, 255, 64, 191);

fonctionne pour 14v (j'ai 7v au neutre)

Je devrais pouvoir faire varier les valeurs en fonction de la tension d'alimentation.