#include <EEPROM.h>

#define bt_up     A0
#define bt_down   A1
#define bt_reset  A2

#define buzzer 13

#define data_pin  3
#define clock_pin 2

uint8_t d[4];
uint8_t dig[4];
// ASCII Map - Index 0 starts at ASCII 32
const uint8_t asciiToSegment[] PROGMEM = {
   0b00000000, // 032 (Space)
   0b00110000, // 033 !
   0b00100010, // 034 "
   0b01000001, // 035 #
   0b01101101, // 036 $
   0b01010010, // 037 %
   0b01111100, // 038 &
   0b00100000, // 039 '
   0b00111001, // 040 (
   0b00001111, // 041 )
   0b00100001, // 042 *
   0b01110000, // 043 +
   0b00001000, // 044 ,
   0b01000000, // 045 -
   0b00001000, // 046 .
   0b01010010, // 047 /
   0b00111111, // 048 0
   0b00000110, // 049 1
   0b01011011, // 050 2
   0b01001111, // 051 3
   0b01100110, // 052 4
   0b01101101, // 053 5
   0b01111101, // 054 6
   0b00000111, // 055 7
   0b01111111, // 056 8
   0b01101111, // 057 9
   0b01001000, // 058 :
   0b01001000, // 059 ;
   0b00111001, // 060 <
   0b01001000, // 061 =
   0b00001111, // 062 >
   0b01010011, // 063 ?
   0b01011111, // 064 @
   0b01110111, // 065 A
   0b01111100, // 066 B
   0b00111001, // 067 C
   0b01011110, // 068 D
   0b01111001, // 069 E
   0b01110001, // 070 F
   0b00111101, // 071 G
   0b01110110, // 072 H
   0b00000110, // 073 I
   0b00011110, // 074 J
   0b01110110, // 075 K
   0b00111000, // 076 L
   0b00010101, // 077 M
   0b00110111, // 078 N
   0b00111111, // 079 O
   0b01110011, // 080 P
   0b01100111, // 081 Q
   0b00110001, // 082 R
   0b01101101, // 083 S
   0b01111000, // 084 T
   0b00111110, // 085 U
   0b00011100, // 086 V
   0b00101010, // 087 W
   0b01110110, // 088 X
   0b01101110, // 089 Y
   0b01011011, // 090 Z
   0b00111001, // 091 [
   0b01100100, // 092 (backslash)
   0b00001111, // 093 ]
   0b00100011, // 094 ^
   0b00001000, // 095 _
   0b00100000, // 096 `
   0b01110111, // 097 a
   0b01111100, // 098 b
   0b01011000, // 099 c
   0b01011110, // 100 d
   0b01111001, // 101 e
   0b01110001, // 102 f
   0b01101111, // 103 g
   0b01110100, // 104 h
   0b00000100, // 105 i
   0b00011110, // 106 j
   0b01110110, // 107 k
   0b00011000, // 108 l
   0b00010101, // 109 m
   0b01010100, // 110 n
   0b01011100, // 111 o
   0b01110011, // 112 p
   0b01100111, // 113 q
   0b01010000, // 114 r
   0b01101101, // 115 s
   0b01111000, // 116 t
   0b00011100, // 117 u
   0b00011100, // 118 v
   0b00101010, // 119 w
   0b01110110, // 120 x
   0b01101110, // 121 y
   0b01011011, // 122 z
   0b00111001, // 123 {
   0b00110000, // 124 |
   0b00001111, // 125 }
   0b01000000, // 126 ~
   0b00000000  // 127 
};

uint8_t Cmd_SetData;
 uint8_t Cmd_SetAddr; 
uint8_t Cmd_DispCtrl;
 uint8_t PointData;
//uint8_t lastData[4];

