Aller au contenu


Photo
- - - - -

course du soleil


  • Veuillez vous connecter pour répondre
158 réponses à ce sujet

#81 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 17 janvier 2020 - 05:38

je t'ai mis le code complet avec la course du soleil et le turntable .

encoder sert : appui court de passer d'un ecran à l'autre (premier ecran course du soleil , deuxieme ecran turntable )

appui long reglage rtc .

 

#include <Wire.h>
#include "RTClib.h"
#include <Encoder.h> // from http://www.pjrc.com/teensy/td_libs_Encoder.html
Encoder knob(2, 3); //encoder connected to pins 2 and 3 (and ground)// D2 SEEDSTUDIO shield //3,4
#include <TimeLib.h>
#include <TimeLord.h>
#include <EEPROM.h>
#include <Stepper.h>
const float LATITUDE = 43.70, LONGITUDE = 7.25; // Nice Sun
const int TIMEZONE = + 1;
int r   = 35;//cercle drawLine
int r_1 = 35;//drawbitmap
int angle = 0;
int x1=57;// drawbitmap rattrapage width  65-8 = 57
int y1=42;// drawbitmap rattrapage height 50-8 = 42
int x0=65;// drawLine
int y0=50;// drawLine
int sun;
//int alfa = 0;
int alfa_1 = 0;

int degre = 0;

//int backlight = 6; //backlight control pin 6
                                     
const int nbrepas360 = 48;                        // Fixe le nombre de pas pour faire un tour complet, c'est-à-dire 360°.
Stepper monmoteur (nbrepas360, 8, 9, 10, 11);    // Initialise la librairie Stepper.h
int cptepas = 0;                                // Stockera le nombre de pas compté.
float position_du_moteur=0;

int degrees_pas = 0.5;
#define u8g_logo_width 16
#define u8g_logo_height 16

#if defined(ARDUINO_ARCH_SAMD)
// for Zero, output on USB Serial console, remove line below if using programming port to program the Zero!
   #define Serial SerialUSB
#endif
RTC_DS1307 RTC;
char daysOfTheWeek[7][12] = {"Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"};

