Imanol-Mikel Barba Sabariego / smartcities · Files

#include "sensors.h"

sensor light_sensor 		= {LIGHT_ADDR, "Light sensor", "illumination", "lux",NULL};
sensor ultrasound_sensor 	= {DISTANCE_ADDR, "Ultrasound sensor", "distance", "cm",NULL};
sensor pressure_sensor 		= {PRESSURE_ADDR, "Pressure sensor", "pressure", "hPa",NULL};
sensor humidity_temp_sensor = {HUMIDITY_TEMP_ADDR, "Humidity and Temperature","ºC,RH",NULL};
sensor sound_sensor 		= {SOUND_ADDR, "Sound sensor","mV",NULL};
sensor battery 				= {BATTERY_ADDR, "Battery Level","mV",NULL};

sensor* sensors[TOTAL_SENSORS+1] = {&light_sensor,&ultrasound_sensor,&pressure_sensor,&humidity_temp_sensor,&sound_sensor,&battery};

void wakeup_sensors(uint8_t logic_address)
{
	/* Aquí habría que implementar un control 
	 * inteligente de la alimentación de los 
	 * sensores, levantándolos y durmiéndolos 
	 * cuando tocara
	 */

	 // X 	X 	X	PA7 PA6 PA5 PA4 PA3
	 // b7 	b6 	b5 	b4 	b3 	b2 	b1 	b0

	printf("GRAB A BRUSH AND PUT A LITTLE MAKE-UP\r\n");
	GPIO_InitTypeDef  GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(ADCsound_GPIO_PORT, &GPIO_InitStructure);

	if(logic_address & 0x1)
	{
		printf("Woken Pin 3\r\n");
		GPIO_SetBits(GPIOA,GPIO_Pin_3);
	}
	else
	{
		GPIO_ResetBits(GPIOA,GPIO_Pin_3);
	}
	if(logic_address & 0x2)
	{
		printf("Woken Pin 4\r\n");
		GPIO_SetBits(GPIOA,GPIO_Pin_4);		
	}
	else
	{
		GPIO_ResetBits(GPIOA,GPIO_Pin_4);
	}
	if(logic_address & 0x4)
	{
		printf("Woken Pin 5\r\n");
		GPIO_SetBits(GPIOA,GPIO_Pin_5);
	}
	else
	{
		GPIO_ResetBits(GPIOA,GPIO_Pin_5);
	}
	if(logic_address & 0x8)
	{
		printf("Woken Pin 6\r\n");
		GPIO_SetBits(GPIOA,GPIO_Pin_6);
	}
	else
	{
		GPIO_ResetBits(GPIOA,GPIO_Pin_6);
	}
	if(logic_address & 0x10)
	{
		printf("Woken Pin 7\r\n");
		GPIO_SetBits(GPIOA,GPIO_Pin_7);
	}
	else
	{
		GPIO_ResetBits(GPIOA,GPIO_Pin_7);
	}
}

uint32_t get_light_data(void)
{
	uint32_t data = 0;

	data = get_light_ch1();
	printf("LIGHT: Got ch1\r\n");
	data = data << 16;
	data = data | get_light_ch0();
	printf("LIGHT: Got ch0\r\n");
	return data;
}
uint16_t get_light_ch0(void)
{
	uint16_t data = 0;

	I2C_start(I2C1,LIGHT_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0x0C);
	I2C_stop(I2C1);
	printf("LIGHT: Sent fetch command for low byte for CH1\r\n");

	I2C_start(I2C1, LIGHT_ADDR << 1, I2C_Direction_Receiver);
 	data = I2C_read_ack(I2C1);
 	printf("LIGHT: Got low byte for CH1\r\n");
 	data = data | (I2C_read_ack(I2C1) << 8);
 	printf("LIGHT: Got high byte for CH1\r\n");
 	I2C_stop(I2C1);	
 	
 	return data;
}
uint16_t get_light_ch1(void)
{
	uint16_t data = 0;

	I2C_start(I2C1,LIGHT_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0x0E);
	I2C_stop(I2C1);
	printf("LIGHT: Sent fetch command for low byte for CH1\r\n");

	I2C_start(I2C1, LIGHT_ADDR << 1, I2C_Direction_Receiver);
 	data = I2C_read_ack(I2C1);
 	printf("LIGHT: Got low byte for CH1\r\n");
 	data = data | (I2C_read_ack(I2C1) << 8);
 	printf("LIGHT: Got high byte for CH1\r\n");
 	I2C_stop(I2C1);

 	return data;
}

