Imanol-Mikel Barba Sabariego / smartcities · Files

#include "sensors.h"

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

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_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &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);
	printf("LIGHT: Sent fetch command for CH1\r\n");

	I2C_restart(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_nack(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);
	printf("LIGHT: Sent fetch command for CH1\r\n");

	I2C_restart(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_nack(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;
	I2C_start(I2C1,DISTANCE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0x02);

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

void init_ultrasound(void)
{
	I2C_start(I2C1,DISTANCE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0x00);
	I2C_write(I2C1, 0x50);
	I2C_stop(I2C1);

	chThdSleepMilliseconds(70);
}

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_restart(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_restart(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_restart(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.AC1 = (I2C_read_ack(I2C1) << 8);
 	calib_data.AC1 |= I2C_read_nack(I2C1);
 	I2C_stop(I2C1);

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

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

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

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

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

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

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

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

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

 	I2C_start(I2C1,PRESSURE_ADDR << 1, I2C_Direction_Transmitter);
	I2C_write(I2C1, 0xBE);
	I2C_restart(I2C1, PRESSURE_ADDR << 1, I2C_Direction_Receiver);
 	calib_data.MD = (I2C_read_ack(I2C1) << 8);
 	calib_data.MD |= I2C_read_nack(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));
	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)
{
	printf("HUMIDITY: Initializing sensor\r\n");
	I2C_start(I2C1,HUMIDITY_TEMP_ADDR << 1, I2C_Direction_Transmitter);
	I2C_stop(I2C1);
	//Reset I2C?
}
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;
}