#include "U8glib.h"
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);
//U8GLIB_SSD1309_128X64 u8g(U8G_I2C_OPT_NONE);
//U8GLIB_ST7920_128X64 u8g(13, 11, 12, U8G_PIN_NONE);//U8GLIB_ST7920_128X64_1X u8g(7, 6, 5 ,8); //Enable, RW, RS, RESET
/*
const uint8_t bonsai_bitmap[] PROGMEM = {

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x80,0x00,0x00,0x00,0x00,0x00,0x00, // .................................................................########.......................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xF3,0xF0,0x00,0x00,0x00,0x00,0x00, // ............................................................################..######............................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00, // ........................................................###############################.........................................
  0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xFF,0xFE,0x7F,0x00,0x00,0x00,0x00,0x00, // ............................................###################################..#######........................................
  0x00,0x00,0x00,0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xF8,0x1F,0x00,0x00,0x00,0x00,0x00, // ...........................................##################################......#####........................................
  0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x7F,0x00,0x00,0x00, // ................................................#################################................#######........................
  0x00,0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0xF8,0x01,0xFF,0x83,0xE0,0x00, // ..........................................###########################################..........##########.....#####.............
  0x00,0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0xFC,0x19,0xFC,0xFF,0xF0,0x00, // ..........................................############################################.....##..#######..############............
  0x00,0x00,0x00,0x00,0x00,0x07,0xFF,0xFF,0xFD,0xFF,0x30,0x3F,0xFF,0xFF,0xE0,0x00, // .............................................#########################.#########..##......#########################.............
  0x00,0x00,0x00,0x00,0x00,0x1F,0xFF,0xFF,0xF8,0x00,0x07,0xFF,0xFF,0xFC,0x00,0x00, // ...........................................##########################................#########################..................
  0x00,0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0xE0,0x00,0x7F,0xFF,0xFF,0xFC,0xF8,0x00, // ..........................................#########################..............#############################..#####...........
  0x00,0x00,0x00,0x00,0x1C,0x1F,0xFF,0x8F,0x80,0x3F,0xFF,0xFF,0xFF,0xFF,0xF8,0x00, // ...................................###.....##############...#####.........###########################################...........
  0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0x87,0xFF,0xFF,0xFF,0xFF,0x80,0x7F,0xE0,0x00, // ..................................#######################....####################################........##########.............
  0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0x87,0xFF,0xC0,0x03,0xC3,0xE0,0x00,0x00,0x00, // ..................................#######################....#############............####....#####.............................
  0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x0F,0xF0,0x00,0x00,0x01,0xE0,0x00,0x00,0x00, // ........................................################....########...........................####.............................
  0x00,0x00,0x00,0x00,0x01,0xFF,0x87,0xFF,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // .......................................##########....############...............................................................
  0x00,0x00,0x00,0x00,0x00,0x0F,0xF0,0xFF,0x00,0x00,0x00,0x03,0xFC,0x00,0x00,0x00, // ............................................########....########..............................########..........................
  0x00,0x00,0x3F,0xE7,0xDF,0x01,0xF0,0x3F,0xC0,0x00,0x7F,0x07,0xC0,0x07,0xF0,0x00, // ..................#########..#####.#####.......#####......########...............#######.....#####...........#######............
  0x00,0x00,0x1F,0xFF,0xFF,0xF8,0x00,0x1F,0xF8,0x00,0xFF,0xFF,0xFF,0xFF,0xF0,0x00, // ...................##########################..............##########...........####################################............
  0x00,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xBF,0xFF,0xE0,0x3F,0xFF,0xFF,0xFF,0xF8,0x00, // .......................##################################.#################.......###################################...........
  0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xE1,0xFF,0xFF,0xFF,0xFF,0xFF,0x00, // ...................########################################################....#########################################........
  0x00,0xDF,0xBF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80, // ........##.######.#######################################################################################################.......
  0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80, // .......##################################################################################################################.......
  0x03,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x00,0x7F,0xFF,0xFF,0xFF,0xE0,0x00, // ......#################################################################..........##################################.............
  0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF0,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0x00, // .......#############################################################..............######################################........
  0x00,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x1F,0xFF,0xFF,0xFF,0x0E,0x00, // .........#######################################################...................#############################....###.........
  0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0x87,0xFC,0x03,0xF0,0x00,0x1F,0x0F,0xFC,0x00,0x00, // ...........######################################....#########........######...............#####....##########..................
  0x00,0x3F,0xFF,0xFF,0xC7,0xFF,0x1F,0xF0,0xE3,0xF9,0xE0,0x0E,0x0F,0xFF,0x80,0x00, // ..........########################...###########...#########....###...#######..####.........###.....#############...............
  0x00,0xFF,0xFF,0xF3,0x80,0x00,0x1F,0xC1,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00, // ........####################..###..................#######.....#####################............................................
  0x00,0x7E,0x1F,0xE7,0x80,0x00,0x7F,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x00,0x00,0x00, // .........######....########..####................########################################.......................................
  0x00,0x3E,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0x00,0x00,0x00, // ..........#####.................................##########################################......................................
  0x00,0x00,0x00,0x00,0x00,0x03,0xFF,0x0C,0x7C,0x3F,0x03,0xC0,0x00,0x00,0x00,0x00, // ..............................................##########....##...#####....######......####......................................
  0x00,0x00,0x00,0x00,0x00,0x07,0xFC,0x00,0x00,0x07,0xF8,0x00,0x00,0x00,0x00,0x00, // .............................................#########.......................########...........................................
  0x00,0x00,0x00,0x00,0x00,0x07,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // .............................................#########..........................................................................
  0x00,0x00,0x00,0x00,0x00,0x0F,0xFC,0x00,0x00,0x01,0x00,0x00,0x01,0x40,0x00,0x00, // ............................................##########.........................#.......................#.#......................
  0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xC0,0x00,0x01,0x00,0x00,0x00,0x00,0xE0,0x00, // ............................................##############.....................#................................###.............
  0x00,0x00,0x00,0x00,0x00,0x07,0xFF,0xFC,0x00,0x01,0xC6,0x31,0xCC,0x81,0x10,0x00, // .............................................#################.................###...##...##...###..##..#......#...#............
  0x00,0x00,0x00,0x00,0x00,0x03,0xFF,0xFF,0x80,0x01,0x29,0x4A,0x12,0x81,0x10,0x00, // ..............................................###################..............#..#.#..#.#..#.#....#..#.#......#...#............
  0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xC0,0x01,0x29,0x49,0x9E,0x81,0x10,0x00, // ....................................................##############.............#..#.#..#.#..#..##..####.#......#...#............
  0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xFF,0xE0,0x01,0x29,0x48,0x52,0x80,0xA0,0x00, // ......................................................#############............#..#.#..#.#..#....#.#..#.#.......#.#.............
  0x00,0x00,0x00,0x00,0x00,0x00,0x07,0xFF,0xF0,0x00,0xC6,0x4B,0x92,0x91,0xB0,0x00, // .....................................................###############............##...##..#..#.###..#..#.#..#...##.##............
  0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................#####################...........................................................
  0x00,0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x00,0x00,0x00, // ...........................##############################################################.......................................
  0x00,0x00,0x0F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00, // ....................############################################################################................................
  0x00,0x00,0x7F,0xE0,0x00,0x1F,0xFF,0xE0,0x00,0x00,0x00,0x3F,0xF0,0x00,0x00,0x00, // .................##########................################...............................##########............................
  0x00,0x00,0x78,0x03,0xE0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x00,0x00, // .................####.........#####.............................................................####............................
  0x00,0x00,0x7F,0x73,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x70,0x00,0x00,0x00, // .................#######.###..########..................................................#####....###............................
  0x00,0x00,0x3F,0xFF,0xC0,0x00,0x00,0x00,0x00,0x00,0x07,0xFF,0xF0,0x00,0x00,0x00, // ..................################...................................................###############............................
  0x00,0x00,0x1F,0xFF,0xE0,0x00,0x00,0x00,0x00,0x00,0x1F,0xFF,0xE0,0x00,0x00,0x00, // ...................################................................................################.............................
  0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x00,0x00, // ........................#########################################################################...............................
  0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00, // .........................######################################################################.................................
  0x00,0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF8,0x00,0x00,0x00,0x00, // ...........................##################################################################...................................
  0x00,0x00,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0x00,0x00,0x00, // .............................#############################################################......................................
  0x00,0x00,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00, // ...............................#########################################################........................................
  0x00,0x00,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00, // ...............................########################################################.........................................
  0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF8,0x00,0x00,0x00,0x00,0x00, // ................................#####################################################...........................................
  0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xFF,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00, // ....................................################################################............................................
  0x00,0x00,0x00,0x00,0x0F,0xC0,0x00,0xFF,0xC0,0x07,0xE0,0x00,0x00,0x00,0x00,0x00, // ....................................######..............##########...........######.............................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  // ................................................................................................................................
};
0x00, 0x00, 0x80, 0x00, 0x80, 0x01, 0x84, 0x10, 0x08, 0x08, 0xe0, 0x03, 0x10, 0x04, 0x10, 0x04, 0x17, 0x74, 0x10, 0x04, 0x10, 0x04, 0xe0, 0x03, 0x08, 0x08, 0x84, 0x10, 0x80, 0x01, 0x00, 0x00
*/
static unsigned char u8g_sun_3_bits[] U8G_PROGMEM = {// soleil
0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x90, 0x04, 0xa0, 0x02, 0xc0, 0x01, 0xfc, 0x1f, 0xc0, 0x01, 0xa0, 0x02, 0x90, 0x04, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/*
int X = 0;
int Y = 0;
int I = 0;
int X2 = 0;
int Y2 = 0;
int X3 = 0;
int Y3 = 0;
*/
int Timer = 0;
int Minutt = 0;
int Sekund = 0;
float Vinkel = 0;
int an = 0;
int luna = 0;
int zi = 0;
int zis = 0;
/*
int ScreenWith = 128;
int ScreenWithC = 64;
int ScreenHeight = 64;
int ScreenHeightC = 32;
int yArray[128];
int deics = ScreenWith/4;
int deigrec = 14;
int deics2 = 0;
int de = 10;
*/
//the variables provide the holding values for the set clock routine
int setyeartemp;
int setmonthtemp;
int setdaytemp;
int setoretemp;
int setzitemp;
int setminstemp;
int setsecs = 0;
int maxday; // maximum number of days in the given month
int TimeMins; // number of seconds since midnight
int TimerMode = 2; //mode 0=Off 1=On 2=Auto
int TimeOut = 10;
int TimeOutCounter;

// These variables are for the push button routine
int buttonstate = 0; //flag to see if the button has been pressed, used internal on the subroutine only
int pushlengthset = 1500; // value for a long push in mS
int pushlength = pushlengthset; // set default pushlength
int pushstart = 0;// sets default push value for the button going low
int pushstop = 0;// sets the default value for when the button goes back high
int pwm2  ;// pwm Sun
int margeAube,margeCrepuscule;
int heureMidi;
int Sunrise, Sunset,Sun_zenith ; //sunrise and sunset expressed as minute of day (0-1439)
TimeLord myLord; // TimeLord Object, Global variable
byte sunTime[]  = {0, 0, 0, 1, 1, 13}; // 17 Oct 2013
int SunriseHour, SunriseMin, SunsetHour, SunsetMin,zenithHour,zenithMin,zenith,zenith_Hour,zenith_Min ;
int knobval; // value for the rotation of the knob
boolean buttonflag = false; // default value for the button flag
//#define buton 4
//char s[3] = "";
int backlight = 6;//backlight control pin 6
#include <stdlib.h>
char tmp_string[8];

void draw(void) {
      DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    EEPROM.update(14,zenith_Hour);
    EEPROM.update(15,zenith_Min);
    zenithMin = (Sunset+Sunrise)/2;
    zenith_Min = (zenithMin)%60;
    zenithHour = (Sunset+Sunrise)/2;
    zenith_Hour = (zenithHour)/60;
    TimeMins = (now.hour() * 60) + now.minute();
    uint16_t time = now.hour() * 60 + now.minute();
    uint16_t angle =   map(time, Sunrise, Sunset, 0, 180);// Angle
    /*evite de depasser l'angle*/
    if(angle < 0)
      angle = 0;
    else if(angle > 180)
     angle = 180;
    margeAube = (Sunset - Sunrise)/180*6;            //calcul de la durer de uint16_t angle multiplier par 6° angle Aube Civil
    heureMidi = (Sunrise + Sunset)/2;
    margeCrepuscule =(Sunset - Sunrise)/180*6; //calcul de la durer de uint16_t angle multiplier par 6° angle Crepuscule Civil
    
    if(TimeMins < heureMidi ){
    pwm2 = map ( time, Sunrise - margeAube, heureMidi, 0, 255);
    }
    else {
    pwm2 = map ( time, heureMidi, Sunset + margeCrepuscule, 255, 0);
    }
    if(pwm2<0) {
        pwm2=0;
    }
    analogWrite(5,pwm2);// PIN 5 timer 8 bits
    int maxday;// maximum de jours
   if (now.month() == 4 || now.month() == 5 || now.month() == 9 || now.month() == 11){  //30 jours =  Septembre, Avril, Juin,  Novembre.
    maxday = 30;
  EEPROM.update(7,maxday);
    
  }
  else {
    maxday = 31; //... all the others have 31
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 == 0){  //... Exception Fevrier = 28 jours , ou 29 jours année bissextile.
    maxday = 29;
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 != 0){
    maxday = 28;
    EEPROM.update(7,maxday);
  }

    EEPROM.update(9,SunriseHour);
    EEPROM.update(10,SunriseMin);
    EEPROM.update(11,SunsetHour);
    EEPROM.update(12,SunsetMin);
    EEPROM.update(13,angle);
    u8g.setFont(u8g_font_6x13);   
    u8g.setPrintPos(2,10);
    if (zi < 10) u8g.print("0");
    u8g.print(zi);
    u8g.print("/");
    if (luna < 10) u8g.print("0");
    u8g.print(luna);
    u8g.print("/");
    u8g.setPrintPos(40,10);
    u8g.print(daysOfTheWeek[zis]);

    u8g.setFont(u8g_font_6x13);
    u8g.setPrintPos(80,10);
    if (Timer < 10) u8g.print(" ");
    u8g.print(Timer);
    u8g.setPrintPos(93,10);
    if (Sekund%2 != 1)
    u8g.print(":");
    u8g.setPrintPos(115,10);
    u8g.setFont(u8g_font_6x10);
    if(Sekund<10)u8g.print("0");
    u8g.print(Sekund);
    u8g.setPrintPos(100,10);
    u8g.setFont(u8g_font_6x13);
    if (Minutt < 10) u8g.print("0");
    u8g.print(Minutt);
    
    // Display sun moon //
/*
    u8g.setPrintPos(8,20);
    u8g.setFont(u8g_font_6x10);
    u8g.print("Sun");
    u8g.setPrintPos(27,20);
    u8g.print("R");
    u8g.setPrintPos(34,20);
    if(SunriseHour<10);
    u8g.print("0");
    u8g.print(SunriseHour);
    u8g.print (":");
    if (SunriseMin <10)
    u8g.print("0");
    u8g.print (SunriseMin);
    u8g.setPrintPos(85,20);
    u8g.print ("S");
    u8g.setPrintPos(93,20);
    if(SunsetHour<10)
    u8g.print("0");
    u8g.print (SunsetHour);
    u8g.print (":");
    if (SunsetMin <10)
    u8g.print("0");
    u8g.print (SunsetMin);
  */
  /* affichage heure zenith*/
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(95,20 );
    if(EEPROM.read(14)<0)
    u8g.print("0");
    u8g.print(EEPROM.read(14));
    u8g.print(":");
    if (EEPROM.read(15) <10)
    u8g.print("0");
    u8g.print (EEPROM.read(15));
  /* affichage maxday */
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(105,30 );
    u8g.print(EEPROM.read(7));
  /* affichage margeAube*/
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(1,30 );
    u8g.print(margeAube);
  /* affichage pwm2*/
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(1,20 );
    u8g.print(pwm2);
  /* affichege heureMidi*/
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(1,40 );
    u8g.print(heureMidi);  
    /* affichage angle */
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(54,60 );
    u8g.print(angle);
    EEPROM.update(13,angle);
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(5,60);
    if(EEPROM.read(9)<10);
    u8g.print("0");
    u8g.print(EEPROM.read(9));
    u8g.print (":");
    if (EEPROM.read(10) <10)
    u8g.print("0");
    u8g.print (EEPROM.read(10));
    u8g.setPrintPos(95,60);
    if(EEPROM.read(11)<10)
    u8g.print("0");
    u8g.print (EEPROM.read(11));
    u8g.print (":");
    if (EEPROM.read(12) <10)
    u8g.print("0");
    u8g.print (EEPROM.read(12));
    maxday = EEPROM.read(7);
    alfa_1=360*now.day()/maxday;
    EEPROM.update(16,alfa_1);
    
    u8g.drawLine(20, 50, 110, 50);//droite du bas de l'écran
    u8g.drawCircle(x0, y0, r, U8G_DRAW_UPPER_RIGHT);//x0=65,y0=50,r=35
    u8g.drawCircle(x0, y0, r, U8G_DRAW_UPPER_LEFT);//cercle
    
    //u8g.drawLine(x0,y0,x0-r*cos(1*angle*2*3.14/360),y0-r*sin(1*angle*2*3.14/360));//droite qui visualise l'angle du soleil
     
     
    u8g.drawXBMP(x1-r_1*cos(1*angle*2*3.14/360),y1-r_1*sin(1*angle*2*3.14/360),u8g_logo_width, u8g_logo_height, u8g_sun_3_bits);//dessin du soleil
    //x1=57,y1=43,r_1=35,u8g_logo_width = 16,u8g_logo_height = 16,
    TimeMins = (now.hour() * 60) + now.minute();
    
    if (TimeMins >= Sunrise && TimeMins <=Sunset-1) { //If it's after sunrise and before sunset, switch our relay on
            digitalWrite (A3, HIGH);// cdt PONT H
            //analogWrite(backlight,255);// lcd rétroéclairage On
            u8g.setColorIndex(1); // Pixel On
      }
       else {  //otherwise switch it off
            digitalWrite (A3,LOW);// cdt PONT H
            //analogWrite(backlight,0);// lcd rétroéclairage Off
            u8g.setColorIndex(0);// Pixel Off
       }    
}

void setup(void) {
   u8g.setContrast(0);//Config the constrast to the best effect
  //u8g.setRot();
  analogWrite(backlight,255);
  // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 )
    u8g.setColorIndex(255);     // white
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
    u8g.setColorIndex(3);         // max intensity
  else if ( u8g.getMode() == U8G_MODE_BW )
    u8g.setColorIndex(1);         // pixel on
    u8g.setFont(u8g_font_6x10);


#ifndef ESP8266
  while (!Serial); // for Leonardo/Micro/Zero
#endif

  Serial.begin(9600);
  if (! RTC.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
   
    RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
    
  }


pinMode(A0,INPUT);//push button on encoder connected to A0 (and GND)
digitalWrite(A0,HIGH); //Pull button high
pinMode (5,OUTPUT); // pwm led horticole
analogWrite(5,0);//pwm led horticole
}

void loop(void) {

    u8g.setFont(u8g_font_6x10);
    DateTime now = RTC.now();
    
    Timer = now.hour(), DEC;
    Minutt = now.minute(), DEC;
    Sekund = now.second(), DEC;
    Serial.print(Timer);
    Serial.print(':');
    Serial.print(Minutt);
    Serial.print(':');
    Serial.print(Sekund);
    Serial.print(" - ");
    an = now.year(), DEC;
    Serial.print(an);
    Serial.print('/');
    luna = now.month(), DEC;
    Serial.print(luna);
    Serial.print('/');
    zi = now.day(), DEC;
    Serial.print(zi);
    Serial.print(" (");
    zis = now.dayOfTheWeek();
    Serial.print(daysOfTheWeek[zis]);
    Serial.println(") ");
    moteur_pas();
  // picture loop
  u8g.firstPage();
  do {
    draw();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(100);

 pushlength = pushlengthset;
 pushlength = getpushlength();
 delay (10);
 
 if (pushlength < pushlengthset)
 {
  //ShortPush ();   
   Serial.println("short push");
    // picture loop
  u8g.firstPage();
  do {
    draw1();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(3000);

 }
  //This runs the setclock routine if the knob is pushed for a long time
       if (pushlength > pushlengthset) {
  //       lcd.clear();
  Serial.println("long push");
         DateTime now = RTC.now();
         setyeartemp=now.year(),DEC;
         setmonthtemp=now.month(),DEC;
         setdaytemp=now.day(),DEC;
         setoretemp=now.hour(),DEC;
         setminstemp=now.minute(),DEC;
         setzitemp = now.dayOfTheWeek();
         setclock();
         pushlength = pushlengthset;
       };
//}

 
} // end main loop

void moteur_pas(){
  position_du_moteur = cptepas*5.6;
  EEPROM.update(17,position_du_moteur);
  {
  if(position_du_moteur < alfa_1 - degrees_pas ){
  monmoteur.step(+1);                   // Avance de 1 pas.
  Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
  Serial.println(cptepas);            // le nbre de pas effectué.
  EEPROM.update(18,cptepas);
  cptepas++;                        // Incrémente la variable cptepas pour compter les pas.
  delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
if(position_du_moteur > alfa_1 + degrees_pas){
  monmoteur.step(-1);
  Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
  Serial.println(cptepas);           // le nbre de pas effectué.
  EEPROM.update(18,cptepas);
  cptepas--;                        // décrémente la variable cptepas pour compter les pas.
  delay(500);                  
   }
  }
}
 
// subroutine to return the length of the button push.
int getpushlength()
{
  buttonstate = digitalRead(A0);  
       if(buttonstate == LOW && buttonflag==false) {     
              pushstart = millis();
              buttonflag = true;
          };     
       if (buttonstate == HIGH && buttonflag==true) {
         pushstop = millis ();
         pushlength = pushstop - pushstart;
         buttonflag = false;
       };
        Serial.println("_");
       return pushlength;
}

void draw1(void) {
  DateTime now = RTC.now();
    // center  
 int x2=128/2;  
 int y2=64/2;  
 // radius  
 int r2=22;
 // angle  
 int alfa_1 = 0;
 maxday = EEPROM.read(7);
 alfa_1=360*now.day()/maxday;
 u8g.setPrintPos(1,10);
 u8g.print(EEPROM.read(16));
 u8g.setPrintPos(30,10);
 u8g.print(EEPROM.read(17));
  EEPROM.update(16,alfa_1);
 u8g.setPrintPos(62,9);
 u8g.print("0");
 u8g.setPrintPos(90,32);
 u8g.print("90");
 u8g.setPrintPos(56,64);
 u8g.print("180");
 u8g.setPrintPos(22,32);
 u8g.print("270");
 u8g.drawLine(x2,y2, x2+r2*sin(1*alfa_1*2*3.14/360), y2-r2*cos(1*alfa_1*2*3.14/360));  
 u8g.drawCircle(x2, y2, r2);
}
         
//}
//sets the clock
void setclock (){
   setyear ();//Annee
   setmonth ();//Mois
   setday ();//Jour
   setzi();//semaine
   setore ();//hours
   setmins ();//Minutes
   RTC.adjust(DateTime(setyeartemp,setmonthtemp,setdaytemp,setoretemp,setminstemp,setsecs));
   CalcSun();
   delay (1000);
}

   
 
 
int CalcSun () { //Calculates the Sunrise and Sunset times
    DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    uint16_t time = now.hour() * 60 + now.minute();
    uint16_t angle = map(time, Sunrise, Sunset, 0, 180);
    return angle;
    if(angle < 0)
     angle = 0;
    else if(angle > 180)
     angle = 180;
}     
// The following subroutines set the individual clock parameters
int setyear () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setyeartemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) { //bit of software de-bounce
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setyeartemp=setyeartemp + knobval;
    if (setyeartemp < 2018) { //Year can't be older than currently, it's not a time machine.
      setyeartemp = 2018;
    }
//itoa(setyeartemp - 2000, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
itoa(setyeartemp, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
  u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Annee");
//  u8g.drawStr( 0, 40, "20");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );  
    setyear();
}

int setmonth () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setmonthtemp;
    }

 //   lcd.setCursor (0,1);
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setmonthtemp=setmonthtemp + knobval;
    if (setmonthtemp < 1) {// month must be between 1 and 12
      setmonthtemp = 1;
    }
    if (setmonthtemp > 12) {
      setmonthtemp=12;
    }
    itoa(setmonthtemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Mois");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmonth();
}


int setday () {
  if (setmonthtemp == 4 || setmonthtemp == 5 || setmonthtemp == 9 || setmonthtemp == 11) { //30 days hath September, April June and November
    maxday = 30;
  }
  else {
  maxday = 31; //... all the others have 31
  }
  if (setmonthtemp ==2 && setyeartemp % 4 ==0) { //... Except February alone, and that has 28 days clear, and 29 in a leap year.
    maxday = 29;
  }
  if (setmonthtemp ==2 && setyeartemp % 4 !=0) {
    maxday = 28;
  }
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setdaytemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setdaytemp = setdaytemp+ knobval;
    if (setdaytemp < 1) {
      setdaytemp = 1;
    }
    if (setdaytemp > maxday) {
      setdaytemp = maxday;
      
    }
  itoa(setdaytemp, tmp_string, 10);
      u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setday();
}


int setzi () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setzitemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setzitemp=setzitemp + knobval;
    if (setzitemp < 0) {// month must be between 0 and 6
      setzitemp = 0;
    }
    if (setzitemp > 6) {
      setzitemp=6;
    }
    itoa(setzitemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour of Week");
  u8g.drawStr(25, 40, tmp_string);
  u8g.drawStr(0,60, daysOfTheWeek[setzitemp]);
  } while( u8g.nextPage() );
    setzi();
}

int setore () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setoretemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setoretemp=setoretemp + knobval;
    if (setoretemp < 0) {
      setoretemp = 0;
    }
    if (setoretemp > 23) {
      setoretemp=23;
    }
   itoa(setoretemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Heures");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setore();
}

int setmins () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setminstemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setminstemp=setminstemp + knobval;
    if (setminstemp < 0) {
      setminstemp = 0;
    }
    if (setminstemp > 59) {
      setminstemp=59;
    }
   itoa(setminstemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Minutes");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmins();
}



 
 
 
 
 
 


#82 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 17 janvier 2020 - 05:45

re Bonsoir Sandro,

voila le code complet ;

appui court sur encoder :passe de l’écran visu course du soleil à écran turntable .

appui long reglages rtc .

je parler d'oscillation ,plutôt ajustement de degrés le moteur stepper (+)

et ensuite stepper(-)

bonne soirée, michel .

#include <Wire.h>
#include "RTClib.h"
#include <Encoder.h> // from http://www.pjrc.com/teensy/td_libs_Encoder.html
Encoder knob(2, 3); //encoder connected to pins 2 and 3 (and ground)// D2 SEEDSTUDIO shield //3,4
#include <TimeLib.h>
#include <TimeLord.h>
#include <EEPROM.h>
#include <Stepper.h>
const float LATITUDE = 43.70, LONGITUDE = 7.25; // Nice Sun
const int TIMEZONE = + 1;
int r   = 35;//cercle drawLine
int r_1 = 35;//drawbitmap
int angle = 0;
int x1=57;// drawbitmap rattrapage width  65-8 = 57
int y1=42;// drawbitmap rattrapage height 50-8 = 42
int x0=65;// drawLine
int y0=50;// drawLine
int sun;
//int alfa = 0;
int alfa_1 = 0;

int degre = 0;

//int backlight = 6; //backlight control pin 6
                                     
const int nbrepas360 = 48;                        // Fixe le nombre de pas pour faire un tour complet, c'est-à-dire 360°.
Stepper monmoteur (nbrepas360, 8, 9, 10, 11);    // Initialise la librairie Stepper.h
int cptepas = 0;                                // Stockera le nombre de pas compté.
float position_du_moteur=0;

int degrees_pas = 0.5;
#define u8g_logo_width 16
#define u8g_logo_height 16

#if defined(ARDUINO_ARCH_SAMD)
// for Zero, output on USB Serial console, remove line below if using programming port to program the Zero!
   #define Serial SerialUSB
#endif
RTC_DS1307 RTC;
char daysOfTheWeek[7][12] = {"Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"};

#include "U8glib.h"
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);
//U8GLIB_SSD1309_128X64 u8g(U8G_I2C_OPT_NONE);
//U8GLIB_ST7920_128X64 u8g(13, 11, 12, U8G_PIN_NONE);//U8GLIB_ST7920_128X64_1X u8g(7, 6, 5 ,8); //Enable, RW, RS, RESET
/*
const uint8_t bonsai_bitmap[] PROGMEM = {

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x80,0x00,0x00,0x00,0x00,0x00,0x00, // .................................................................########.......................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xF3,0xF0,0x00,0x00,0x00,0x00,0x00, // ............................................................################..######............................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00, // ........................................................###############################.........................................
  0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xFF,0xFE,0x7F,0x00,0x00,0x00,0x00,0x00, // ............................................###################################..#######........................................
  0x00,0x00,0x00,0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xF8,0x1F,0x00,0x00,0x00,0x00,0x00, // ...........................................##################################......#####........................................
  0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x7F,0x00,0x00,0x00, // ................................................#################################................#######........................
  0x00,0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0xF8,0x01,0xFF,0x83,0xE0,0x00, // ..........................................###########################################..........##########.....#####.............
  0x00,0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0xFC,0x19,0xFC,0xFF,0xF0,0x00, // ..........................................############################################.....##..#######..############............
  0x00,0x00,0x00,0x00,0x00,0x07,0xFF,0xFF,0xFD,0xFF,0x30,0x3F,0xFF,0xFF,0xE0,0x00, // .............................................#########################.#########..##......#########################.............
  0x00,0x00,0x00,0x00,0x00,0x1F,0xFF,0xFF,0xF8,0x00,0x07,0xFF,0xFF,0xFC,0x00,0x00, // ...........................................##########################................#########################..................
  0x00,0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0xE0,0x00,0x7F,0xFF,0xFF,0xFC,0xF8,0x00, // ..........................................#########################..............#############################..#####...........
  0x00,0x00,0x00,0x00,0x1C,0x1F,0xFF,0x8F,0x80,0x3F,0xFF,0xFF,0xFF,0xFF,0xF8,0x00, // ...................................###.....##############...#####.........###########################################...........
  0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0x87,0xFF,0xFF,0xFF,0xFF,0x80,0x7F,0xE0,0x00, // ..................................#######################....####################################........##########.............
  0x00,0x00,0x00,0x00,0x3F,0xFF,0xFF,0x87,0xFF,0xC0,0x03,0xC3,0xE0,0x00,0x00,0x00, // ..................................#######################....#############............####....#####.............................
  0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x0F,0xF0,0x00,0x00,0x01,0xE0,0x00,0x00,0x00, // ........................................################....########...........................####.............................
  0x00,0x00,0x00,0x00,0x01,0xFF,0x87,0xFF,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // .......................................##########....############...............................................................
  0x00,0x00,0x00,0x00,0x00,0x0F,0xF0,0xFF,0x00,0x00,0x00,0x03,0xFC,0x00,0x00,0x00, // ............................................########....########..............................########..........................
  0x00,0x00,0x3F,0xE7,0xDF,0x01,0xF0,0x3F,0xC0,0x00,0x7F,0x07,0xC0,0x07,0xF0,0x00, // ..................#########..#####.#####.......#####......########...............#######.....#####...........#######............
  0x00,0x00,0x1F,0xFF,0xFF,0xF8,0x00,0x1F,0xF8,0x00,0xFF,0xFF,0xFF,0xFF,0xF0,0x00, // ...................##########################..............##########...........####################################............
  0x00,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xBF,0xFF,0xE0,0x3F,0xFF,0xFF,0xFF,0xF8,0x00, // .......................##################################.#################.......###################################...........
  0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xE1,0xFF,0xFF,0xFF,0xFF,0xFF,0x00, // ...................########################################################....#########################################........
  0x00,0xDF,0xBF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80, // ........##.######.#######################################################################################################.......
  0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80, // .......##################################################################################################################.......
  0x03,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x00,0x7F,0xFF,0xFF,0xFF,0xE0,0x00, // ......#################################################################..........##################################.............
  0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF0,0x00,0x3F,0xFF,0xFF,0xFF,0xFF,0x00, // .......#############################################################..............######################################........
  0x00,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x1F,0xFF,0xFF,0xFF,0x0E,0x00, // .........#######################################################...................#############################....###.........
  0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0x87,0xFC,0x03,0xF0,0x00,0x1F,0x0F,0xFC,0x00,0x00, // ...........######################################....#########........######...............#####....##########..................
  0x00,0x3F,0xFF,0xFF,0xC7,0xFF,0x1F,0xF0,0xE3,0xF9,0xE0,0x0E,0x0F,0xFF,0x80,0x00, // ..........########################...###########...#########....###...#######..####.........###.....#############...............
  0x00,0xFF,0xFF,0xF3,0x80,0x00,0x1F,0xC1,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00, // ........####################..###..................#######.....#####################............................................
  0x00,0x7E,0x1F,0xE7,0x80,0x00,0x7F,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x00,0x00,0x00, // .........######....########..####................########################################.......................................
  0x00,0x3E,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0x00,0x00,0x00, // ..........#####.................................##########################################......................................
  0x00,0x00,0x00,0x00,0x00,0x03,0xFF,0x0C,0x7C,0x3F,0x03,0xC0,0x00,0x00,0x00,0x00, // ..............................................##########....##...#####....######......####......................................
  0x00,0x00,0x00,0x00,0x00,0x07,0xFC,0x00,0x00,0x07,0xF8,0x00,0x00,0x00,0x00,0x00, // .............................................#########.......................########...........................................
  0x00,0x00,0x00,0x00,0x00,0x07,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // .............................................#########..........................................................................
  0x00,0x00,0x00,0x00,0x00,0x0F,0xFC,0x00,0x00,0x01,0x00,0x00,0x01,0x40,0x00,0x00, // ............................................##########.........................#.......................#.#......................
  0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xC0,0x00,0x01,0x00,0x00,0x00,0x00,0xE0,0x00, // ............................................##############.....................#................................###.............
  0x00,0x00,0x00,0x00,0x00,0x07,0xFF,0xFC,0x00,0x01,0xC6,0x31,0xCC,0x81,0x10,0x00, // .............................................#################.................###...##...##...###..##..#......#...#............
  0x00,0x00,0x00,0x00,0x00,0x03,0xFF,0xFF,0x80,0x01,0x29,0x4A,0x12,0x81,0x10,0x00, // ..............................................###################..............#..#.#..#.#..#.#....#..#.#......#...#............
  0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0xFF,0xC0,0x01,0x29,0x49,0x9E,0x81,0x10,0x00, // ....................................................##############.............#..#.#..#.#..#..##..####.#......#...#............
  0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xFF,0xE0,0x01,0x29,0x48,0x52,0x80,0xA0,0x00, // ......................................................#############............#..#.#..#.#..#....#.#..#.#.......#.#.............
  0x00,0x00,0x00,0x00,0x00,0x00,0x07,0xFF,0xF0,0x00,0xC6,0x4B,0x92,0x91,0xB0,0x00, // .....................................................###############............##...##..#..#.###..#..#.#..#...##.##............
  0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................#####################...........................................................
  0x00,0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x00,0x00,0x00, // ...........................##############################################################.......................................
  0x00,0x00,0x0F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00, // ....................############################################################################................................
  0x00,0x00,0x7F,0xE0,0x00,0x1F,0xFF,0xE0,0x00,0x00,0x00,0x3F,0xF0,0x00,0x00,0x00, // .................##########................################...............................##########............................
  0x00,0x00,0x78,0x03,0xE0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x00,0x00, // .................####.........#####.............................................................####............................
  0x00,0x00,0x7F,0x73,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x70,0x00,0x00,0x00, // .................#######.###..########..................................................#####....###............................
  0x00,0x00,0x3F,0xFF,0xC0,0x00,0x00,0x00,0x00,0x00,0x07,0xFF,0xF0,0x00,0x00,0x00, // ..................################...................................................###############............................
  0x00,0x00,0x1F,0xFF,0xE0,0x00,0x00,0x00,0x00,0x00,0x1F,0xFF,0xE0,0x00,0x00,0x00, // ...................################................................................################.............................
  0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x00,0x00, // ........................#########################################################################...............................
  0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00, // .........................######################################################################.................................
  0x00,0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF8,0x00,0x00,0x00,0x00, // ...........................##################################################################...................................
  0x00,0x00,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0x00,0x00,0x00, // .............................#############################################################......................................
  0x00,0x00,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00, // ...............................#########################################################........................................
  0x00,0x00,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00, // ...............................########################################################.........................................
  0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF8,0x00,0x00,0x00,0x00,0x00, // ................................#####################################################...........................................
  0x00,0x00,0x00,0x00,0x0F,0xFF,0xFF,0xFF,0xFF,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00, // ....................................################################################............................................
  0x00,0x00,0x00,0x00,0x0F,0xC0,0x00,0xFF,0xC0,0x07,0xE0,0x00,0x00,0x00,0x00,0x00, // ....................................######..............##########...........######.............................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................................................................................
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  // ................................................................................................................................
};
0x00, 0x00, 0x80, 0x00, 0x80, 0x01, 0x84, 0x10, 0x08, 0x08, 0xe0, 0x03, 0x10, 0x04, 0x10, 0x04, 0x17, 0x74, 0x10, 0x04, 0x10, 0x04, 0xe0, 0x03, 0x08, 0x08, 0x84, 0x10, 0x80, 0x01, 0x00, 0x00
*/
static unsigned char u8g_sun_3_bits[] U8G_PROGMEM = {// soleil
0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x90, 0x04, 0xa0, 0x02, 0xc0, 0x01, 0xfc, 0x1f, 0xc0, 0x01, 0xa0, 0x02, 0x90, 0x04, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/*
int X = 0;
int Y = 0;
int I = 0;
int X2 = 0;
int Y2 = 0;
int X3 = 0;
int Y3 = 0;
*/
int Timer = 0;
int Minutt = 0;
int Sekund = 0;
float Vinkel = 0;
int an = 0;
int luna = 0;
int zi = 0;
int zis = 0;
/*
int ScreenWith = 128;
int ScreenWithC = 64;
int ScreenHeight = 64;
int ScreenHeightC = 32;
int yArray[128];
int deics = ScreenWith/4;
int deigrec = 14;
int deics2 = 0;
int de = 10;
*/
//the variables provide the holding values for the set clock routine
int setyeartemp;
int setmonthtemp;
int setdaytemp;
int setoretemp;
int setzitemp;
int setminstemp;
int setsecs = 0;
int maxday; // maximum number of days in the given month
int TimeMins; // number of seconds since midnight
int TimerMode = 2; //mode 0=Off 1=On 2=Auto
int TimeOut = 10;
int TimeOutCounter;

// These variables are for the push button routine
int buttonstate = 0; //flag to see if the button has been pressed, used internal on the subroutine only
int pushlengthset = 1500; // value for a long push in mS
int pushlength = pushlengthset; // set default pushlength
int pushstart = 0;// sets default push value for the button going low
int pushstop = 0;// sets the default value for when the button goes back high
int pwm2  ;// pwm Sun
int margeAube,margeCrepuscule;
int heureMidi;
int Sunrise, Sunset,Sun_zenith ; //sunrise and sunset expressed as minute of day (0-1439)
TimeLord myLord; // TimeLord Object, Global variable
byte sunTime[]  = {0, 0, 0, 1, 1, 13}; // 17 Oct 2013
int SunriseHour, SunriseMin, SunsetHour, SunsetMin,zenithHour,zenithMin,zenith,zenith_Hour,zenith_Min ;
int knobval; // value for the rotation of the knob
boolean buttonflag = false; // default value for the button flag
//#define buton 4
//char s[3] = "";
int backlight = 6;//backlight control pin 6
#include <stdlib.h>
char tmp_string[8];

void draw(void) {
      DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    EEPROM.update(14,zenith_Hour);
    EEPROM.update(15,zenith_Min);
    zenithMin = (Sunset+Sunrise)/2;
    zenith_Min = (zenithMin)%60;
    zenithHour = (Sunset+Sunrise)/2;
    zenith_Hour = (zenithHour)/60;
    TimeMins = (now.hour() * 60) + now.minute();
    uint16_t time = now.hour() * 60 + now.minute();
    uint16_t angle =   map(time, Sunrise, Sunset, 0, 180);// Angle
    /*evite de depasser l'angle*/
    if(angle < 0)
      angle = 0;
    else if(angle > 180)
     angle = 180;
    margeAube = (Sunset - Sunrise)/180*6;            //calcul de la durer de uint16_t angle multiplier par 6° angle Aube Civil
    heureMidi = (Sunrise + Sunset)/2;
    margeCrepuscule =(Sunset - Sunrise)/180*6; //calcul de la durer de uint16_t angle multiplier par 6° angle Crepuscule Civil
    
    if(TimeMins < heureMidi ){
    pwm2 = map ( time, Sunrise - margeAube, heureMidi, 0, 255);
    }
    else {
    pwm2 = map ( time, heureMidi, Sunset + margeCrepuscule, 255, 0);
    }
    if(pwm2<0) {
        pwm2=0;
    }
    analogWrite(5,pwm2);// PIN 5 timer 8 bits
    int maxday;// maximum de jours
   if (now.month() == 4 || now.month() == 5 || now.month() == 9 || now.month() == 11){  //30 jours =  Septembre, Avril, Juin,  Novembre.
    maxday = 30;
  EEPROM.update(7,maxday);
    
  }
  else {
    maxday = 31; //... all the others have 31
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 == 0){  //... Exception Fevrier = 28 jours , ou 29 jours année bissextile.
    maxday = 29;
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 != 0){
    maxday = 28;
    EEPROM.update(7,maxday);
  }

    EEPROM.update(9,SunriseHour);
    EEPROM.update(10,SunriseMin);
    EEPROM.update(11,SunsetHour);
    EEPROM.update(12,SunsetMin);
    EEPROM.update(13,angle);
    u8g.setFont(u8g_font_6x13);   
    u8g.setPrintPos(2,10);
    if (zi < 10) u8g.print("0");
    u8g.print(zi);
    u8g.print("/");
    if (luna < 10) u8g.print("0");
    u8g.print(luna);
    u8g.print("/");
    u8g.setPrintPos(40,10);
    u8g.print(daysOfTheWeek[zis]);

    u8g.setFont(u8g_font_6x13);
    u8g.setPrintPos(80,10);
    if (Timer < 10) u8g.print(" ");
    u8g.print(Timer);
    u8g.setPrintPos(93,10);
    if (Sekund%2 != 1)
    u8g.print(":");
    u8g.setPrintPos(115,10);
    u8g.setFont(u8g_font_6x10);
    if(Sekund<10)u8g.print("0");
    u8g.print(Sekund);
    u8g.setPrintPos(100,10);
    u8g.setFont(u8g_font_6x13);
    if (Minutt < 10) u8g.print("0");
    u8g.print(Minutt);
    
    // Display sun moon //
/*
    u8g.setPrintPos(8,20);
    u8g.setFont(u8g_font_6x10);
    u8g.print("Sun");
    u8g.setPrintPos(27,20);
    u8g.print("R");
    u8g.setPrintPos(34,20);
    if(SunriseHour<10);
    u8g.print("0");
    u8g.print(SunriseHour);
    u8g.print (":");
    if (SunriseMin <10)
    u8g.print("0");
    u8g.print (SunriseMin);
    u8g.setPrintPos(85,20);
    u8g.print ("S");
    u8g.setPrintPos(93,20);
    if(SunsetHour<10)
    u8g.print("0");
    u8g.print (SunsetHour);
    u8g.print (":");
    if (SunsetMin <10)
    u8g.print("0");
    u8g.print (SunsetMin);
  */
  /* affichage heure zenith*/
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(95,20 );
    if(EEPROM.read(14)<0)
    u8g.print("0");
    u8g.print(EEPROM.read(14));
    u8g.print(":");
    if (EEPROM.read(15) <10)
    u8g.print("0");
    u8g.print (EEPROM.read(15));
  /* affichage maxday */
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(105,30 );
    u8g.print(EEPROM.read(7));
  /* affichage margeAube*/
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(1,30 );
    u8g.print(margeAube);
  /* affichage pwm2*/
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(1,20 );
    u8g.print(pwm2);
  /* affichege heureMidi*/
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(1,40 );
    u8g.print(heureMidi);  
    /* affichage angle */
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(54,60 );
    u8g.print(angle);
    EEPROM.update(13,angle);
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(5,60);
    if(EEPROM.read(9)<10);
    u8g.print("0");
    u8g.print(EEPROM.read(9));
    u8g.print (":");
    if (EEPROM.read(10) <10)
    u8g.print("0");
    u8g.print (EEPROM.read(10));
    u8g.setPrintPos(95,60);
    if(EEPROM.read(11)<10)
    u8g.print("0");
    u8g.print (EEPROM.read(11));
    u8g.print (":");
    if (EEPROM.read(12) <10)
    u8g.print("0");
    u8g.print (EEPROM.read(12));
    maxday = EEPROM.read(7);
    alfa_1=360*now.day()/maxday;
    EEPROM.update(16,alfa_1);
    
    u8g.drawLine(20, 50, 110, 50);//droite du bas de l'écran
    u8g.drawCircle(x0, y0, r, U8G_DRAW_UPPER_RIGHT);//x0=65,y0=50,r=35
    u8g.drawCircle(x0, y0, r, U8G_DRAW_UPPER_LEFT);//cercle
    
    //u8g.drawLine(x0,y0,x0-r*cos(1*angle*2*3.14/360),y0-r*sin(1*angle*2*3.14/360));//droite qui visualise l'angle du soleil
     
     
    u8g.drawXBMP(x1-r_1*cos(1*angle*2*3.14/360),y1-r_1*sin(1*angle*2*3.14/360),u8g_logo_width, u8g_logo_height, u8g_sun_3_bits);//dessin du soleil
    //x1=57,y1=43,r_1=35,u8g_logo_width = 16,u8g_logo_height = 16,
    TimeMins = (now.hour() * 60) + now.minute();
    
    if (TimeMins >= Sunrise && TimeMins <=Sunset-1) { //If it's after sunrise and before sunset, switch our relay on
            digitalWrite (A3, HIGH);// cdt PONT H
            //analogWrite(backlight,255);// lcd rétroéclairage On
            u8g.setColorIndex(1); // Pixel On
      }
       else {  //otherwise switch it off
            digitalWrite (A3,LOW);// cdt PONT H
            //analogWrite(backlight,0);// lcd rétroéclairage Off
            u8g.setColorIndex(0);// Pixel Off
       }    
}

void setup(void) {
   u8g.setContrast(0);//Config the constrast to the best effect
  //u8g.setRot();
  analogWrite(backlight,255);
  // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 )
    u8g.setColorIndex(255);     // white
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
    u8g.setColorIndex(3);         // max intensity
  else if ( u8g.getMode() == U8G_MODE_BW )
    u8g.setColorIndex(1);         // pixel on
    u8g.setFont(u8g_font_6x10);


#ifndef ESP8266
  while (!Serial); // for Leonardo/Micro/Zero
#endif

  Serial.begin(9600);
  if (! RTC.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
   
    RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
    
  }


pinMode(A0,INPUT);//push button on encoder connected to A0 (and GND)
digitalWrite(A0,HIGH); //Pull button high
pinMode (5,OUTPUT); // pwm led horticole
analogWrite(5,0);//pwm led horticole
}

void loop(void) {

    u8g.setFont(u8g_font_6x10);
    DateTime now = RTC.now();
    
    Timer = now.hour(), DEC;
    Minutt = now.minute(), DEC;
    Sekund = now.second(), DEC;
    Serial.print(Timer);
    Serial.print(':');
    Serial.print(Minutt);
    Serial.print(':');
    Serial.print(Sekund);
    Serial.print(" - ");
    an = now.year(), DEC;
    Serial.print(an);
    Serial.print('/');
    luna = now.month(), DEC;
    Serial.print(luna);
    Serial.print('/');
    zi = now.day(), DEC;
    Serial.print(zi);
    Serial.print(" (");
    zis = now.dayOfTheWeek();
    Serial.print(daysOfTheWeek[zis]);
    Serial.println(") ");
    moteur_pas();
  // picture loop
  u8g.firstPage();
  do {
    draw();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(100);

 pushlength = pushlengthset;
 pushlength = getpushlength();
 delay (10);
 
 if (pushlength < pushlengthset)
 {
  //ShortPush ();   
   Serial.println("short push");
    // picture loop
  u8g.firstPage();
  do {
    draw1();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(3000);

 }
  //This runs the setclock routine if the knob is pushed for a long time
       if (pushlength > pushlengthset) {
  //       lcd.clear();
  Serial.println("long push");
         DateTime now = RTC.now();
         setyeartemp=now.year(),DEC;
         setmonthtemp=now.month(),DEC;
         setdaytemp=now.day(),DEC;
         setoretemp=now.hour(),DEC;
         setminstemp=now.minute(),DEC;
         setzitemp = now.dayOfTheWeek();
         setclock();
         pushlength = pushlengthset;
       };
//}

 
} // end main loop

void moteur_pas(){
  position_du_moteur = cptepas*5.6;
  EEPROM.update(17,position_du_moteur);
  {
  if(position_du_moteur < alfa_1 - degrees_pas ){
  monmoteur.step(+1);                   // Avance de 1 pas.
  Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
  Serial.println(cptepas);            // le nbre de pas effectué.
  EEPROM.update(18,cptepas);
  cptepas++;                        // Incrémente la variable cptepas pour compter les pas.
  delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
if(position_du_moteur > alfa_1 + degrees_pas){
  monmoteur.step(-1);
  Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
  Serial.println(cptepas);           // le nbre de pas effectué.
  EEPROM.update(18,cptepas);
  cptepas--;                        // décrémente la variable cptepas pour compter les pas.
  delay(500);                  
   }
  }
}
 
// subroutine to return the length of the button push.
int getpushlength()
{
  buttonstate = digitalRead(A0);  
       if(buttonstate == LOW && buttonflag==false) {     
              pushstart = millis();
              buttonflag = true;
          };     
       if (buttonstate == HIGH && buttonflag==true) {
         pushstop = millis ();
         pushlength = pushstop - pushstart;
         buttonflag = false;
       };
        Serial.println("_");
       return pushlength;
}

void draw1(void) {
  DateTime now = RTC.now();
    // center  
 int x2=128/2;  
 int y2=64/2;  
 // radius  
 int r2=22;
 // angle  
 int alfa_1 = 0;
 maxday = EEPROM.read(7);
 alfa_1=360*now.day()/maxday;
 u8g.setPrintPos(1,10);
 u8g.print(EEPROM.read(16));
 u8g.setPrintPos(30,10);
 u8g.print(EEPROM.read(17));
  EEPROM.update(16,alfa_1);
 u8g.setPrintPos(62,9);
 u8g.print("0");
 u8g.setPrintPos(90,32);
 u8g.print("90");
 u8g.setPrintPos(56,64);
 u8g.print("180");
 u8g.setPrintPos(22,32);
 u8g.print("270");
 u8g.drawLine(x2,y2, x2+r2*sin(1*alfa_1*2*3.14/360), y2-r2*cos(1*alfa_1*2*3.14/360));  
 u8g.drawCircle(x2, y2, r2);
}
         
//}
//sets the clock
void setclock (){
   setyear ();//Annee
   setmonth ();//Mois
   setday ();//Jour
   setzi();//semaine
   setore ();//hours
   setmins ();//Minutes
   RTC.adjust(DateTime(setyeartemp,setmonthtemp,setdaytemp,setoretemp,setminstemp,setsecs));
   CalcSun();
   delay (1000);
}

   
 
 
int CalcSun () { //Calculates the Sunrise and Sunset times
    DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    uint16_t time = now.hour() * 60 + now.minute();
    uint16_t angle = map(time, Sunrise, Sunset, 0, 180);
    return angle;
    if(angle < 0)
     angle = 0;
    else if(angle > 180)
     angle = 180;
}     
// The following subroutines set the individual clock parameters
int setyear () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setyeartemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) { //bit of software de-bounce
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setyeartemp=setyeartemp + knobval;
    if (setyeartemp < 2018) { //Year can't be older than currently, it's not a time machine.
      setyeartemp = 2018;
    }
//itoa(setyeartemp - 2000, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
itoa(setyeartemp, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
  u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Annee");
//  u8g.drawStr( 0, 40, "20");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );  
    setyear();
}

int setmonth () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setmonthtemp;
    }

 //   lcd.setCursor (0,1);
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setmonthtemp=setmonthtemp + knobval;
    if (setmonthtemp < 1) {// month must be between 1 and 12
      setmonthtemp = 1;
    }
    if (setmonthtemp > 12) {
      setmonthtemp=12;
    }
    itoa(setmonthtemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Mois");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmonth();
}


int setday () {
  if (setmonthtemp == 4 || setmonthtemp == 5 || setmonthtemp == 9 || setmonthtemp == 11) { //30 days hath September, April June and November
    maxday = 30;
  }
  else {
  maxday = 31; //... all the others have 31
  }
  if (setmonthtemp ==2 && setyeartemp % 4 ==0) { //... Except February alone, and that has 28 days clear, and 29 in a leap year.
    maxday = 29;
  }
  if (setmonthtemp ==2 && setyeartemp % 4 !=0) {
    maxday = 28;
  }
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setdaytemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setdaytemp = setdaytemp+ knobval;
    if (setdaytemp < 1) {
      setdaytemp = 1;
    }
    if (setdaytemp > maxday) {
      setdaytemp = maxday;
      
    }
  itoa(setdaytemp, tmp_string, 10);
      u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setday();
}


int setzi () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setzitemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setzitemp=setzitemp + knobval;
    if (setzitemp < 0) {// month must be between 0 and 6
      setzitemp = 0;
    }
    if (setzitemp > 6) {
      setzitemp=6;
    }
    itoa(setzitemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour of Week");
  u8g.drawStr(25, 40, tmp_string);
  u8g.drawStr(0,60, daysOfTheWeek[setzitemp]);
  } while( u8g.nextPage() );
    setzi();
}

int setore () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setoretemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setoretemp=setoretemp + knobval;
    if (setoretemp < 0) {
      setoretemp = 0;
    }
    if (setoretemp > 23) {
      setoretemp=23;
    }
   itoa(setoretemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Heures");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setore();
}

int setmins () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setminstemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setminstemp=setminstemp + knobval;
    if (setminstemp < 0) {
      setminstemp = 0;
    }
    if (setminstemp > 59) {
      setminstemp=59;
    }
   itoa(setminstemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Minutes");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmins();
}



 


#83 Sandro

Sandro

    Membre passionné

  • Membres
  • PipPipPip
  • 339 messages
  • Gender:Male

Posté 17 janvier 2020 - 05:52

Bonsoir,

le problème est la ligne suivante :

int degrees_pas = 0.5;

Si tu déclare degrees_pas comme étant un int, et que tu essaye d'y stoquer un nombre décimal (0.5), le nombre décimal sera automatiquement arrondi à l'inférieur : degrees_pas vaut donc 0 (et n'a donc aucun effet dans les tests pour éviter les oscilations).

 

Il faut que tu remplaces "int" par "float".

 

La ligne devient donc :

float degrees_pas = 0.5;

ça devrait résoudre le problème.

 

Bonne soirée

Sandro

 

PS : essaye à l'occasion de faire un peu le ménage dans ton code :

- tu mélanges au moins 3 langues différentes dans ton code

- dans la fonction "void moteur_pas()" tu as une paire d’accolades qui ne servent à rien

- tu as un #ifdef ESP... à un moment que tu peux enlver avec son contenu (tu utilise un arduino et pas un ESP)

- des bouts de codes commentés qui n'ont plus l'air de servir

- et probablement d'autres choses encore que je n'ai pas vu en cherchant l'erreur des oscillations
 




 



#84 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 18 janvier 2020 - 11:51

bonjour Sandro ,

j'ai dû mettre 1 degré de tolérance pour éviter les oscillations .

j'ai un autre soucis c'est qu' au redémarrage de la carte ça recompte les pas

peut-être à cause de float position du moteur = 0;

malgré que je l'enregistre en EEPROM.update () et récupére l'info en EEPROM.read()

il repart de zéro .

void moteur_pas(){
  position_du_moteur = cptepas*5.625;
  EEPROM.update(17,position_du_moteur);
  {
  if(EEPROM.read(17) < alfa_1 - degrees_pas ){
  monmoteur.step(+1);                   // Avance de 1 pas.
  Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
  Serial.println(cptepas);            // le nbre de pas effectué.
  EEPROM.update(18,cptepas);
  cptepas++;                        // Incrémente la variable cptepas pour compter les pas.
  delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
if(EEPROM.read(17) > alfa_1 + degrees_pas){
  monmoteur.step(-1);
  Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
  Serial.println(cptepas);           // le nbre de pas effectué.
  EEPROM.update(18,cptepas);
  cptepas--;                        // décrémente la variable cptepas pour compter les pas.
  delay(500);                  
   }
 }
}


#85 Sandro

Sandro

    Membre passionné

  • Membres
  • PipPipPip
  • 339 messages
  • Gender:Male

Posté 18 janvier 2020 - 08:25

Bonsoir,

Le problème est que quand tu déclare int cptepas = 0;   , cptepas vas valoir 0. Donc quand tu exécute moteur_pas pour la première fois, postion_du_moteur vas valoir cptepas*5.625=0*5.625=0. Juste après, tu enregistre cette valeur (ie 0) dans l'EEPROM, avant de la lire : du coup, tu vas forcément lire 0!.

 

Ce que tu devrais stoquer, c'est donc cptepas, et pas position_du_moteur.

Je te propose la structure suivante :

- dans la fonction setup, tu vas lire cptepas dans l'EEPROM

- dans ta fonction moteur_pas, tu fais tous les calculs sans refaire de lecture dans l'eeprom, et tout à la fin de la fonction, tu enregistre la nouvelle valeur de cptepas dans l'eeprom.

 

Bonne soirée

Sandro



#86 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 21 janvier 2020 - 05:59

bonsoir Sandro,

je ne sais pas si j'ai bien fait ce que tu m'a conseiller de faire .

je te joint le code :

je suis un peu larguer sur ce coup .

j'ai l'impression que le moteur n'avance pas d'un pas .

bonne soirée ..

void moteur_pas(){
  position_du_moteur = cptepas*5.625;
  cptepas =  EEPROM.read(18);
  EEPROM.update(17,position_du_moteur);   
  {
  if(EEPROM.read(17) < alfa_1 - degrees_pas ){
  monmoteur.step(+1);                   // Avance de 1 pas.
  cptepas++;
  EEPROM.update(18,cptepas);// Incrémente la variable cptepas pour compter les pas.
  Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
  Serial.println(cptepas);// le nbre de pas effectué.
  delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
if(EEPROM.read(17) > alfa_1 + degrees_pas){
  monmoteur.step(-1);
  cptepas--;// décrémente la variable cptepas pour compter les pas.
  EEPROM.update(18,cptepas);// decrémente la variable cptepas pour compter les pas.
  Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
  Serial.println(cptepas); // le nbre de pas effectué.                   
  delay(500);                  
   }
 }
}
 


#87 Sandro

Sandro

    Membre passionné

  • Membres
  • PipPipPip
  • 339 messages
  • Gender:Male

Posté 21 janvier 2020 - 06:52

Bonsoir,

- La variable "position_du_moteur", ça ne sert plus a rien de la sauvegarder dans l'EEPROM, puisque tu la recalcule à partir de cptepas (qui pour le coup est sauvegardé dans l'EEPROM).

- Tu as aussi une paire d’accolades (ouverture ligne 5, fermeture avant dernière ligne) totalement inutiles dans ton code, qui le rendent moins lisible

- la lecture de cptepas depuis l'EEPROM devrait se faire avant de calculer cptepas, sinon au démarage tu utilise une valeur "aléatoire" au lieu de celle stoquée dans l'EEPROM.

- tu utilise uniquement des variables globales (ie visibles dans tout le code), ce qui correspond à les déclarer en dehors de toute fonction. Si tu utilise des variables locales (ie déclarées dans une fonction), alors elles ne seront visible (ie accessibles) que dans cette fonction, ce qui améliore la lisibilité et garant que tu ne les utilise pas ailleurs pour autre chose. Nb : il peut parfois être pratique d'utiliser des variables globales pour des variables auxquelles tu as besoin d'accéder depuis un peu partout, mais dans les autres cas évite.

 

Je te propose donc le code suivant :

void moteur_pas(){
  int cptepas2 =  EEPROM.read(18);
  float position_du_moteur2 = cptepas2*5.625;
  if(position_du_moteur2 < alfa_1 - degrees_pas ){
    monmoteur.step(+1);                   // Avance de 1 pas.
    cptepas2++;
    EEPROM.update(18,cptepas2);// Incrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
    Serial.println(cptepas2);// le nbre de pas effectué.
    delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
  if(position_du_moteur2 > alfa_1 + degrees_pas){
    monmoteur.step(-1);
    cptepas2--;// décrémente la variable cptepas pour compter les pas.
    EEPROM.update(18,cptepas2);// decrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
    Serial.println(cptepas2); // le nbre de pas effectué.                   
    delay(500);                  
   }
}

EDIT: petit complément d'infos :

J'ai remplacé les variables globales cptepas et position_du_moteur par des variables locales : je les ai renommées en rajoutant un 2 à la fin du nom pour les différentier des variables globales. Si tu n'utilisais ces variables que là, alors tu peux supprimer la déclaration "globale" (et dans ce cas, tu n'est pas  obligé de les renommer). Si tu les utilises ailleurs de manière indépendante, alors il faut que tu fasse le changement de nom. Si tu as besoin d'avoir l'une ou l'autre de ses variables globales car ton code repose sur le fait que la fonction moteur_pas les met a jour, alors il faut que tu ne mettes PAS les 2 à la fin du nom de cette variable et que tu enlève le "float" ou "int" qui précède le nom de la variable dans la déclaration locale (ie dans la fonction moteur_pas).



#88 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 22 janvier 2020 - 06:08

bonsoir sandro,

j'ai voulu simplifier mon code et laisser les choses essentiel et maintenant il me manque la position du moteur et cptepas sur l'affichage .

je ne sais pas ce que j'ai fait et je ne trouve pas mon erreur .

JE TE MET LE CODE EN ENTIER .

je te remerci d'avance bonne soirée .

#include <Wire.h>
#include "RTClib.h"
#include <Encoder.h> // from http://www.pjrc.com/teensy/td_libs_Encoder.html
Encoder knob(3, 4); //encoder connected to pins 2 and 3 (and ground)// D2 SEEDSTUDIO shield
#include <TimeLib.h>
#include <TimeLord.h>
#include <EEPROM.h>
const float LATITUDE = 43.70, LONGITUDE = 7.25; // Nice Sun
const int TIMEZONE = + 1;
int r   = 35;//cercle drawLine
int r_1 = 35;//drawbitmap
int angle = 0;
int x1=57;// drawbitmap rattrapage width  65-8 = 57
int y1=43;// drawbitmap rattrapage height 50-8 = 42
int x0=65;// drawLine
int y0=50;// drawLine
int sun;
int alfa=0;
int degre = 0;
//int backlight = 6; //backlight control pin 6
/* variables stepper */
#include <Stepper.h>                                     
const int nbrepas360 = 64;                       // Fixe le nombre de pas pour faire un tour complet, c'est-à-dire 360°.
Stepper monmoteur (nbrepas360, 8, 9, 10, 11);    // Initialise la librairie Stepper.h
int cptepas=0 ;
int alfa_1 = 0;
float position_du_moteur=0;
float degrees_pas = 1;

#define u8g_logo_width 16
#define u8g_logo_height 16

#if defined(ARDUINO_ARCH_SAMD)
// for Zero, output on USB Serial console, remove line below if using programming port to program the Zero!
   #define Serial SerialUSB
#endif
RTC_DS1307 RTC;
char daysOfTheWeek[7][12] = {"Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"};

#include "U8glib.h"
//U8GLIB_ST7920_128X64 u8g(13, 11, 12, U8G_PIN_NONE);//U8GLIB_ST7920_128X64_1X u8g(7, 6, 5 ,8); //Enable, RW, RS, RESET
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);

int Timer = 0;
int Minutt = 0;
int Sekund = 0;
float Vinkel = 0;
int an = 0;
int luna = 0;
int zi = 0;
int zis = 0;

//the variables provide the holding values for the set clock routine
int setyeartemp;
int setmonthtemp;
int setdaytemp;
int setoretemp;
int setzitemp;
int setminstemp;
int setsecs = 0;
int maxday; // maximum number of days in the given month
int TimeMins; // number of seconds since midnight
int TimerMode = 2; //mode 0=Off 1=On 2=Auto
int TimeOut = 10;
int TimeOutCounter;

// These variables are for the push button routine
int buttonstate = 0; //flag to see if the button has been pressed, used internal on the subroutine only
int pushlengthset = 1500; // value for a long push in mS
int pushlength = pushlengthset; // set default pushlength
int pushstart = 0;// sets default push value for the button going low
int pushstop = 0;// sets the default value for when the button goes back high

int Sunrise, Sunset; //sunrise and sunset expressed as minute of day (0-1439)
TimeLord myLord; // TimeLord Object, Global variable
byte sunTime[]  = {0, 0, 0, 1, 1, 13}; // 17 Oct 2013
int SunriseHour, SunriseMin, SunsetHour, SunsetMin;
int knobval; // value for the rotation of the knob
boolean buttonflag = false; // default value for the button flag

int backlight = 6;//backlight control pin 6
#include <stdlib.h>
char tmp_string[8];

void turntable(void) {
  DateTime now = RTC.now();
    // center  
 int x2=128/2;  
 int y2=64/2;  
 // radius  
 int r2=22;
 // angle  
 int alfa_1 = 0;
 int cptepas =0;
 maxday = EEPROM.read(7);
 EEPROM.update(18,cptepas);
 alfa_1 =360*now.day()/maxday;
 u8g.setFont(u8g_font_6x10);
 u8g.setPrintPos(1,60);
 u8g.print(EEPROM.read(16));//alfa_1
 u8g.setPrintPos(30,60);
 u8g.print(EEPROM.read(17));//pos_moteur
  EEPROM.update(16,alfa_1);
 u8g.setPrintPos(90,60);
 u8g.print(EEPROM.read(18));//cptepas
  /* affichage maxday */
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(110,30 );
    u8g.print(EEPROM.read(7));
 u8g.setPrintPos(62,9);
 u8g.print("0");
 u8g.setPrintPos(90,32);
 u8g.print("90");
 u8g.setPrintPos(56,64);
 u8g.print("180");
 u8g.setPrintPos(22,32);
 u8g.print("270");
 u8g.drawLine(x2,y2, x2+r2*sin(1*alfa_1*2*3.14/360), y2-r2*cos(1*alfa_1*2*3.14/360));  
 u8g.drawCircle(x2, y2, r2);
 
 }
 void moteur_pas(){
    position_du_moteur = cptepas*5.625;
    EEPROM.update(17,position_du_moteur);
   if(position_du_moteur < alfa_1 - degrees_pas ){
    monmoteur.step(+1);                   // Avance de 1 pas.
    cptepas++;
    EEPROM.update(18,cptepas);// Incrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
    Serial.println(cptepas);// le nbre de pas effectué.
    delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
  if(position_du_moteur > alfa_1 + degrees_pas){
    monmoteur.step(-1);
    cptepas--;// décrémente la variable cptepas pour compter les pas.
    EEPROM.update(18,cptepas);// decrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
    Serial.println(cptepas); // le nbre de pas effectué.                   
    delay(500);                  
   }
}

 void draw(void) {
      DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    turntable();
    u8g.setFont(u8g_font_6x13);   
    u8g.setPrintPos(2,10);
    if (zi < 10) u8g.print("0");
    u8g.print(zi);
    u8g.print("/");
    if (luna < 10) u8g.print("0");
    u8g.print(luna);
    u8g.print("/");
    u8g.setPrintPos(40,10);
    u8g.print(daysOfTheWeek[zis]);

    u8g.setFont(u8g_font_6x13);
    u8g.setPrintPos(80,10);
    if (Timer < 10) u8g.print(" ");
    u8g.print(Timer);
    u8g.setPrintPos(93,10);
    if (Sekund%2 != 1)
    u8g.print(":");
    u8g.setPrintPos(115,10);
    u8g.setFont(u8g_font_6x10);
    if(Sekund<10)u8g.print("0");
    u8g.print(Sekund);
    u8g.setPrintPos(100,10);
    u8g.setFont(u8g_font_6x13);
    if (Minutt < 10) u8g.print("0");
    u8g.print(Minutt);
    
    int maxday;// maximum de jours
   if (now.month() == 4 || now.month() == 5 || now.month() == 9 || now.month() == 11){  //30 jours =  Septembre, Avril, Juin,  Novembre.
    maxday = 30;
  EEPROM.update(7,maxday);
    
  }
  else {
    maxday = 31; //... all the others have 31
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 == 0){  //... Exception Fevrier = 28 jours , ou 29 jours année bissextile.
    maxday = 29;
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 != 0){
    maxday = 28;
    EEPROM.update(7,maxday);
  }

    TimeMins = (now.hour() * 60) + now.minute();
    
    if (TimeMins >= Sunrise && TimeMins <=Sunset-1) { //If it's after sunrise and before sunset, switch our relay on
            digitalWrite (A3, HIGH);// cdt PONT H
            //analogWrite(backlight,255);// lcd rétroéclairage On
            u8g.setColorIndex(1); // Pixel On SH1106
      }
       else {  //otherwise switch it off
            digitalWrite (A3,LOW);// cdt PONT H
            //analogWrite(backlight,0);// lcd rétroéclairage Off
            u8g.setColorIndex(1);// Pixel Off SH1106
       }    
}

void setup(void) {
   u8g.setContrast(0);//Config the constrast to the best effect
   analogWrite(backlight,255);
   EEPROM.read(18);
   // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 )
    u8g.setColorIndex(255);     // white
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
    u8g.setColorIndex(3);         // max intensity
  else if ( u8g.getMode() == U8G_MODE_BW )
    u8g.setColorIndex(1);         // pixel on
    
  Serial.begin(9600);
  if (! RTC.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
   
    RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
    
  }
pinMode(A0,INPUT);//push button on encoder connected to A0 (and GND)
digitalWrite(A0,HIGH); //Pull button high
}

void loop(void) {
    
    u8g.setFont(u8g_font_6x10);
    DateTime now = RTC.now();
    Timer = now.hour(), DEC;
    Minutt = now.minute(), DEC;
    Sekund = now.second(), DEC;
    Serial.print(Timer);
    Serial.print(':');
    Serial.print(Minutt);
    Serial.print(':');
    Serial.print(Sekund);
    Serial.print(" - ");
    an = now.year(), DEC;
    Serial.print(an);
    Serial.print('/');
    luna = now.month(), DEC;
    Serial.print(luna);
    Serial.print('/');
    zi = now.day(), DEC;
    Serial.print(zi);
    Serial.print(" (");
    zis = now.dayOfTheWeek();
    Serial.print(daysOfTheWeek[zis]);
    Serial.println(") ");
    moteur_pas();
      
  // picture loop
  u8g.firstPage();
  do {
    draw();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(100);

 pushlength = pushlengthset;
 pushlength = getpushlength();
 delay (10);
 
 if (pushlength < pushlengthset)
 {
  //ShortPush ();   
   Serial.println("short push");
    // picture loop
  u8g.firstPage();
  do {
    draw1();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(1000);

 }
  //This runs the setclock routine if the knob is pushed for a long time
       if (pushlength > pushlengthset) {
 
  Serial.println("long push");
         DateTime now = RTC.now();
         setyeartemp=now.year(),DEC;
         setmonthtemp=now.month(),DEC;
         setdaytemp=now.day(),DEC;
         setoretemp=now.hour(),DEC;
         setminstemp=now.minute(),DEC;
         setzitemp = now.dayOfTheWeek();
         setclock();
         pushlength = pushlengthset;
       };
 
} // end main loop


// subroutine to return the length of the button push.
int getpushlength()
{
  buttonstate = digitalRead(A0);  
       if(buttonstate == LOW && buttonflag==false) {     
              pushstart = millis();
              buttonflag = true;
          };     
       if (buttonstate == HIGH && buttonflag==true) {
         pushstop = millis ();
         pushlength = pushstop - pushstart;
         buttonflag = false;
       };
        Serial.println("_");
       return pushlength;
}

void draw1(void) {
 
//  u8g.drawBitmapP(0, 0, 16,64, bonsai_bitmap);//u8g.drawStr( 10, 32, "Thx to niq_ro!");
}


//sets the clock
void setclock (){
 
   setyear ();//Annee
   setmonth ();//Mois
   setday ();//Jour
   setzi();//semaine
   setore ();//hours
   setmins ();//Minutes
   RTC.adjust(DateTime(setyeartemp,setmonthtemp,setdaytemp,setoretemp,setminstemp,setsecs));
   CalcSun();
   delay (1000);
}
int CalcSun () { //Calculates the Sunrise and Sunset times
    DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    
 
}
// The following subroutines set the individual clock parameters
int setyear () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setyeartemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) { //bit of software de-bounce
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setyeartemp=setyeartemp + knobval;
    if (setyeartemp < 2018) { //Year can't be older than currently, it's not a time machine.
      setyeartemp = 2018;
    }
//itoa(setyeartemp - 2000, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
itoa(setyeartemp, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
  u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Annee");
//  u8g.drawStr( 0, 40, "20");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );  
    setyear();
}

int setmonth () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setmonthtemp;
    }

 //   lcd.setCursor (0,1);
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setmonthtemp=setmonthtemp + knobval;
    if (setmonthtemp < 1) {// month must be between 1 and 12
      setmonthtemp = 1;
    }
    if (setmonthtemp > 12) {
      setmonthtemp=12;
    }
    itoa(setmonthtemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Mois");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmonth();
}


int setday () {
  if (setmonthtemp == 4 || setmonthtemp == 5 || setmonthtemp == 9 || setmonthtemp == 11) { //30 days hath September, April June and November
    maxday = 30;
  }
  else {
  maxday = 31; //... all the others have 31
  }
  if (setmonthtemp ==2 && setyeartemp % 4 ==0) { //... Except February alone, and that has 28 days clear, and 29 in a leap year.
    maxday = 29;
  }
  if (setmonthtemp ==2 && setyeartemp % 4 !=0) {
    maxday = 28;
  }
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setdaytemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setdaytemp = setdaytemp+ knobval;
    if (setdaytemp < 1) {
      setdaytemp = 1;
    }
    if (setdaytemp > maxday) {
      setdaytemp = maxday;
    }
  itoa(setdaytemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setday();
}


int setzi () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setzitemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setzitemp=setzitemp + knobval;
    if (setzitemp < 0) {// month must be between 0 and 6
      setzitemp = 0;
    }
    if (setzitemp > 6) {
      setzitemp=6;
    }
    itoa(setzitemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour of Week");
  u8g.drawStr(25, 40, tmp_string);
  u8g.drawStr(0,60, daysOfTheWeek[setzitemp]);
  } while( u8g.nextPage() );
    setzi();
}

int setore () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setoretemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setoretemp=setoretemp + knobval;
    if (setoretemp < 0) {
      setoretemp = 0;
    }
    if (setoretemp > 23) {
      setoretemp=23;
    }
   itoa(setoretemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Heures");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setore();
}

int setmins () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setminstemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setminstemp=setminstemp + knobval;
    if (setminstemp < 0) {
      setminstemp = 0;
    }
    if (setminstemp > 59) {
      setminstemp=59;
    }
   itoa(setminstemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Minutes");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmins();
}

 


#89 Sandro

Sandro

    Membre passionné

  • Membres
  • PipPipPip
  • 339 messages
  • Gender:Male

Posté 22 janvier 2020 - 07:05

Bonsoir,

 

tout d'abord, j'ai plusieurs remarques sur ton code :

- tu as une fonction "draw", qui appelle la fonction turntable, qui met à jour des variables dans l'EEPROM : quand tu as une fonction avec un nom comme draw, je te conseille vivement qu'elle fasse des dessins ET RIEN D'AUTRE, entre autre, elle ne doit faire aucun calcul qui n'est pas local (ie qui influance ailleurs dans le code)

- par conséquent, dans la fonction turntable, qui est appellée depuis la fonction draw, il ne faut faire aucun update de l'EEPROM (d'ailleurs l'update que tu fais de cptepas met cptepas a 0!!!)

 

 

Je te propose donc la fonction turntable suivante :

void turntable(void) {
  DateTime now = RTC.now();
    // center  
 int x2=128/2;  
 int y2=64/2;  
 // radius  
 int r2=22;
 // angle  
 int alfa_1 = 0;
 int cptepas =EEPROM.read(7);      //on initialise cptepas avec la valeur stoquée dans l'EEPROM
 maxday = EEPROM.read(7);
 //EEPROM.update(18,cptepas);        //supprime cette ligne
 alfa_1 =360*now.day()/maxday;
 u8g.setFont(u8g_font_6x10);
 u8g.setPrintPos(1,60);
 u8g.print(EEPROM.read(16));//alfa_1
 u8g.setPrintPos(30,60);
 u8g.print(EEPROM.read(17));//pos_moteur
  EEPROM.update(16,alfa_1);
 u8g.setPrintPos(90,60);
 u8g.print(EEPROM.read(18));//cptepas
  /* affichage maxday */
    u8g.setFont(u8g_font_6x10);
    u8g.setPrintPos(110,30 );
    u8g.print(EEPROM.read(7));
 u8g.setPrintPos(62,9);
 u8g.print("0");
 u8g.setPrintPos(90,32);
 u8g.print("90");
 u8g.setPrintPos(56,64);
 u8g.print("180");
 u8g.setPrintPos(22,32);
 u8g.print("270");
 u8g.drawLine(x2,y2, x2+r2*sin(1*alfa_1*2*3.14/360), y2-r2*cos(1*alfa_1*2*3.14/360));  
 u8g.drawCircle(x2, y2, r2);
 
 }

Ensuite, dans la fonction moteur pas, tu ne fais pas l'update de position moteur au bon moment : tu fait l'update avant de déplacer le moteur, du coup, position_moteur est toujours d'un cran en retard.

Je te suggère la modification suivante :

 void moteur_pas(){
    position_du_moteur = cptepas*5.625;
    //EEPROM.update(17,position_du_moteur);                                //enlève cette ligne d'ici
   if(position_du_moteur < alfa_1 - degrees_pas ){
    monmoteur.step(+1);                   // Avance de 1 pas.
    cptepas++;
    EEPROM.update(18,cptepas);// Incrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
    Serial.println(cptepas);// le nbre de pas effectué.
    delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
  if(position_du_moteur > alfa_1 + degrees_pas){
    monmoteur.step(-1);
    cptepas--;// décrémente la variable cptepas pour compter les pas.
    EEPROM.update(18,cptepas);// decrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
    Serial.println(cptepas); // le nbre de pas effectué.                   
    delay(500);                  
   }
  EEPROM.update(17,position_du_moteur);                    //et ajoute là ici à la place
}

PS : quand tu aura un code de nouveau fonctionnel, je te donnerais quelques pistes pour simplifier/rendre le code plus clair (par exemple, les calculs de maxday n'ont aucune raison d'être dans la fonction draw)



#90 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 23 janvier 2020 - 08:17

bonjour Sandro,

merci beaucoup pour tout ces informations .

tu as deviner que les draws sont des infos pour faire des dessins , mais je ne savais pas pour les calculs .

j'ai récupérer un programme avec rréglages rtc ,

https://github.com/t..._RTC_clock2.ino

je l'ai modifier sans trop de connaissance .

je te tiens au courant merci encore pour ton aide . 

bonne journée.



#91 Sandro

Sandro

    Membre passionné

  • Membres
  • PipPipPip
  • 339 messages
  • Gender:Male

Posté 23 janvier 2020 - 12:26

Bonjour,

disons que l'idée, pour avoir un programme lisible, c'est qu'il y ait une fonction pour chaque tache, et que chaque fonction fasse cette tache et rien d'autre. En particulier, on évite d'avoir une fonction dont le nom ne dit pas tout (si tu tiens pour  des raisons de simplicité de faire 2 tâches avec la même fonction (par exemple car elles sont toujours exécutées ensemble que ça simplifie le code), alors choisis un nom qui reflète les deux tâches (par exemple, au lieu de "draw", se serait "draw_and_update_maxday").



#92 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 23 janvier 2020 - 05:35

bonsoir sandro,

je te remet le code complet car j'ai un nouveau soucis je n'ai plus alfa_1 ou plutôt alfa_1 = 11 ? ça devrait afficher alfa_1 = 360*23 aujourdhui/31mois = 267 .

u8g.setPrintPos(1,60);
u8g.print(EEPROM.read(16));

EEPROM.update(16,alfa_1); = 11

parcontre l'angle donner sur le dessin est exact affichage turntable

j'ai passer toute l’après-midi sans rien trouver .

je te souhaite une bonne soirée .

#include <Encoder.h> // from http://www.pjrc.com/teensy/td_libs_Encoder.html
Encoder knob(3, 4); //encoder connected to pins 2 and 3 (and ground)// D2 SEEDSTUDIO shield
#include <TimeLib.h>
#include <TimeLord.h>
#include <EEPROM.h>
const float LATITUDE = 43.70, LONGITUDE = 7.25; // Nice Sun
const int TIMEZONE = + 1;
int r   = 35;//cercle drawLine
int r_1 = 35;//drawbitmap
int angle = 0;
int x1=57;// drawbitmap rattrapage width  65-8 = 57
int y1=43;// drawbitmap rattrapage height 50-8 = 42
int x0=65;// drawLine
int y0=50;// drawLine
int sun;
int alfa=0;
int degre = 0;
//int backlight = 6; //backlight control pin 6
/* variables stepper */
                                    
const int nbrepas360 = 64;                       // Fixe le nombre de pas pour faire un tour complet, c'est-à-dire 360°.
Stepper monmoteur (nbrepas360, 8, 9, 10, 11);    // Initialise la librairie Stepper.h
int cptepas = 0 ;
int alfa_1 = 0;
float position_du_moteur=0;
float degrees_pas = 1;

#define u8g_logo_width 16
#define u8g_logo_height 16

#if defined(ARDUINO_ARCH_SAMD)
// for Zero, output on USB Serial console, remove line below if using programming port to program the Zero!
   #define Serial SerialUSB
#endif
RTC_DS1307 RTC;
char daysOfTheWeek[7][12] = {"Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"};

#include "U8glib.h"
//U8GLIB_ST7920_128X64 u8g(13, 11, 12, U8G_PIN_NONE);//U8GLIB_ST7920_128X64_1X u8g(7, 6, 5 ,8); //Enable, RW, RS, RESET
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);

int Timer = 0;
int Minutt = 0;
int Sekund = 0;
float Vinkel = 0;
int an = 0;
int luna = 0;
int zi = 0;
int zis = 0;

//the variables provide the holding values for the set clock routine
int setyeartemp;
int setmonthtemp;
int setdaytemp;
int setoretemp;
int setzitemp;
int setminstemp;
int setsecs = 0;
int maxday; // maximum number of days in the given month
int TimeMins; // number of seconds since midnight
int TimerMode = 2; //mode 0=Off 1=On 2=Auto
int TimeOut = 10;
int TimeOutCounter;

// These variables are for the push button routine
int buttonstate = 0; //flag to see if the button has been pressed, used internal on the subroutine only
int pushlengthset = 1500; // value for a long push in mS
int pushlength = pushlengthset; // set default pushlength
int pushstart = 0;// sets default push value for the button going low
int pushstop = 0;// sets the default value for when the button goes back high

int Sunrise, Sunset; //sunrise and sunset expressed as minute of day (0-1439)
TimeLord myLord; // TimeLord Object, Global variable
byte sunTime[]  = {0, 0, 0, 1, 1, 13}; // 17 Oct 2013
int SunriseHour, SunriseMin, SunsetHour, SunsetMin;
int knobval; // value for the rotation of the knob
boolean buttonflag = false; // default value for the button flag

int backlight = 6;//backlight control pin 6
#include <stdlib.h>
char tmp_string[8];

void turntable(void) {
  DateTime now = RTC.now();
 
    // center  
 int x2=128/2;  
 int y2=64/2;  
 // radius  
 int r2=22;
 // angle
 int cptepas = EEPROM.read(18);
 maxday = EEPROM.read(7);
 alfa_1 =360*now.day()/maxday;
 position_du_moteur = cptepas*5.625;
 EEPROM.update(17,position_du_moteur);
 u8g.setFont(u8g_font_6x10);
 u8g.setPrintPos(1,60);
 u8g.print(EEPROM.read(16));//alfa_1
 u8g.setPrintPos(30,60);
 u8g.print(EEPROM.read(17));//pos_moteur
 u8g.setPrintPos(90,60);
 u8g.print(EEPROM.read(18));//cptepas
  /* affichage maxday */
 u8g.setFont(u8g_font_6x10);
 u8g.setPrintPos(110,30 );
 u8g.print(EEPROM.read(7));
 u8g.setPrintPos(62,9);
 u8g.print("0");
 u8g.setPrintPos(90,32);
 u8g.print("90");
 u8g.setPrintPos(56,64);
 u8g.print("180");
 u8g.setPrintPos(22,32);
 u8g.print("270");
 u8g.drawLine(x2,y2, x2+r2*sin(1*alfa_1*2*3.14/360), y2-r2*cos(1*alfa_1*2*3.14/360));  
 u8g.drawCircle(x2, y2, r2);
 
 }
 void moteur_pas(){
    position_du_moteur = cptepas*5.625;
         
   if(position_du_moteur < alfa_1 - degrees_pas ){
    monmoteur.step(+1);                   // Avance de 1 pas.
    cptepas++;
    EEPROM.update(18,cptepas);// Incrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
    Serial.println(cptepas);// le nbre de pas effectué.
    delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
  if(position_du_moteur > alfa_1 + degrees_pas){
    monmoteur.step(-1);
    cptepas--;// décrémente la variable cptepas pour compter les pas.
    EEPROM.update(18,cptepas);// decrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
    Serial.println(cptepas); // le nbre de pas effectué.                   
    delay(500);                  
   }
    EEPROM.update(17,position_du_moteur);
}


 void draw(void) {
      
      DateTime now = RTC.now();
      
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    u8g.setFont(u8g_font_6x13);   
    u8g.setPrintPos(2,10);
    if (zi < 10) u8g.print("0");
    u8g.print(zi);
    u8g.print("/");
    if (luna < 10) u8g.print("0");
    u8g.print(luna);
    u8g.print("/");
    u8g.setPrintPos(40,10);
    u8g.print(daysOfTheWeek[zis]);

    u8g.setFont(u8g_font_6x13);
    u8g.setPrintPos(80,10);
    if (Timer < 10) u8g.print(" ");
    u8g.print(Timer);
    u8g.setPrintPos(93,10);
    if (Sekund%2 != 1)
    u8g.print(":");
    u8g.setPrintPos(115,10);
    u8g.setFont(u8g_font_6x10);
    if(Sekund<10)u8g.print("0");
    u8g.print(Sekund);
    u8g.setPrintPos(100,10);
    u8g.setFont(u8g_font_6x13);
    if (Minutt < 10) u8g.print("0");
    u8g.print(Minutt);
    TimeMins = (now.hour() * 60) + now.minute();
    alfa_1 = 360*now.day()/maxday;
    EEPROM.update(16,alfa_1);
    maxday = EEPROM.read(7);
    u8g.setPrintPos(1,60);
    u8g.print(EEPROM.read(16));
    
    int maxday;// maximum de jours
   if (now.month() == 4 || now.month() == 5 || now.month() == 9 || now.month() == 11){  //30 jours =  Septembre, Avril, Juin,  Novembre.
    maxday = 30;
  EEPROM.update(7,maxday);
    
  }
  else {
    maxday = 31; //... all the others have 31
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 == 0){  //... Exception Fevrier = 28 jours , ou 29 jours année bissextile.
    maxday = 29;
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 != 0){
    maxday = 28;
    EEPROM.update(7,maxday);
  }
    
    TimeMins = (now.hour() * 60) + now.minute();
    
    if (TimeMins >= Sunrise && TimeMins <=Sunset-1) { //If it's after sunrise and before sunset, switch our relay on
            digitalWrite (A3, HIGH);// cdt PONT H
            //analogWrite(backlight,255);// lcd rétroéclairage On
            u8g.setColorIndex(1); // Pixel On SH1106
      }
       else {  //otherwise switch it off
            digitalWrite (A3,LOW);// cdt PONT H
            //analogWrite(backlight,0);// lcd rétroéclairage Off
            u8g.setColorIndex(0);// Pixel Off SH1106
       }    
}

void setup(void) {
   u8g.setContrast(0);//Config the constrast to the best effect
   analogWrite(backlight,255);
      // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 )
    u8g.setColorIndex(255);     // white
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
    u8g.setColorIndex(3);         // max intensity
  else if ( u8g.getMode() == U8G_MODE_BW )
    u8g.setColorIndex(1);         // pixel on
    
  Serial.begin(9600);
  if (! RTC.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
   
    RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
    
  }
pinMode(A0,INPUT);//push button on encoder connected to A0 (and GND)
digitalWrite(A0,HIGH); //Pull button high
}

void loop(void) {
    
    u8g.setFont(u8g_font_6x10);
    DateTime now = RTC.now();
    Timer = now.hour(), DEC;
    Minutt = now.minute(), DEC;
    Sekund = now.second(), DEC;
    Serial.print(Timer);
    Serial.print(':');
    Serial.print(Minutt);
    Serial.print(':');
    Serial.print(Sekund);
    Serial.print(" - ");
    an = now.year(), DEC;
    Serial.print(an);
    Serial.print('/');
    luna = now.month(), DEC;
    Serial.print(luna);
    Serial.print('/');
    zi = now.day(), DEC;
    Serial.print(zi);
    Serial.print(" (");
    zis = now.dayOfTheWeek();
    Serial.print(daysOfTheWeek[zis]);
    Serial.println(") ");
    moteur_pas();
    EEPROM.update(7,maxday);
    alfa_1 = 360*now.day()/maxday;
    EEPROM.update(16,alfa_1);
    u8g.setPrintPos(1,60);
    u8g.print(EEPROM.read(16));
  // picture loop
  u8g.firstPage();
  do {
    draw();
    turntable();
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(100);

 pushlength = pushlengthset;
 pushlength = getpushlength();
 delay (10);
 
 if (pushlength < pushlengthset)
 {
  //ShortPush ();   
   Serial.println("short push");
    // picture loop
  u8g.firstPage();
  do {
    draw1();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(1000);

 }
  //This runs the setclock routine if the knob is pushed for a long time
       if (pushlength > pushlengthset) {
 
  Serial.println("long push");
         DateTime now = RTC.now();
         setyeartemp=now.year(),DEC;
         setmonthtemp=now.month(),DEC;
         setdaytemp=now.day(),DEC;
         setoretemp=now.hour(),DEC;
         setminstemp=now.minute(),DEC;
         setzitemp = now.dayOfTheWeek();
         setclock();
         pushlength = pushlengthset;
       };
 
} // end main loop


// subroutine to return the length of the button push.
int getpushlength()
{
  buttonstate = digitalRead(A0);  
       if(buttonstate == LOW && buttonflag==false) {     
              pushstart = millis();
              buttonflag = true;
          };     
       if (buttonstate == HIGH && buttonflag==true) {
         pushstop = millis ();
         pushlength = pushstop - pushstart;
         buttonflag = false;
       };
        Serial.println("_");
       return pushlength;
}

void draw1(void) {
  u8g.drawStr( 10, 32, "Thx to niq_ro!");
}
//sets the clock
void setclock (){
 
   setyear ();//Annee
   setmonth ();//Mois
   setday ();//Jour
   setzi();//semaine
   setore ();//hours
   setmins ();//Minutes
   RTC.adjust(DateTime(setyeartemp,setmonthtemp,setdaytemp,setoretemp,setminstemp,setsecs));
   CalcSun();
   delay (1000);
}
int CalcSun () { //Calculates the Sunrise and Sunset times
    DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    
 
}
// The following subroutines set the individual clock parameters
int setyear () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setyeartemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) { //bit of software de-bounce
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setyeartemp=setyeartemp + knobval;
    if (setyeartemp < 2018) { //Year can't be older than currently, it's not a time machine.
      setyeartemp = 2018;
    }
//itoa(setyeartemp - 2000, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
itoa(setyeartemp, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
  u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Annee");
//  u8g.drawStr( 0, 40, "20");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );  
    setyear();
}

int setmonth () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setmonthtemp;
    }

 //   lcd.setCursor (0,1);
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setmonthtemp=setmonthtemp + knobval;
    if (setmonthtemp < 1) {// month must be between 1 and 12
      setmonthtemp = 1;
    }
    if (setmonthtemp > 12) {
      setmonthtemp=12;
    }
    itoa(setmonthtemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Mois");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmonth();
}


int setday () {
  if (setmonthtemp == 4 || setmonthtemp == 5 || setmonthtemp == 9 || setmonthtemp == 11) { //30 days hath September, April June and November
    maxday = 30;
  }
  else {
  maxday = 31; //... all the others have 31
  }
  if (setmonthtemp ==2 && setyeartemp % 4 ==0) { //... Except February alone, and that has 28 days clear, and 29 in a leap year.
    maxday = 29;
  }
  if (setmonthtemp ==2 && setyeartemp % 4 !=0) {
    maxday = 28;
  }
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setdaytemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setdaytemp = setdaytemp+ knobval;
    if (setdaytemp < 1) {
      setdaytemp = 1;
    }
    if (setdaytemp > maxday) {
      setdaytemp = maxday;
    }
  itoa(setdaytemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setday();
}


int setzi () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setzitemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setzitemp=setzitemp + knobval;
    if (setzitemp < 0) {// month must be between 0 and 6
      setzitemp = 0;
    }
    if (setzitemp > 6) {
      setzitemp=6;
    }
    itoa(setzitemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour of Week");
  u8g.drawStr(25, 40, tmp_string);
  u8g.drawStr(0,60, daysOfTheWeek[setzitemp]);
  } while( u8g.nextPage() );
    setzi();
}

int setore () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setoretemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setoretemp=setoretemp + knobval;
    if (setoretemp < 0) {
      setoretemp = 0;
    }
    if (setoretemp > 23) {
      setoretemp=23;
    }
   itoa(setoretemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Heures");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setore();
}

int setmins () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setminstemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setminstemp=setminstemp + knobval;
    if (setminstemp < 0) {
      setminstemp = 0;
    }
    if (setminstemp > 59) {
      setminstemp=59;
    }
   itoa(setminstemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Minutes");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmins();
}

 


#93 Sandro

Sandro

    Membre passionné

  • Membres
  • PipPipPip
  • 339 messages
  • Gender:Male

Posté 24 janvier 2020 - 12:41

Bonsoir,

 

la raison pour laquelle tu obtiens un résultat correct sur le dessin et faux sur la valeur est simple : tu n'utilises pas la même "variable" :

void turntable(void) {
 ...
 maxday = EEPROM.read(7);
 alfa_1 =360*now.day()/maxday;
 position_du_moteur = cptepas*5.625;
 EEPROM.update(17,position_du_moteur);
 u8g.setFont(u8g_font_6x10);
 u8g.setPrintPos(1,60);
 u8g.print(EEPROM.read(16));//alfa_1

Pour le dessin, tu utilise alfa_1, que tu calcules comme 360*now.day()/maxday où maxday est lu dans l'EEPROM à l'adresse 7.

 

Pour le texte, tu utilise la valeur contenue dans l'EEPROM  à l'adresse 16.

 

Du coup, à un moment ou à un autre, tu enregistre la mauvaise valeur dans l'EEPROM à l'adresse 16.

 

 

 

Une hypothèse est la fin de la fonction draw :

    alfa_1 = 360*now.day()/maxday;
    EEPROM.update(16,alfa_1);
    maxday = EEPROM.read(7);
    u8g.setPrintPos(1,60);
    u8g.print(EEPROM.read(16));
    
    int maxday;// maximum de jours
   if (now.month() == 4 || now.month() == 5 || now.month() == 9 || now.month() == 11){  //30 jours =  Septembre, Avril, Juin,  Novembre.
    maxday = 30;
  EEPROM.update(7,maxday);
    
  }
  else {
    maxday = 31; //... all the others have 31
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 == 0){  //... Exception Fevrier = 28 jours , ou 29 jours année bissextile.
    maxday = 29;
    EEPROM.update(7,maxday);
  }
  if (now.month() == 2 && now.year() % 4 != 0){
    maxday = 28;
    EEPROM.update(7,maxday);
  }
    
    TimeMins = (now.hour() * 60) + now.minute();
    
    if (TimeMins >= Sunrise && TimeMins <=Sunset-1) { //If it's after sunrise and before sunset, switch our relay on
            digitalWrite (A3, HIGH);// cdt PONT H
            //analogWrite(backlight,255);// lcd rétroéclairage On
            u8g.setColorIndex(1); // Pixel On SH1106
      }
       else {  //otherwise switch it off
            digitalWrite (A3,LOW);// cdt PONT H
            //analogWrite(backlight,0);// lcd rétroéclairage Off
            u8g.setColorIndex(0);// Pixel Off SH1106
       }    
}

Il y a là certainement plusieurs problèmes :

1) à la première ligne, tu utilise maxday, dont j'ignore s'il a été initialisé ou pas

2) à la seconde ligne, tu lis maxday dans l'EEPROM (pourquoi? soit tu lis maxday dans l'EEPROM, soit tu le calcule, mais en aucun cas tu le calcule, puis tu l'utilise, puis tu lis la valeur dans l'EEPROM

3) à la 7ième ligne, tu déclare une variable locale "int maxday", qui porte le même nom que ta variable globale : c'est pas interdit par le langage C, mais c'est une très mauvaise pratique car ça crée ÉNNORMÉMENT de confusions : vu qu'en plus tu déclare "int maxday" après avoir utilisé maxday dans la fonction, je ne sais même pas ce que le compilateur fait : après la déclaration "int maxday" c'est la variable locale. Avant, je l'ignore : il est possible que ce soit la variable locale (qui dans ce cas n'est pas initialisée), ou alors qu'il s'agit de la variable globale.

4) tu re-calcule la valeur de maxday, mais après l'avoir utilisé (du coup, soit la valeur ne change pas et le calcul ne sert à rien, soit il change et dans ce cas tu viens d'utiliser une valeur obsolette dans les calculs précédents.

 

 

Bref, un gros bordel autour de maxday. En plus, tu peux recalculer maxday à partir de la date, donc il n'y a aucune raison de stoquer maxday dans l'EEPROM (l'EEPROM, c'est pour les données que tu ne peux pas te permettre de perdre en cas de coupure de courant).

 

Du coup, je te propose la solution suivante (un peu radicale, mais ça simplifiera ton code et résoudra j'espère ton problème :

1) tu crée une fonction max_day qui ne prend pas d'entrée et renvois un entier (maxday).

int max_day()
{
  int ma_valeur_de_maxday=0;
  //les calculs ici
  return ma_valeur_de_maxday;
}

NB : je tiens à ce que tu mettes le tirret entre "max" et "day", ça t'évitera des erreurs dans les étapes suivantes

2) Dans la fonction draw, tu enlèves tout ce qui concerne le calcul de la nouvelle valeur de maxday (vu que tu l'aura déjà mis dans la nouvelle fonction)

3) tu remplace tous les endroits où tu utilise la variable maxday ou que tu lis l'EEPROM à l'adresse 7 par un appel à la fonction max_day(). N'hésite pas à faire un ctrl+F pour trouver toutes les occurences de "maxday" et de "EEPROM.read(7)"

4) tu supprime toutes les déclarations de la variables maxday

5) tu supprime tous les updates de l'EEPROM à l'adresse 7 (ie maxday)

 

 

Donc au final, je ne veux plus voir nulle part la variable maxday, ni de stockage de sa valeur dans l'EEPROM (ni lecture de la valeur stoquée).
 

Une fois que tu as fait se changement, dis moi si ça marche et dans tous les cas, mets le nouveau code complet.

 

 

Bonne soirée

Sandro
 



#94 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 24 janvier 2020 - 04:40

bonsoir Sandro,

j'ai pas pu aller bien loin dans le code j'ai une erreur .

il me souligne ligne 199 la parenthèse et me dis  a function- definition is not allowed here before '{' token .

j'ai rajouter parenthéses il me dit toujours quelque chose de différent .

#include <Wire.h>
#include "RTClib.h"
#include <Stepper.h>
#include <Encoder.h> // from http://www.pjrc.com/teensy/td_libs_Encoder.html
Encoder knob(3, 4); //encoder connected to pins 2 and 3 (and ground)// D2 SEEDSTUDIO shield
#include <TimeLib.h>
#include <TimeLord.h>
#include <EEPROM.h>
const float LATITUDE = 43.70, LONGITUDE = 7.25; // Nice Sun
const int TIMEZONE = + 1;
int r   = 35;//cercle drawLine
int r_1 = 35;//drawbitmap
int angle = 0;
int x1=57;// drawbitmap rattrapage width  65-8 = 57
int y1=43;// drawbitmap rattrapage height 50-8 = 42
int x0=65;// drawLine
int y0=50;// drawLine
int sun;
int alfa=0;
int degre = 0;
//int backlight = 6; //backlight control pin 6
/* variables stepper */
                                    
const int nbrepas360 = 64;                       // Fixe le nombre de pas pour faire un tour complet, c'est-à-dire 360°.
Stepper monmoteur (nbrepas360, 8, 9, 10, 11);    // Initialise la librairie Stepper.h
int cptepas = 0 ;
int alfa_1 = 0;
float position_du_moteur=0;
float degrees_pas = 1;

#define u8g_logo_width 16
#define u8g_logo_height 16

#if defined(ARDUINO_ARCH_SAMD)
// for Zero, output on USB Serial console, remove line below if using programming port to program the Zero!
   #define Serial SerialUSB
#endif
RTC_DS1307 RTC;
char daysOfTheWeek[7][12] = {"Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"};

#include "U8glib.h"
//U8GLIB_ST7920_128X64 u8g(13, 11, 12, U8G_PIN_NONE);//U8GLIB_ST7920_128X64_1X u8g(7, 6, 5 ,8); //Enable, RW, RS, RESET
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);

int Timer = 0;
int Minutt = 0;
int Sekund = 0;
float Vinkel = 0;
int an = 0;
int luna = 0;
int zi = 0;
int zis = 0;

//the variables provide the holding values for the set clock routine
int setyeartemp;
int setmonthtemp;
int setdaytemp;
int setoretemp;
int setzitemp;
int setminstemp;
int setsecs = 0;
int maxday; // maximum number of days in the given month
int TimeMins; // number of seconds since midnight
int TimerMode = 2; //mode 0=Off 1=On 2=Auto
int TimeOut = 10;
int TimeOutCounter;

// These variables are for the push button routine
int buttonstate = 0; //flag to see if the button has been pressed, used internal on the subroutine only
int pushlengthset = 1500; // value for a long push in mS
int pushlength = pushlengthset; // set default pushlength
int pushstart = 0;// sets default push value for the button going low
int pushstop = 0;// sets the default value for when the button goes back high

int Sunrise, Sunset; //sunrise and sunset expressed as minute of day (0-1439)
TimeLord myLord; // TimeLord Object, Global variable
byte sunTime[]  = {0, 0, 0, 1, 1, 13}; // 17 Oct 2013
int SunriseHour, SunriseMin, SunsetHour, SunsetMin;
int knobval; // value for the rotation of the knob
boolean buttonflag = false; // default value for the button flag

int backlight = 6;//backlight control pin 6
#include <stdlib.h>
char tmp_string[8];

void turntable(void) {
  DateTime now = RTC.now();
 
    // center  
 int x2=128/2;  
 int y2=64/2;  
 // radius  
 int r2=22;
 // angle
 int cptepas = EEPROM.read(18);
 alfa_1 =360*now.day()/maxday;
 position_du_moteur = cptepas*5.625;
 EEPROM.update(17,position_du_moteur);
 u8g.setFont(u8g_font_6x10);
 u8g.setPrintPos(1,60);
 u8g.print(EEPROM.read(16));//alfa_1
 u8g.setPrintPos(30,60);
 u8g.print(EEPROM.read(17));//pos_moteur
 u8g.setPrintPos(90,60);
 u8g.print(EEPROM.read(18));//cptepas
  /* affichage maxday */
 u8g.setFont(u8g_font_6x10);
 u8g.setPrintPos(110,30 );
 u8g.print(EEPROM.read(7));
 u8g.setPrintPos(62,9);
 u8g.print("0");
 u8g.setPrintPos(90,32);
 u8g.print("90");
 u8g.setPrintPos(56,64);
 u8g.print("180");
 u8g.setPrintPos(22,32);
 u8g.print("270");
 u8g.drawLine(x2,y2, x2+r2*sin(1*alfa_1*2*3.14/360), y2-r2*cos(1*alfa_1*2*3.14/360));  
 u8g.drawCircle(x2, y2, r2);
 
 }
 void moteur_pas(){
    position_du_moteur = cptepas*5.625;
         
   if(position_du_moteur < alfa_1 - degrees_pas ){
    monmoteur.step(+1);                   // Avance de 1 pas.
    cptepas++;
    EEPROM.update(18,cptepas);// Incrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
    Serial.println(cptepas);// le nbre de pas effectué.
    delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
  if(position_du_moteur > alfa_1 + degrees_pas){
    monmoteur.step(-1);
    cptepas--;// décrémente la variable cptepas pour compter les pas.
    EEPROM.update(18,cptepas);// decrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
    Serial.println(cptepas); // le nbre de pas effectué.                   
    delay(500);                  
   }
    EEPROM.update(17,position_du_moteur);
}


 void draw(void) {
      
      DateTime now = RTC.now();
      
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    u8g.setFont(u8g_font_6x13);   
    u8g.setPrintPos(2,10);
    if (zi < 10) u8g.print("0");
    u8g.print(zi);
    u8g.print("/");
    if (luna < 10) u8g.print("0");
    u8g.print(luna);
    u8g.print("/");
    u8g.setPrintPos(40,10);
    u8g.print(daysOfTheWeek[zis]);

    u8g.setFont(u8g_font_6x13);
    u8g.setPrintPos(80,10);
    if (Timer < 10) u8g.print(" ");
    u8g.print(Timer);
    u8g.setPrintPos(93,10);
    if (Sekund%2 != 1)
    u8g.print(":");
    u8g.setPrintPos(115,10);
    u8g.setFont(u8g_font_6x10);
    if(Sekund<10)u8g.print("0");
    u8g.print(Sekund);
    u8g.setPrintPos(100,10);
    u8g.setFont(u8g_font_6x13);
    if (Minutt < 10) u8g.print("0");
    u8g.print(Minutt);
    TimeMins = (now.hour() * 60) + now.minute();
    alfa_1 = 360*now.day()/maxday;
    EEPROM.update(16,alfa_1);
    u8g.setPrintPos(1,60);
    u8g.print(EEPROM.read(16));
 
    int max_day(){
          
        
    int ma_valeur_de_maxday =0;
    }
   if (now.month() == 4 || now.month() == 5 || now.month() == 9 || now.month() == 11){  //30 jours =  Septembre, Avril, Juin,  Novembre.
    maxday = 30;
     }
  else {
    maxday = 31; //... all the others have 31
    
  }
  if (now.month() == 2 && now.year() % 4 == 0){  //... Exception Fevrier = 28 jours , ou 29 jours année bissextile.
    maxday = 29;
  }
  if (now.month() == 2 && now.year() % 4 != 0){
    maxday = 28;
 
    return ma_valeur_de_maxday;
 
 }   
    TimeMins = (now.hour() * 60) + now.minute();
    
    if (TimeMins >= Sunrise && TimeMins <=Sunset-1) { //If it's after sunrise and before sunset, switch our relay on
            digitalWrite (A3, HIGH);// cdt PONT H
            //analogWrite(backlight,255);// lcd rétroéclairage On
            u8g.setColorIndex(1); // Pixel On SH1106
      }
       else {  //otherwise switch it off
            digitalWrite (A3,LOW);// cdt PONT H
            //analogWrite(backlight,0);// lcd rétroéclairage Off
            u8g.setColorIndex(0);// Pixel Off SH1106
       }    
}

void setup(void) {
   u8g.setContrast(0);//Config the constrast to the best effect
   analogWrite(backlight,255);
      // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 )
    u8g.setColorIndex(255);     // white
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
    u8g.setColorIndex(3);         // max intensity
  else if ( u8g.getMode() == U8G_MODE_BW )
    u8g.setColorIndex(1);         // pixel on
    
  Serial.begin(9600);
  if (! RTC.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
   
    RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
    
  }
pinMode(A0,INPUT);//push button on encoder connected to A0 (and GND)
digitalWrite(A0,HIGH); //Pull button high
}

void loop(void) {
    
    u8g.setFont(u8g_font_6x10);
    DateTime now = RTC.now();
    Timer = now.hour(), DEC;
    Minutt = now.minute(), DEC;
    Sekund = now.second(), DEC;
    Serial.print(Timer);
    Serial.print(':');
    Serial.print(Minutt);
    Serial.print(':');
    Serial.print(Sekund);
    Serial.print(" - ");
    an = now.year(), DEC;
    Serial.print(an);
    Serial.print('/');
    luna = now.month(), DEC;
    Serial.print(luna);
    Serial.print('/');
    zi = now.day(), DEC;
    Serial.print(zi);
    Serial.print(" (");
    zis = now.dayOfTheWeek();
    Serial.print(daysOfTheWeek[zis]);
    Serial.println(") ");
    moteur_pas();
    //EEPROM.update(7,Maxday);
    alfa_1 = 360*now.day()/maxday;
    EEPROM.update(16,alfa_1);
    u8g.setPrintPos(1,60);
    u8g.print(EEPROM.read(16));
  // picture loop
  u8g.firstPage();
  do {
    draw();
    turntable();
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(100);

 pushlength = pushlengthset;
 pushlength = getpushlength();
 delay (10);
 
 if (pushlength < pushlengthset)
 {
  //ShortPush ();   
   Serial.println("short push");
    // picture loop
  u8g.firstPage();
  do {
    draw1();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(1000);

 }
  //This runs the setclock routine if the knob is pushed for a long time
       if (pushlength > pushlengthset) {
 
  Serial.println("long push");
         DateTime now = RTC.now();
         setyeartemp=now.year(),DEC;
         setmonthtemp=now.month(),DEC;
         setdaytemp=now.day(),DEC;
         setoretemp=now.hour(),DEC;
         setminstemp=now.minute(),DEC;
         setzitemp = now.dayOfTheWeek();
         setclock();
         pushlength = pushlengthset;
       };
 
} // end main loop


// subroutine to return the length of the button push.
int getpushlength()
{
  buttonstate = digitalRead(A0);  
       if(buttonstate == LOW && buttonflag==false) {     
              pushstart = millis();
              buttonflag = true;
          };     
       if (buttonstate == HIGH && buttonflag==true) {
         pushstop = millis ();
         pushlength = pushstop - pushstart;
         buttonflag = false;
       };
        Serial.println("_");
       return pushlength;
}

void draw1(void) {
  u8g.drawStr( 10, 32, "Thx to niq_ro!");
}
//sets the clock
void setclock (){
 
   setyear ();//Annee
   setmonth ();//Mois
   setday ();//Jour
   setzi();//semaine
   setore ();//hours
   setmins ();//Minutes
   RTC.adjust(DateTime(setyeartemp,setmonthtemp,setdaytemp,setoretemp,setminstemp,setsecs));
   CalcSun();
   delay (1000);
}
int CalcSun () { //Calculates the Sunrise and Sunset times
    DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    
 
}
// The following subroutines set the individual clock parameters
int setyear () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setyeartemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) { //bit of software de-bounce
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setyeartemp=setyeartemp + knobval;
    if (setyeartemp < 2018) { //Year can't be older than currently, it's not a time machine.
      setyeartemp = 2018;
    }
//itoa(setyeartemp - 2000, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
itoa(setyeartemp, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
  u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Annee");
//  u8g.drawStr( 0, 40, "20");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );  
    setyear();
}

int setmonth () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setmonthtemp;
    }

 //   lcd.setCursor (0,1);
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setmonthtemp=setmonthtemp + knobval;
    if (setmonthtemp < 1) {// month must be between 1 and 12
      setmonthtemp = 1;
    }
    if (setmonthtemp > 12) {
      setmonthtemp=12;
    }
    itoa(setmonthtemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Mois");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmonth();
}


int setday () {
  if (setmonthtemp == 4 || setmonthtemp == 5 || setmonthtemp == 9 || setmonthtemp == 11) { //30 days hath September, April June and November
    maxday = 30;
  }
  else {
  maxday = 31; //... all the others have 31
  }
  if (setmonthtemp ==2 && setyeartemp % 4 ==0) { //... Except February alone, and that has 28 days clear, and 29 in a leap year.
    maxday = 29;
  }
  if (setmonthtemp ==2 && setyeartemp % 4 !=0) {
    maxday = 28;
  }
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setdaytemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setdaytemp = setdaytemp+ knobval;
    if (setdaytemp < 1) {
      setdaytemp = 1;
    }
    if (setdaytemp > maxday) {
      setdaytemp = maxday;
    }
  itoa(setdaytemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setday();
}


int setzi () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setzitemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setzitemp=setzitemp + knobval;
    if (setzitemp < 0) {// month must be between 0 and 6
      setzitemp = 0;
    }
    if (setzitemp > 6) {
      setzitemp=6;
    }
    itoa(setzitemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour of Week");
  u8g.drawStr(25, 40, tmp_string);
  u8g.drawStr(0,60, daysOfTheWeek[setzitemp]);
  } while( u8g.nextPage() );
    setzi();
}

int setore () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setoretemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setoretemp=setoretemp + knobval;
    if (setoretemp < 0) {
      setoretemp = 0;
    }
    if (setoretemp > 23) {
      setoretemp=23;
    }
   itoa(setoretemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Heures");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setore();
}

int setmins () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setminstemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setminstemp=setminstemp + knobval;
    if (setminstemp < 0) {
      setminstemp = 0;
    }
    if (setminstemp > 59) {
      setminstemp=59;
    }
   itoa(setminstemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Minutes");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmins();
}


#95 Sandro

Sandro

    Membre passionné

  • Membres
  • PipPipPip
  • 339 messages
  • Gender:Male

Posté 24 janvier 2020 - 05:00

le problème est que tu ne peux pas déclarer une fonction depuis l'intérieur d'une fonction.

Je te conseille d'écrire la fonction "max_day" au dessus de la fonction turntable (il faut mettre déclarer une fonction avant de l'utiliser, même si on peut aussi juste mettre un prototype (dans ce cas "int max_day();") avant, et écrire la fonction plus loin (nb : dans le cas du protoype, il ne faut pas oublier le point virgule, qui n'y ait pas si tu écris directement le contenu de la fonction)



#96 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 25 janvier 2020 - 12:35

bonjour Sandro,

 

au lieu de faire u8g.print(EEPROM.read(16) oû j'avais en valeur lu 34,

j'ai fait u8g.print(alfa_1) et j'ai 290°,ce qui est correct

je ne comprends pourquoi je n'ai pas la même valeur

alfa_1 = 360*now.day()/maxday;

enregistrement valeur dans l' EEPROM.update(16,alfa_1);
  u8g.setPrintPos(1,60);
  u8g.print(EEPROM.read(16));

bonne journée ,michel



#97 Sandro

Sandro

    Membre passionné

  • Membres
  • PipPipPip
  • 339 messages
  • Gender:Male

Posté 25 janvier 2020 - 07:47

Bonsoir,

tout d'abord, essaye de mettre le dernier code à chaque fois que tu fais une modification et que tu a une nouvelle question, sinon je ne peux que deviner à quoi ressemble ton code.

 

Ensuite, je t'ai dis que je ne voulais plus voir "maxday" dans ton code : il faut TOUS les remplacer par un appel à la fonction max_day (avec tiret).

 

Enfin, à la ligne 62 du dernier code que tu as posté, tu n'as pas supprimé la déclaration de maxday comme je t'avais dit de le faire (si tu l'avais supprimé, le compilateur t'aurais probablement mis une erreur à la ligne

alfa_1 = 360*now.day()/maxday; , là tu te retrouve probablement avec une variable déclarée mais pas initialisée, qui peut donc valoir n'importe quoi (ie la dernière valeur contenu dans la RAM à l'endroit où le compilateur a décidé de mettre cette variable).

 

Du coup, remplace "maxday" par "max_day()" dans ton calcul de alfa_1, et supprime la déclaration "int maxday;" de la ligne 62.

 

Nb : pense à remplacer toutes les utilisations de maxday par max_day();

Nb2 : dans la déclaration de la nouvelle fonction max_day, il faut utiliser la variable "ma_valeur_de_maxday" et pas "maxday" (sinon la fonction renvois 0).

 

Bonne soirée

Sandro



#98 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 26 janvier 2020 - 05:25

bonsoir Sandro ,

j'ai essayer de faire ce que tu m'as demander mais j'ai -1 affichage alfa_1 et dessin egalement.

par contre ligne 62 c'est dans le programme de réglage de la date du programme ligne 463 je ne peu pas l'enlever.

j'ai une petite idée pourquoi u8g.print(EEPROM.read16);donnez 34 pour un angle de 290°  comme la valeur maximum de l EEPROM et de 255.

290 - 255 = 35 je ne sais pas ce que tu en pense .

c'est surement pour cela que u8g.print (alfa_1 ) ; direct sans passer par l'EEPROM donne la bonne valeur .

je te met le programme complet .

merci pour ton aide et ta patience  .

bon dimanche et bonne soirée .

#include <Wire.h>
#include "RTClib.h"
#include <Stepper.h>
#include <Encoder.h> // from http://www.pjrc.com/teensy/td_libs_Encoder.html
Encoder knob(3, 4); //encoder connected to pins 2 and 3 (and ground)// D2 SEEDSTUDIO shield
#include <TimeLib.h>
#include <TimeLord.h>
#include <EEPROM.h>
const float LATITUDE = 43.70, LONGITUDE = 7.25; // Nice Sun
const int TIMEZONE = + 1;
int r   = 35;//cercle drawLine
int r_1 = 35;//drawbitmap
int angle = 0;
int x1=57;// drawbitmap rattrapage width  65-8 = 57
int y1=43;// drawbitmap rattrapage height 50-8 = 42
int x0=65;// drawLine
int y0=50;// drawLine
int sun;
int alfa=0;
int degre = 0;
//int backlight = 6; //backlight control pin 6
/* variables stepper */
                                    
const int nbrepas360 = 64;                       // Fixe le nombre de pas pour faire un tour complet, c'est-à-dire 360°.
Stepper monmoteur (nbrepas360, 8, 9, 10, 11);    // Initialise la librairie Stepper.h
int cptepas = 0 ;
int alfa_1 = 0;
float position_du_moteur;
float degrees_pas = 1;

#define u8g_logo_width 16
#define u8g_logo_height 16

#if defined(ARDUINO_ARCH_SAMD)
// for Zero, output on USB Serial console, remove line below if using programming port to program the Zero!
   #define Serial SerialUSB
#endif
RTC_DS1307 RTC;
char daysOfTheWeek[7][12] = {"Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"};

#include "U8glib.h"
//U8GLIB_ST7920_128X64 u8g(13, 11, 12, U8G_PIN_NONE);//U8GLIB_ST7920_128X64_1X u8g(7, 6, 5 ,8); //Enable, RW, RS, RESET
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);

int Timer = 0;
int Minutt = 0;
int Sekund = 0;
float Vinkel = 0;
int an = 0;
int luna = 0;
int zi = 0;
int zis = 0;

//the variables provide the holding values for the set clock routine
int setyeartemp;
int setmonthtemp;
int setdaytemp;
int setoretemp;
int setzitemp;
int setminstemp;
int setsecs = 0;
int maxday; // maximum number of days in the given month
int TimeMins; // number of seconds since midnight
int TimerMode = 2; //mode 0=Off 1=On 2=Auto
int TimeOut = 10;
int TimeOutCounter;

// These variables are for the push button routine
int buttonstate = 0; //flag to see if the button has been pressed, used internal on the subroutine only
int pushlengthset = 1500; // value for a long push in mS
int pushlength = pushlengthset; // set default pushlength
int pushstart = 0;// sets default push value for the button going low
int pushstop = 0;// sets the default value for when the button goes back high

int Sunrise, Sunset; //sunrise and sunset expressed as minute of day (0-1439)
TimeLord myLord; // TimeLord Object, Global variable
byte sunTime[]  = {0, 0, 0, 1, 1, 13}; // 17 Oct 2013
int SunriseHour, SunriseMin, SunsetHour, SunsetMin;
int knobval; // value for the rotation of the knob
boolean buttonflag = false; // default value for the button flag

int backlight = 6;//backlight control pin 6
#include <stdlib.h>
char tmp_string[8];

int max_day(){
  int ma_valeur_de_maxday=0;
    DateTime now = RTC.now();
      
   if (now.month() == 4 || now.month() == 5 || now.month() == 9 || now.month() == 11){  //30 jours =  Septembre, Avril, Juin,  Novembre.
    maxday = 30;
     }
  else {
    maxday = 31; //... all the others have 31
    
  }
  if (now.month() == 2 && now.year() % 4 == 0){  //... Exception Fevrier = 28 jours , ou 29 jours année bissextile.
    maxday = 29;
  }
  if (now.month() == 2 && now.year() % 4 != 0){
    maxday = 28;
   return ma_valeur_de_maxday;
 
 }   
}

void turntable(void) {
  DateTime now = RTC.now();
 
    /* center */
 int x2=128/2;  
 int y2=64/2;  
 /* radius */
 int r2=22;
 /* angle*/
 int cptepas = EEPROM.read(18);
 int ma_valeur_de_maxday;
  max_day() ;
  alfa_1 =360*now.day()/ma_valeur_de_maxday;
 
 u8g.setPrintPos(1,60);
 u8g.print(alfa_1);
 
 position_du_moteur = cptepas*5.625;
 EEPROM.update(17,position_du_moteur);
 u8g.setFont(u8g_font_6x10);
 
 u8g.setPrintPos(30,60);
 u8g.print(EEPROM.read(17));//pos_moteur
 u8g.setPrintPos(90,60);
 u8g.print(EEPROM.read(18));//cptepas
  /* affichage maxday */
 u8g.setFont(u8g_font_6x10);
 u8g.setPrintPos(110,30 );
 u8g.print(EEPROM.read(7));
 u8g.setPrintPos(62,9);
 u8g.print("0");
 u8g.setPrintPos(90,32);
 u8g.print("90");
 u8g.setPrintPos(56,64);
 u8g.print("180");
 u8g.setPrintPos(22,32);
 u8g.print("270");
 u8g.drawLine(x2,y2, x2+r2*sin(1*alfa_1*2*3.14/360), y2-r2*cos(1*alfa_1*2*3.14/360));  
 u8g.drawCircle(x2, y2, r2);
 
 }
 void moteur_pas(){
    position_du_moteur = cptepas*5.625;
              
   if(position_du_moteur < alfa_1 - degrees_pas ){
    monmoteur.step(+1);                   // Avance de 1 pas.
    cptepas++;
    EEPROM.update(18,cptepas);// Incrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
    Serial.println(cptepas);// le nbre de pas effectué.
    delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
  if(position_du_moteur > alfa_1 + degrees_pas){
    monmoteur.step(-1);
    cptepas--;// décrémente la variable cptepas pour compter les pas.
    EEPROM.update(18,cptepas);// decrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
    Serial.println(cptepas); // le nbre de pas effectué.                   
    delay(500);                  
   }
    EEPROM.update(17,position_du_moteur);
}

 void draw(void) {
      
      DateTime now = RTC.now();
      
    /*Timelord initialisation*/
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    u8g.setFont(u8g_font_6x13);   
    u8g.setPrintPos(2,10);
    if (zi < 10) u8g.print("0");
    u8g.print(zi);
    u8g.print("/");
    if (luna < 10) u8g.print("0");
    u8g.print(luna);
    u8g.print("/");
    u8g.setPrintPos(40,10);
    u8g.print(daysOfTheWeek[zis]);

    u8g.setFont(u8g_font_6x13);
    u8g.setPrintPos(80,10);
    if (Timer < 10) u8g.print(" ");
    u8g.print(Timer);
    u8g.setPrintPos(93,10);
    if (Sekund%2 != 1)
    u8g.print(":");
    u8g.setPrintPos(115,10);
    u8g.setFont(u8g_font_6x10);
    if(Sekund<10)u8g.print("0");
    u8g.print(Sekund);
    u8g.setPrintPos(100,10);
    u8g.setFont(u8g_font_6x13);
    if (Minutt < 10) u8g.print("0");
    u8g.print(Minutt);
    TimeMins = (now.hour() * 60) + now.minute();
    max_day();
    //u8g.setPrintPos(1,60);
    //u8g.print(EEPROM.read(16));
    
    TimeMins = (now.hour() * 60) + now.minute();
    
    if (TimeMins >= Sunrise && TimeMins <=Sunset-1) { //If it's after sunrise and before sunset, switch our relay on
            digitalWrite (A3, HIGH);// cdt PONT H
            //analogWrite(backlight,255);// lcd rétroéclairage On
            u8g.setColorIndex(1); // Pixel On SH1106
      }
       else {  //otherwise switch it off
            digitalWrite (A3,LOW);// cdt PONT H
            //analogWrite(backlight,0);// lcd rétroéclairage Off
            u8g.setColorIndex(0);// Pixel Off SH1106
     }    
  }
        
        
    
void setup(void) {
   u8g.setContrast(0);//Config the constrast to the best effect
   analogWrite(backlight,255);
      // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 )
    u8g.setColorIndex(255);     // white
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
    u8g.setColorIndex(3);         // max intensity
  else if ( u8g.getMode() == U8G_MODE_BW )
    u8g.setColorIndex(1);         // pixel on
    
  Serial.begin(9600);
  Wire.begin();
  if (! RTC.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
   
    RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
    
  }
pinMode(A0,INPUT);//push button on encoder connected to A0 (and GND)
digitalWrite(A0,HIGH); //Pull button high
}

void loop(void) {
    
    u8g.setFont(u8g_font_6x10);
    DateTime now = RTC.now();
    Timer = now.hour(), DEC;
    Minutt = now.minute(), DEC;
    Sekund = now.second(), DEC;
    Serial.print(Timer);
    Serial.print(':');
    Serial.print(Minutt);
    Serial.print(':');
    Serial.print(Sekund);
    Serial.print(" - ");
    an = now.year(), DEC;
    Serial.print(an);
    Serial.print('/');
    luna = now.month(), DEC;
    Serial.print(luna);
    Serial.print('/');
    zi = now.day(), DEC;
    Serial.print(zi);
    Serial.print(" (");
    zis = now.dayOfTheWeek();
    Serial.print(daysOfTheWeek[zis]);
    Serial.println(") ");
    moteur_pas();
    max_day();
    //EEPROM.update(7,max_day);
    //alfa_1 = 360*now.day()/max_day();
           
  /* picture loop*/
  u8g.firstPage();
  do {
    draw();
    turntable();
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(100);

 pushlength = pushlengthset;
 pushlength = getpushlength();
 delay (10);
 
 if (pushlength < pushlengthset)
 {
  //ShortPush ();   
   Serial.println("short push");
    // picture loop
  u8g.firstPage();
  do {
    draw1();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(1000);

 }
  //This runs the setclock routine if the knob is pushed for a long time
       if (pushlength > pushlengthset) {
 
  Serial.println("long push");
         DateTime now = RTC.now();
         setyeartemp=now.year(),DEC;
         setmonthtemp=now.month(),DEC;
         setdaytemp=now.day(),DEC;
         setoretemp=now.hour(),DEC;
         setminstemp=now.minute(),DEC;
         setzitemp = now.dayOfTheWeek();
         setclock();
         pushlength = pushlengthset;
       };
 
} // end main loop


// subroutine to return the length of the button push.
int getpushlength()
{
  buttonstate = digitalRead(A0);  
       if(buttonstate == LOW && buttonflag==false) {     
              pushstart = millis();
              buttonflag = true;
          };     
       if (buttonstate == HIGH && buttonflag==true) {
         pushstop = millis ();
         pushlength = pushstop - pushstart;
         buttonflag = false;
       };
        Serial.println("_");
       return pushlength;
}

void draw1(void) {
  u8g.drawStr( 10, 32, "Thx to niq_ro!");
}
//sets the clock
void setclock (){
 
   setyear ();//Annee
   setmonth ();//Mois
   setday ();//Jour
   setzi();//semaine
   setore ();//hours
   setmins ();//Minutes
   RTC.adjust(DateTime(setyeartemp,setmonthtemp,setdaytemp,setoretemp,setminstemp,setsecs));
   CalcSun();
   delay (1000);
}
int CalcSun () { //Calculates the Sunrise and Sunset times
    DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    
 
}
// The following subroutines set the individual clock parameters
int setyear () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setyeartemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) { //bit of software de-bounce
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setyeartemp=setyeartemp + knobval;
    if (setyeartemp < 2018) { //Year can't be older than currently, it's not a time machine.
      setyeartemp = 2018;
    }
//itoa(setyeartemp - 2000, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
itoa(setyeartemp, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
  u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Annee");
//  u8g.drawStr( 0, 40, "20");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );  
    setyear();
}

int setmonth () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setmonthtemp;
    }

 //   lcd.setCursor (0,1);
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setmonthtemp=setmonthtemp + knobval;
    if (setmonthtemp < 1) {// month must be between 1 and 12
      setmonthtemp = 1;
    }
    if (setmonthtemp > 12) {
      setmonthtemp=12;
    }
    itoa(setmonthtemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Mois");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmonth();
}


int setday () {
  if (setmonthtemp == 4 || setmonthtemp == 5 || setmonthtemp == 9 || setmonthtemp == 11) { //30 days hath September, April June and November
    maxday = 30;
  }
  else {
  maxday = 31; //... all the others have 31
  }
  if (setmonthtemp ==2 && setyeartemp % 4 ==0) { //... Except February alone, and that has 28 days clear, and 29 in a leap year.
    maxday = 29;
  }
  if (setmonthtemp ==2 && setyeartemp % 4 !=0) {
    maxday = 28;
  }
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setdaytemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setdaytemp = setdaytemp+ knobval;
    if (setdaytemp < 1) {
      setdaytemp = 1;
    }
    if (setdaytemp > maxday) {
      setdaytemp = maxday;
    }
  itoa(setdaytemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setday();
}


int setzi () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setzitemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setzitemp=setzitemp + knobval;
    if (setzitemp < 0) {// month must be between 0 and 6
      setzitemp = 0;
    }
    if (setzitemp > 6) {
      setzitemp=6;
    }
    itoa(setzitemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour of Week");
  u8g.drawStr(25, 40, tmp_string);
  u8g.drawStr(0,60, daysOfTheWeek[setzitemp]);
  } while( u8g.nextPage() );
    setzi();
}

int setore () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setoretemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setoretemp=setoretemp + knobval;
    if (setoretemp < 0) {
      setoretemp = 0;
    }
    if (setoretemp > 23) {
      setoretemp=23;
    }
   itoa(setoretemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Heures");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setore();
}

int setmins () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setminstemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setminstemp=setminstemp + knobval;
    if (setminstemp < 0) {
      setminstemp = 0;
    }
    if (setminstemp > 59) {
      setminstemp=59;
    }
   itoa(setminstemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Minutes");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmins();
}


 
 
 


#99 Sandro

Sandro

    Membre passionné

  • Membres
  • PipPipPip
  • 339 messages
  • Gender:Male

Posté 27 janvier 2020 - 12:17

Bonsoir,

pour ton problème d'affichage incohérent, je voudrais tout d'abord qu'on finisse de régler le problème de maxday, car ça peut être une cause du problème.

 

Et s'il te plait, lis attentivement les messages, comme ça tu ne ratera pas des consignes de fautes à corriger.

 

 1) En particulier, tu n'as pas fait le "NB2" de mon message précédent, à savoir remplacer "maxday" par "ma_valeur_de_maxday" partout dans ta fonction max_day (qui du coup renvoi 0).

La fonction mad_day doit être la suivante :

int max_day(){
  int ma_valeur_de_maxday=0;
    DateTime now = RTC.now();
      
   if (now.month() == 4 || now.month() == 5 || now.month() == 9 || now.month() == 11){  //30 jours =  Septembre, Avril, Juin,  Novembre.
    ma_valeur_de_maxday = 30;
     }
  else {
    ma_valeur_de_maxday = 31; //... all the others have 31
    
  }
  if (now.month() == 2 && now.year() % 4 == 0){  //... Exception Fevrier = 28 jours , ou 29 jours année bissextile.
    ma_valeur_de_maxday = 29;
  }
  if (now.month() == 2 && now.year() % 4 != 0){
    ma_valeur_de_maxday = 28;
   return ma_valeur_de_maxday;
 
 }   
}

2) dans la fonction turntable, je ne t'ai jamais dit de mettre "ma_valeur_de_maxday" (cette variable n'est sensé exister que dans la fonction max_day et nulle part ailleurs.

Du coup :

2.1) tu supprime la déclaration de ma_valeur_de_maxday de la ligne 117

2.2) tu remplace "ma_valeur_de_maxday" par "max_day()" a la ligne 119

 

3) Dans la fonction setday, ce n'est pas vraiment le maxday du mois en cours qu'on utilise mais celui de setmonthtemp. Du coup, utiliser la même variable maxday que pour le reste du programme est peu naturel (je pense qu'au final sa ne crée pas de vrai erreur, mais c'est pas logique).

Je te suggère donc :

3.1) en toute première ligne de la fonction setday, tu déclare une variable maxdaytemp (int maxdaytemp;)