static const uint8_t minusSegments = 0b01000000;
static const uint8_t degreeSegments = 0b01100011;
                       /*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
const int digits[] = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0xff,0x00};
                          
                         // 12%,  25%,  38%,  50%,  63%,  75%,  88%, 100% 
const int Brightness[] = { 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f};

static uint32_t pv;
int h=0, flag1=0, flag2=0, timer=0;

void setup(){ // put your setup code here, to run once  
 Serial.begin(9600);
pinMode(bt_up,    INPUT_PULLUP);
pinMode(bt_down,  INPUT_PULLUP);
pinMode(bt_reset, INPUT_PULLUP);

pinMode(buzzer, OUTPUT);

pinMode(clock_pin, OUTPUT);
pinMode(data_pin, OUTPUT);

start();
writeValue(Brightness[6]); // set Brightness 0 to 7
stop();




}





void loop(){  

//showString("b",1,1);
//stringBlink("a",1,0,1000);
//stringBlink("ab",2,0,1000); 
//
    //strScroll("AbduLLAH_AL_YAHYA",4,0,1000);  
  scroll("AbcdE",2,0,100);
  
       
digitalWrite(buzzer, LOW);
}

void scroll(uint8_t s[],uint8_t len,uint8_t pos, int dd) {
   
     uint8_t l[1];
     for (byte i = 0; i < strlen(s);  i++) {
        l[i] = e(s[i]);
    }
    Byte(l,len,pos, dd);
}


void Byte(uint8_t s[],uint8_t len,uint8_t pos,int dd){ 
 
byte newByte=s;
byte step = 0;
byte data1=newByte&0b00001000;

swapBytes(&step,data1,0,3);
d_Byte(step,pos);
delay(dd); 

Serial.print("data1 : "); 
Serial.print(newByte,BIN);
Serial.print(" bin : "); 
Serial.println(data1,BIN); 

step = 0;
swapBytes(&step, newByte, 6, 0);
swapBytes(&step, newByte, 2,1);
swapBytes(&step, newByte, 4,5);
swapBytes(&step, newByte, 3,6); 
    
Serial.print("STEP1 : "); 
Serial.print(data1,BIN);
Serial.print(" bin : "); 
Serial.println(step,BIN); 
d_Byte(step,pos);
delay(dd);

Serial.print("newByte ; "); 
Serial.print(newByte,BIN); 
Serial.print(" bin : "); 
Serial.println(newByte,BIN); 
d_Byte(s[pos],pos);
delay(dd);

step = 0;
swapBytes(&step, newByte, 0, 6);
swapBytes(&step, newByte, 1, 2);
swapBytes(&step, newByte, 5, 4);
swapBytes(&step, newByte, 6, 3); 

delay(dd);

Serial.print(" last step "); 
Serial.print(" : "); 
Serial.print(step,BIN);
Serial.print(" bin : "); 
Serial.println(step,BIN);
set_dig(step,len,pos);
delay(dd); 


strScroll_b(step,len,pos,dd*2);    
/*Serial.print(" end "); 
Serial.print(" : "); 
Serial.print(s,BIN);
Serial.print(" bin : "); 
Serial.println(s,BIN);*/
delay(dd);    

}


void swapBytes(byte* newByte, byte oldByte, byte newP, byte oldP) {
    byte newBit = 0;
    if (oldByte & (1 << oldP)) newBit = 1;
    else newBit = 0;
    *newByte = *newByte | (newBit << newP);    
}

void d_Byte(uint8_t DispData[],uint8_t pos)
{
    uint8_t SegData[4];
    //for (byte  i = 0; i < 4; i ++) {
        //if (DispData[i] == 0x7f) SegData[i] = 0x00;
        //else SegData[i] = DispData[i];
        //{
        dig[2] = DispData[pos];
        SegData[pos] = DispData[pos] + PointData;
        //}	
   // }
    write_data(dig[2]);
}


void showString(const char s[],int len, int pos){
   uint8_t j=pos;
    memset(d,0,sizeof(d));
   for (int x = 0; x < strlen(s); x++) {
      d[x] = e(s[x]);
    } 
        
   set_dig(d,len,pos);  
}


