Agrainoir

Bonjour a tous... J'aurais besoin de beaucoup d'aide pour créer un nourrisseur pour mais animaux.

Cela fait très très longtemps que je n'ai pas effectuer de la programmation c'est pour cela que je demande de l'aide.

Explication du système: - suivant l'heure et le jour, le système me délivre ou pas de la nourriture, Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche - par le biais d'un relais actionnera un moteur qui éparpillera la nourriture, la séquence est entre 0s et 20s

Affichage et réglage: - Heure et Jour (Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche) - Lundi / Heure départ (XX:XX) et Durée (0s 5s 10s 15s 20s) - .... - Dimanche / Heure départ (XX:XX) et Durée (0s 5s 10s 15s 20s) - Test Moteur / OK (le moteur se lance 5s)

J'ai pu lire les sujets sur le programmateur horaire, nourriture poisson... Mais rien ne va pour mon projet.

Je recherche quelqu'un qui pour me suivre pour se programme... Voilà je vous attends...

J'aurais besoin de beaucoup d'aide pour créer un nourrisseur pour mais animaux.

ah, mais, on ne peut pas envoyer ses surplus alimentaires par internet ! ;D

Sérieusement, commence par faire un organigramme de ce que tu veux faire, avec un papier et un crayon (si, si ça existe encore...)

il faut une RTC( pour les heures/jours/secondes)...

un moteur.. peut etre une vis sans fin

certain du forum ont deja fait cela... donc recherche un peu..

Si rien ne te plait de ce qu'il existe, ou que tu as vu, il suffit de le faire soi meme...

Merci de vos conseils.

Pour ma part c’est toutes la partie programmation, j’en ai fait en cours mais il y a longtemps…

Pour la partie mécanique, et électronique ça c’est bon. J’ai déjà ma petite idée.

Après j’ai vu quelques programme comme le Programmateur Horaire…

hello
regarde ce code

//debut programme
#include <Wire.h>
#include <DS3231.h>
DS3231 clock;
RTCDateTime dt;
int memo_heure;                 // bit de vie affiche la date toutes les heures
int memo_minute;                // bit de vie affiche un . ou un * toutes les minutes
boolean flag_minute=true;       //flag pour faire l'inversion des affichages . et *
const byte relais_sonnerie = 3; //raccorder  la cde de la sonnerie à la pinoche 3
int TabEvt [18][1][6] =         //tableau des haoraires de sonnerie
{
  { { 7, 45,00,  7, 45,02}},    //fourchette de 2 secondes pour déclencher la sonnerie
  { { 7, 57,00,  7, 57,02}}, 
  { { 8, 56,00,  8, 56,02}},    //la sonnerie devra durer 2 secondes minimum
  { { 9, 00,00,  9, 00,02}}, 
  { { 9, 55,00,  9, 55,02}},    //pour ne pas avoir de double déclenchement
  { {10, 06,00, 10, 06,02}}, 
  { {10, 57,00, 10, 57,02}},    //la durée de la sonnerie se parametre dans le tableau tempo
  { {11, 00,00, 11, 00,02}},
  { {12, 00,00, 12, 00,02}},    //ci dessous.
  { {12, 45,00, 12, 45,02}},
  { {12, 57,00, 12, 57,02}},    //si la durée doit etre inférieure à 2 secondes, il faudra 
  { {13, 56,00, 13, 56,02}},
  { {14, 00,00, 14, 00,02}},    //modifier la fouchette dans TabEvt
  { {14, 55,00, 14, 55,02}},
  { {15, 05,00, 15, 05,02}},    //
  { {15, 56,00, 15, 56,02}},
  { {16, 00,00, 16, 00,02}},
  { {17, 00,00, 17, 00,02}},
};
int tempo [18] {04,04,04,04,04,04,04,04,04,04,04,04,04,04,04,04,04,04}; // durée de la sonnerie en secondes
char* JOURS []={"    ","lundi ","mardi ","mercredi ","jeudi ","vendredi ","samedi ","dimanche "};
//**************************************************************************************************************************
//************************************************************************************SETUP*********************************
//**************************************************************************************************************************
void setup() 
{
Wire.begin();
Serial.begin(115200);
pinMode (relais_sonnerie, OUTPUT); analogWrite(relais_sonnerie, LOW);
clock.begin();
clock.setDateTime(__DATE__, __TIME__);
dt = clock.getDateTime();
affichage_date_en_francais();
memo_heure=(atoi(clock.dateFormat("H", dt)));         //  "bit de vie" horaire
memo_minute=(atoi(clock.dateFormat("i", dt)));        //  "bit de vie" minute
Serial.println("fin set up");
}