3.2) dans tout le reste de la fonction setday, tu remplace "maxday" par "maxdaytemp"

3.3) maintenant tu devrais enfin pouvoir me supprimer la déclaration de maxday à la ligne 62.

 

 

Il est bien possible qu'une fois ces étapes exécutées le problème soit résolu (et dans le cas contraire, au moins ça facilitera les recherches).

 

Bonne soirée

Sandro

 

PS : si tu veux, on peut aussi faire une "vidéoconférence" avec partage d'écran (skype, zoom, ...), ce sera probablement plus efficace pour chercher les erreurs et au passage t'expliquer le pourquoi de mes consignes (de mon coté, je n'ai pas le matériel pour faire le même montage que toi donc je peux pas tester, et de toute façon, si je me contente de modifier ton code et de te le renvoyer, tu n'apprendra rien)



#100 michel

michel

    Membre occasionnel

  • Membres
  • Pip
  • 86 messages
  • Gender:Male
  • Location:nice

Posté 27 janvier 2020 - 03:41

Bonjour Sandro,

voila j'ai tout modifier mais cela  donne "1" pour alfa_1 .

je te joins le code .

bonne journée ,michel.

#include <Wire.h>
#include "RTClib.h"
#include <Stepper.h>
#include <Encoder.h> // from http://www.pjrc.com/teensy/td_libs_Encoder.html
Encoder knob(3, 4); //encoder connected to pins 2 and 3 (and ground)// D2 SEEDSTUDIO shield
#include <TimeLib.h>
#include <TimeLord.h>
#include <EEPROM.h>
const float LATITUDE = 43.70, LONGITUDE = 7.25; // Nice Sun
const int TIMEZONE = + 1;
int r   = 35;//cercle drawLine
int r_1 = 35;//drawbitmap
int angle = 0;
int x1=57;// drawbitmap rattrapage width  65-8 = 57
int y1=43;// drawbitmap rattrapage height 50-8 = 42
int x0=65;// drawLine
int y0=50;// drawLine
int sun;
int alfa=0;
int degre = 0;
//int backlight = 6; //backlight control pin 6
/* variables stepper */
                                    
