Générateur/testeur 4-20ma utilisant Arduino : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Des générateurs 4-20 mA sont disponibles sur ebay, mais pour ma part, j'adore la partie bricolage des choses et l'utilisation de pièces que j'ai autour.

Je voulais tester les entrées analogiques de notre automate pour vérifier nos lectures scada et tester la sortie des instruments 4-20mA. Il existe de nombreux convertisseurs courant-tension et tension-courant pour arduino sur ebay, ils nécessitent cependant un étalonnage. Je peux l'utiliser pour calibrer n'importe lequel de ces convertisseurs trouvés sur ebay et autres.

J'ai décidé de bricoler un générateur et un testeur. À ce stade, il s'agit encore d'un travail en cours et d'un prototype.

J'avais un vieux système audio 2.1 qui n'était pas utilisé (petites enceintes). J'ai donc utilisé l'une des enceintes comme enceinte. J'ai également eu un amplificateur qui est mort à cause de la foudre, j'ai retiré la borne d'enceinte de cet amplificateur pour faciliter la connexion. J'ai l'intention de faire un PCB à l'avenir et un meilleur boîtier.

Fournitures:

Liste des pièces.

LCD // 20x4 (adapter le code si le votre est plus petit)

LM7808 // régulateur 8 volts

LED // Tout type ou taille

Résistance pour LED // Convient pour le type LED et 8volt

Résistance 100 ohms + résistance 47 ohms en série // Sera utilisé comme résistance shunt

Résistance 10K // Arduino analogique en protection contre la haute tension

Résistance 22K // Pour empêcher A0 de flotter

Trimpot 100 ohm + résistance 47 ohm en série // Simulateur PT100

Condensateur 35 volts // J'ai utilisé 470 uF, juste pour réduire les fluctuations de la tension d'alimentation

RTD (transducteur PT100) //La portée n'a pas d'importance (plage)

DIODE (pour la protection de polarité)

INA219

Arduino

Étape 1:

Suivre le schéma devrait vous aider à savoir où ajouter les pièces et les câbler.

Le LM7808 permet une entrée maximale de 25 volts, ce qui est bien pour les systèmes PLC, ils utilisent généralement des alimentations de 24 volts. Ajoutez un dissipateur thermique au régulateur et ne l'utilisez pas pendant de longues périodes. Une chute de 16 volts fait que le régulateur génère beaucoup de chaleur.

L'alimentation d'entrée alimente le régulateur et se connecte au VIN INA219, dans cette configuration, l'INA219 sera également capable de mesurer la tension d'alimentation correcte moins la chute de tension de la diode. Vous devez mesurer la chute de tension de votre diode et l'ajouter au code afin d'obtenir la lecture correcte de la tension d'alimentation.

De l'INA219 VOUT au RTD+ alimente le RTD. RTD- à la terre complète le circuit.

Pour tester une carte analogique PLC, vous devez connecter RTD- à l'entrée de la carte analogique et la masse de la carte à la masse arduino. (Assurez-vous de déconnecter tout instrument connecté au canal testé).

R5 et LED1, indiquant que le système est sous tension.

Le régulateur alimente le VIN arduino (arduino a un régulateur intégré à 5 volts).

La broche Arduino 5V va à INA219 pour alimenter la puce intégrée. INA219 GND à la masse arduino.

Trim pot wiper à RTD PIN1 et Trim pot pin 3 à RTD pin 2 simulera une connexion PT100. (Échangez les fils si tourner le potentiomètre dans le sens des aiguilles d'une montre n'augmente pas le mA).

Étape 2: Test de sortie de l'instrument

Pour tester la sortie de l'instrument, des pièces supplémentaires sont nécessaires, comme une résistance shunt. Les résistances normales de 0,25 W feront parfaitement l'affaire. Vous pouvez laisser la résistance shunt et ajouter un deuxième INA219 pour tester la sortie de l'instrument. Il ne m'en restait plus qu'un donc j'ai utilisé une résistance à la place.

Les tests à l'aide d'un shunt ne peuvent être effectués que sur le côté négatif de l'appareil. Si vous utilisez le côté positif, vous alimenterez votre arduino avec plus de 4 fois la tension autorisée et laisserez la fumée s'échapper.

Ajoutez la résistance shunt en série avec le fil négatif de l'instrument. Le côté du shunt le plus proche de l'appareil deviendra l'analogue positif pour arduino. L'autre côté du shunt le plus proche de l'alimentation deviendra la masse arduino complétant le circuit d'entrée analogique.