uint16_t get_distance_data(void)
{
	init_ultrasound();
	printf("DISTANCE: Initialized\r\n");
	uint16_t data = get_distance_high();
	printf("Got distance high byte\r\n");
	data = data << 8;
	data = data | get_distance_low();
	printf("Got distance low byte\r\n");
	return data;
}
void init_ultrasound(void)
{
	I2C_start(I2C1,DISTANCE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0x00);
	I2C_stop(I2C1);

	I2C_start(I2C1,DISTANCE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0x50);
	I2C_stop(I2C1);

	chThdSleepMilliseconds(70);
}
uint8_t get_distance_low(void)
{
	uint8_t data;
	I2C_start(I2C1,DISTANCE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0x03);
	I2C_stop(I2C1);
	
	I2C_start(I2C1, DISTANCE_ADDR << 1, I2C_Direction_Receiver);
 	data = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);
 	return data;
}
uint8_t get_distance_high(void)
{
	uint8_t data;
	I2C_start(I2C1,DISTANCE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0x02);
	I2C_stop(I2C1);
	
	I2C_start(I2C1, DISTANCE_ADDR << 1, I2C_Direction_Receiver);
 	data = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);
 	return data;
}

uint16_t get_pressure_data(void)
{
	uint16_t data;
	init_pressure();
	printf("PRESSURE: Initialized\r\n");
	I2C_start(I2C1,DISTANCE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xF6);
	I2C_stop(I2C1);

	I2C_start(I2C1, DISTANCE_ADDR << 1, I2C_Direction_Receiver);
 	data = I2C_read_ack(I2C1);
 	printf("PRESSURE: Got high byte\r\n");
 	data = data << 8;
 	data = data | I2C_read_nack(I2C1);
 	printf("PRESSURE: Got low byte\r\n");
	return data;
}

uint16_t get_pressure_temperature_data(void)
{
	uint16_t data;
	init_pressure_temperature();
	printf("PRESSURE: Initialized temperature\r\n");
	I2C_start(I2C1,DISTANCE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xF6);
	I2C_stop(I2C1);

	I2C_start(I2C1, DISTANCE_ADDR << 1, I2C_Direction_Receiver);
 	data = I2C_read_ack(I2C1);
 	printf("PRESSURE: Got temperature high byte\r\n");
 	data = data << 8;
 	data = data | I2C_read_nack(I2C1);
 	printf("PRESSURE: Got temperature low byte\r\n");
	return data;
}

bmp085_callibration get_pressure_callibration_data(void)
{
	printf("PRESSURE: Fetching callibration data\r\n");
	bmp085_callibration calib_data;

	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xAA);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.AC1 = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xAC);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.AC2 = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xAE);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.AC3 = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xB0);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.AC4 = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xB2);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.AC5 = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xB4);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.AC6 = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xB6);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.B1 = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xB8);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.B2 = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xBA);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.MB = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xBC);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.MC = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xBE);
	I2C_stop(I2C1);
	I2C_start(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.MD = I2C_read_ack(I2C1);
 	I2C_stop(I2C1);
 	printf("PRESSURE: Got callibration data\r\n");
 	return calib_data;
}
char* callibration_pressure_data_csv(bmp085_callibration parameters)
{
	char *str = chHeapAlloc(NULL,sizeof(char)*(11*11-1));
	memset(str,0x00,sizeof(char)*(11*11-1));
	sprintf(str + strlen(str),"%d,",parameters.AC1);
	sprintf(str + strlen(str),"%d,",parameters.AC2);
	sprintf(str + strlen(str),"%d,",parameters.AC3);
	sprintf(str + strlen(str),"%d,",parameters.AC4);
	sprintf(str + strlen(str),"%d,",parameters.AC5);
	sprintf(str + strlen(str),"%d,",parameters.AC6);
	sprintf(str + strlen(str),"%d,",parameters.B1);
	sprintf(str + strlen(str),"%d,",parameters.B2);
	sprintf(str + strlen(str),"%d,",parameters.MB);
	sprintf(str + strlen(str),"%d,",parameters.MC);
	sprintf(str + strlen(str),"%d",parameters.MD);
	return str;
}

void init_pressure(void)
{
	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xF4);
	I2C_write(I2C1, 0x34);
	I2C_stop(I2C1);
	
  	chThdSleepMilliseconds(5);
}

void init_pressure_temperature(void)
{
	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xF4);
	I2C_write(I2C1, 0x2E);
	I2C_stop(I2C1);
	
  	chThdSleepMilliseconds(5);
}

