Serial.begin(115200);
Serial.println("hello world!");
                

Serial1.begin(115200);
Serial1.println("hello world!");
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín
 */

#include "Wire.h"


void setup(){
	Wire.begin();
	Wire.beginTransmission(9);
	Wire.write('o'); //End the current Light script
	Wire.endTransmission();
}

void loop(){
	for (int i=0;i < 5;i++){
		Wire.beginTransmission(9);
		Wire.write('n'); //Change to color
		Wire.write(byte(0xff)); //Red component
		Wire.write(byte(0x00)); //Green component
		Wire.write(byte(0x00)); //Blue component
		Wire.endTransmission();

		delay(500);
		
		Wire.beginTransmission(9);
		Wire.write('n'); //Change to color
		Wire.write(byte(0x00)); //Red component
		Wire.write(byte(0x00)); //Green component
		Wire.write(byte(0xff)); //Blue component
		Wire.endTransmission();
		
		delay(500);
	}
	
	for (int i=0;i < 10;i++){
		Wire.beginTransmission(9);
		Wire.write('c'); //Fade to color
		Wire.write(byte(0xff)); //Red component
		Wire.write(byte(0x00)); //Green component
		Wire.write(byte(0x5a)); //Blue component
		Wire.endTransmission();

		delay(150);
		
		Wire.beginTransmission(9);
		Wire.write('c'); //Fade to color
		Wire.write(byte(0x55)); //Red component
		Wire.write(byte(0x20)); //Green component
		Wire.write(byte(0x5a)); //Blue component
		Wire.endTransmission();

		delay(150);
	}
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín
 */

// include the SPI library:
#include <SPI.h>

int latchPin = 8;
unsigned char char1[]=" Cooking Hacks  ";
unsigned char char2[]="  SPI LCD for   ";
unsigned char char3[]="  Raspberry Pi  ";

void setup(){
	SPI.begin();
	SPI.setBitOrder(MSBFIRST);
	SPI.setDataMode(SPI_MODE0);
	SPI.setClockDivider(SPI_CLOCK_DIV128);

	initialise();
}

void loop(){
	displayString(0,0,char1,16);
	delay(2000);
	clear();
	displayString(1,0,char2,16);
	displayString(2,0,char3,16);
	delay(2000);
	clear();
}

void initialise(){
	pinMode(latchPin, OUTPUT);     
	digitalWrite(latchPin, LOW);

	delayMicroseconds(80);

	writeCommand(0x30);
	writeCommand(0x0c);
	writeCommand(0x01);
	writeCommand(0x06);
}


void displayString(int X,int Y,unsigned char *ptr,int dat){
	int i;

	switch(X){
		case 0:  Y|=0x80;break;

		case 1:  Y|=0x90;break;

		case 2:  Y|=0x88;break;

		case 3:  Y|=0x98;break;

		default: break;
	}

	writeCommand(Y);

	for(i=0;i < dat;i++){ 
		writeData(ptr[i]);
	}

}

void writeCommand(int CMD){
	int H_data,L_data;
	H_data = CMD;
	H_data &= 0xf0;
	L_data = CMD;
	L_data &= 0x0f;
	L_data <<= 4;
	writeByte(0xf8);
	writeByte(H_data);
	writeByte(L_data);
}

void writeData(int CMD){
	int H_data,L_data;
	H_data = CMD;
	H_data &= 0xf0;
	L_data = CMD;
	L_data &= 0x0f;
	L_data <<= 4;
	writeByte(0xfa);
	writeByte(H_data);
	writeByte(L_data);
}

void writeByte(int dat){
	digitalWrite(latchPin, HIGH);
	delayMicroseconds(80);
	SPI.transfer(dat);
	digitalWrite(latchPin, LOW);
}

void clear(){
	writeCommand(0x30);
	writeCommand(0x01);
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */


#include #include <eHealth.h>
#include "Wire.h"

void setup() { 
  delay (1000);
  eHealth.readGlucometer();
  Serial.begin(115200);
  delay(1000);    
}

void loop() { 

  uint8_t numberOfData = eHealth.getGlucometerLength();   
  Serial.print("Number of measures : ");    
  Serial.println(numberOfData, DEC);   
  delay(100);


  for (int i = 0; i<numberOfData; i++) { 
    // The protocol sends data in this order 
    Serial.println("==========================================");

    Serial.print("Measure number ");
    Serial.println(i + 1);

    Serial.print("Date -> "); 
    Serial.print(eHealth.glucoseDataVector[i].day); 
    Serial.print(" of "); 
    Serial.print(eHealth.numberToMonth(eHealth.glucoseDataVector[i].month));
    Serial.print(" of ");
    Serial.print(2000 + eHealth.glucoseDataVector[i].year);    
    Serial.print(" at ");

    if (eHealth.glucoseDataVector[i].hour < 10) {
      Serial.print(0); // Only for best representation.
    }

    Serial.print(eHealth.glucoseDataVector[i].hour);
    Serial.print(":");

    if (eHealth.glucoseDataVector[i].minutes < 10) {
      Serial.print(0);// Only for best representation.
    }
    Serial.print(eHealth.glucoseDataVector[i].minutes);

    if (eHealth.glucoseDataVector[i].meridian == 0xBB)
      Serial.println(" pm");
    else if (eHealth.glucoseDataVector[i].meridian == 0xAA)
      Serial.println(" am"); 

    Serial.print("Glucose value : "); 
    Serial.print(eHealth.glucoseDataVector[i].glucose);
    Serial.println(" mg/dL");
  }

  delay(20000);
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */

#include <eHealth.h>
#include "Wire.h"

// the setup routine runs once when you press reset:
void setup() {
  Serial.begin(115200);  
}

// the loop routine runs over and over again forever:
void loop() {
  float temperature = eHealth.getTemperature();

  Serial.print("Temperature (ºC): ");       
  Serial.print(temperature, 2);  
  Serial.println(""); 

  delay(1000);	// wait for a second 
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */


#include <eHealth.h>
#include "Wire.h"


void setup() { 
  delay(1000); 
  eHealth.readBloodPressureSensor();
  Serial.begin(115200);
  delay(100);    
}

void loop() { 

  uint8_t numberOfData = eHealth.getBloodPressureLength();   
  Serial.print("Number of measures : ");    
  Serial.println(numberOfData, DEC);   
  delay(100);


  for (int i = 0; i<numberOfData; i++) { 
    // The protocol sends data in this order 
    Serial.println("==========================================");

    Serial.print("Measure number ");
    Serial.println(i + 1);

    Serial.print("Date -> "); 
    Serial.print(eHealth.bloodPressureDataVector[i].day); 
    Serial.print(" of "); 
    Serial.print(eHealth.numberToMonth(eHealth.bloodPressureDataVector[i].month));
    Serial.print(" of ");
    Serial.print(2000 + eHealth.bloodPressureDataVector[i].year);    
    Serial.print(" at ");

    if (eHealth.bloodPressureDataVector[i].hour < 10) {
      Serial.print(0); // Only for best representation.
    }

    Serial.print(eHealth.bloodPressureDataVector[i].hour);
    Serial.print(":");

    if (eHealth.bloodPressureDataVector[i].minutes < 10) {
      Serial.print(0);// Only for best representation.
    }
    Serial.println(eHealth.bloodPressureDataVector[i].minutes);

    Serial.print("Systolic value : "); 
    Serial.print(30+eHealth.bloodPressureDataVector[i].systolic);
    Serial.println(" mmHg");
    
    Serial.print("Diastolic value : "); 
    Serial.print(eHealth.bloodPressureDataVector[i].diastolic);
    Serial.println(" mmHg");
    
    Serial.print("Pulse value : "); 
    Serial.print(eHealth.bloodPressureDataVector[i].pulse);
    Serial.println(" bpm");
  }
  
  delay(20000);
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */


#include <eHealth.h>
#include "Wire.h"

// The setup routine runs once when you press reset:
void setup() {
  Serial.begin(115200);  
}

// the loop routine runs over and over again forever:
void loop() {

  int air = eHealth.getAirFlow();   
  eHealth.airFlowWave(air);  
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */

#include <eHealth.h>
#include "Wire.h"

// the setup routine runs once when you press reset:
void setup() {
  Serial.begin(115200);  
}

// the loop routine runs over and over again forever:
void loop() {

  float conductance = eHealth.getSkinConductance();
  float resistance = eHealth.getSkinResistance();
  float conductanceVol = eHealth.getSkinConductanceVoltage();

  Serial.print("Conductance : ");       
  Serial.print(conductance, 2);  
  Serial.println("");         

  Serial.print("Resistance : ");       
  Serial.print(resistance, 2);  
  Serial.println("");    

  Serial.print("Conductance Voltage : ");       
  Serial.print(conductanceVol, 4);  
  Serial.println("");

  Serial.print("\n");

  // wait for a second  
  delay(1000);            
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */

#include <eHealth.h>
#include "Wire.h"

// The setup routine runs once when you press reset:
void setup() {
  Serial.begin(115200);  
}

// The loop routine runs over and over again forever:
void loop() {

  float ECG = eHealth.getECG();

  Serial.print("ECG value :  ");
  Serial.print(ECG, 2); 
  Serial.print(" V"); 
  Serial.println(""); 

  delay(1);	// wait for a millisecond
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */

#include <eHealth.h>
#include "Wire.h"

// The setup routine runs once when you press reset:
void setup() {
  Serial.begin(115200);  
}

// The loop routine runs over and over again forever:
void loop() {

  int EMG = eHealth.getEMG();

  Serial.print("EMG value :  ");
  Serial.print(EMG);  
  Serial.println(""); 

  delay(100);	// wait for a millisecond
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */

#include#include <eHealth.h>
#include "Wire.h"

void setup() {
    Serial.begin(115200);  
    eHealth.initPositionSensor();     
}

void loop() {  
  
  Serial.print("Current position : ");
  uint8_t position = eHealth.getBodyPosition(); 
  eHealth.printPosition(position);  
  
  Serial.print("\n");
  delay(1000); 
  
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */
 
// For more information about the GPRS shield please see our tutorial
// in cooking-hacks web site. http://www.cooking-hacks.com


#include <eHealth.h>
#include "Wire.h"

// the pin to switch on the module (without press on button) 
int pinModuleOn = 2;      

// ********* is the number to call
char phoneNumber[]="**********";    


void switchModule(){       
  digitalWrite(pinModuleOn,HIGH);
  delay(2000);
  digitalWrite(pinModuleOn,LOW);
}

void setup() {

  // UART baud rate
  Serial1.begin(115200);               
  delay(2000);  

  for (int i=0;i < 5;i++){
    Serial.println("Push the button");
    delay(5000);
  }
  // Sets the SMS mode to text
  Serial1.println("AT+CMGF=1");         
  delay(100);
}

void loop(){

  delay(100);
  float temperature = eHealth.getTemperature();     

  delay(1500);
  // send the SMS number 
  Serial1.print("AT+CMGS=\"");     
  Serial1.print(phoneNumber);
  Serial1.println("\"");
  // the SMS body 
  while(Serial1.read()!='>');      
  Serial1.print(temperature);

  delay(1000);
  //sends ++
  Serial1.write(0x1A);       
  Serial1.write(0x0D);
  Serial1.write(0x0A);
  delay(5000);

}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */

// For more information about the 3G shield please see our tutorial
// in cooking-hacks web site. http://www.cooking-hacks.com

#include <eHealth.h>
#include "Wire.h"

char data[512];
char tosend[128];
int led = 13;
int onModulePin = 2;        // the pin to switch on the module (without press on button) 

int x = 0;

char name[20];

char server[ ]="192.198.1.1"; //Your server IP address
char port[ ]="5555"; // Your port. 

void switchModule(){
  digitalWrite(onModulePin,HIGH);
  delay(2000);
  digitalWrite(onModulePin,LOW);
}

void setup(){

  Serial1.begin(115200);         // UART baud rate
  delay(2000);
  pinMode(led, OUTPUT);
  pinMode(onModulePin, OUTPUT);
  switchModule();              // switches the module ON

  for (int i=0;i< 5;i++){
    delay(5000);
  } 

  Serial1.println("AT+CGSOCKCONT=1,\"IP\",\"internetmas\"");
  Serial1.flush();
  x=0;
  do
  {
    while(Serial1.available()==0);
    data[x]=Serial1.read();  
    x++;  
  } while(!(data[x-1]=='K'&&data[x-2]=='O')); //waits for response "Network opened"


}

void loop()
{
  float temperature = eHealth.getTemperature();    
  int longitud = sprintf(tosend,"%d", temperature); 

  Serial1.print("AT+NETOPEN=\"TCP\",");
  //Opens the socket with the type of protocol and the port 
  Serial1.println(port);        
  Serial1.flush();
  x=0;
  
  do
  {
    while(Serial1.available()==0);
    data[x]=Serial1.read();  
    x++;  
  }
  while(!(data[x-1]=='K'&&data[x-2]=='O'));        //waits for response "Network opened"

  Serial1.print("AT+TCPCONNECT=\""); //Connects with the server
  Serial1.print(server);
  Serial1.print("\",");    
  Serial1.println(port);

  Serial1.flush();
  while(Serial.read()!='K');  

  Serial1.print("AT+TCPWRITE=");
  Serial1.println(longitud, DEC);    //Sends TCP data
  Serial1.flush();



  do 
  { 
    while (Serial1.available() == 0) {};      
    //Serial.println(char(Serial.read()));      
  } while(Serial1.read()!='>');  

  Serial1.println(tosend); 

  x=0;

  do
  {
    while(Serial1.available()==0);
    data[x]=Serial1.read();  
    x++;                        
  }
  while(!(data[x-1]=='K'&&data[x-2]=='O'));

  Serial1.println("AT+NETCLOSE"); //Opens the socket with the type of protocol and the port 
  Serial1.flush();
  while(Serial1.read()!='K'); 

  while(1);

}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */
 

#include <eHealth.h>
#include "Wire.h"

char recv[256];
uint8_t cont = 0;


void setup(){ 

  //eHealth.readGlucometer();
  Serial1.begin(9600);

} 

void loop(){ 

  Serial1.print("$$$"); 
  check();  

  // 1. Configure the transport protocol (UDP, TCP, FTP, HTTP...)  
  Serial1.print("set i p 3\r");  check();   
  // 2. Configure the way the modules will resolve the IP address. 
  Serial1.print("set i d 2\r");  check();   
  // 3. Configure how to connect the AP. 
  Serial1.print("set w a 6\r");  check();   
  // 3.1 Sets the name of the ADhoc network.  
  Serial1.print("set w s iPHONE_ADHOC\r");  check();   
  // 3.2 Sets the channel of the ADhoc network     
  Serial1.print("set w c 6\r");  check();

  Serial1.print("set w j 4\r");  check();
  Serial1.print("save\r");  check();
  Serial1.print("exit\r");  check();
  Serial1.print("$$$");  check();
  // Configures UDP host and ports.
  Serial1.print("set i h 255.255.255.255\r");  check();
  Serial1.print("set i r 12345\r");  check();
  Serial1.print("set i l 2000\r");  check();
  // Checks if everything is Ok, even if It's correctly connected.

  // Exits from command mode, and then the UDP messages 
  // can be sent and received.
  Serial1.print("exit\r");
  check();

  delay(1000);  


  while(1){     

    //1. Read from eHealth. 
    int airFlow = eHealth.getAirFlow();     
    float temperature = eHealth.getTemperature();     
    float conductance = eHealth.getSkinConductance();   
    float resistance = eHealth.getSkinResistance();
    float conductanceVol = eHealth.getSkinConductanceVoltage();
    int BPM = 0;     
    int SPO2 = 0;     
    uint8_t pos = 0;      
    //int syst = eHealth.getSystolicPressure(1);
    //int diast = eHealth.getDiastolicPressure(1);         
    float ECG = eHealth.getECG();
    //uint8_t glucose = eHealth.glucoseDataVector[0].glucose;

    // 2. Send data to the Android smartphone    
    Serial1.print(int(airFlow));         Serial1.print("#");
    Serial1.print(ECG);                  Serial1.print("#");
    Serial1.print(temperature);          Serial1.print("#");
    Serial1.print(int(BPM));             Serial1.print("#");
    Serial1.print(int(SPO2));            Serial1.print("#");
    Serial1.print(conductance);          Serial1.print("#");
    Serial1.print(int(resistance));      Serial1.print("#");
    Serial1.print(int(airFlow));         Serial1.print("#");
    Serial1.print(0);                    Serial1.print("#");  //Systolic is not implemented
    Serial1.print(0);                    Serial1.print("#");  //Diastolic is not implemented 
    Serial1.print(int(0));               Serial1.print("#");  //Glucose is not implemented
    Serial1.print(int(pos));             Serial1.print("#");
    Serial1.print("\n");    
    
    // Reduce this delay for more data rate
    delay(100);  
  }

}

//=========================================================================

void check(){
  cont=0; 
  delay(500);
  while (Serial1.available()>0)
  {
    recv[cont]=Serial1.read(); 
    delay(10);
    cont++;
  }
  recv[cont]='\0';
  Serial.println(recv);
  Serial1.flush(); 
  delay(100);
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */
 

#include <eHealth.h>
#include "Wire.h"

char recv[128];
uint8_t cont = 0;


void setup()
{ 
  Serial1.begin(9600);
  delay(1000);
  
}

void loop()
{
  while (Serial1.available()>0) {}
  // Enters in command mode    
    Serial1.print("$$$"); check();  
  // Sets DHCP and TCP protocol
    Serial1.print("set ip dhcp 1\r"); check();
    Serial1.print("set ip protocol 1\r"); check();
  // Configures the way to join the network AP
    Serial1.print("set wlan join 0\r"); check();
    Serial1.print("join ANDROID\r"); check();
  
    Serial1.print("set i h 255.255.255.255\r"); delay(1000);
    
    Serial1.print("set i r 12345\r"); check();
    Serial1.print("set i l 2000\r"); check();
    Serial1.print("exit\r"); check();

    while(1){     
      
      //1. Read from eHealth. 
       int airFlow = eHealth.getAirFlow();     
       float temperature = eHealth.getTemperature();     
       float conductance = eHealth.getSkinConductance();   
       float resistance = eHealth.getSkinResistance();
       float conductanceVol = eHealth.getSkinConductanceVoltage();
       int BPM = 0;     
       int SPO2 = 0;     
       uint8_t pos = 0;      
       //int syst = eHealth.getSystolicPressure(1);
       //int diast = eHealth.getDiastolicPressure(1);     
       float ECG = eHealth.getECG();
       //uint8_t glucose = eHealth.glucoseDataVector[0].glucose;      

      //Data sensor must be sent in this order to mobile android application 
      Serial1.print(int(airFlow));     Serial1.print("#");
      Serial1.print(int(ECG));         Serial1.print("#");
      Serial1.print(int(0));           Serial1.print("#"); //Systolic is not implemented
      Serial1.print(int(0));           Serial1.print("#"); //Diastolic is not implemented 
      Serial1.print(int(0));           Serial1.print("#"); //Glucose is not implemented
      Serial1.print(int(temperature)); Serial1.print("#");
      Serial1.print(int(BPM));         Serial1.print("#");
      Serial1.print(int(SPO2));        Serial1.print("#");
      Serial1.print(int(conductance)); Serial1.print("#");
      Serial1.print(int(resistance));  Serial1.print("#");
      Serial1.print(int(airFlow));     Serial1.print("#");
      Serial1.print(int(pos));         Serial1.print("#");
      Serial1.print("\n");    
    
      // Reduce this delay for more data rate
      delay(250);  
  }
}

void check(){
  cont=0; delay(500);
  while (Serial1.available()>0)
  {
     recv[cont]=Serial1.read(); delay(10);
     cont++;
  }
  recv[cont]='\0';
  Serial.println(recv);
  Serial.flush(); delay(100);
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Alejandro Gallego
 */
 
 
int8_t answer;
int onModulePin = 2;
int button = 12;
char aux_str[30];

char phone_number[]="*********";     // ********* is the number to call

void setup(){

    pinMode(onModulePin, OUTPUT);
    pinMode(button, INPUT);
    Serial1.begin(115200);
    Serial.begin(115200);      

    Serial.println("Starting...");
    power_on();
    
    delay(3000);
    
    // sets the PIN code
    sendATcommand("AT+CPIN=****", "OK", 2000);
    
    delay(3000);
    
    Serial.println("Connecting to the network...");

    while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) || 
            sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );

    sprintf(aux_str, "ATD%s;", phone_number);
    sendATcommand(aux_str, "OK", 10000);
    
    // press the button for hang the call 
    while(digitalRead(button)==1);        

    //Serial.println("ATH");            // disconnects the existing call
    

}

void loop(){

}

void power_on(){

    uint8_t answer=0;
    
    // checks if the module is started
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // power on pulse
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // waits for an answer from the module
        while(answer == 0){     // Send AT every two seconds and wait for the answer
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout){

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    memset(response, '\0', 100);    // Initialice the string
    
    delay(100);
    
    while( Serial1.available() > 0) Serial1.read();    // Clean the input buffer
    
    Serial1.println(ATcommand);    // Send the AT command 


    x = 0;
    previous = millis();

    // this loop waits for the answer
    do{
        // if there are data in the UART input buffer, reads it and checks for the asnwer
        if(Serial1.available() != 0){    
            response[x] = Serial1.read();
            x++;
            // check if the desired answer is in the response of the module
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < timeout));    

    return answer;
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Alejandro Gallego
 */

int8_t answer;
int onModulePin= 2;
char aux_string[30];
char phone_number[]="*********";

void setup(){

    pinMode(onModulePin, OUTPUT);
    Serial1.begin(115200);    
    Serial.begin(115200);
    Serial.println("Starting...");
    power_on();
    
    delay(3000);
    
    // sets the PIN code
    sendATcommand("AT+CPIN=****", "OK", 2000);
    
    delay(3000);
    
    Serial.println("Connecting to the network...");

    while( (sendATcommand("AT+CREG?", "+CREG: 0,1", 500) || 
            sendATcommand("AT+CREG?", "+CREG: 0,5", 500)) == 0 );

    Serial.print("Setting SMS mode...");
    sendATcommand("AT+CMGF=1", "OK", 1000);    // sets the SMS mode to text
    Serial.println("Sending SMS");
    
    sprintf(aux_string,"AT+CMGS=\"%s\"", phone_number);
    answer = sendATcommand(aux_string, ">", 2000);    // send the SMS number
    if (answer == 1)
    {
        Serial1.println("Test-Arduino-Hello World");
        Serial1.write(0x1A);
        answer = sendATcommand("", "OK", 20000);
        if (answer == 1)
        {
            Serial.print("Sent ");    
        }
        else
        {
            Serial.print("error ");
        }
    }
    else
    {
        Serial.print("error ");
        Serial.println(answer, DEC);
    }

}


void loop(){

}

void power_on(){

    uint8_t answer=0;
    
    // checks if the module is started
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // power on pulse
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // waits for an answer from the module
        while(answer == 0){     // Send AT every two seconds and wait for the answer
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}

int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout){

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    memset(response, '\0', 100);    // Initialice the string
    
    delay(100);
    
    while( Serial1.available() > 0) Serial1.read();    // Clean the input buffer
    
    Serial1.println(ATcommand);    // Send the AT command 


    x = 0;
    previous = millis();

    // this loop waits for the answer
    do{
        // if there are data in the UART input buffer, reads it and checks for the asnwer
        if(Serial1.available() != 0){    
            response[x] = Serial1.read();
            x++;
            // check if the desired answer is in the response of the module
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < timeout));    

    return answer;
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Alejandro Gallego
 */
 
 
int8_t answer;
int onModulePin= 2;
int counter;
long previous;


char Basic_str[100];
char GGA_str[100];
char GLL_str[100];
char RMC_str[100];
char VTG_str[100];
char ZDA_str[100];

void setup(){
    
    pinMode(onModulePin, OUTPUT);
    Serial.begin(115200);
    Serial1.begin(115200);      
    
    Serial.println("Starting...");
    power_on();
    
    delay(3000);
    
    // sets the PIN code
    sendATcommand("AT+CPIN=****", "OK", 2000);
    
    delay(3000);
    
    // sets APN, user name and password
    sendATcommand("AT+CGPSPWR=1", "OK", 2000);
    sendATcommand("AT+CGPSRST=0", "OK", 2000);
    
    
    // waits for fix GPS
    while( (sendATcommand("AT+CGPSSTATUS?", "2D Fix", 5000) || 
            sendATcommand("AT+CGPSSTATUS?", "3D Fix", 5000)) == 0 );
    

}

void loop(){
    // Basic
    // Clean the input buffer
    while( Serial.available() > 0) Serial.read();    
    delay(100);
    // request Basic string
    sendATcommand("AT+CGPSINF=0", "AT+CGPSINF=0\r\n\r\n", 2000);
    
    counter = 0;
    answer = 0;
    memset(Basic_str, '\0', 100);    // Initialize the string
    previous = millis();
    // this loop waits for the NMEA string
    do{

        if(Serial.available() != 0){    
            Basic_str[counter] = Serial.read();
            counter++;
            // check if the desired answer is in the response of the module
            if (strstr(Basic_str, "OK") != NULL)    
            {
                answer = 1;
            }
        }
        // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < 2000));  
    
    Basic_str[counter-3] = '\0';
    
    //**********************************************************
    // GGA
    // Clean the input buffer
    while( Serial.available() > 0) Serial.read();    
    delay(100);
    // request GGA string
    sendATcommand("AT+CGPSINF=2", "AT+CGPSINF=2\r\n\r\n", 2000);
    
    counter = 0;
    answer = 0;
    memset(GGA_str, '\0', 100);    // Initialize the string
    previous = millis();
    // this loop waits for the NMEA string
    do{

        if(Serial.available() != 0){    
            GGA_str[counter] = Serial.read();
            counter++;
            // check if the desired answer is in the response of the module
            if (strstr(GGA_str, "OK") != NULL)    
            {
                answer = 1;
            }
        }
        // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < 2000));  
    
    GGA_str[counter-3] = '\0';
    
    //**********************************************************
    // GLL
    // Clean the input buffer
    while( Serial.available() > 0) Serial.read();    
       
    delay(100);
    // request GLL string
    sendATcommand("AT+CGPSINF=4", "AT+CGPSINF=4\r\n\r\n", 2000);   
    
    counter = 0;
    answer = 0;
    memset(GLL_str, '\0', 100);    // Initialize the string
    previous = millis();
    // this loop waits for the NMEA string
    do{

        if(Serial.available() != 0){    
            GLL_str[counter] = Serial.read();
            counter++;
            // check if the desired answer is in the response of the module
            if (strstr(GLL_str, "OK") != NULL)    
            {
                answer = 1;
            }
        }
        // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < 2000)); 
    
    GLL_str[counter-3] = '\0';
        
    //**********************************************************
    // RMC
    // Clean the input buffer
    while( Serial.available() > 0) Serial.read();    
       
    delay(100);
    // request RMC string 
    sendATcommand("AT+CGPSINF=32", "AT+CGPSINF=32\r\n\r\n", 2000);
    
    counter = 0;
    answer = 0;
    memset(RMC_str, '\0', 100);    // Initialize the string
    previous = millis();
    // this loop waits for the NMEA string
    do{

        if(Serial.available() != 0){    
            RMC_str[counter] = Serial.read();
            counter++;
            // check if the desired answer is in the response of the module
            if (strstr(RMC_str, "OK") != NULL)    
            {
                answer = 1;
            }
        }
        // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < 2000)); 
    
    RMC_str[counter-3] = '\0';
    
    //**********************************************************
    // VTG
    // Clean the input buffer
    while( Serial.available() > 0) Serial.read();    
       
    delay(100);
    // request VTG string
    sendATcommand("AT+CGPSINF=64", "AT+CGPSINF=64\r\n\r\n", 2000); 
    
    counter = 0;
    answer = 0;
    memset(VTG_str, '\0', 100);    // Initialize the string
    previous = millis();
    // this loop waits for the NMEA string
    do{

        if(Serial.available() != 0){    
            VTG_str[counter] = Serial.read();
            counter++;
            // check if the desired answer is in the response of the module
            if (strstr(VTG_str, "OK") != NULL)    
            {
                answer = 1;
            }
        }
        // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < 2000)); 
    
    VTG_str[counter-3] = '\0';
    
    //**********************************************************
    // ZDA
    // Clean the input buffer
    while( Serial.available() > 0) Serial.read();    
       
    delay(100);
    // request ZDA string
    sendATcommand("AT+CGPSINF=128", "AT+CGPSINF=128\r\n\r\n", 2000);
    
    counter = 0;
    answer = 0;
    memset(ZDA_str, '\0', 100);    // Initialize the string
    previous = millis();
    // this loop waits for the NMEA string
    do{

        if(Serial.available() != 0){    
            ZDA_str[counter] = Serial.read();
            counter++;
            // check if the desired answer is in the response of the module
            if (strstr(ZDA_str, "OK") != NULL)    
            {
                answer = 1;
            }
        }
        // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < 2000));
    
    ZDA_str[counter-3] = '\0';
    
    Serial.println("*************************************************");
    Serial.print("Basic string: ");
    Serial.println(Basic_str);
    Serial.print("GGA string: ");
    Serial.println(GGA_str);
    Serial.print("GLL string: ");
    Serial.println(GLL_str);
    Serial.print("RMC string: ");
    Serial.println(RMC_str);
    Serial.print("VTG string: ");
    Serial.println(VTG_str);
    Serial.print("ZDA string: ");
    Serial.println(ZDA_str);
   
    delay(15000);

}

void power_on(){

    uint8_t answer=0;
    
    // checks if the module is started
    answer = sendATcommand("AT", "OK", 2000);
    if (answer == 0)
    {
        // power on pulse
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
    
        // waits for an answer from the module
        while(answer == 0){    
            // Send AT every two seconds and wait for the answer
            answer = sendATcommand("AT", "OK", 2000);    
        }
    }
    
}


int8_t sendATcommand(char* ATcommand, char* expected_answer, unsigned int timeout){

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    memset(response, '\0', 100);    // Initialice the string
    
    delay(100);
    
    while( Serial1.available() > 0) Serial1.read();    // Clean the input buffer
    
    Serial1.println(ATcommand);    // Send the AT command 


    x = 0;
    previous = millis();

    // this loop waits for the answer
    do{
        // if there are data in the UART input buffer, reads it and checks for the asnwer
        if(Serial1.available() != 0){    
            response[x] = Serial1.read();
            x++;
            // check if the desired answer is in the response of the module
            if (strstr(response, expected_answer) != NULL)    
            {
                answer = 1;
            }
        }
    // Waits for the asnwer with time out
    }while((answer == 0) && ((millis() - previous) < timeout));    

    return answer;
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín
 */


int8_t answer;
int onModulePin = 2;
int button = 12;
char aux_str[30];

char phone_number[]="619913824";     // ********* is the number to call

void setup(){

    pinMode(onModulePin, OUTPUT);
    pinMode(button, INPUT);
    Serial1.begin(115200);      
    Serial.begin(115200);   

    Serial.println("Starting...");
    power_on();
    Serial.println("Starting...");
    delay(3000);

    // sets the PIN code
    sendATcommand2("AT+CPIN=****", "OK", "ERROR", 2000);

    delay(3000);

    Serial.println("Connecting to the network...");

    while(sendATcommand2("AT+CREG?", "+CREG: 0,1", "+CREG: 0,5", 1000) == 0 );


    // Starts the camera
    answer = sendATcommand2("AT+CCAMS", "OK", "CAMERA NO SENSOR", 3000);
    if (answer == 1)
    {
        // Sets resolution
        sendATcommand2("AT+CCAMSETD=320,240", "OK", "ERROR", 2000);

        sprintf(aux_str, "AT+VPMAKE=%s", phone_number);
        answer = sendATcommand2(aux_str, "VPCONNECTED", "VPEND", 30000);
        if (answer == 1)
        {
            delay(20000);
            sendATcommand2("AT+VPEND", "OK", "", 30000);
        }
        else
        {
            Serial.println("Error originating the call");    
        }
    }
    else if (answer == 2)
    {
        Serial.println("Camera not detected");    
    }
    else
    {
        Serial.println("Error starting the camera");    
    }

}


void loop(){

}



void power_on(){

    uint8_t answer=0;

    // checks if the module is started
    answer = sendATcommand2("AT", "OK", "OK", 2000);
    
    Serial.println("Error starting the camera");  
    if (answer == 0)
    {
        // power on pulse
        digitalWrite(onModulePin,HIGH);
        delay(3000);
        digitalWrite(onModulePin,LOW);
Serial.println("Error");  
        // waits for an answer from the module
        while(answer == 0){    
            // Send AT every two seconds and wait for the answer
            answer = sendATcommand2("AT", "OK", "OK", 2000);    
        }
    }

}


int8_t sendATcommand2(char* ATcommand, char* expected_answer1,
    char* expected_answer2, unsigned int timeout)
{

    uint8_t x=0,  answer=0;
    char response[100];
    unsigned long previous;

    memset(response, '\0', 100);    // Initialize the string

    delay(100);

    // Clean the input buffer
    while( Serial1.available() > 0) Serial1.read(); 

    Serial1.println(ATcommand);    // Send the AT command 


        x = 0;
    previous = millis();

    // this loop waits for the answer
    do{
   int hola = Serial1.available();
      Serial.println(hola,DEC);  
        if(Serial1.available() != 0){    
            response[x] = Serial1.read();
            Serial.println(response[x]);  
            x++;
            // check if the expected answer 1 is in the response of the module
            if (strstr(response, expected_answer1) != NULL)    
            {
                answer = 1;
            }
            // check if the expected answer 2 is in the response of the module
            if (strstr(response, expected_answer2) != NULL)    
            {
                answer = 2;
            }
        }
        // Waits for the asnwer with time out
    }
    while((answer == 0) && ((millis() - previous) < timeout));    

    return answer;
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Marcos Yarza
 */

// var
int led = 13;
byte data_1 = 0x00;
byte data_2 = 0x00;
byte data_3 = 0x00;
byte data_4 = 0x00;
byte data_5 = 0x00;
int val = 0;

void setup(){
// Start serial port 19200 bps
Serial.begin(19200);
Serial1.begin(19200);


pinMode(led, OUTPUT);
delay(500);
  
// Setting Auto Read Mode - EM4102 Decoded Mode - No password
// command: FF 01 09 87 01 03 02 00 10 20 30 40 37
Serial1.write(0xFF);
Serial1.write(0x01);
Serial1.write(0x09);
Serial1.write(0x87);
Serial1.write(0x01);
Serial1.write(0x03);
Serial1.write(0x02);
Serial1.write((byte)0x00);
Serial1.write(0x10);
Serial1.write(0x20);
Serial1.write(0x30);
Serial1.write(0x40);
Serial1.write(0x37);

delay(500);
Serial1.flush();
Serial.println();
Serial.println("RFID module started in Auto Read Mode");
}

void loop(){

val = Serial1.read();
while (val != 0xff){
  Serial.println("Waiting card");
  val = Serial1.read();
  delay(1000);
}

// Serial.read();    // we read ff
Serial1.read();    // we read 01
Serial1.read();    // we read 06
Serial1.read();    // we read 10
data_1 = Serial1.read();    // we read data 1
data_2 = Serial1.read();    // we read data 2
data_3 = Serial1.read();    // we read data 3
data_4 = Serial1.read();    // we read data 4
data_5 = Serial1.read();    // we read data 5
Serial1.read();    // we read checksum

// Led blink
for(int i = 0;i<4;i++){
  digitalWrite(led,HIGH);
  delay(500);
  digitalWrite(led,LOW);
  delay(500);
}

// Printing the code of the card
Serial.println();
Serial.print("EM4100 card found - Code: ");
writeByte(data_1);
writeByte(data_2);
writeByte(data_3);
writeByte(data_4);
writeByte(data_5);
Serial.println();
Serial.println();

}

//Write a byte (hex) in ASCII
void writeByte(byte data){
int aux_1 = 0;
int aux_2 = 0;

  aux_1=data/16;
  aux_2=data%16;
  if (aux_1<10){
  Serial.write(aux_1 + 48);
  }
  else{
  Serial.write(aux_1+55);
  }
  if (aux_2<10){
  Serial.write(aux_2 + 48);
  }
  else{
  Serial.write(aux_2 + 55);
  }
Serial.print(" ");
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Marcos Yarza
 */

// var
int led = 13;
byte block1_byte1 = 0x00;
byte block1_byte2 = 0x00;
byte block1_byte3 = 0x00;
byte block1_byte4 = 0x00;

byte block2_byte1 = 0x00;
byte block2_byte2 = 0x00;
byte block2_byte3 = 0x00;
byte block2_byte4 = 0x00;

byte block3_byte1 = 0x00;
byte block3_byte2 = 0x00;
byte block3_byte3 = 0x00;
byte block3_byte4 = 0x00;

byte block4_byte1 = 0x00;
byte block4_byte2 = 0x00;
byte block4_byte3 = 0x00;
byte block4_byte4 = 0x00;

byte block5_byte1 = 0x00;
byte block5_byte2 = 0x00;
byte block5_byte3 = 0x00;
byte block5_byte4 = 0x00;

byte block6_byte1 = 0x00;
byte block6_byte2 = 0x00;
byte block6_byte3 = 0x00;
byte block6_byte4 = 0x00;

byte block7_byte1 = 0x00;
byte block7_byte2 = 0x00;
byte block7_byte3 = 0x00;
byte block7_byte4 = 0x00;

int val = 0;

void setup(){
// Start serial port 19200 bps
Serial.begin(19200);
Serial1.begin(19200);

pinMode(led, OUTPUT);
delay(500);
  
// Setting Auto Read Mode - T5557 7 blocks without password
  
Serial1.write(0xFF);
Serial1.write(0x01);
Serial1.write(0x09);
Serial1.write(0x87);
Serial1.write(0x01);
Serial1.write(0x01);
Serial1.write(0x07);
Serial1.write((byte)0x00);
Serial1.write(0x10);
Serial1.write(0x20);
Serial1.write(0x30);
Serial1.write(0x40);
Serial1.write(0x3A);

delay(500);
Serial1.flush();
Serial.println();
Serial.println();
Serial.println("RFID module started in Auto Read Mode");
}

void loop(){

val = Serial1.read();
while (val != 0xff){
  Serial.println("Waiting card");
  val = Serial1.read();
  delay(1000);
}

// Serial.read();    // we read ff
Serial1.read();    // we read 01
Serial1.read();    // we read 1d
Serial1.read();    // we read 10

block1_byte1 = Serial1.read();    // we read block 1 byte 1
block1_byte2 = Serial1.read();    // we read block 1 byte 2
block1_byte3 = Serial1.read();    // we read block 1 byte 3
block1_byte4 = Serial1.read();    // we read block 1 byte 4

block2_byte1 = Serial1.read();    // we read block 2 byte 1
block2_byte2 = Serial1.read();    // we read block 2 byte 2
block2_byte3 = Serial1.read();    // we read block 2 byte 3
block2_byte4 = Serial1.read();    // we read block 2 byte 4

block3_byte1 = Serial1.read();    // we read block 3 byte 1
block3_byte2 = Serial1.read();    // we read block 3 byte 2
block3_byte3 = Serial1.read();    // we read block 3 byte 3
block3_byte4 = Serial1.read();    // we read block 3 byte 4

block4_byte1 = Serial1.read();    // we read block 4 byte 1
block4_byte2 = Serial1.read();    // we read block 4 byte 2
block4_byte3 = Serial1.read();    // we read block 4 byte 3
block4_byte4 = Serial1.read();    // we read block 4 byte 4

block5_byte1 = Serial1.read();    // we read block 5 byte 1
block5_byte2 = Serial1.read();    // we read block 5 byte 2
block5_byte3 = Serial1.read();    // we read block 5 byte 3
block5_byte4 = Serial1.read();    // we read block 5 byte 4

block6_byte1 = Serial1.read();    // we read block 6 byte 1
block6_byte2 = Serial1.read();    // we read block 6 byte 2
block6_byte3 = Serial1.read();    // we read block 6 byte 3
block6_byte4 = Serial1.read();    // we read block 6 byte 4

block7_byte1 = Serial1.read();    // we read block 7 byte 1
block7_byte2 = Serial1.read();    // we read block 7 byte 2
block7_byte3 = Serial1.read();    // we read block 7 byte 3
block7_byte4 = Serial1.read();    // we read block 7 byte 4
  
Serial1.read();    // we read checksum

// Led blink
for(int i = 0;i<4;i++){
  digitalWrite(led,HIGH);
  delay(500);
  digitalWrite(led,LOW);
  delay(500);
}

// Printing the code of the card
Serial.println();
Serial.println("T5557 card found - Data read: ");
Serial.println("---------------------------------------");
Serial.print("-- Block 1 -- | ");  writeByte(block1_byte1);
Serial.print(" | ");  writeByte(block1_byte2);
Serial.print(" | ");  writeByte(block1_byte3);
Serial.print(" | ");  writeByte(block1_byte4);
Serial.println(" |");
Serial.print("-- Block 2 -- | ");  writeByte(block2_byte1);
Serial.print(" | ");  writeByte(block2_byte2);
Serial.print(" | ");  writeByte(block2_byte3);
Serial.print(" | ");  writeByte(block2_byte4);
Serial.println(" |");
Serial.print("-- Block 3 -- | ");  writeByte(block3_byte1);
Serial.print(" | ");  writeByte(block3_byte2);
Serial.print(" | ");  writeByte(block3_byte3);
Serial.print(" | ");  writeByte(block3_byte4);
Serial.println(" |");
Serial.print("-- Block 4 -- | ");  writeByte(block4_byte1);
Serial.print(" | ");  writeByte(block4_byte2);
Serial.print(" | ");  writeByte(block4_byte3);
Serial.print(" | ");  writeByte(block4_byte4);
Serial.println(" |");
Serial.print("-- Block 5 -- | ");  writeByte(block5_byte1);
Serial.print(" | ");  writeByte(block5_byte2);
Serial.print(" | ");  writeByte(block5_byte3);
Serial.print(" | ");  writeByte(block5_byte4);
Serial.println(" |");
Serial.print("-- Block 6 -- | ");  writeByte(block6_byte1);
Serial.print(" | ");  writeByte(block6_byte2);
Serial.print(" | ");  writeByte(block6_byte3);
Serial.print(" | ");  writeByte(block6_byte4);
Serial.println(" |");
Serial.print("-- Block 7 -- | ");  writeByte(block7_byte1);
Serial.print(" | ");  writeByte(block7_byte2);
Serial.print(" | ");  writeByte(block7_byte3);
Serial.print(" | ");  writeByte(block7_byte4);
Serial.println(" |");
Serial.println("---------------------------------------");

Serial.println();

}

//Write a byte (hex) in ASCII
void writeByte(byte data){
int aux_1 = 0;
int aux_2 = 0;

  aux_1=data/16;
  aux_2=data%16;
  if (aux_1<10){
Serial.write(aux_1 + 48);
  }
  else{
Serial.write(aux_1+55);
  }
  if (aux_2<10){
Serial.write(aux_2 + 48);
  }
  else{
Serial.write(aux_2 + 55);
  }
Serial.print(" ");
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Ahmad Saad
 */

uint8_t dataRX[35];//Receive buffer.
uint8_t dataTX[35];//Transmit buffer.
uint8_t _UID[4];// stores the UID (unique identifier) of a card.
uint8_t keyAccess[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } ;// stores the key or password.
uint8_t address = 0x04;//Address to read.
uint8_t ATQ[2];//Answer to request
uint8_t state;//state of the process
uint8_t aux[16];//Auxiliar buffer. 

void setup()
{
	//Start serial port 115200 bps:
	Serial.begin(115200);
	Serial1.begin(115200);
	delay(100);
	Serial.print("RFID/NFC @ 13.56 MHz module started");
	delay(1000);
	//!It is needed to launch a simple command to sycnchronize
	getFirmware();
	configureSAM();
}

void loop()
{
	Serial.print("\n");
	Serial.println("Ready to read...");
	/////////////////////////////////////////////////////////////
	//Get the UID Identifier
	init(_UID, ATQ);
	Serial.print("\n");
	Serial.print( "The UID : ");
	print(_UID , 4);
	/////////////////////////////////////////////////////////////
	//Auntenticate a block with his keyAccess
	state = authenticate(_UID, address, keyAccess);
	Serial.print("\n");

	if ( state == 0) {
		Serial.println("Authentication block OK");
	} else {
	Serial.println("Authentication failed");
	}
	/////////////////////////////////////////////////////////////
	//Read from address after authentication
	state = readData(address, aux);
	Serial.print("\n");

	if (state == 0) {
		Serial.println("Read block OK");
	} else {
		Serial.println("Read failed");
	}

	Serial.print("\n");
	Serial.print("Data readed : ");
	print(aux , 16);
	Serial.print("\n");
	delay(2000);
}
//**********************************************************************
//!The goal of this command is to detect as many targets (maximum MaxTg)
// as possible in passive mode.
uint8_t init(uint8_t *UID , uint8_t *ATQ)   //! Request InListPassive
{
  Serial1.flush();

	dataTX[0] = 0x04; // Length
	lengthCheckSum(dataTX); // Length Checksum
	dataTX[2] = 0xD4;
	dataTX[3] = 0x4A; // Code
	dataTX[4] = 0x01; //MaxTarget
	dataTX[5] = 0x00; //BaudRate = 106Kbps
	dataTX[6] = 0x00; // Clear checkSum position
	checkSum(dataTX); 

	sendTX(dataTX , 7 ,23);

	for (int i = 17; i < (21) ; i++){
		_UID[i-17] = dataRX[i];
	UID[i-17] = _UID[i-17];
	}

	ATQ[0] = dataRX[13];
	ATQ[1] = dataRX[14];

	if ((dataRX[9]== 0xD5) & (dataRX[10] == 0x4B) & (dataRX[11] == 0x01)) {
		return 0;
	} else {
		return 1;
	}
}
//**********************************************************************
//!A block must be authenticated before read and write operations
uint8_t authenticate(uint8_t *UID, uint8_t blockAddress, uint8_t *keyAccess)
{
	dataTX[0] = 0x0F;
	lengthCheckSum(dataTX);
	dataTX[2] = 0xD4;
	dataTX[3] = 0x40; // inDataEchange
	dataTX[4] = 0x01; //Number of targets
	dataTX[5] = 0x60; // Authentication code
	dataTX[6] = blockAddress;
	for (int i = 0; i < 6 ; i++) {
		dataTX[i + 7] = keyAccess[i];
	}
	dataTX[13] = UID[0];  dataTX[14] = UID[1];
	dataTX[15] = UID[2];  dataTX[16] = UID[3];
	dataTX[17] = 0x00;
	checkSum(dataTX);
	sendTX(dataTX , 18 ,14);

	if ((dataRX[9]== 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
		return 0;
	} else {
		return 1;
	}
}
//**********************************************************************
//!Write 16 bytes in address .
uint8_t writeData(uint8_t address, uint8_t *blockData)  //!Writing
{
	Serial1.print("                ");
	dataTX[0] = 0x15;
	lengthCheckSum(dataTX); // Length Checksum
	dataTX[2] = 0xD4;
	dataTX[3] = 0x40;//inDataEchange CODE
	dataTX[4] = 0x01;//Number of targets
	dataTX[5] = 0xA0;//Write Command
	dataTX[6] = address; //Address		

	for (int i = 0; i < 16; i++) {
		dataTX[i+7] = blockData[i];
	}

	dataTX[23] = 0x00;
	checkSum(dataTX);
	sendTX(dataTX , 24 ,14);		

	if ((dataRX[9]== 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
		return 0;
	} else {
		return 1;
	}
}
//**********************************************************************
//!Read 16 bytes from  address .
uint8_t readData(uint8_t address, uint8_t *readData) //!Reading
{
	Serial1.print("                ");

	dataTX[0] = 0x05;
	lengthCheckSum(dataTX); // Length Checksum
	dataTX[2] = 0xD4; // Code
	dataTX[3] = 0x40; // Code
	dataTX[4] = 0x01; // Number of targets
	dataTX[5] = 0x30; //ReadCode
	dataTX[6] = address;  //Read address
	dataTX[7] = 0x00;
	checkSum(dataTX);
	sendTX(dataTX , 8, 30);
	memset(readData, 0x00, 16);  

	if ((dataRX[9]== 0xD5) & (dataRX[10] == 0x41) & (dataRX[11] == 0x00)) {
		for (int i = 12; i < 28; i++) {
			readData[i-12] = dataRX[i];
		}
		return 0;
	} else {
		return 1;
	}
}
//**********************************************************************
//!The PN532 sends back the version of the embedded firmware.
bool getFirmware(void)  //! It is needed to launch a simple command to sycnchronize
{
  Serial1.print("                ");

	memset(dataTX, 0x00, 35);
	dataTX[0] = 0x02; // Length
	lengthCheckSum(dataTX); // Length Checksum
	dataTX[2] = 0xD4; // CODE
	dataTX[3] = 0x02; //TFI
	checkSum(dataTX); //0x2A; //Checksum   

	sendTX(dataTX , 5 , 17);
	Serial1.print("\n");
	Serial.print("Your Firmware version is : ");

	for (int i = 11; i < (15) ; i++){
		Serial1.print(dataRX[i], HEX);
		Serial1.print(" ");
	}
	Serial1.print("\n");
}

//**********************************************************************
//!Print data stored in vectors .
void print(uint8_t * _data, uint8_t length)
{
	for (int i = 0; i < length ; i++){
		Serial.print(_data[i], HEX);
		Serial.print(" ");
	}
	Serial.print("\n");
}
//**********************************************************************
//!This command is used to set internal parameters of the PN532,
bool configureSAM(void)//! Configure the SAM
{
	Serial1.print("               ");

	dataTX[0] = 0x05; //Length
	lengthCheckSum(dataTX); // Length Checksum
	dataTX[2] = 0xD4;
	dataTX[3] = 0x14;
	dataTX[4] = 0x01; // Normal mode
	dataTX[5] = 0x14; // TimeOUT
	dataTX[6] = 0x00; // IRQ
	dataTX[7] = 0x00; // Clean checkSum position
	checkSum(dataTX);

	sendTX(dataTX , 8, 13);
}
//**********************************************************************
//!Send data stored in dataTX
void sendTX(uint8_t *dataTX, uint8_t length, uint8_t outLength)
{
	Serial1.print(char(0x00));
	Serial1.print(char(0x00));
	Serial1.print(char(0xFF)); 

	for (int i = 0; i < length; i++) {
		Serial1.print(char(dataTX[i]));
	}

	Serial1.print(char(0x00));
	getACK();
	waitResponse();// Receive response
	getData(outLength);
}
//**********************************************************************
//!Wait for ACK response and stores it in the dataRX buffer
void getACK(void)
{
	delay(5);
	waitResponse();
	for (int i = 0; i < 5 ; i++) {
		dataRX[i] = Serial1.read();
	}
}
//**********************************************************************
//!Wait the response of the module
void waitResponse(void)
{
	int val = 0xFF;
	int cont = 0x00;
	while(val != 0x00) { //Wait for 0x00 response
		val = Serial1.read();
		delay(5);
		cont ++;
	}
}
//**********************************************************************
//!Get data from the module
void getData(uint8_t outLength)
{
	for (int i=5; i < outLength; i++) {
		dataRX[i] = Serial1.read();//read data from the module.
	}
}
//**********************************************************************
//!Calculates the checksum and stores it in dataTX buffer
void checkSum(uint8_t *dataTX)
{
	for (int i = 0; i < dataTX[0] ; i++) {
		dataTX[dataTX[0] + 2] += dataTX[i + 2];
	}
	byte(dataTX[dataTX[0] + 2]= - dataTX[dataTX[0] + 2]);
}
//**********************************************************************
//!Calculates the length checksum and sotres it in the buffer.
uint8_t lengthCheckSum(uint8_t *dataTX)
{
	dataTX[1] = byte(0x100 - dataTX[0]);
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Marcos Yarza
 */


int led = 13;
int val = -1;

void setup(){
	delay(2000);
	Serial1.begin(115200);
	delay(2000);
	Serial1.print("AT+JSEC=1,1,1,04,1111\r\n"); // Enable security command
	delay(2000);
	Serial1.print("AT+JDIS=3\r\n"); // Discorable command
	delay(2000);
	Serial1.print("AT+JRLS=1101,11,Serial Port,01,000000\r\n"); // Register local sevice command
	delay(2000);
	Serial1.print("AT+JAAC=1\r\n");// Auto accept connection requests command
	delay(2000);
	pinMode(led, OUTPUT);
	digitalWrite(led,HIGH);
	Serial1.flush();
	val = Serial1.read();
	while (val != 'R'){
	  val = Serial1.read();
	}
	delay(1000);
	Serial1.print("AT+JSCR\r\n"); // Stream Connection Request command
}

void loop(){
	Serial1.println("Hola caracola...");
	delay(2000);
}
                

/*  
 *  Using Intel Galileo with the Arduino and Raspberry Pi Shields designed by Cooking Hacks
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  a
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see http://www.gnu.org/licenses/. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Luis Martín & Marcos Yarza
 */



// Threshold values for the led bar
#define TH1 45
#define TH2 95
#define TH3 200
#define TH4 400
#define TH5 600

// Conversion factor - CPM to uSV/h
#define CONV_FACTOR 0.00812

// Variables
int ledArray [] = {10,11,12,13,9};
int geiger_input = 2;
long count = 0;
long countPerMinute = 0;
long timePrevious = 0;
long timePreviousMeassure = 0;
long countPrevious = 0;
float radiationValue = 0.0;

void setup(){
  pinMode(geiger_input, INPUT);
  //digitalWrite(geiger_input,HIGH);
  for (int i=0;i<5;i++){
    pinMode(ledArray[i],OUTPUT);
  }

  Serial.begin(19200);
}

void loop(){
  count = 0;
  timePreviousMeassure = millis();
  while (millis()-timePreviousMeassure < 10000)
  {
    if(digitalRead(geiger_input) == 0)
    {
      count++;
      while(digitalRead(geiger_input) == 0); // do nothing until pin goes back to HIGH
    }
  }
  radiationValue = 6.0*count * CONV_FACTOR;
  countPerMinute = 6*count;
  Serial.print("CPM = ");
  Serial.print(count*6);
  Serial.print(" | uSV/h = ");
  Serial.println(radiationValue);   

    //led var setting  
    if(countPerMinute <= TH1) ledVar(0);
    if((countPerMinute <= TH2)&&(countPerMinute>TH1)) ledVar(1);
    if((countPerMinute <= TH3)&&(countPerMinute>TH2)) ledVar(2);
    if((countPerMinute <= TH4)&&(countPerMinute>TH3)) ledVar(3);
    if((countPerMinute <= TH5)&&(countPerMinute>TH4)) ledVar(4);
    if(countPerMinute>TH5) ledVar(5);

}



void ledVar(int value){
  if (value > 0){
    for(int i=0;i<=value;i++){
      digitalWrite(ledArray[i],HIGH);
    }
    for(int i=5;i>value;i--){
      digitalWrite(ledArray[i],LOW);
    }
  }
  else {
    for(int i=5;i>=0;i--){
      digitalWrite(ledArray[i],LOW);
    }
  }
}