const int nbrepas360 = 64;                       // Fixe le nombre de pas pour faire un tour complet, c'est-à-dire 360°.
Stepper monmoteur (nbrepas360, 8, 9, 10, 11);    // Initialise la librairie Stepper.h
int cptepas = 0 ;
int alfa_1 = 0;
float position_du_moteur;
float degrees_pas = 1;

#define u8g_logo_width 16
#define u8g_logo_height 16

#if defined(ARDUINO_ARCH_SAMD)
// for Zero, output on USB Serial console, remove line below if using programming port to program the Zero!
   #define Serial SerialUSB
#endif
RTC_DS1307 RTC;
char daysOfTheWeek[7][12] = {"Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"};

#include "U8glib.h"
//U8GLIB_ST7920_128X64 u8g(13, 11, 12, U8G_PIN_NONE);//U8GLIB_ST7920_128X64_1X u8g(7, 6, 5 ,8); //Enable, RW, RS, RESET
U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);

int Timer = 0;
int Minutt = 0;
int Sekund = 0;
float Vinkel = 0;
int an = 0;
int luna = 0;
int zi = 0;
int zis = 0;

//the variables provide the holding values for the set clock routine
int setyeartemp;
int setmonthtemp;
int setdaytemp;
int setoretemp;
int setzitemp;
int setminstemp;
int setsecs = 0;
int maxdaytemp; // maximum number of days in the given month
int TimeMins; // number of seconds since midnight
int TimerMode = 2; //mode 0=Off 1=On 2=Auto
int TimeOut = 10;
int TimeOutCounter;