void init_humidity_temp(void)
{
	I2C_start(I2C1,HUMIDITY_TEMP_ADDR << 1, I2C_Direction_Transmitter);
	I2C_stop(I2C1);
}
uint16_t get_humidity_data(void)
{
	init_humidity_temp();
	printf("HUMIDITY_TEMP: Initialized humidity\r\n");
	uint16_t data = 0;
	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Receiver);
	data = I2C_read_ack(I2C1) & 0x3F;
	printf("HUMIDITY_TEMP: Got humidity high byte\r\n");
	data = data << 8;
	data |= I2C_read_nack(I2C1);
	printf("HUMIDITY_TEMP: Got humidity low byte\r\n");
	I2C_stop(I2C1);
	return data;
}
uint16_t get_temperature_data(void)
{
	init_humidity_temp();
	printf("HUMIDITY_TEMP: Initialized temperature\r\n");
	uint16_t data = 0;
	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Receiver);
	I2C_read_ack(I2C1);
	printf("HUMIDITY_TEMP: Discarded first humidity byte\r\n");
	I2C_read_ack(I2C1);
	printf("HUMIDITY_TEMP: Discarded second humidity byte\r\n");
	data = I2C_read_ack(I2C1);
	printf("HUMIDITY_TEMP: Got temperature high byte\r\n");
	data = data << 8;
	data |= I2C_read_nack(I2C1) & 0xFC ;
	printf("HUMIDITY_TEMP: Got temperature low byte\r\n");
	data = data >> 2;
	I2C_stop(I2C1);
	return data;
}

char* light_value(uint32_t light)
{
	char *value = chHeapAlloc(NULL,10 + 1);
	sprintf(value,"%d",(unsigned int)light);
	return value;
}
char* distance_value(uint16_t distance)
{
	char *value = chHeapAlloc(NULL,5 + 1);
	sprintf(value,"%d",distance);
	return value;
}
char* pressure_value(uint16_t pressure, uint16_t temperature)
{
	char *value = chHeapAlloc(NULL,11 + 1);
	sprintf(value,"%d,%d",pressure,temperature);
	return value;
}
char* temp_humidity_value(uint16_t temp, uint16_t humidity)
{
	char *value = chHeapAlloc(NULL,11 + 1);
	sprintf(value,"%d,%d",temp,humidity);
	return value;
}

void init_sound(void)
{
	//DARLE CHICHA AL INTERRUPTOR I2C
	adc_sound_init();
}
uint32_t get_sound_data(void)
{
	init_sound();
	return adc_sound_process();
}
char* sound_value(uint32_t sound)
{
	char *value = chHeapAlloc(NULL,11 + 1);
	sprintf(value,"%4u",(unsigned int)sound);
	return value;
}

void collectData(char* valueSensors[], uint8_t* sensors){
	uint8_t i;
	for(i=0;i<strlen((char*)sensors);i++)
	{

		if(valueSensors[i]!=NULL)
		{
			printf("Freeing memory from previous entry\r\n");
			chHeapFree(valueSensors[i]);
		}

		if(sensors[i]==LIGHT_ADDR)
		{
			printf("Fetching data from light sensor\r\n");
			valueSensors[i]=light_value(get_light_data());
			continue;
		}
		else if(sensors[i]==DISTANCE_ADDR)
		{
			printf("Fetching data from distance sensor\r\n");
			valueSensors[i]=distance_value(get_distance_data());
			continue;
		}
		else if(sensors[i]==SOUND_ADDR)
		{
			printf("Fetching data from sound sensor\r\n");
			valueSensors[i]=sound_value(get_sound_data());
			continue;
		}
		else if(sensors[i]==PRESSURE_ADDR)
		{
			printf("Fetching data from pressure sensor\r\n");
			valueSensors[i]=pressure_value(get_pressure_data(), get_pressure_temperature_data());
			continue;
		}
		else if(sensors[i]==HUMIDITY_TEMP_ADDR)
		{
			printf("Fetching data from humidity and temperature sensor\r\n");
			valueSensors[i]=temp_humidity_value(get_temperature_data(),get_humidity_data());
			continue;
		}
	}
}

void init_battery(void)
{
	adc_batt_init();
}

uint32_t get_battery_data(void)
{
	init_battery();
	return adc_batt_process();
}

char* battery_value(uint32_t battery)
{
	char *value = chHeapAlloc(NULL,11 + 1);
	sprintf(value,"%4u",(unsigned int)battery);
	return value;
}

//light_value(get_light_data());
//temp_humidity_value(get_temperature_data(),get_humidity_data());
//pressure_value(get_pressure_data(), get_pressure_temperature_data());