#include <RCSwitch.h>
#include <Narcoleptic.h>
#include <Adafruit_BMP085.h>
#include <Wire.h>
#include "DHT.h"


// ECRAN LCD 
#include <SPI.h> // We'll use SPI to transfer  data. Faster!
#define PIN_RESET 3
#define PIN_SCE   4
#define PIN_DC    5
#define PIN_SDIN  6
#define PIN_SCLK  7
#define PIN_LCD   9 // backlight


#define PIN_FADER 1 // analog
#define PIN_TMP   0 // analog
#define LCD_C     LOW
#define LCD_D     HIGH
#define LCD_COMMAND  0
#define LCD_X     84
#define LCD_Y     48

long contrast = 200;
char strBuffer[30];


static const byte ASCII[][5] =
{
 {0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f backslash
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ←
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f →
};


// FIN ECRAN


#define DHTPIN A2     // what pin we're connected to
#define DHTTYPE DHT11   // DHT 11 
// Initialize DHT sensor for normal 16mhz Arduino
DHT dht(DHTPIN, DHTTYPE);


#define SEND_MESSAGE_DELAY 30000 // Ne pas dépasser 32000 !! Delay in ms between each value's extraction
#define SEND_433_PAUSE 160 // 16 multiple

//#define DEBUG true

const unsigned long activation = 111269;
const unsigned long idTemp=1969;
const unsigned long idPressure=2069;
const unsigned long idPression=2169;
const unsigned long idLum=2269;
const unsigned long idHum=2369;
const unsigned long desactivation = 962111;
const unsigned int delai = 11;

const unsigned long TIME = 512;
const unsigned long TWOTIME = TIME*2;

// ################# Barometre ####
Adafruit_BMP085 bmp;
// #####################

float temperature = 0.0;
float pressure    = 0.0;
float pression    = 0.0;
float presiune = 0.0;
float humidite = 0.0; 

RCSwitch mySwitch = RCSwitch();

void setup() {
  #ifdef DEBUG   
  Serial.begin(9600);
  Serial.println("\n[Oregon V2.1 encoder]");
  #endif
  
  
  // ECRAN
  LcdInitialise();
  LcdClear();
  LcdString("Starting");
  setContrast(contrast);
  
  // FIN ECRAN
  
  pinMode(13, OUTPUT);
  
  mySwitch.enableTransmit(9);  
  //mySwitch.setRepeatTransmit(2);
  
    // DHT
    dht.begin();
}

// Commande pour barometre humidité température 
// Virtual Device 
// http://192.168.0.10:8080/json.htm?type=command&param=udevice&idx=160&nvalue=0&svalue=23.3;50;2;1024.20;1024&battery=89

void doDHT() {
   // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  humidite = h;
  
  // Read temperature as Celsius
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit
  float f = dht.readTemperature(true);
  
  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
   // Serial.println("Failed to read from DHT sensor!");
    return;
  } else {
        // Compute heat index
    // Must send in temp in Fahrenheit!
    float hi = dht.computeHeatIndex(f, h);
#ifdef DEBUG    
    Serial.print("Humidity: "); 
    Serial.print(h);
    Serial.print(" %\t");
    Serial.print("Temperature: "); 
    Serial.print(t);
    Serial.print(" *C ");
    Serial.print(f);
    Serial.print(" *F\t");
    Serial.print("Heat index: ");
    Serial.print(hi);
    Serial.println(" *F");
#endif
  }
}

// Prise Eléctrique 
//ON 1 1381719 1398103 
//ON 2 1394007 
//ON 3 1397079 1398103
//
//OFF 1 1381716 
//OFF 2 1398103
//OFF 3 1397076