//**************************************************************************************************************************
//************************************************************************************LOOP**********************************
//**************************************************************************************************************************
void loop() 
{
  dt = clock.getDateTime();
  if(memo_minute!=(atoi(clock.dateFormat("i", dt))))                  //pour avoir un affichage de l'heure à chaque heure pile
  {
    if (flag_minute == true){Serial.print(".");flag_minute = false;}
    else {Serial.print("*");flag_minute = true;}                      //car l'attente d'un evemement est longue
    memo_minute=(atoi(clock.dateFormat("i", dt)));
  }            
    
  if(memo_heure!=(atoi(clock.dateFormat("H", dt))))                 //pour avoir un affichage de l'heure à chaque heure pile
   {
     Serial.println("");
     affichage_date_en_francais();                             //cet appel à l'affichage permet de savoir que le prg tourne bien
     memo_heure=(atoi(clock.dateFormat("H", dt)));             //car l'attente d'un evemement est longue
   }            
  //si nous sommes un lundi, mardi, mercredi, jeudi, vendredi et si c'est une heure programmée, la sonnerie retentira
  if (((atoi(clock.dateFormat("w", dt)))>=1)&&((atoi(clock.dateFormat("w", dt)))<=6))//samedi=6
    {
    for (int indice = 0; indice<=17; indice++) 
      {
      if  (((atoi(clock.dateFormat("H", dt))) == TabEvt[indice] [0][0])     //heure   de declenchement de la sonnerie
        && ((atoi(clock.dateFormat("i", dt))) == TabEvt[indice] [0][1])     //minute  de declenchement de la sonnerie
        && ((atoi(clock.dateFormat("s", dt))) == TabEvt [indice][0][2])     //seconde de declenchement de la sonnerie
        && ((atoi(clock.dateFormat("h", dt))) <= TabEvt [indice][0][3])     //heure   d'arret de la sonnerie
        && ((atoi(clock.dateFormat("i", dt))) <= TabEvt [indice][0][4])     //minute  d'arret de la sonnerie
        && ((atoi(clock.dateFormat("s", dt))) <= TabEvt [indice][0][5]))    //seconde d'arret de la sonnerie
        {
        Serial.println(clock.dateFormat("l d F Y H:i:s",  dt));
        Serial.print  ("indice =");Serial.print(indice);Serial.print("    ");
        Serial.print  (TabEvt[indice] [0][0]);Serial.print("  ");Serial.print(TabEvt[indice] [0][1]);Serial.print("  ");
        Serial.print  (TabEvt[indice] [0][2]);Serial.print("................");
        Serial.print  (TabEvt[indice] [0][3]);Serial.print("  ");Serial.print(TabEvt[indice] [0][4]);Serial.print("  ");
        Serial.println(TabEvt[indice] [0][5]);
        Serial.flush();
        on_sonne(tempo[indice]);
        }
        else 
          {
            // on_ne_sonne_pas();
          }
      }
    }
delay(1000);
}

//************************************
//**************SONNERIE**************
//************************************
void on_sonne(int temps)//
{
digitalWrite(relais_sonnerie,HIGH);Serial.print("  sonnerie on.....");
delay(temps*1000);                                                                //secondes*1000 pour avoir des miliSecondes
digitalWrite(relais_sonnerie,LOW);Serial.println("  sonnerie off");
}