La résistance shunt de 150 ohms est le maximum absolu qui doit être utilisé lors de l'utilisation d'un arduino. La résistance a une chute de tension linéaire au mA qui la traverse. Plus le mA est élevé, plus la tension est élevée.

Au courant de 20mA # 150ohm * 0,02A = 3 volts vers arduino.

Au courant de 4mA # 150ohm * 0,004A = 0,6 volt vers arduino.

Maintenant, vous voudrez peut-être que la tension soit plus proche de 5 volts afin que vous puissiez utiliser toute la gamme ADC de l'arduino. (Pas une bonne idée).

Les RTD peuvent atteindre une sortie de 30,2 mA (le mien le fait). 150ohm * 0,03A = 4,8 volts. C'est aussi proche que je voudrais l'être.

Un autre site Web a indiqué d'utiliser une résistance de 250 ohms.

Au courant de 20mA # 250ohm * 0,02A = 5 volts vers arduino.

Au courant de 30mA # 250ohm * 0,03A = 7,5 volts vers arduino.

Vous risquez de brûler votre ADC et votre arduino.

Pour tester un instrument sur le terrain, prenez une batterie de 12 volts avec vous et connectez-la à l'entrée d'alimentation. L'utilisation d'une source d'alimentation externe n'influencera pas la configuration actuelle de l'API.

Pour tester une carte d'entrée analogique sur le terrain, emportez avec vous une batterie de 12 volts. Débrancher l'instrument + du circuit. Connectez la terre à la terre de l'instrument et le RTD- au fil de l'instrument déconnecté.

Étape 3: Étalonnage

Pour calibrer la lecture de votre résistance shunt, câblez RTD- à l'entrée analogique du shunt. Réglez votre potentiomètre de sorte que le mA généré soit de 4 mA. Si le mA de votre appareil n'est pas égal, modifiez la première valeur du code à la ligne 84. L'augmentation de cette valeur réduira la lecture du mA.

Ensuite, réglez votre potentiomètre pour générer 20mA. Si le mA de votre appareil n'est pas égal, modifiez la deuxième valeur dans le code à la ligne 84.

Donc votre 4-20mA deviendra maintenant 0,6-3volts (théorique). Portée plus que suffisante. En utilisant la bibliothèque d'eRCaGuy, le suréchantillonnage vous donnera une lecture meilleure et stable.

J'espère que vous lisez ceci. Il s'agit de mon premier instructable, alors s'il vous plaît allez-y doucement si j'ai fait une erreur quelque part ou omis quelque chose.

Ce projet n'est probablement pas la meilleure façon de s'y prendre, mais cela fonctionne pour moi et c'était amusant de le faire.

Quelques idées que j'ai en plus…

Ajoutez un servo pour faire pivoter le potentiomètre à l'intérieur de la boîte.

Ajoutez des boutons poussoirs pour faire pivoter le servo vers la gauche ou la droite.

Ajoutez un capteur de température numérique au dissipateur thermique du régulateur pour avertir d'une chaleur dangereuse.

Étape 4: Programmation Arduino

#comprendre

// #include // Décommentez si vous utilisez un LCD avec un registre à décalage.

#comprendre

#comprendre

#comprendre

#comprendre

//A4 = (SDA)

//A5 = (SCL)

Adafruit_INA219 ina219;

LiquidCrystal LCD (12, 11, 5, 4, 3, 2);

// LiquidCrystal_SR lcd(3, 4, 2); // Décommentez si vous utilisez un LCD avec un registre à décalage.

// | | |_ Goupille de verrouillage

// | \_ Pin d'horloge

// \_ Données/Activer la broche

octet bitsOfResolution = 12; //résolution suréchantillonnée commandée

numSamplesToAvg long non signé = 20; //nombre d'échantillons À LA RÉSOLUTION SURÉCHANTILLONNÉE que vous souhaitez prendre et moyenne

ADC_prescaler_t ADCSpeed = ADC_DEFAULT;

long précédentMillis non signé = 0;

tension de dérivation flottante = 0,0; //Depuis INA219

tension de bus flottante = 0,0; //Depuis INA219

courant_mA flottant = 0,0; //Depuis INA219

tension de charge flottante = 0,0; //Depuis INA219

arduinotension flottante = 0,0; //Calcul de tension à partir de la broche A0

