Contrôle de pompe de puits semi-automatique utilisant STM32 dans un environnement Arduino
De nombreux propriétaires de parcelles domestiques ont des puits d'eau sur leurs possessions, et peuvent avoir rencontré le problème d'envasement du puits / dégradation de l'eau pendant la période d'inactivité du puits de l'automne au printemps.
Il se trouve que le puits de ma région est resté inactif pendant plusieurs années, et lorsqu'il a été utilisé, très peu d'eau a été prélevée.
En essayant de le nettoyer de diverses manières, on a compris que tout n'était pas si mal et qu'il suffisait pour assurer un prélèvement d'eau stable. Pour ce faire, un appareil simple a été assemblé, composé d'une unité d'alimentation avec un adaptateur micro-usb, (il n'y a pas de chargeur de batterie du téléphone, sur la photo), une carte de pilule bleue basée sur le galet stm32f103c8t6, un module relais, un démarreur magnétique bipolaire, un interrupteur à bouton fermé conventionnel, et assemblé dans la boîte de jonction.
La carte du microcontrôleur a été préparée conformément au
manuel du HWman . Dans les commentaires, il a été demandé de préciser que STM32 peut être flashé avec un chargeur de démarrage spécial, ce qui vous permet par la suite de le programmer via USB, comme l'arduinki ordinaire.
Je programme en utilisant un
plugin dans Visual Studio Community. L'installation du plugin est primitive, il n'y aura pas de travail mental. J'ajouterai seulement que le plugin nécessite l'IDE ARDUINO installé. Je pense que les professionnels seront gênés par cette approche, mais le produit fini fonctionne de manière stable depuis plus de six mois et remplit la tâche. Et pourtant, je suis ouvert à la coopération sur des idées pour améliorer l'appareil.
Nous obtenons un environnement extrêmement pratique avec l'analyse de code, IntelliSense et ce qui est subjectivement important - un thème sombre. Pour les petits yeux.
Cousez un foulard:
Code/* Name: Nasos.ino Created: 23.02.2017 19:08:20 Author: Ksiw , () . , 10 . , , , 20 /. 99% delay() */ unsigned long Work = 2UL*60; /*2 */ // , // ... ! . const unsigned long Sleep = (unsigned long)20*60; // unsigned long TimeLeft; // int tempo = iter; // int iter = 10; // unsigned long timeNextSwich; int button = PB4; // unsigned long WorkTime, SleepTime ; // bool handOn = false; // bool flag; // int RelayPin = PB7; // unsigned long PreviousMillis = 0; unsigned long CurrentMillis = millis(); unsigned long fullTimeIteration = 4200000000; // //(long 4,294,967,295) //--------------------- void SwichFlag(); void SwichRelay(); void Button(); unsigned long SecToMillis(unsigned long); void ResidueTime(); void ResetTimeToWork(); //------------------------------------- --------------------------- void(*resetFunc) (void) = 0; //*************************************************************************** void setup() { Serial.begin(115200); flag = false; // //----------- pinMode(RelayPin, OUTPUT); pinMode(button, INPUT); digitalWrite(RelayPin, flag); Serial.println(""); WorkTime = SecToMillis(Work); SleepTime = SecToMillis(Sleep); PreviousMillis = millis(); } void loop() //************************************************************************** { while(true) { CurrentMillis = millis(); // ResetTimeToWork(); // milis() SwichFlag(); // SwichRelay(); // , ResidueTime(); // Button(); // tempo++; handOn = false; delay(100); } } //------------------------------------- ---------------------------------------------- void SwichFlag() { if(flag && CurrentMillis-PreviousMillis>=SleepTime) { PreviousMillis = CurrentMillis; flag = false; // , Serial.println("Flag On"); } else if(!flag && CurrentMillis-PreviousMillis>=WorkTime) //, , "" { PreviousMillis = CurrentMillis; flag = true; Serial.println("Flag OFF"); } } //------------------------------------- ------------------------------------------------------- void Button() { if(digitalRead(button)==HIGH) // { do { if(handOn) { delay(50); continue; } Serial.println("TURNED ON"); digitalWrite(RelayPin, LOW); // flag = true; handOn = true; delay(100); // }while (digitalRead(button)==HIGH); CurrentMillis = millis(); // PreviousMillis = CurrentMillis; // delay(20); } } //------------------------------------- --------------------------- unsigned long SecToMillis(unsigned long Temp) { return Temp*1000; } //------------------------------------- ---------------------------------------------- void ResidueTime() { if(CurrentMillis<PreviousMillis && tempo > iter) { if(flag) { TimeLeft = timeNextSwich/1000+1; Serial.print(" Time to ON: "); Serial.print(TimeLeft); Serial.print("sec"); Serial.println(""); } else { TimeLeft = timeNextSwich/1000+1; Serial.print(" Time to OFF: "); Serial.print(TimeLeft); Serial.print("sec"); Serial.println(""); } tempo = 0; } if(tempo > iter) // { if(flag) { TimeLeft = (PreviousMillis+SleepTime-CurrentMillis)/1000+1; Serial.print(" Time to ON: "); Serial.print(TimeLeft); Serial.print("sec"); Serial.println(""); } else { TimeLeft = (PreviousMillis+WorkTime-CurrentMillis)/1000+1; Serial.print(" Time to OFF: "); Serial.print(TimeLeft); Serial.print("sec"); Serial.println(""); } tempo = 0; } } //------------------------------------- milis(); void ResetTimeToWork() { while(CurrentMillis<PreviousMillis) // { if(flag) // { timeNextSwich = SleepTime-(4294967295-PreviousMillis); // while(timeNextSwich>=CurrentMillis) // { CurrentMillis = millis(); ResidueTime(); Button(); // , ResetTimeToWork()! if(CurrentMillis>PreviousMillis) return; tempo++; // ResidueTime(); } flag = false; PreviousMillis = CurrentMillis; // CurrentMillis = millis(); return; } if(!flag) { timeNextSwich = WorkTime-(4294967295-PreviousMillis); while(timeNextSwich>=CurrentMillis) // { CurrentMillis = millis(); ResidueTime(); Button(); if(CurrentMillis>PreviousMillis) return; tempo++; } flag = true; PreviousMillis = CurrentMillis; CurrentMillis = millis(); return; } } } //-------------------------------------- -------------------------------------------------- void SwichRelay() { if(!flag) { digitalWrite(RelayPin, flag); // } else { digitalWrite(RelayPin, flag); // } }
Concernant le code. Le programme a été rédigé selon plusieurs approches, modifiant dans le processus d'identification des lacunes. Cela semble assez déroutant, mais je vais essayer de clarifier.
Cela fonctionne comme suit:
0) L' architecture du programme est conçue pour interroger tout appareil externe (bouton, capteur de pression, minuterie, etc.) et définir le drapeau pour activer ou désactiver le relais, puis, à l'aide d'une fonction distincte, vérifier l'état du drapeau et le mettre dans la position appropriée.
1) Le code de programme repose sur la minuterie de la fonction millis (), la fonction ResidueTime () calcule l'heure de la prochaine commutation de relais, SwichRelay () vérifie l'état du drapeau et donne la commande de commutation, si nécessaire.
2) Le relais s'active lorsqu'un signal bas est appliqué à partir de la jambe PB7. Lorsque l'appareil est allumé, après l'initialisation du MK, le relais bascule en position ON, fournissant une tension à la bobine de démarrage, et qui à son tour fournit la tension à la pompe.
3) La durée de fonctionnement de l'appareil est de 2 minutes, après quoi il passe en mode veille pendant 20 minutes.
4) L'activation de l'interrupteur est traitée immédiatement et après la désactivation, le programme maintient un intervalle de repos de 20 minutes. Il s'agit de s'assurer que le puits réapprovisionne l'eau évacuée et d'exclure le cas de fonctionnement à sec de la pompe.
5) De plus, la fonction ResetTimeToWork () est présente dans le code, qui est déclenchée lorsque la fonction millis () déborde, ce qui
Renvoie le nombre de millisecondes depuis le début de l'exécution du programme en cours sur la carte Arduino. Ce montant est remis à zéro, en raison d'un dépassement de valeur, après environ 50 jours.
(du site Arduino.ru)
Par conséquent, afin que l'appareil ne "tombe" pas après cette période de fonctionnement continu, la fonction mentionnée a été développée pour assurer le fonctionnement stable de l'appareil sans redémarrage supplémentaire.
Nous procédons à la collecte du circuit.
Schéma d'assemblage:
Le signal de la jambe PB4 doit être pressé au sol avec une résistance de 4,7 K ohms, sinon le relais ne fonctionne pas correctement.
Dans la boîte, nous installons le dynrey pour le démarreur:
Et nous montons les pièces restantes, en fixant leur position à l'aide de morve chaude, comme sur la première photo.
Un trou pour le démarreur doit être percé dans le couvercle, il est supérieur à la profondeur de la boîte.
N'oubliez pas d'installer l'alimentation de la carte, vous pouvez la cacher à l'intérieur de la boîte, il y a encore assez d'espace dedans, ou la retirer et la brancher dans la prise la plus proche.
L'appareil fini, il ne reste plus qu'à mettre un câble 230V sur les bornes du démarreur et connecter la charge.
L'interrupteur utilisait l'ancien, il se tenait sur la pompe. À l'extérieur, il a une pollution irréparable par le ciment et d'autres abrasions, mais il a une enceinte scellée, l'intérieur est complètement intact et continuera de fonctionner correctement dans le jardin pendant longtemps. Compte tenu du faible courant de commutation - presque pour toujours, jusqu'à ce qu'il se casse mécaniquement.
Merci à
HWman d' avoir soumis un article sur stm32 dans le framework ARDUINO.
J'attache l' archive avec le croquis.