void loop() {

  
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(10);              // wait for a second
  digitalWrite(13, LOW);
  
  long vcc = readVcc();
  barometre();
  doDHT();
  
  #ifdef DEBUG  
  Serial.print("Send");
  Serial.println(vcc);
  #endif

  mySwitch.send(activation, 24);  
  (delai); //delayMicroseconds
  
  myMessageSend(idTemp,temperature * 100);
  myMessageSend(idPressure,pressure * 10);
  myMessageSend(idHum,humidite);
  myMessageSend(idPression,pression * 10);
  
  // LUX 
  // R=K*L^-gamma
  // R étant la résistance pour un niveau d'éclairement L.
   int lum = analogRead(1);
   
   int lux = (1000.0 * lum / 1024.0);
  myMessageSend(idLum,lux);
  
  
  mySwitch.send(desactivation, 24);
  delay(delai);
  
  // ECRAN
   LcdClear();
  float fractionC;
  
  fractionC = temperature - ((int)temperature);
  
    gotoXY(0,0);
    LcdString("TEMP ");
    itoa(temperature,strBuffer,10);
    LcdString(strBuffer);
    itoa(fractionC,strBuffer,10);
    LcdString(".");
    LcdString(strBuffer);
    LcdString("C ");
  
  fractionC = pression - ((int) pression);
  
    gotoXY(0,10);
    LcdString("Pres ");
    itoa(pression,strBuffer,10);
    LcdString(strBuffer);
    itoa(fractionC,strBuffer,10);
    LcdString(".");
    LcdString(strBuffer);
    LcdString("hp");  

  fractionC = lux - ((int) lux);
  
    gotoXY(0,20);
    LcdString("Lum ");
    itoa(lux,strBuffer,10);
    LcdString(strBuffer);
    itoa(fractionC,strBuffer,10);
    LcdString(".");
    LcdString(strBuffer);
    LcdString("Lux ");   
  // FIN ECRAN
  
  #ifdef DEBUG  
  Serial.print("Luminosite=");
  Serial.println(lum);
  delay(delai);
  #endif  
  delayMicroseconds(TWOTIME*8);
  
  Narcoleptic.delay(SEND_MESSAGE_DELAY);
  Narcoleptic.delay(SEND_MESSAGE_DELAY);
  Narcoleptic.delay(SEND_MESSAGE_DELAY);
  Narcoleptic.delay(SEND_MESSAGE_DELAY);
}
void barometre() {
  /* See Example: TypeA_WithDIPSwitches */
//  mySwitch.switchOn("00001", "10000");
//  delay(1000);
    // BMP
   if (bmp.begin()) {  
      temperature = bmp.readTemperature();  
      pressure= bmp.readPressure() / 100.0;
      pression = pressure / 101.325;
      pression = pression * 0.760 * 100;
        // http://en.wikipedia.org/wiki/Atmospheric_pressure#Mean_sea_level_pressure
      //  Serial.print("Presiure la nivelul marii (calculata) = ");
      presiune = bmp.readSealevelPressure(19) / 101.325;
      presiune = presiune * 0.760;
      #ifdef DEBUG  
      Serial.print("Temperature="); Serial.println(temperature);
      Serial.print("pressure="); Serial.println(pressure);
      Serial.print("pression="); Serial.println(pression);
      #endif
    
   }
}  

void myMessageSend(long id, long value) {
  
    #ifdef DEBUG  
  Serial.print("Send id="); Serial.print(id);
  Serial.print(" value="); Serial.println(value);
  #endif
  
  mySwitch.send(id, 24); //"000000000001010100010001");
  delay(delai);
  mySwitch.send(value, 24); //"000000000001010100010001");
  delay(delai);

  //delay(5000);
  //delayMicroseconds(TWOTIME*8);
}
//--------------------------------------------------------------------------------------------------
// Read current supply voltage
//--------------------------------------------------------------------------------------------------
 long readVcc() {
   bitClear(PRR, PRADC); ADCSRA |= bit(ADEN); // Enable the ADC
   long result;
   // Read 1.1V reference against Vcc
   #if defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
    ADMUX = _BV(MUX5) | _BV(MUX0); // For ATtiny84
   #elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
    ADMUX = _BV(MUX3) | _BV(MUX2);
   #else
    ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);  // For ATmega328
   #endif
   // ADCSRB = 0;
   
   delay(2); // Wait for Vref to settle
   ADCSRA |= _BV(ADSC); // Convert
   while (bit_is_set(ADCSRA,ADSC));
   result = ADCL;
   result |= ADCH<<8;
   result = 1126400L / result; // Back-calculate Vcc in mV
   // ADCSRA &= ~ bit(ADEN); bitSet(PRR, PRADC); // Disable the ADC to save power
   
   // analogReference(DEFAULT);
    
   return result; // Vcc in millivolts
} 

// ECRAN Methodes
void LcdCharacter(char character)
{
  LcdWrite(LCD_D, 0x00);
  for (int index = 0; index < 5; index++)
  {
    LcdWrite(LCD_D, ASCII[character - 0x20][index]);
  }
  LcdWrite(LCD_D, 0x00);
}

void LcdClear(void)
{
  for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
  {
    LcdWrite(LCD_D, 0x00);
  }
}

void LcdInitialise(void)
{
  pinMode(PIN_SCE, OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC, OUTPUT);
  pinMode(PIN_SDIN, OUTPUT);
  pinMode(PIN_SCLK, OUTPUT);
  pinMode(PIN_LCD, OUTPUT);
  digitalWrite(PIN_LCD, HIGH);
  digitalWrite(PIN_RESET, LOW);
  digitalWrite(PIN_RESET, HIGH);
  LcdWrite(LCD_C, 0x21 );  // LCD Extended Commands.
  LcdWrite(LCD_C, 0x91 );  // Set LCD Vop (Contrast).
  LcdWrite(LCD_C, 0x04 );  // Set Temp coefficent. //0x04
  LcdWrite(LCD_C, 0x14 );  // LCD bias mode 1:48. //0x13
  LcdWrite(LCD_C, 0x0C );  // LCD in normal mode.
  LcdWrite(LCD_C, 0x20 );
  LcdWrite(LCD_C, 0x0C );
}

void LcdString(char *characters)
{
  while (*characters)
  {
    LcdCharacter(*characters++);
  }
}

void LcdWrite(byte dc, byte data)
{
  digitalWrite(PIN_DC, dc);
  digitalWrite(PIN_SCE, LOW);
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
  digitalWrite(PIN_SCE, HIGH);
}

void setContrast(byte contrast)
{
  analogWrite(PIN_LCD, contrast);
}
void gotoXY(int x, int y)
{
  LcdWrite( 0, 0x80 | x);  // Column.
  LcdWrite( 0, 0x40 | y);  // Row.


}