//************************************
//**********AFFICHAGE DATE************
//************************************
void affichage_date_en_francais()                                                 //affichage de la date en français
{
dt = clock.getDateTime();
byte jours=(atoi(clock.dateFormat("w", dt)));                                     //on affiche le jour en français
Serial.print(JOURS[jours]);Serial.println(clock.dateFormat("d F Y H:i:s",  dt));  //puis la date normale
}
//fin programme

Ca existe aussi tout fait (prise programmable pour le chauffage électrique par exemple) à partir de 10€. Ex : Programmateur-horaire-pour-prise-electrique-numerique

Ca peut être intéressant de hacker une prise de ce type, elle gère le top départ, et réveille l'Arduino qui s'occupe du reste (timing du moteur du nourrisseur, etc...).

oui j'avais pensais a un programmateur et puis un relais temporisé. Mais je trouve cette carte intéressante.

Puis comme ça je pourrais aussi faire évoluer mon montage, comme par exemple avoir 2 alimentation différente, donner celle la un jour et l'autre un autre jour....

Je ne connaissais pas cette carte Arduino. Et je la trouve très sympathique. Je viens juste de recevoir mon premier kit Arduino...

Je vais partir sur la base du programmateur horaire que j'ai trouvé sur le forum https://forum.arduino.cc/index.php?topic=447778.0.

Je vais avancé petit a petit le temps de se remettre a la programmation... Et vous tiendrais au courant de l'avancement de mon projet peut etre que sa aidera d'autres personnes...