// These variables are for the push button routine
int buttonstate = 0; //flag to see if the button has been pressed, used internal on the subroutine only
int pushlengthset = 1500; // value for a long push in mS
int pushlength = pushlengthset; // set default pushlength
int pushstart = 0;// sets default push value for the button going low
int pushstop = 0;// sets the default value for when the button goes back high

int Sunrise, Sunset; //sunrise and sunset expressed as minute of day (0-1439)
TimeLord myLord; // TimeLord Object, Global variable
byte sunTime[]  = {0, 0, 0, 1, 1, 13}; // 17 Oct 2013
int SunriseHour, SunriseMin, SunsetHour, SunsetMin;
int knobval; // value for the rotation of the knob
boolean buttonflag = false; // default value for the button flag

int backlight = 6;//backlight control pin 6
#include <stdlib.h>
char tmp_string[8];

int max_day(){
  int ma_valeur_de_maxday=0;
    DateTime now = RTC.now();
      
   if (now.month() == 4 || now.month() == 5 || now.month() == 9 || now.month() == 11){  //30 jours =  Septembre, Avril, Juin,  Novembre.
     ma_valeur_de_maxday  = 30;
     }
  else {
     ma_valeur_de_maxday  = 31; //... all the others have 31
    
  }
  if (now.month() == 2 && now.year() % 4 == 0){  //... Exception Fevrier = 28 jours , ou 29 jours année bissextile.
     ma_valeur_de_maxday  = 29;
  }
  if (now.month() == 2 && now.year() % 4 != 0){
     ma_valeur_de_maxday  = 28;
   return ma_valeur_de_maxday;
 
 }   
}

