void center()
{
for(m = 0; m < 8; m++)
{
ADC_Start(m);
ADC_Get( &ad[m] );
ad_data[m] = ad[m];
}
X_l = abs(abs(ad_data[0]-ad_data[1]) - abs(ad_data[2]-ad_data[3]));
Y_l = abs(abs(ad_data[0]-ad_data[2]) - abs(ad_data[1]-ad_data[3]));
X_r = abs(abs(ad_data[4]-ad_data[5]) - abs(ad_data[6]-ad_data[7]));
Y_r = abs(abs(ad_data[4]-ad_data[6]) - abs(ad_data[5]-ad_data[7]));
if(X_l>X_r)
{
center_x = ((float)(X_l-X_r))/2;
center_y = ((float)(Y_l-Y_r))/2;
}
if(X_l<X_r)
{
center_x = ((float)(X_r-X_l))/2;
center_y = ((float)(Y_r-Y_l))/2;
}
usart1_transmit(100);
usart1_transmit(center_x);
}
/*
* Start reading sensor value
* returns the lightvalue in promille (0.1% per bit)
*/
uint16_t LDR_GetData(uint8_t sensor)
{
uint16_t ldr = ADC_Get(sensor);
if (ldr>1000) {
ldr=1000;
}
return ldr;
}
void sns_VoltageCurrent_Process(void)
{
if (Timer_Expired(sns_VoltageCurrent_TIMER)) {
StdCan_Msg_t txMsg;
StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_SNS);
StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
txMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_VOLTAGECURRENT;
txMsg.Header.ModuleId = sns_VoltageCurrent_ID;
txMsg.Length = 3;
uint16_t ADvalue;
#ifdef sns_VoltageCurrent0AD
if (VoltageCurrentChannelToSend==0)
{
ADvalue = ADC_Get(sns_VoltageCurrent0AD);
ADvalue = ADvalue * sns_VoltageCurrent0Factor;
#if sns_VoltageCurrent0VorA==0
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_VOLTAGE;
#else
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_CURRENT;
#endif
txMsg.Data[0] = 0;
txMsg.Data[1] = (ADvalue>>(sns_VoltageCurrent0Scale-6+8))&0xff;
txMsg.Data[2] = (ADvalue>>(sns_VoltageCurrent0Scale-6))&0xff;
while (StdCan_Put(&txMsg) != StdCan_Ret_OK) {}
}
#endif
#ifdef sns_VoltageCurrent1AD
if (VoltageCurrentChannelToSend==1)
{
ADvalue = ADC_Get(sns_VoltageCurrent1AD);
ADvalue = ADvalue * sns_VoltageCurrent1Factor;
#if sns_VoltageCurrent1VorA==0
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_VOLTAGE;
#else
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_CURRENT;
#endif
txMsg.Data[0] = 1;
txMsg.Data[1] = (ADvalue>>(sns_VoltageCurrent1Scale-6+8))&0xff;
txMsg.Data[2] = (ADvalue>>(sns_VoltageCurrent1Scale-6))&0xff;
while (StdCan_Put(&txMsg) != StdCan_Ret_OK) {}
}
/*
* Start reading and return the temperature value.
*/
uint16_t getTC1047temperature(uint8_t sensor)
{
uint32_t temperatureData;
temperatureData = ADC_Get(sensor);
/* Use 5 volt as reference */
temperatureData = temperatureData * 5;
temperatureData = (temperatureData * 100 / 1024) - 50;
return temperatureData;
}
void sns_BusVoltage_Process(void)
{
///TODO: Stuff that needs doing is done here
if (Timer_Expired(sns_BusVoltage_TIMER)) {
uint16_t busVoltage = ADC_Get(BUSVOLTAGEAD);
busVoltage = (busVoltage & 0x03ff) * ADC_FACTOR;
StdCan_Msg_t txMsg;
StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_SNS);
StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
txMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_BUSVOLTAGE;
txMsg.Header.ModuleId = sns_BusVoltage_ID;
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_VOLTAGE;
txMsg.Length = 3;
txMsg.Data[0] = 0;
txMsg.Data[1] = (busVoltage>>(ADC_SCALE-6+8))&0xff;
txMsg.Data[2] = (busVoltage>>(ADC_SCALE-6))&0xff;
StdCan_Put(&txMsg);
}
}
void zmp()
{
for(m = 0; m < 8; m++)
{
ADC_Start(m);
ADC_Get( &ad[m] );
ad_data[m] = ad[m];
}
for(gg=0;gg<8;gg++)
{
numerator=ad_data[gg]*lenx[gg];
count_numerator = count_numerator+numerator;
}
for(gg=0;gg<8;gg++)
{
denominator=ad_data[gg];
count_denominator = count_denominator+denominator;
}
zmpx = count_numerator/count_denominator;
for(gg=0;gg<8;gg++)
{
numerator_1=ad_data[gg]*leny[gg];
count_numerator_1 = count_numerator_1+numerator_1;
}
for(gg=0;gg<8;gg++)
{
denominator_1=ad_data[gg];
count_denominator_1 = count_denominator_1+denominator_1;
}
zmpy = count_numerator_1/count_denominator_1;
unsigned_dec(zmpx);
unsigned_dec(zmpy);
usart1_transmit(0x0d);
usart1_transmit(0x0a);
}
void sns_inputAnalog_Process(void)
{
/* When the timer has overflowed the AD channels shall be read */
if (Timer_Expired(sns_inputAnalog_TIMER))
{
StdCan_Msg_t txMsg;
StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_SNS);
StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
txMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_INPUTANALOG;
txMsg.Header.ModuleId = sns_inputAnalog_ID;
uint16_t AdValue=0;
/* For each channel */
for (uint8_t i=0; i<sns_inputAnalog_NUM_SUPPORTED; i++)
{
/* Do reading of AD channel */
switch (i)
{
case 0:
AdValue = ADC_Get(sns_inputAnalog0AD);
break;
case 1:
AdValue = ADC_Get(sns_inputAnalog1AD);
break;
case 2:
AdValue = ADC_Get(sns_inputAnalog2AD);
break;
case 3:
AdValue = ADC_Get(sns_inputAnalog3AD);
break;
}
/* If this channel is configured as periodic transmission of voltage */
if (sns_inputAnalog_Config[i].Type == CAN_MODULE_ENUM_INPUTANALOG_ANALOGCONFIG_SETTING_PERIODICMEASURE)
{
/* Count periodicity */
sns_inputAnalog_Sensor[i].PeriodCnt += sns_inputAnalog_POLL_PERIOD_MS;
/* If periodicity overflowed or AD value changed more than threshold since last sent value */
if (sns_inputAnalog_Sensor[i].PeriodCnt >= sns_inputAnalog_Config[i].Periodicity ||
MAX(AdValue,sns_inputAnalog_Sensor[i].LastSentAdVal)-MIN(AdValue,sns_inputAnalog_Sensor[i].LastSentAdVal) > sns_inputAnalog_Config[i].LowTh)
//if (sns_inputAnalog_Sensor[i].PeriodCnt >= sns_inputAnalog_Config[i].Periodicity ||
// abs(AdValue-sns_inputAnalog_Sensor[i].LastSentAdVal) > sns_inputAnalog_Config[i].LowTh)
{
/* Reset periodicity counter */
sns_inputAnalog_Sensor[i].PeriodCnt = 0;
/* Store value as last sent */
sns_inputAnalog_Sensor[i].LastSentAdVal = AdValue;
/* send sensor value on CAN with command CAN_MODULE_CMD_PHYSICAL_VOLTAGE */
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_VOLTAGE;
txMsg.Length = 3;
/* The channel should be transmitted in byte 0 */
txMsg.Data[0] = i;
uint8_t analogScale = 10;
/* Select parameters for AD conversion */
switch (i)
{
case 0:
analogScale = sns_inputAnalog0Scale;
AdValue = AdValue * sns_inputAnalog0Factor;
break;
case 1:
analogScale = sns_inputAnalog1Scale;
AdValue = AdValue * sns_inputAnalog1Factor;
break;
case 2:
analogScale = sns_inputAnalog2Scale;
AdValue = AdValue * sns_inputAnalog2Factor;
break;
case 3:
analogScale = sns_inputAnalog3Scale;
AdValue = AdValue * sns_inputAnalog3Factor;
break;
}
txMsg.Data[1] = (AdValue>>(analogScale-6+8))&0xff;
txMsg.Data[2] = (AdValue>>(analogScale-6))&0xff;
/* Send value on CAN */
while (StdCan_Put(&txMsg) != StdCan_Ret_OK) {}
}
}
/* If this channel is configured as digital input */
else if (sns_inputAnalog_Config[i].Type == CAN_MODULE_ENUM_INPUTANALOG_ANALOGCONFIG_SETTING_DIGITALINPUT)
void sns_flower_Process(void)
{
static uint8_t measureState=0;
static uint16_t results[6];
static uint16_t resultsInv[6];
uint16_t temp;
static uint8_t flowerChannelToSend = 0;
if (Timer_Expired(sns_flower_WAIT_TIMER)) {
gpio_set_out(sns_flower_highSide_PIN);
gpio_set_out(sns_flower_lowSide_PIN);
gpio_set_pin(sns_flower_highSide_PIN);
gpio_clr_pin(sns_flower_lowSide_PIN);
measureState=0;
Timer_SetTimeout(sns_flower_MEASUREMENT_TIMER, sns_flower_MEASUREMENT_PERIOD_MS , TimerTypeOneShot, 0);
}
if (Timer_Expired(sns_flower_MEASUREMENT_TIMER)) {
StdCan_Msg_t txMsg;
StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_SNS);
StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
txMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_VOLTAGECURRENT;
txMsg.Header.ModuleId = sns_flower_ID;
txMsg.Length = 3;
switch (measureState) {
case 0:
#ifdef sns_flower0AD
results[0] = ADC_Get(sns_flower0AD);
#endif
#ifdef sns_flower1AD
results[1] = ADC_Get(sns_flower1AD);
#endif
#ifdef sns_flower2AD
results[2] = ADC_Get(sns_flower2AD);
#endif
#ifdef sns_flower3AD
results[3] = ADC_Get(sns_flower3AD);
#endif
#ifdef sns_flower4AD
results[4] = ADC_Get(sns_flower4AD);
#endif
#ifdef sns_flower5AD
results[5] = ADC_Get(sns_flower5AD);
#endif
gpio_clr_pin(sns_flower_highSide_PIN);
gpio_set_pin(sns_flower_lowSide_PIN);
measureState=1;
Timer_SetTimeout(sns_flower_MEASUREMENT_TIMER, sns_flower_MEASUREMENT_PERIOD_MS , TimerTypeOneShot, 0);
break;
case 1:
#ifdef sns_flower0AD
resultsInv[0] = 1023-ADC_Get(sns_flower0AD);
#endif
#ifdef sns_flower1AD
resultsInv[1] = 1023-ADC_Get(sns_flower1AD);
#endif
#ifdef sns_flower2AD
resultsInv[2] = 1023-ADC_Get(sns_flower2AD);
#endif
#ifdef sns_flower3AD
resultsInv[3] = 1023-ADC_Get(sns_flower3AD);
#endif
#ifdef sns_flower4AD
resultsInv[4] = 1023-ADC_Get(sns_flower4AD);
#endif
#ifdef sns_flower5AD
resultsInv[5] = 1023-ADC_Get(sns_flower5AD);
#endif
gpio_clr_pin(sns_flower_highSide_PIN);
gpio_clr_pin(sns_flower_lowSide_PIN);
gpio_set_in(sns_flower_highSide_PIN);
gpio_set_in(sns_flower_lowSide_PIN);
measureState=2;
flowerChannelToSend=0;
Timer_SetTimeout(sns_flower_MEASUREMENT_TIMER, sns_flower_MEASUREMENT_PERIOD_MS , TimerTypeOneShot, 0);
break;
case 2:
switch(flowerChannelToSend) {
case 0:
#ifdef sns_flower0AD
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_PERCENT;
txMsg.Data[0] = 0;
temp = (uint16_t)((float)(results[0]+resultsInv[0])*4.888);
txMsg.Data[1] = (temp>>8)&0xff;
txMsg.Data[2] = (temp)&0xff;
while (StdCan_Put(&txMsg) != StdCan_Ret_OK) {}
flowerChannelToSend = 1;
# if !(defined(sns_flower1AD) || defined(sns_flower2AD) || defined(sns_flower3AD) || defined(sns_flower4AD) || defined(sns_flower5AD))
flowerChannelToSend = 0;
measureState=0;
# endif
break;
#endif
case 1:
#ifdef sns_flower1AD
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_PERCENT;
txMsg.Data[0] = 1;
temp = (uint16_t)((float)(results[1]+resultsInv[1])*4.888);
txMsg.Data[1] = (temp>>8)&0xff;
txMsg.Data[2] = (temp)&0xff;
while (StdCan_Put(&txMsg) != StdCan_Ret_OK) {}
flowerChannelToSend = 2;
# if !(defined(sns_flower2AD) || defined(sns_flower3AD) || defined(sns_flower4AD) || defined(sns_flower5AD))
flowerChannelToSend = 0;
measureState=0;
# endif
break;
#endif
case 2:
#ifdef sns_flower2AD
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_PERCENT;
txMsg.Data[0] = 2;
temp = (uint16_t)((float)(results[2]+resultsInv[2])*4.888);
txMsg.Data[1] = (temp>>8)&0xff;
txMsg.Data[2] = (temp)&0xff;
while (StdCan_Put(&txMsg) != StdCan_Ret_OK) {}
flowerChannelToSend = 3;
#if !(defined(sns_flower3AD) || defined(sns_flower4AD) || defined(sns_flower5AD))
flowerChannelToSend = 0;
measureState=0;
#endif
break;
#endif
case 3:
#ifdef sns_flower3AD
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_PERCENT;
txMsg.Data[0] = 3;
temp = (uint16_t)((float)(results[3]+resultsInv[3])*4.888);
txMsg.Data[1] = (temp>>8)&0xff;
txMsg.Data[2] = (temp)&0xff;
while (StdCan_Put(&txMsg) != StdCan_Ret_OK) {}
flowerChannelToSend = 4;
#if !( defined(sns_flower4AD) || defined(sns_flower5AD))
flowerChannelToSend = 0;
measureState=0;
#endif
break;
#endif
case 4:
#ifdef sns_flower4AD
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_PERCENT;
txMsg.Data[0] = 4;
temp = (uint16_t)((float)(results[4]+resultsInv[4])*4.888);
txMsg.Data[1] = (temp>>8)&0xff;
txMsg.Data[2] = (temp)&0xff;
while (StdCan_Put(&txMsg) != StdCan_Ret_OK) {}
flowerChannelToSend = 5;
#if !(defined(sns_flower5AD))
flowerChannelToSend = 0;
measureState=0;
#endif
break;
#endif
case 5:
#ifdef sns_flower5AD
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_PERCENT;
txMsg.Data[0] = 5;
temp = (uint16_t)((float)(results[5]+resultsInv[5])*4.888);
txMsg.Data[1] = (temp>>8)&0xff;
txMsg.Data[2] = (temp)&0xff;
while (StdCan_Put(&txMsg) != StdCan_Ret_OK) {}
flowerChannelToSend = 0;
measureState=0;
break;
#endif
default:
measureState=0;
break;
}
if (measureState != 0) {
Timer_SetTimeout(sns_flower_MEASUREMENT_TIMER, sns_flower_CAN_MSG_PAUS_MS , TimerTypeOneShot, 0);
}
break;
}
}
}
void act_hd44780_Process(void)
{
#if act_hd44780_USE_AUTO_BL == 1
if (autoMode == CAN_MODULE_ENUM_HD44789_LCD_BACKLIGHT_AUTOLIGHT_ON) {
#if (act_hd44780_TYPE==0)
if ( OCR0A == 0) {
#else
if ( OCR0B == 0) {
#endif
} else {
uint16_t Voltage = (0x3ff & ADC_Get(act_hd44780_LIGHTSENSOR_AD));
#if (act_hd44780_TYPE==0)
OCR0A = Voltage/4;
if (OCR0A == 0) {
OCR0A = 1;
}
#else
OCR0B = Voltage/4;
if (OCR0B == 0) {
OCR0B = 1;
}
#endif
}
}
#endif
#if (act_hd44780_TYPE==0)
if (OCR0A==0 && (TCCR0A & ((1<<COM0A1)|(1<<WGM01)|(1<<WGM00))) == ((1<<COM0A1)|(1<<WGM01)|(1<<WGM00)))
{
TCCR0A &= ~((1<<COM0A1)|(1<<WGM01)|(1<<WGM00));
}
if (OCR0A!=0 && (TCCR0A & ((1<<COM0A1)|(1<<WGM01)|(1<<WGM00))) != ((1<<COM0A1)|(1<<WGM01)|(1<<WGM00)))
{
TCCR0A |= (1<<COM0A1)|(1<<WGM01)|(1<<WGM00);
}
#endif
}
void act_hd44780_HandleMessage(StdCan_Msg_t *rxMsg)
{
StdCan_Msg_t txMsg;
uint8_t n = 0;
if ( StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_ACT &&
StdCan_Ret_direction(rxMsg->Header) == DIRECTIONFLAG_TO_OWNER &&
rxMsg->Header.ModuleType == CAN_MODULE_TYPE_ACT_HD44789 &&
rxMsg->Header.ModuleId == act_hd44780_ID)
{
switch (rxMsg->Header.Command)
{
case CAN_MODULE_CMD_HD44789_LCD_CLEAR:
lcd_clrscr();
break;
case CAN_MODULE_CMD_HD44789_LCD_CURSOR:
lcd_gotoxy(rxMsg->Data[0], rxMsg->Data[1]);
break;
case CAN_MODULE_CMD_HD44789_LCD_TEXTAT:
lcd_gotoxy(rxMsg->Data[0], rxMsg->Data[1]);
for (n = 2; n < rxMsg->Length; n++)
{
lcd_putc((char)rxMsg->Data[n]);
}
break;
/*
case CAN_MODULE_CMD_HD44789_LCD_CLEARROW:
lcd_gotoxy(0, rxMsg->Data[0]);
for (n = 0; n < act_hd44780_WIDTH; n++)
{
lcd_putc(' ');
}
break;
*/
case CAN_MODULE_CMD_HD44789_LCD_TEXT:
for (n = 0; n < rxMsg->Length; n++)
{
lcd_putc((char)rxMsg->Data[n]);
}
break;
case CAN_MODULE_CMD_HD44789_LCD_SIZE:
StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT);
StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_HD44789;
txMsg.Header.ModuleId = act_hd44780_ID;
txMsg.Header.Command = CAN_MODULE_CMD_HD44789_LCD_SIZE;
txMsg.Length = 2;
txMsg.Data[0] = act_hd44780_WIDTH;
txMsg.Data[1] = act_hd44780_HEIGHT;
while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
break;
case CAN_MODULE_CMD_HD44789_LCD_BACKLIGHT:
if (rxMsg->Length > 0) {
#if (act_hd44780_TYPE==0)
OCR0A = rxMsg->Data[0];
#else
OCR0B = rxMsg->Data[0];
#endif
#if act_hd44780_USE_AUTO_BL == 1
if (rxMsg->Length == 2) {
autoMode = rxMsg->Data[0];
}
#endif
}
StdCan_Msg_t txMsg;
StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT);
StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_HD44789;
txMsg.Header.ModuleId = act_hd44780_ID;
txMsg.Header.Command = CAN_MODULE_CMD_HD44789_LCD_BACKLIGHT;
txMsg.Length = 1;
#if (act_hd44780_TYPE==0)
txMsg.Data[0] = OCR0A;
#else
txMsg.Data[0] = OCR0B;
#endif
#if act_hd44780_USE_AUTO_BL == 1
txMsg.Data[1] = autoMode;
txMsg.Length = 2;
#endif
while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
break;
}
}
}