Pour donner a manger régulièrement a des animaux deux fois par jour. Je suis parti du progamme de Le Programmateur Horaire nouveau est arrivé (https://forum.arduino.cc/index.php?topic=447778.0)

Matériel: arduino uno, une carte relais, un LCD Keyboard Shield

Dans le Programme j’ai juste changer la deuxième heure par une Tempo…

J ai juste un probleme dans la temporisation quand je mets 10 secondes cela fait plus 15s et je ne comprends pas tout cela peut venir

Je vais esayer de mettre le schéma, et des photos plus tard. Mais si quelqu un me trouve le pb de tempo je suis preneur!!!

ProgrammateurAgrainoir2temps.V5.ino (11.9 KB)

hello

ça date :slight_smile:

test ce code

 int TabEvt [2][3] =
    {
    {19, 0, 10},
    {19, 5, 10}
    };      

void setup (){
  Serial.begin(1000000);
  for ( int i = 0; i < 2; i++ ) //ligne de 0 à 1
  {
  for(int f=0;f<3;f++) //colonne de 0 à 2 
  {
  Serial.print("tabevt ligne ");
  Serial.print(i);//valeur pour delay 
  Serial.print("   colonne ");
  Serial.print(f);//valeur pour delay 
  Serial.print("  ");
 
  if (f==2){Serial.print(TabEvt [i] [f] * 1000);
  Serial.println(" ms pour le delay");}
  else{Serial.print(TabEvt [i] [f] );Serial.println("");}
  }}}
  void loop(){}

et souviens toi que les éléments d’un tableau commencent à 0

Bonjour

Grace a la remarque de dfgh que les éléments d’un tableau commencent à 0. J’ai relu mon code et je mettais trompé dans mon code j’avais mis delay (TabEvt [3] * 1000); au lieu de delay (TabEvt [2] * 1000); >:( >:(
* // Rechercher si heure actuelle est dans dans la ou les plages horaires*
* for ( i = 0; i < 2; i++ ) {*
if (now.hour() == TabEvt [0] && now.minute() == TabEvt [1] ) {
* lcd.setCursor(6,1);*
* lcd.print("ON ");*
* digitalWrite (Relais, HIGH);*
delay (TabEvt [2] * 1000);
* lcd.setCursor(6,1);*
* lcd.print(“OFF”);*
* digitalWrite (Relais, LOW);*
* delay (60000);*
* }*

Maintenant il ne reste plus qu'a mettre la date et l'heure du RTC3132 dans le tableau pour le setup!!!

si quelqu'un c'est me dire comment faire cette ligne la sa serais genial!!!

c'est de mettre cette tab byte TabMaH[6] = {20, 5, 14, 18, 20, 24}; a jour avec le RTC???

hello regardes et testes

             //pour mettre à l'heure l'horloge, supprimer les // de commentaire en tete de la ligne 119
                      //puis compiler et téléverser dans la platine arduino. l'horloge sera à l'heure du PC
                      //ensuite remettre les "//" de cpmmentaires en tete de la ligne  119 
                      //et recommencer la compilation et le televersement. l'horloge aura gardé l'heure du PC
(ici, ligne 119) //clock.setDateTime(__DATE__, __TIME__);//valider cette ligne, téléverser mettra l'horloge à l'heure puis commenter cette ligne et re téléverser le pgr

oui sa j'avais bien compris pour la mise a l heure avec le PC

Mais quand je reviens dans mon menu de mise a jour de la date et heure. Je prends les valeur de la byte TabMaH[6] = {20, 5, 14, 18, 20, 24};

Tu coup si je mets a l'heure une fois et que j’éteins et je rallume. Si je reviens dans mon menu de mise a jour date et heure j'ai les valeurs de ma TabMaH qui remonte et pas la date et heure de mon DS3231.

J'aurais voulu dans mon setup rentrer dans la TabMaH, la date et heure du DS3231

Mais je n'ai pas trouvé de reponse sur le net!!! :'(

hello
j’ai pas mal joué avec ce prg
j’avais la meme prob que toi
j’ai fini par faire le système suivant:
si BP select appuyé pendant le set up, je vais faire le parametrage de l’heure, sinon c’est l’heure de l’horloge
voici en fichier joint un prog qui fait ça.
( il a besoin d’un autre prg pour initialiser l’EEprom)

______programmateur_4z_4p_7j_V8.zip (17.3 KB)

Merci

Bien domage que l'on ne peut pas prendre l heure et la date du RTC pour mettre dans une table

Bonjour a tous

Je reviens avec mon petit programme.

Le petit soucis quand je mets l’heure et la date a jour, puis je valide tout; cela fonctionne bien. Mais si je reviens a faire une mise a l’heure et date ça me prends se qu’il y a dans la table TabMaH. Je voudrais mettre l heure et la date qui se trouve dans le RTC pour le mettre dans le TabMaH mais j’ai essayé plein de truc sans solutionner???

Si quelqu’un a une idée je suis preneur

MerciProgrammateurAgrainoir2temps.V5.ino (11.9 KB) ProgrammateurTest.ino (11.9 KB)

hello
c’est décourageant, je t’ai donné un prog qui fait ce que tu demandes, mais tu n’as pas dû l’ouvrir .

il y a un onglet “notes” qui explique le fonctionnement du prg.

Salut

C’est pas décourageant!!! J’ai bien ouvert ton programme et tout. Mais je ne vois qu une mise a l’heure automatique avec le pc.

Moi je voudrais récupérer les données qui se trouvent dans le module RTC pour les mettre dans une table…

ah bon ?
je me demande ce que font ces lignes dans le setup

 BP_Select = analogRead (0);
  if ( BP_Select < 250)
  {
    parametrage();
  } else
  {
    dt = clock.getDateTime();
    affiche_heure(); Serial.println(clock.dateFormat("l d F Y H:i:s",  dt)); Serial.flush();
  }

donc, si je n’appuie pas sur le BP Select pendant le boot, le setup appelle la fonction affiche heure , (heure qu’il vient tout juste de lire dans la rtc

void affiche_heure() {
  lcd.setCursor(0,0);lcd.print("        ");lcd.setCursor(0,0);
  jour = dt.dayOfWeek; //Serial.print("jour = "); Serial.println(jour);//lundi=1
  lcd.print(JOURS[dt.dayOfWeek]);
  dt = clock.getDateTime();
  lcd.setCursor(0, 1);
  if (dt.hour < 10) {
    lcd.print("0");
  }

etc