void turntable(void) {
  DateTime now = RTC.now();
 
    /* center */
 int x2=128/2;  
 int y2=64/2;  
 /* radius */
 int r2=22;
 /* angle*/
 int cptepas = EEPROM.read(18);
  max_day() ;
  alfa_1 =360*now.day()/max_day();
 
 u8g.setPrintPos(1,60);
 u8g.print(alfa_1);
 
 position_du_moteur = cptepas*5.625;
 EEPROM.update(17,position_du_moteur);
 u8g.setFont(u8g_font_6x10);
 
 u8g.setPrintPos(30,60);
 u8g.print(EEPROM.read(17));//pos_moteur
 u8g.setPrintPos(90,60);
 u8g.print(EEPROM.read(18));//cptepas
  /* affichage maxday */
 u8g.setFont(u8g_font_6x10);
 u8g.setPrintPos(110,30 );
 u8g.print(EEPROM.read(7));
 u8g.setPrintPos(62,9);
 u8g.print("0");
 u8g.setPrintPos(90,32);
 u8g.print("90");
 u8g.setPrintPos(56,64);
 u8g.print("180");
 u8g.setPrintPos(22,32);
 u8g.print("270");
 u8g.drawLine(x2,y2, x2+r2*sin(1*alfa_1*2*3.14/360), y2-r2*cos(1*alfa_1*2*3.14/360));  
 u8g.drawCircle(x2, y2, r2);
 
 }
 void moteur_pas(){
    position_du_moteur = cptepas*5.625;
              
   if(position_du_moteur < alfa_1 - degrees_pas ){
    monmoteur.step(+1);                   // Avance de 1 pas.
    cptepas++;
    EEPROM.update(18,cptepas);// Incrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );     // Affiche dans le moniteur "série"
    Serial.println(cptepas);// le nbre de pas effectué.
    delay(500);                      // Pause d'une demi seconde entre chaque pas.
  }
  if(position_du_moteur > alfa_1 + degrees_pas){
    monmoteur.step(-1);
    cptepas--;// décrémente la variable cptepas pour compter les pas.
    EEPROM.update(18,cptepas);// decrémente la variable cptepas pour compter les pas.
    Serial.print("nombre de pas:" );    // Affiche dans le moniteur "série"
    Serial.println(cptepas); // le nbre de pas effectué.                   
    delay(500);                  
   }
    EEPROM.update(17,position_du_moteur);
}

 void draw(void) {
      
      DateTime now = RTC.now();
      
    /*Timelord initialisation*/
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    u8g.setFont(u8g_font_6x13);   
    u8g.setPrintPos(2,10);
    if (zi < 10) u8g.print("0");
    u8g.print(zi);
    u8g.print("/");
    if (luna < 10) u8g.print("0");
    u8g.print(luna);
    u8g.print("/");
    u8g.setPrintPos(40,10);
    u8g.print(daysOfTheWeek[zis]);

    u8g.setFont(u8g_font_6x13);
    u8g.setPrintPos(80,10);
    if (Timer < 10) u8g.print(" ");
    u8g.print(Timer);
    u8g.setPrintPos(93,10);
    if (Sekund%2 != 1)
    u8g.print(":");
    u8g.setPrintPos(115,10);
    u8g.setFont(u8g_font_6x10);
    if(Sekund<10)u8g.print("0");
    u8g.print(Sekund);
    u8g.setPrintPos(100,10);
    u8g.setFont(u8g_font_6x13);
    if (Minutt < 10) u8g.print("0");
    u8g.print(Minutt);
    TimeMins = (now.hour() * 60) + now.minute();
    max_day();
    //u8g.setPrintPos(1,60);
    //u8g.print(EEPROM.read(16));
    
    TimeMins = (now.hour() * 60) + now.minute();
    
    if (TimeMins >= Sunrise && TimeMins <=Sunset-1) { //If it's after sunrise and before sunset, switch our relay on
            digitalWrite (A3, HIGH);// cdt PONT H
            //analogWrite(backlight,255);// lcd rétroéclairage On
            u8g.setColorIndex(1); // Pixel On SH1106
      }
       else {  //otherwise switch it off
            digitalWrite (A3,LOW);// cdt PONT H
            //analogWrite(backlight,0);// lcd rétroéclairage Off
            u8g.setColorIndex(0);// Pixel Off SH1106
     }    
  }
        
        
    