A0analogReading long non signé = 0;

octet analogIn = A0;

float ma_mapped = 0.0; //Tension de carte de A0 à 4-20mA

void setup() {

adc.setADCSpeed(ADCSpeed);

adc.setBitsOfResolution(bitsOfResolution);

adc.setNumSamplesToAvg(numSamplesToAvg);

uint32_t currentFrequency;

ina219.begin();

ina219.setCalibration_32V_30mA(); //Bibliothèque modifiée pour plus de précision sur mA

lcd.begin (20, 4); // initialise l'écran LCD

lcd.clear();

lcd.home (); // rentrer chez soi

lcd.print("************************");

retard (2000);

lcd.clear();

}

boucle vide()

{

non signé long currentMillis = millis();

const intervalle long = 100;

//&&&&&&&&&&&&&&&&&

Lisez les appareils I2C à intervalles et faites quelques calculs

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

if (currentMillis - previousMillis >= intervalle) {

previousMillis = currentMillis;

Intervalle();

}

Print_To_LCD(); // Je n'ai probablement pas besoin de mettre à jour l'écran LCD aussi rapidement et je peux le déplacer en dessous d'Interval()

}

annuler

Intervalle() {

shuntvoltage = ina219.getShuntVoltage_mV();

busvoltage = ina219.getBusVoltage_V();

current_mA = ina219.getCurrent_mA();

tension de charge = (tension de bus + (tension de dérivation / 1000)) + 0,71; // +0.71 est ma chute de tension de diode

A0analogReading = adc.newAnalogRead(analogIn);

arduinovoltage = (5.0 * A0analogReading); //Calculé en mV

ma_mapped = map(arduinovoltage, 752, 8459, 30, 220) / 10,0; //La carte ne peut pas utiliser de flottants. Ajoutez un 0 derrière la valeur mappée et divisez par 10 pour obtenir une lecture flottante.

// La cartographie à partir du calcul de la tension donne une lecture plus stable que l'utilisation de la lecture ADC brute.

if (shuntvoltage >= -0,10 && shuntvoltage <= -0,01) //Avec aucune charge, l'INA219 a tendance à lire en dessous de -0,01, bien le mien le fait.

{

courant_mA = 0;

tension de bus = 0;

tension de charge = 0;

tension de dérivation = 0;

}

}

annuler

Print_To_LCD() {

lcd.setCursor(0, 0);

if (ma_mapped < 1,25) { // Sans courant, c'est ma lecture en mA, donc je la jette.

lcd.print("* Générateur 4-20mA *");

}

autre {

lcd.print("** Testeur analogique **");

}

lcd.setCursor(0, 1);

lcd.print("Périphérique:");

lcd.setCursor (10, 1);

si (ma_mappé < 1,25) {

lcd.print("pas de périphérique ");

}

autre {

lcd.print(ma_mapped);

}

lcd.print("mA ");

lcd.setCursor(0, 2);

lcd.print("Générer:");

lcd.setCursor(10, 2);

lcd.print(current_mA);

lcd.print("mA ");

lcd.setCursor(0, 3);

lcd.print("Fourniture:");

lcd.setCursor (10, 3);

lcd.print (tension de charge);

lcd.print("V ");

}

Étape 5: Quelques photos supplémentaires

Borne de haut-parleur d'amplificateur. LED pilotée par le générateur de courant (RTD). Le câblage de la carte analogique remplacera la LED.

La borne à l'extrême gauche est pour l'entrée d'alimentation. Les bornes sur la droite sont pour l'entrée de l'instrument.

Étape 6: s'adapter

Tout semble correspondre. J'ai utilisé du silicone pour maintenir temporairement certaines choses ensemble. Le pot de garniture est siliconé en haut à droite. Un petit trou a été pré-percé. Je peux régler le courant par le haut de la boîte.

Étape 7: Juste des photos

Étape 8: Derniers mots

J'ai testé la sortie de cet appareil avec un automate Allan Bradley. Les résultats étaient très bons. J'ai une gamme complète. J'ai également testé cet appareil avec un capteur de pression 4-20 mA doté d'un écran LCD intégré. Encore une fois, les résultats étaient très bons. Mes lectures étaient décalées de quelques décimales.

J'écris mon code arduino dans des onglets. Dans les automates, elles sont appelées sous-routines. Facilite le débogage pour my.

Ci-joint les fichiers texte de ces onglets.