// sidereal clock
// Antonio C B Oliveira
// Observatorio Longa Vista
// cal@longavista.com.br
// www.longavista.com.br
// November 2011

#include <Time.h>
#include <Wire.h>
#include <DS1307RTC.h>  // a basic DS1307 library that returns time as a time_t
#include "HT1632.h"

// ethernet libraries
#include <SPI.h>
#include <Ethernet.h>
#include <Udp.h>

// global variables, some have to be changed for each observatory
#include "gmst0.h"


// control pins for display
#define DATA 2
#define WR   3
#define CS   5
#define CS2  6
#define LED 8

// brigthness control potentiometer
#define POT 0

// dispaly definition
HT1632LEDMatrix matrix = HT1632LEDMatrix(DATA, WR, CS, CS2);

// NTP time stamp is in the first 48 bytes of the message
const int NTP_PACKET_SIZE=48;
// buffer to hold incoming and outgoing messages
byte pb[NTP_PACKET_SIZE];
//local port to listen for UDP packets
unsigned int localPort=8888;


int valPot;
int8_t brilho=15,brilhoAnt=15;


// display variables
char displayUT[9];
char displayLST[9];

time_t lastSyncNTP;
const int syncInterval=600;
 

void setup()  {
  
  // deselect SD card
  pinMode(4,OUTPUT);
  digitalWrite(4 , HIGH);
  
  pinMode(LED, OUTPUT);
  
  // sync real time clock with arduino 
  setSyncProvider(RTC.get);   
  while(timeStatus()!= timeSet);
  
  // inicialize LED matrix
  matrix.begin(HT1632_COMMON_16NMOS);  
  matrix.fillScreen();
  delay(500);
  
  // start Ethernet and UDP
  Ethernet.begin(mac, ip);
  Udp.begin(localPort);
  delay(5000);
  
  // clear display
  matrix.clearScreen(); 
  matrix.setTextSize(1);    // size 1 == 8 pixels high
  matrix.setTextColor(1);   // 'lit' LEDs  
   
  lastSyncNTP=0;  
}

void loop()
{
  time_t agora=now();
  clockDisplay(agora);
  time_t proximo=agora+1;
  
  // adjust brightness
  valPot=analogRead(POT);
  brilho=valPot/64;
  if (brilho!=brilhoAnt) {
    matrix.setBrightness(brilho);
    brilhoAnt=brilho;
  }
  
 // NTP sync
 if ((agora-lastSyncNTP)>=syncInterval) {
   lastSyncNTP=syncNTP();
 }
  
  // wait for next second
  while (agora<proximo) agora=now();
}

 

void clockDisplay(time_t a){
  
  // display UT e LST
  int h=hour(a);
  int m=minute(a);
  int s=second(a);
   
  // format UT
  sprintf(displayUT,"%2u:%2u:%2u\0",h,m,s);
  for ( int i=0; i<8; i++){
    if (displayUT[i]==' ') displayUT[i]='O';
    if (displayUT[i]=='0') displayUT[i]='O';
  }
  
  // calculate Local Sidereal Time
  time_t lst=localSidTime(a);
  
  // format LST
  sprintf(displayLST,"%2u:%2u:%2u\0",hour(lst),minute(lst),second(lst));
  for ( int i=0; i<8; i++){
    if (displayLST[i]==' ') displayLST[i]='O';
    if (displayLST[i]=='0') displayLST[i]='O';
  } 
  
  // display UT and LST
  matrix.clearScreen();
  matrix.setCursor(0,0);
  matrix.print(displayUT);
  matrix.setCursor(0,9);
  matrix.print(displayLST);
  matrix.writeScreen();
}
 
 

time_t localSidTime(time_t a){
  time_t lst=0L;
  time_t gmst0;
  int diaSeq=0;
  long deltaDia;
  
  // calculate number of days past first day on table
  deltaDia=(((long)a)-day0)/86400L;
   
  // get gmst at 0h from tables
  if (deltaDia>=0 && deltaDia<tab1Size){
    diaSeq=(int)deltaDia;
    gmst0=pgm_read_dword(tab1+diaSeq);
  }
  else return(lst);
 
  // calcula o LST
  long utSec=a%86400L;
  lst=(gmst0+longitude+5)/10; // both are in tenths of second
  lst=lst+mult1(utSec);
  lst=lst%86400L;
  return(lst);
}

long mult1(long z){
  // multiplies UT hours expressed in seconds (0<=z<=24*3600) 
  // by 1.00273790935 without using float data type
  const long b=1002L;
  const long c=7379L;
  const long d=935L;
  const long base=10000L;
  long dz=d*z;
  long cz=c*z;
  long bz=b*z;
  long dz2=dz/base;
  cz=cz+dz2;
  long cz2=cz/base;
  bz=bz+cz2;
  long bz1=bz%base;
  long bz2=bz/base;
  long n=((bz2*100+bz1/100)+5)/10;
  n=n%86400L;
  return(n);
}  

time_t syncNTP(void) {
  time_t t;
  long offset;
  // turn NTP LED on
  digitalWrite(LED, HIGH);
  
  // obter NTP
  offset=obterNTP();
 
 // add offset to adjust RTC and Arduino clock
 if (offset != 0L) {
   t=now()+offset;
   RTC.set(t);
   setTime(t);
 }

 t=now();
 return(t);
 }
  
long obterNTP(){
  
  time_t t1,t2,t3,t4,tLim,tCurr;
  long offset;
  
  int i;
  const unsigned long seventyYears=2208988800UL;
  
  // discard packets received after previous timeouts, if any
  while (Udp.available()) {
     Udp.readPacket(pb, NTP_PACKET_SIZE);
  }
  
  // send an NTP packet to the time server
  t1=now();
  sendNTPpacket(timeServer);
  
  // wait up to one second for reply
  t4=0;
  tCurr=now();
  tLim=tCurr+1;
  while (tCurr<tLim){
    if ( Udp.available() ) {
      t4=now();
      // read the packet into the buffer
      Udp.readPacket(pb, NTP_PACKET_SIZE);
      tLim=tCurr;
    }
    else {
      tCurr=now();
    }
  }
  
  // t4 == 0 means NTP request was not received
  if (t4==0) {
    return(0L);} 
    
  //turn NTP LED off; request was received
  digitalWrite(LED, LOW);
    
  // get integer values of NTP time stamps
  for (i=0; i<4; i++) {
    t2=t2 << 8 | pb[32+i];
    t3=t3 << 8 | pb[40+i]; 
  }  
  
  //  NTP time begin in 1900;  Arduino in 1970
  t2=t2-seventyYears;
  t3=t3-seventyYears;
 
  
  // calculate offset  
  offset=((((long)t2)-((long)t1))+(((long)t3)-((long)t4)))/2L;
  return(offset);
}
  
// send an NTP request to the time server at the given address 
unsigned long sendNTPpacket(byte *address)
{
  // set all bytes in the buffer to 0
  memset(pb, 0, NTP_PACKET_SIZE); 
  // Initialize values needed to form NTP request
  pb[0] = 0b11100011;   // LI, Version, Mode
  pb[1] = 0;     // Stratum, or type of clock
  pb[2] = 6;     // Polling Interval
  pb[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  pb[12]  = 49; 
  pb[13]  = 0x4E;
  pb[14]  = 49;
  pb[15]  = 52;

  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp: 		   
  Udp.sendPacket( pb,NTP_PACKET_SIZE,  address, 123); //NTP requests are to port 123
}