void setup(void) {
   u8g.setContrast(0);//Config the constrast to the best effect
   analogWrite(backlight,255);
      // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 )
    u8g.setColorIndex(255);     // white
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
    u8g.setColorIndex(3);         // max intensity
  else if ( u8g.getMode() == U8G_MODE_BW )
    u8g.setColorIndex(1);         // pixel on
    
  Serial.begin(9600);
  Wire.begin();
  if (! RTC.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
   
    RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
    
  }
pinMode(A0,INPUT);//push button on encoder connected to A0 (and GND)
digitalWrite(A0,HIGH); //Pull button high
}

void loop(void) {
    
    u8g.setFont(u8g_font_6x10);
    DateTime now = RTC.now();
    Timer = now.hour(), DEC;
    Minutt = now.minute(), DEC;
    Sekund = now.second(), DEC;
    Serial.print(Timer);
    Serial.print(':');
    Serial.print(Minutt);
    Serial.print(':');
    Serial.print(Sekund);
    Serial.print(" - ");
    an = now.year(), DEC;
    Serial.print(an);
    Serial.print('/');
    luna = now.month(), DEC;
    Serial.print(luna);
    Serial.print('/');
    zi = now.day(), DEC;
    Serial.print(zi);
    Serial.print(" (");
    zis = now.dayOfTheWeek();
    Serial.print(daysOfTheWeek[zis]);
    Serial.println(") ");
    moteur_pas();
    max_day();
    //EEPROM.update(7,max_day);
    //alfa_1 = 360*now.day()/max_day();
           
  /* picture loop*/
  u8g.firstPage();
  do {
    draw();
    turntable();
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(100);

 pushlength = pushlengthset;
 pushlength = getpushlength();
 delay (10);
 
 if (pushlength < pushlengthset)
 {
  //ShortPush ();   
   Serial.println("short push");
    // picture loop
  u8g.firstPage();
  do {
    draw1();
    
  } while( u8g.nextPage() );
  // rebuild the picture after some delay
  delay(1000);

 }
  //This runs the setclock routine if the knob is pushed for a long time
       if (pushlength > pushlengthset) {
 
  Serial.println("long push");
         DateTime now = RTC.now();
         setyeartemp=now.year(),DEC;
         setmonthtemp=now.month(),DEC;
         setdaytemp=now.day(),DEC;
         setoretemp=now.hour(),DEC;
         setminstemp=now.minute(),DEC;
         setzitemp = now.dayOfTheWeek();
         setclock();
         pushlength = pushlengthset;
       };
 
} // end main loop


// subroutine to return the length of the button push.
int getpushlength()
{
  buttonstate = digitalRead(A0);  
       if(buttonstate == LOW && buttonflag==false) {     
              pushstart = millis();
              buttonflag = true;
          };     
       if (buttonstate == HIGH && buttonflag==true) {
         pushstop = millis ();
         pushlength = pushstop - pushstart;
         buttonflag = false;
       };
        Serial.println("_");
       return pushlength;
}

void draw1(void) {
  u8g.drawStr( 10, 32, "Thx to niq_ro!");
}
//sets the clock
void setclock (){
 
   setyear ();//Annee
   setmonth ();//Mois
   setday ();//Jour
   setzi();//semaine
   setore ();//hours
   setmins ();//Minutes
   RTC.adjust(DateTime(setyeartemp,setmonthtemp,setdaytemp,setoretemp,setminstemp,setsecs));
   CalcSun();
   delay (1000);
}
int CalcSun () { //Calculates the Sunrise and Sunset times
    DateTime now = RTC.now();
    //Timelord initialisation
    myLord.TimeZone(TIMEZONE * 60);
    myLord.Position(LATITUDE, LONGITUDE);
    sunTime[3] = now.day(); // Give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunRise(sunTime); // Computes Sun Rise.
    Sunrise = sunTime[2] * 60 + sunTime[1]; // Sunrise returned in minutes past midnight
    SunriseHour = sunTime[2];
    SunriseMin = sunTime [1];
    sunTime[3] = now.day(); // Uses the Time library to give Timelord the current date
    sunTime[4] = now.month();
    sunTime[5] = now.year();
    myLord.SunSet(sunTime); // Computes Sun Set.
    Sunset = sunTime[2] * 60 + sunTime[1]; // Sunset returned in minutes past midnight
    SunsetHour = sunTime[2];
    SunsetMin = sunTime [1];
    
 
}
// The following subroutines set the individual clock parameters
int setyear () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setyeartemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) { //bit of software de-bounce
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setyeartemp=setyeartemp + knobval;
    if (setyeartemp < 2018) { //Year can't be older than currently, it's not a time machine.
      setyeartemp = 2018;
    }
//itoa(setyeartemp - 2000, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
itoa(setyeartemp, tmp_string, 10); // https://www.avrfreaks.net/forum/how-do-i-print-variable-u8glib
  u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Annee");
//  u8g.drawStr( 0, 40, "20");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );  
    setyear();
}

