Mesdames, Messieurs
Est-ce que certains d’entre vous conaissent les modifications à apporter au fichier .ino de la coupure de tronçons ?
J’ai essayé de compiler le fichier Relay.ino et AGRate.ino et pas moyen de faire marcher l’un ou l’autre
Sachant que la modulation de dose ne m’intéresse pas encore
Il me semble que ce même fichier est capable de faire fonction UTurn selon les parametres choisi dans PCBV3.ino ( du moins c’est ce que j’aurai besoin )
Bien à vous
Clément
Je l’ai trouvé le coquin !
Coupure de tronçons opérationnelle
RelayPort.ino (3.5 KB) Relays.ino (855 Bytes)
Il n’y a plus de modulation pour le moment.
Ton pulvé a un régulation par pression ou débitmètre ?!
Par pression
Bonsoir à tous,
Merci pour les fichiers.
Pour ma part, je récupère l’info des tronçons en UDP (Wifi port 8888) avec un esp8266
connecté à une carte 8 relais.
J’ai du ajouter deux modifications
Est-ce que tu aurais des photos de ton montage ? ou des schémas ?
Quelqu’un a réalisé une modulation par pression reliée à AOG ?
See my other post, I ve put the schematic diagram.
I’ve chose the lolin board because it has a lot of available I/O
I’ve still an issue : I need an additional signal for my regulation system
(SprayMatic) and don’t know exactly how to handle it. This Is a flow regulation
I’ll do it manually for instance to control that everything is fine in AOG
Regards, francois
Quelqu un a t il une idée a me soumettre pour simuler un bouton poussoir ,( et non pas un interrupteur !) pour activer un tronçons ? Je me suis arraché les cheveux pendant 3h dessus hier soir , et rien a faire je ne trouve pas la solution . Je manque de base de codage .
Oui c’est toujours faisable relativement simplement avec un timer
mais ça me paraît très scabreux, si il y a un décalage, tout fonctionne à l’envers.
Il n’y a aucun contrôle (voyant …) ?
Pas si simple que ca , parceque je n ai pas trouvé 
Quel genre de voyant ? pour quelle utilité ?
If (bitRead(relaylo, 0)) bitClear(PORTD,5) ;
else bitSet(PORTD,5);
Dans une premier temps ,j’ ai besoin pour faire fonctionner de réussir a faire durer le bitClear pendant 1 seconde seulement .
Un simple delay() fera clignoter … c est plus subtil … il faut tenir compte du fait que tant que le troncons n a pas été coupé ( bitSet) , il ne faut pas renvoyer une impulsion pour ouvrir ( bitClear) …
Dans une second temps je pourrais extrapoler la solutions a toutes les sections , et aussi a leur fermeture .
Pour résumer la mécanique , je souhaite mettre les relais en parallèle des mes commandes manuelles de tronçons . Ce sont des interrupteur a bascule momentané. Une impulsion vers les haut j ouvre le tronçon, une impulsion vers le bas je ferme le tronçon.
Salut Tooki,
Pour éviter d’utiliser la fonction delay(), qui va figer tout le programme pendant l’attente du temps défini dans delay(), tu peux utiliser la fonction millis() : j’ai regardé le code machine_USB.ino, je n’ai pas trop d’idée à quel point un delay() pourrait poser problème ou non.
La fonction millis() permet d’aller lire la valeur du compteur interne de l’Arduino. Pour les détails de la fonction millis(), voir paragraphe 9.4 de cette doc qui explique ça mieux que ce que je ne saurais le faire ici : https://eskimon.fr/extra/ebooks/arduino-premiers-pas-en-informatique-embarquee.pdf.
Ca permettrait d’éviter de bloquer le programme pendant 1s avec la fonction delay().
A noter que dans de début du loop() de l’INO, il y a déjà des initialisations de variable avec utilisation de la fonction millis() ou mettre en variable le compteur actuel.
Pour la transformation d’une commande en entrée stable (maintenue à 0 ou 1) en une impulsion 0-1-0 : j’ai un pote qui a fait exactement ça en Arduido pour cockpit de simulateur de vol qu’il est en train de faire.
Je le contacte pour récupérer son bout de code et je t’envoie ça une fois que je l’ai.
@+
Math
Merci pour vos conseil j y jetterai un oeil ce soir .
J ai trouvé quelque chose qui marche et ne ralenti pas trop , a defaut de mieux dans un premier temps . millis() serait surement mieux mais delay(10) ne freine pas tellement .
voila le bout de code qu on m a soufflé et qui fonctionne pour mon cas .
if ((bitRead(relayLo,0) == 1) & (section1 == 0 )){
bitClear(PORTD, 5); //Digital Pin 5 to open section relay
section1 = 1;
delay(10);
}
else if ((bitRead(relayLo,0) == 0) & (section1 == 1 )){
bitClear(PORTC, 2) ; // A2>>16 to close section relay
section1= 0;
delay(10);
}
else{
bitSet(PORTD, 5);
bitSet(PORTC, 2);
}
Sinon déjà vu un mpntage avec transistor qui génère une impulsion à la fermeture du relai 
Salut,
J’ai pas eu de retours de comment a procédé mon pote, mais à partir de quelques tutos trouvés sur le net, j’aurais proposé le code suivant, qui ne fait pas appel à la fonction delay() ce qui évite de figer le programme.
C’est un exemple pour traiter les changements d’état du bit 0 du byte relayLo.
Je pense que ça fonctionne, mais j’ai pas le matos nécessaire pour vérifier.
Si ça fonctionne, à décliner pour tous les bits du byte relayLo.
void SetRelays(void) {
static boolean bit0Status, bit0MemoryState = 0; // Déclaration des variable booléennes qui vont permettre de détecter un front montant ou descendant du bit 0 du byte relayLo:
static char bit0Counter = 0; // Un compteur pour conmpter le temps d'activation du des pins
bit0Status = bitRead(relayLo,0); // Lecture de l'état du bit 0 du byte relayLo et stockage dans la variable bit0Status
if (( bit0Status != bit0MemoryState) && (bit0Status == 1)) // Si le bit0Status est différent de son état mémoire & qu'il est à 1, c'est qu'on a eu un changement de 0 à 1 de la part d'AOG
{
/*Description du if else qui suit :
* Si le bit0Counter est inférieur à 5, la fonction SetRelays a été appellée moins de 5 fois depuis que le AOG a changé l'état du bit 0 du byte relayLo
* Si le résultat est supérieur, c'est que la fonction a été appelée plus de 5 fois
* La boucle principale qui appelle la fonction SetRelays est exécuté toutes les 200ms (voir le début de la boucle void loop () avec le currentTime
* Donc pour activer la sortie 1 seconde, il faut que la fonction setRelays soit appelée 5 fois.
* Pour ajuster le temps d'activation de la sortie, ajuster le compteur qui permet d'ajuster par pas de 200ms
*/
if (bit0Counter <= 5)
{
bitSet(PORTD, 5); // On active digital pin 5
bit0Counter++; // On incrémente de 1 bit0Counter
}
else
{
bitClear(PORD, 5); // On désactive digital pin 5
bit0MemoryState = bit0Status; // On met en mémoire l'étant du bit 0 fournis par AOG pour ne plus activer la sortie tant qu'on a pas eu de changement d'état du bit 0 de la part d'AOG
bit0Counter == 0; // On remet le compteur à 0 pour le prochain coup
}
}
if (( bit0Status != bit0MemoryState) && (bit0Status == 0)) // Si le bit0Status est différent de son état mémoire & qu'il est à 0, c'est qu'on a eu un changement de 1 à 0 de la part d'AOG
{
if (bit0Counter <= 5)
{
/* bitSet(PORTD, ??) activer ici le pin qui t'interesse */
bit0Counter++; // On incrémente de 1 bit0Counter
bit0Counter == 0; // On remet le compteur à 0 pour le prochain coup
}
else
{
/* bitClear(PORD, ??); désactiver ici le pin qui t'interesse */
bit0MemoryState = bit0Status; // On met en mémoire l'étant du bit 0 fournis par AOG pour ne plus activer la sortie tant qu'on a pas eu de changement d'état du bit 0 de la part d'AOG
}
}
}
Attention, j’ai pas la carte relays, j’ai peut-être inversé l’état des sorties pour l’activation / désactivation des relais.
En espérant que ça puisse t’aider.
Math
Ca me plait bien comme solution . Ca fait juste un peu plus a ecrire .
J essaie des que j ai quelques minutes a y consacrer .
Merci pour ton temps !
Salut,
Voici le code final, suite aux tests et debugs de Tooki, au cas où certains soient intéressés.
Ce code est un exemple avec les hypothèses suivantes:
Le code est pour une section. Il est à copier et a adapter pour les autres sections à piloter : autres bits du byte relayLo à aller lire et adapter les sorties à piloter en conséquence.
Seule la variable globale pulseCounter n’a pas besoin d’être dupliquée.
Globalement, ce que fait le code, c’est qu’il détecte un front montant ou descendant sur le bit0 du byte relayLo et va générer en fonction du front une pulsation l’une ou l’autre des sorties Digital pin 5 ou 13.
Variables à déclarer en début de programme, avant la boucle “void setup ()”:
// Paramètres pour generateur de pulse sur sorties relais
#define pulseCounter 5 // Compteur qui défini le temps du pulse par pas de 200ms (ici 5*200ms = 1s)
boolean bit0Status, bit0MemoryState = 0; // Déclaration des variable booléennes qui vont permettre de détecter un front montant ou descendant du bit 0 du byte relayLo:
char bit0Counter = 0; // Un compteur pour compter le temps d'activation du/des sorties commandées par le bit 0 du byte relayLo
Modifications de la fonction void “SetRelays(void)”:
void SetRelays(void) {
bit0Status = bitRead(relayLo,0); // Lecture de l'état du bit 0 du byte relayLo et stockage dans la variable bit0Status
if (( bit0Status != bit0MemoryState) && (bit0Status == 1)) // Si le bit0Status est différent de son état mémoire & qu'il est à 1, c'est qu'on a eu un changement de 0 à 1 de la part d'AOG sur le bit 0 du byte relayLo
{
/*Description du if else qui suit :
* Si le bit0Counter est inférieur à 5, la fonction SetRelays a été appellée moins de 5 fois depuis que le AOG a changé l'état du bit 0 du byte relayLo
* Si le résultat est supérieur, c'est que la fonction a été appelée plus de 5 fois
* La boucle principale qui appelle la fonction SetRelays est exécuté toutes les 200ms (voir le début de la boucle "void loop ()" avec le "currentTime" et le "if" sur le "currentTime")
* Donc pour activer la sortie 1 seconde, il faut que la fonction setRelays soit appelée 5 fois
* Cette logique va permettre d'activer la sortie qui pilote le relais avec un échellon d'un durée de 1s quand on a une commande de section de la part d'AGO
* Pour ajuster le temps d'activation de la sortie, ajuster le compteur (pulseCounter) qui permet d'ajuster par pas de 200ms
*/
if (bit0Counter <= pulseCounter)
{
bitSet(PORTD, 5); // On active digital pin 5
bit0Counter++; // On incrémente de 1 bit0Counter
}
else
{
bitClear(PORD, 5); // On désactive digital pin 5
bit0MemoryState = bit0Status; // On met en mémoire l'étant du bit 0 fournis par AOG pour ne plus activer la sortie tant qu'on a pas eu de changement d'état du bit 0 de la part d'AOG
bit0Counter == 0; // On remet le compteur à 0 pour le prochain coup
}
}
if (( bit0Status != bit0MemoryState) && (bit0Status == 0)) // Si le bit0Status est différent de son état mémoire & qu'il est à 0, c'est qu'on a eu un changement de 1 à 0 de la part d'AOG sur le bit 0 du byte relayLo
{
if (bit0Counter <= pulseCounter) // Boucle if else idem que précédente, mais sur un autre relais, pour le cas du changement du bit 0 byte relayLo de 1 à 0 par AOG
{
bitSet(PORTB, 5); // On active le digital pin 13
bit0Counter++; // On incrémente de 1 bit0Counter
}
else
{
bitClear(PORDB, 5); // On désactive le digital pin 13
bit0MemoryState = bit0Status; // On met en mémoire l'étant du bit 0 fournis par AOG pour ne plus activer la sortie tant qu'on a pas eu de changement d'état du bit 0 de la part d'AOG
bit0Counter == 0; // On remet le compteur à 0 pour le prochain coup
}
}
}
Math