void strScroll_b(const char s[],int len,int pos, int dd){
    memset(d,0,sizeof(d));   

   for (size_t x = 0; x < 4; x++) {   
      int i;   
       d[i] = s;    
        for(i=0;i<3;i++){
        d[i]=d[i+1];
            
       }        
    set_dig(s,len,pos);  
        delay(dd);
        }
       //set_dig(d,len,pos);
   for (int x = 0; x < 4; x++) {      
    int i;
      for(i=0;i<3;i++){
        d[i]=d[i+1];
       } 
       d[i] = 0; 
  set_dig(d,len,pos);
        delay(dd);
        }

}
        




void strScroll(const char s[],int len,int pos, int dd){
    memset(d,0,sizeof(d));   

   for (size_t x = 0; x < strlen(s); x++) {   
      int i;   
       d[i] = e(s[x]);    
        for(i=0;i<3;i++){
        d[i]=d[i+1];
            
       }        
    set_dig(d,len,pos);  
        delay(dd);
        }
       //set_dig(d,len,pos);
   for (int x = 0; x < 4; x++) {      
    int i;
      for(i=0;i<3;i++){
        d[i]=d[i+1];
       } 
       d[i] = 0; 
  set_dig(d,len,pos);
        delay(dd);
        }

}
        


void stringBlink(const char s[],int len, int pos,int dd){
   uint8_t j=pos;
  if(millis()-pv>=dd){
   h=h+1;
   pv=millis();
  if(h>=2){h=0;}     
    }
     
  if(h==0){
   for (int x = 0; x < strlen(s); x++) {
      d[x] = e(s[x]);
    } 
    set_dig(d,len,pos);    
   }
    
  else if(h==1){
   for (int x = 0; x < strlen(s); x++) {
      d[x] = " ";
    } 
    set_dig(d,len,pos);        
    }
}

    
void set_dig(const char s[],int len, int pos){
   uint8_t j=pos;
    
    for(int i=0;i<len;i++){
     dig[j]=s[i];
        j++;   
    }    
   write_data(dig); 
    
    }



void write_data(uint8_t di[]){
  start();
  writeValue(0x40);
  stop();
  start();
  writeValue(0xc0); 
 for(int i=0 ; i<3;i++){
  writeValue(di[i]);
        }
  stop();
    
 start();
writeValue(Brightness[6]); // set Brightness 0 to 7
stop();   
}

void start(void){
  digitalWrite(clock_pin,HIGH);//send start signal to TM1637
  digitalWrite(data_pin,HIGH);
  delayMicroseconds(1);

  digitalWrite(data_pin,LOW);
  digitalWrite(clock_pin,LOW);
  delayMicroseconds(1);
}

void stop(void){
  digitalWrite(clock_pin,LOW);
  digitalWrite(data_pin,LOW);
  delayMicroseconds(1);

  digitalWrite(clock_pin,HIGH);
  digitalWrite(data_pin,HIGH);
  delayMicroseconds(1);
}

bool writeValue(uint8_t value){
  for(uint8_t i = 0; i < 8; i++){
    digitalWrite(clock_pin, LOW);
    delayMicroseconds(1);
    digitalWrite(data_pin, (value & (1 << i)) >> i);
    delayMicroseconds(1);
    digitalWrite(clock_pin, HIGH);
    delayMicroseconds(1);
  }

  // wait for ACK
  digitalWrite(clock_pin,LOW);
  delayMicroseconds(1);
  pinMode(data_pin,INPUT);
  digitalWrite(clock_pin,HIGH);
  delayMicroseconds(1);

  bool ack = digitalRead(data_pin) == 0;
  pinMode(data_pin,OUTPUT);
  return ack;
}


uint8_t e(uint8_t chr)
{
  if(chr == 176) return degreeSegments;   // Degree mark
  if(chr > 127 || chr < 32) return 0;     // Blank
  // return asciiToSegment[chr - 32] using PROGMEM
  return pgm_read_byte(asciiToSegment + (chr - 32));
}