int setmonth () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setmonthtemp;
    }

 //   lcd.setCursor (0,1);
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setmonthtemp=setmonthtemp + knobval;
    if (setmonthtemp < 1) {// month must be between 1 and 12
      setmonthtemp = 1;
    }
    if (setmonthtemp > 12) {
      setmonthtemp=12;
    }
    itoa(setmonthtemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Mois");
  u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmonth();
}


int setday () {
  if (setmonthtemp == 4 || setmonthtemp == 5 || setmonthtemp == 9 || setmonthtemp == 11) { //30 days hath September, April June and November
    maxdaytemp = 30;
  }
  else {
  maxdaytemp = 31; //... all the others have 31
  }
  if (setmonthtemp ==2 && setyeartemp % 4 ==0) { //... Except February alone, and that has 28 days clear, and 29 in a leap year.
    maxdaytemp = 29;
  }
  if (setmonthtemp ==2 && setyeartemp % 4 !=0) {
    maxdaytemp = 28;
  }
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setdaytemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setdaytemp = setdaytemp+ knobval;
    if (setdaytemp < 1) {
      setdaytemp = 1;
    }
    if (setdaytemp > max_day) {
      setdaytemp = max_day;
    }
  itoa(setdaytemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setday();
}


int setzi () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setzitemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
    }
    if (knobval > 1) {
      knobval = 1;
    }
    setzitemp=setzitemp + knobval;
    if (setzitemp < 0) {// month must be between 0 and 6
      setzitemp = 0;
    }
    if (setzitemp > 6) {
      setzitemp=6;
    }
    itoa(setzitemp, tmp_string, 10);
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Jour of Week");
  u8g.drawStr(25, 40, tmp_string);
  u8g.drawStr(0,60, daysOfTheWeek[setzitemp]);
  } while( u8g.nextPage() );
    setzi();
}

int setore () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setoretemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setoretemp=setoretemp + knobval;
    if (setoretemp < 0) {
      setoretemp = 0;
    }
    if (setoretemp > 23) {
      setoretemp=23;
    }
   itoa(setoretemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Heures");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setore();
}

int setmins () {
    pushlength = pushlengthset;
    pushlength = getpushlength ();
    if (pushlength != pushlengthset) {
      return setminstemp;
    }
    knob.write(0);
    delay (50);
    knobval=knob.read();
    if (knobval < -1) {
      knobval = -1;
      delay (50);
    }
    if (knobval > 1) {
      knobval = 1;
      delay (50);
    }
    setminstemp=setminstemp + knobval;
    if (setminstemp < 0) {
      setminstemp = 0;
    }
    if (setminstemp > 59) {
      setminstemp=59;
    }
   itoa(setminstemp, tmp_string, 10);  
    u8g.firstPage();
  do {
  u8g.drawStr( 0, 20, "Set Minutes");
u8g.drawStr(25, 40, tmp_string);
  } while( u8g.nextPage() );
    setmins();
}

 
 
 





1 utilisateur(s) li(sen)t ce sujet

0 members, 1 guests, 0 anonymous users