void ReadTemperature(void)
{
static uint8_t SearchSensorsTimeout = sns_ds18x20_SEARCH_TIMEOUT;
static uint8_t CurrentSensor = 0;
uint8_t subzero, cel, cel_frac_bits = 0;
StdCan_Msg_t txMsg;
StdCan_Set_class(txMsg.Header, CAN_CLASS_MODULE_SNS);
StdCan_Set_direction(txMsg.Header, DIR_FROM_OWNER);
txMsg.Header.ModuleType = CAN_TYPE_MODULE_sns_ds18x20;
txMsg.Header.ModuleId = sns_ds18x20_ID;
txMsg.Header.Command = CAN_CMD_MODULE_PHYS_TEMPERATURE_CELSIUS;
txMsg.Length = 3;
txMsg.Data[0] = SensorIds[CurrentSensor];
if (DS18X20_read_meas(&gSensorIDs[CurrentSensor][0], &subzero, &cel, &cel_frac_bits) == DS18X20_OK)
{
int16_t temp = cel;
temp = temp << 6;
temp += (cel_frac_bits << 2);
if (subzero)
{
temp = -temp;
}
txMsg.Data[1] = (uint8_t)(temp >> 8);
txMsg.Data[2] = (uint8_t)(temp & 0xff);
}
void read1WirePin(struct IO_pin *vpin, uint8_t power_mode) {
uint8_t port_num = 0;
uint8_t pin_num = 0;
uint8_t ram_virt_data_addr = 0;
uint16_t result;
uint8_t subzero, cel, cel_frac_bits;
uint8_t *tempID = 0;
for (uint8_t vpin_num = 0; vpin_num < COUNT_IO_PINS; vpin_num++) {
port_num = vpin_num/8;
pin_num = vpin_num%8;
ram_virt_data_addr = VIRTUAL_DATA_START + (port_num * (VIRTUAL_PORT_PINCOUNT * VIRTUAL_DATA_LENGTH)) + (pin_num * VIRTUAL_DATA_LENGTH);
if(&io_pins[port_num].pins[pin_num] == vpin) { //try to find virtual pin by given pointer
I2C_MAIN_DEBUG("Found OW PIN[0x%x;0x%x]\r\n", port_num, pin_num);
tempID = &rxbuffer[ram_virt_data_addr]; //get 1 wire rom code pointer
#ifndef OW_ONE_BUS
//set current pin to current used 1 wire bus
ow_set_bus(vpin->PPIN, vpin->PPORT, vpin->PDDR, vpin->pin);
#endif
if ( ss%10 == 5 ) {
I2C_MAIN_DEBUG("st OW\r\n");
DS18X20_start_meas( power_mode, NULL );
}
if (ss % 10 == 8) {
I2C_MAIN_DEBUG("rd OW\r\n");
txbuffer[ram_virt_data_addr]++; //raise seqnr
if (DS18X20_read_meas(tempID, &subzero, &cel, &cel_frac_bits) == DS18X20_OK) {
result = DS18X20_temp_to_decicel(subzero, cel, cel_frac_bits);
// Minuswerte:
if (subzero)
result *= (-1);
I2C_MAIN_DEBUG("T:%i\r\n", result);
txbuffer[ram_virt_data_addr + 1] = 0; //set data ok
txbuffer[ram_virt_data_addr + 2] = result >> 8; //high byte
txbuffer[ram_virt_data_addr + 3] = result & 0xFF; //low byte
} else {
void async_finish_read_sensors(void) {
uint8_t subzero, cel, cel_frac_bits;
for (uint8_t i=0; i<nSensors; i++ ) {
if ( DS18X20_read_meas( &gSensorIDs[i][0], &subzero,
&cel, &cel_frac_bits) == DS18X20_OK ) {
// Put the reading in the global readings array
readings[i].subzero=subzero;
readings[i].cel=cel;
readings[i].cel_frac_bits=cel_frac_bits;
}
else logs_P("CRC Error (lost connection?)");
//logs_P("\r\n");
}
}
void ReadTemperature(void)
{
static uint8_t SearchSensorsTimeout = sns_ds18x20_SEARCH_TIMEOUT;
static uint8_t CurrentSensor = 0;
uint8_t subzero, cel, cel_frac_bits = 0;
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_DS18X20;
txMsg.Header.ModuleId = sns_ds18x20_ID;
txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_TEMPERATURE_CELSIUS;
txMsg.Length = 3;
txMsg.Data[0] = SensorIds[CurrentSensor];
if (DS18X20_read_meas(&gSensorIDs[CurrentSensor][0], &subzero, &cel, &cel_frac_bits) == DS18X20_OK)
{
int16_t temp = cel;
temp = temp << 6;
temp += (cel_frac_bits << 2);
if (subzero)
{
temp = -temp;
}
txMsg.Data[1] = (uint8_t)(temp >> 8);
txMsg.Data[2] = (uint8_t)(temp & 0xff);
#ifdef CHN_LOADED
for( uint8_t i=0; i<DS18x20_MAXSENSORS; i++) {
if( sns_ds18s20_sensorids[i] == SensorIds[CurrentSensor] ) {
chn_ChnMaster_UpdateChannel( sns_ds18x20_CHN_CHANNEL + i, (temp<<2) + 25600 );
}
}
#endif
}
// read the latest measurement off the scratchpad of the ds18x20 sensor
// and store it in gTempdata
void read_temp_meas(void){
uint8_t i;
uint8_t subzero, cel, cel_frac_bits;
for ( i=0; i<gNsensors; i++ )
{
if ( DS18X20_read_meas( &gSensorIDs[i][0], &subzero,
&cel, &cel_frac_bits) == DS18X20_OK )
{
gTempdata[i]=cel*10;
gTempdata[i]+=DS18X20_frac_bits_decimal(cel_frac_bits);
if (subzero)
{
gTempdata[i]=-gTempdata[i];
}
}
else
{
gTempdata[i]=0;
}
}
}
int main(void)
{
#if _EXT_EEPROM_EMPTY==1
DDRB=0xFF;
PORTB=0x00;
i2cSetBitrate(100); //Ustaw prêdkoœæ i2c na 100kHz
EXT_EEPROM_var *struktura_eeprom;
struktura_eeprom=malloc(sizeof(EXT_EEPROM_var));
strcpy(struktura_eeprom->empty, " ");
strcpy(struktura_eeprom->temperatura, "Temperatura: ");
strcpy(struktura_eeprom->m1, "Ustawienia ");
strcpy(struktura_eeprom->m10, "Data: ");
strcpy(struktura_eeprom->m11, "Godzina: ");
strcpy(struktura_eeprom->m12, "LCD: ");
strcpy(struktura_eeprom->eePCF_Sunday, "Niedziela");
strcpy(struktura_eeprom->eePCF_Monday, "Poniedzialek");
strcpy(struktura_eeprom->eePCF_Tuesday, "Wtorek");
strcpy(struktura_eeprom->eePCF_Wednesday, "Sroda");
strcpy(struktura_eeprom->eePCF_Thursday, "Czwartek");
strcpy(struktura_eeprom->eePCF_Friday, "Piatek");
strcpy(struktura_eeprom->eePCF_Saturday, "Sobota");
strcpy(struktura_eeprom->eePCF_January, "Styczen");
strcpy(struktura_eeprom->eePCF_February, "Luty");
strcpy(struktura_eeprom->eePCF_March, "Marzec");
strcpy(struktura_eeprom->eePCF_April, "Kwiecien");
strcpy(struktura_eeprom->eePCF_May, "Maj");
strcpy(struktura_eeprom->eePCF_June, "Czerwiec");
strcpy(struktura_eeprom->eePCF_July, "Lipiec");
strcpy(struktura_eeprom->eePCF_August, "Sierpien");
strcpy(struktura_eeprom->eePCF_September, "Wrzesien");
strcpy(struktura_eeprom->eePCF_October, "Pazdziernik");
strcpy(struktura_eeprom->eePCF_November, "Listopad");
strcpy(struktura_eeprom->eePCF_December, "Grudzien");
PORTB=0x0F;
EI2C_write_buf(ADDR_EEMEM_24C64, 0, sizeof(EXT_EEPROM_var), (uint8_t*)struktura_eeprom);
free(struktura_eeprom);
PORTB=0xFF;
#endif // _EXT_EEPROM_EMPTY
#if _EXT_EEPROM_EMPTY==0
char bufor_lcd[41]; //Bufor przechowuj¹cy znaki z pamiêci EEPROM
//Zmienne wykorzystywane w opóŸnieniach:
uint8_t state=0;
uint32_t cnt=0, offset_cnt=0;
uint8_t state_light=0;
uint32_t cnt_light=0, offset_cnt_light=0;
Ustawienia ustawienia; //Struktura s³u¿¹ca do odczytania ustawieñ z EEPROM
ustawienia.ustawienia_poczatkowe=0;
//Ustaw PORTB jak wyjœcie dla LED:
DDRB=0xFF;
PORTB=0x00;
Flagi.flaga_klawiatura=1;
//// ustawienia TIMER0, przerwanie co 10us
OCR0 = 19;
TCCR0 |= (1<<WGM01); //Tryb ctc
TCCR0 |= (1<<CS01); // Preskaler 8
TIMSK |= (1<<OCIE0);
// Przerwanie INT0
MCUCR |= (1<<ISC01); // wyzwalanie zboczem opadaj¹cym
GICR |= (1<<INT0); // odblokowanie przerwania
PORTD |= (1<<PD2); // podci¹gniêcie pinu INT0 do VCC
i2cSetBitrate(100); //Ustaw prêdkoœæ i2c na 100kHz
lcd_init();
pobierz_czas(&czas);
pobierz_date(&data);
/* sprawdzamy ile czujników DS18xxx widocznych jest na magistrali */
czujniki_cnt = search_sensors();
/* wysy³amy rozkaz wykonania pomiaru temperatury
* do wszystkich czujników na magistrali 1Wire
* zak³adaj¹c, ¿e zasilane s¹ w trybie NORMAL,
* gdyby by³ to tryb Parasite, nale¿a³oby u¿yæ
* jako pierwszego prarametru DS18X20_POWER_PARASITE */
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );
/* czekamy 750ms na dokonanie konwersji przez pod³¹czone czujniki */
_delay_ms(750);
/* dokonujemy odczytu temperatury z pierwszego czujnika o ile zosta³ wykryty */
/* wyœwietlamy temperaturê gdy czujnik wykryty */
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) display_temp(0);
else {
lcd_locate(0,0);
lcd_str("term. error "); /* wyœwietlamy informacjê o b³êdzie jeœli np brak czujnika lub b³¹d odczytu */
}
#endif // _EXT_EEPROM_EMPTY
while (1)
{
#if _EXT_EEPROM_EMPTY==0
eeprom_read_block(&ustawienia, &deafult_flags, sizeof(deafult_flags));
if (ustawienia.ustawienia_poczatkowe)
{
eeprom_read_block(&data, &deafult_data, sizeof(data));
eeprom_read_block(&czas, &deafult_czas, sizeof(czas));
ustaw_date(&data);
ustaw_czas(&czas);
ustawienia.ustawienia_poczatkowe=0;
eeprom_update_block(&ustawienia, &deafult_flags, sizeof(deafult_flags));
}
switch(state_light)
{
case 0:
if (Flagi.light_lcd)
{
state_light=1;
cli();
cnt_light=200000;
offset_cnt_light=licznik;
sei();
}
break;
case 1:
if(cnt_light<=licznik-offset_cnt_light)
{
Flagi.light_lcd=0;
state_light=0;
}
break;
}
lcd_light(Flagi.light_lcd);
//OpóŸnienie dzia³añ po wciœniêciu przycisku
switch(state)
{
case 0:
key_code=debouncer(KlawiaturaSkan());
if(key_code)
{
state=1;
Flagi.light_lcd=1; //W³¹cz podœwietlanie LCD
cli();
cnt=50000;
offset_cnt=licznik;
sei();
}
break;
case 1:
key_code=0;
if(cnt<=licznik-offset_cnt)
{
state=0;
}
break;
}
if (Flagi.flaga_menu_func==1)
{
EI2C_read_buf(ADDR_EEMEM_24C64, menu_ptr->addr_ext_eeprom, menu_ptr->size_ext_eeprom, (uint8_t *)bufor_lcd);
if(Flagi.flaga_lcd)
{
lcd_locate(0, 0);
}
(*menu_ptr->funkcja)(bufor_lcd); //WskaŸnik na funkcje dla danej pozycji menu
}
if(Flagi.flaga_klawiatura==1)
{
if (key_code == PRZYCISK_PRAWO)
{
if(menu_ptr->next!=NULL)
{
Flagi.flaga_lcd=1;
menu_ptr=menu_ptr->next;
}
}
else if (key_code == PRZYCISK_LEWO)
{
if(menu_ptr->prev!=NULL)
{
Flagi.flaga_lcd=1;
menu_ptr=menu_ptr->prev;
}
}
else if (key_code == PRZYCISK_DOL)
{
if(menu_ptr->down!=NULL)
{
Flagi.flaga_lcd=1;
menu_ptr=menu_ptr->down;
}
}
else if (key_code == PRZYCISK_GORA)
{
if(menu_ptr->up!=NULL)
{
Flagi.flaga_lcd=1;
menu_ptr=menu_ptr->up;
}
}
}
if(menu_ptr->funkcja!=NULL)
Flagi.flaga_menu_func=1;
else
Flagi.flaga_menu_func=0;
#endif // _EXT_EEPROM_EMPTY
}
}
void M0(char *str)
{
static uint8_t state=0, term_state=0, i=0;
static uint32_t cnt=0, offset_cnt=0;
static char buf[41], buf_lcd[9];
if(Flagi.flaga_lcd)
{
lcd_locate(0, 0);
lcd_str(str);
lcd_locate(1, 0);
lcd_str(str);
Flagi.flaga_lcd=0;
}
if (Flagi.flaga_term)
{
switch(term_state)
{
case 0:
DS18X20_start_meas( DS18X20_POWER_EXTERN, NULL );
term_state=1;
break;
case 1:
if( DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_fract_bits) ) display_temp(0);
else {
lcd_locate(0,0);
lcd_str("term. error "); /* wyœwietlamy informacjê o b³êdzie jeœli np brak czujnika lub b³¹d odczytu */
}
term_state=0;
break;
}
Flagi.flaga_term=0;
}
if(Flagi.flaga_rtc)
{
pobierz_czas(&czas);
pobierz_date(&data);
Flagi.flaga_rtc=0;
}
lcd_locate(1,0);
if( czas.godziny < 10 ) lcd_char('0');
lcd_int(czas.godziny);
lcd_char(':');
if( czas.minuty < 10 ) lcd_char('0');
lcd_int(czas.minuty);
lcd_char(':');
if( czas.sekundy < 10 ) lcd_char('0');
lcd_int(czas.sekundy);
switch(state)
{
case 0:
state=1;
if(i>= 2*strlen(buf))
i=0;
lcd_wyswietl_date(&data, buf, 0);
fifo_bufor_lcd(buf, i, strlen(buf));
lcd_locate(1,8);
strncpy(buf_lcd,buf,sizeof(buf_lcd)-1);
lcd_str(buf_lcd);
cli();
cnt=25000;
offset_cnt=licznik;
sei();
break;
case 1:
if(cnt<=licznik-offset_cnt)
{
i++;
state=0;
}
break;
}
}
void updateOWSensors()
{
#ifdef OW_DEBUG
printf_P(PSTR("Update onewire \r\n"));
#endif
uint8_t subzero, cel, cel_frac_bits;
uint16_t maalt;
if (!DS18B20Conv) {
DS18B20Conv = true;
for (uint8_t active_OW_channel = 1; active_OW_channel <= 3;
active_OW_channel++) {
OW_selectPort(active_OW_channel);
DS18X20_start_meas(DS18X20_POWER_PARASITE, NULL);
}
} else {
DS18B20Conv = false;
for (uint8_t active_OW_channel = 1; active_OW_channel <= 3;
active_OW_channel++) {
OW_selectPort(active_OW_channel);
#ifdef OW_DEBUG
printf_P(PSTR("Scanner for onewire sensore paa %d\r\n"), active_OW_channel);
#endif
int nSensors = search_sensors(MAXSENSORS); //Finder alle sensore (op til max)
#ifdef OW_DEBUG
printf("Found %d sensors \r\n", nSensors);
#endif
for (int i = 0; i < nSensors; i++) {
if (sensorScan[i * OW_ROMCODE_SIZE + 0] == 0x10
|| sensorScan[i * OW_ROMCODE_SIZE + 0] == 0x28) {
uint8_t sensorID[OW_ROMCODE_SIZE];
for (uint8_t o = 0; o < OW_ROMCODE_SIZE; o++)
sensorID[o] = sensorScan[i * OW_ROMCODE_SIZE + o];
if (DS18X20_read_meas(sensorID, &subzero, &cel, &cel_frac_bits,
&maalt) == DS18X20_OK) {
#ifdef OW_DEBUG
int frac =
cel_frac_bits *
DS18X20_FRACCONV; //Ganger de sidste par bits, med det step DS18B20 bruger
#endif
char sign = (subzero) ? '-' : '+';
uint16_t pos = findSensor(
sensorScan[i * OW_ROMCODE_SIZE + FAMILY],
sensorScan[i * OW_ROMCODE_SIZE + ID1],
sensorScan[i * OW_ROMCODE_SIZE + ID2],
sensorScan[i * OW_ROMCODE_SIZE + ID3],
sensorScan[i * OW_ROMCODE_SIZE + ID4],
sensorScan[i * OW_ROMCODE_SIZE + ID5],
sensorScan[i * OW_ROMCODE_SIZE + ID6],
sensorScan[i * OW_ROMCODE_SIZE + CRC]
);
sensorValues[(pos * SENSORSIZE) + VALUE1] = cel;
sensorValues[(pos * SENSORSIZE) + VALUE2] = cel_frac_bits;
sensorValues[(pos * SENSORSIZE) + SIGN] = sign;
#ifdef OW_DEBUG
printf_P(PSTR("Sensor# %d (%02X%02X%02X%02X%02X%02X%02X%02X) = : %c%d.%04d\r\n"),
i + 1,
sensorValues[(pos * SENSORSIZE) + FAMILY],
sensorValues[(pos * SENSORSIZE) + ID1],
sensorValues[(pos * SENSORSIZE) + ID2],
sensorValues[(pos * SENSORSIZE) + ID3],
sensorValues[(pos * SENSORSIZE) + ID4],
sensorValues[(pos * SENSORSIZE) + ID5],
sensorValues[(pos * SENSORSIZE) + ID6],
sensorValues[(pos * SENSORSIZE) + CRC],
sensorValues[(pos * SENSORSIZE) + SIGN],
sensorValues[(pos * SENSORSIZE) + VALUE1],
frac
);
#endif
} else
printf_P(PSTR("CRC Error (lost connection?)"));
}
}
}
}
}
/*-----------------------------------------------------------------------------
* Main Program
*---------------------------------------------------------------------------*/
int main(void) {
uint8_t nSensors, i;
uint8_t subzero, cel, cel_frac_bits;
Mcu_Init();
Timebase_Init();
Serial_Init();
sei();
printf( "\nDS18X20 1-Wire-Reader\n" );
printf( "-----------------------" );
nSensors = search_sensors();
printf( "%i DS18X20 Sensor(s) available:\n", (int) nSensors );
for (i=0; i<nSensors; i++) {
printf("Sensor# %i is a ", (int) i+1);
if ( gSensorIDs[i][0] == DS18S20_ID)
printf("DS18S20/DS1820");
else printf("DS18B20");
printf(" which is ");
if ( DS18X20_get_power_status( &gSensorIDs[i][0] ) ==
DS18X20_POWER_PARASITE )
printf( "parasite" );
else printf( "externally" );
printf( " powered\n" );
}
printf("CanInit...\n");
if (Can_Init() != CAN_OK) {
printf("FAILED!\n");
}
else {
printf("OK!\n");
}
uint32_t timeStamp = 0;
Can_Message_t txMsg;
Can_Message_t rxMsg;
txMsg.DataLength = 2;
txMsg.Id = 0;
txMsg.RemoteFlag = 0;
txMsg.ExtendedFlag = 1;
/* main loop */
while (1) {
/* service the CAN routines */
Can_Service();
/* check if any messages have been received */
while (Can_Receive(&rxMsg) == CAN_OK) {
}
/* check temperature and send on CAN once every other second */
if (Timebase_PassedTimeMillis(timeStamp) >= 2000) {
timeStamp = Timebase_CurrentTime();
if ( DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL ) == DS18X20_OK) {
printf("Measuring temperature... ");
delay_ms(DS18B20_TCONV_12BIT);
for ( i=0; i<nSensors; i++ ) {
if ( DS18X20_read_meas( &gSensorIDs[i][0], &subzero,
&cel, &cel_frac_bits) == DS18X20_OK ) {
//txMsg.Data.bytes[0] = subzero;
if (subzero) {
txMsg.Data.bytes[i*2] = -cel;
txMsg.Data.bytes[i*2+1] = ~(cel_frac_bits<<4);
} else {
txMsg.Data.bytes[i*2] = cel;
txMsg.Data.bytes[i*2+1] = (cel_frac_bits<<4);
}
}
else printf("CRC Error (lost connection?)\n");
}
txMsg.DataLength = nSensors*2;
printf("sending...\n");
/* send txMsg */
Can_Send(&txMsg);
}
else printf("Start meas. failed (short circuit?)\n");
}
}
return 0;
}
/**
* \ingroup usartcmdline
* \b OWREAD-Befehl DS18x20 auf Bus suchen und anzeigen
*/
int16_t command_OWlookup(char *outbuffer)
{
if (outbuffer) // nur bei USART
return cmd_502(outbuffer);
#if USE_OW
uint8_t i;
uint8_t diff, nSens;
uint16_t TWert;
uint8_t subzero, cel, cel_frac_bits;
uint8_t gSensorIDs[MAXLOOKUP][OW_ROMCODE_SIZE];
usart_write("\r\nScanning Bus for DS18X20");
nSens = 0;
for( diff = OW_SEARCH_FIRST;
diff != OW_LAST_DEVICE && nSens < MAXLOOKUP ; )
{
DS18X20_find_sensor( &diff, &gSensorIDs[nSens][0] );
if( diff == OW_PRESENCE_ERR ) {
usart_write("\r\nNo Sensor found");
break;
}
if( diff == OW_DATA_ERR ) {
usart_write("\r\nBus Error");
break;
}
nSens++;
}
usart_write("\n\r%i 1-Wire Sensoren gefunden.\r\n", nSens);
// for (i=0; i<nSens; i++) {
// // set 10-bit Resolution - Alarm-low-T 0 - Alarm-high-T 85
// DS18X20_write_scratchpad( &gSensorIDs[i][0] , 0, 85, DS18B20_12_BIT);
// }
for (i=0; i<nSens; i++) {
usart_write("\r\n#%i ist ein ",(int) i+1);
if ( gSensorIDs[i][0] == DS18S20_ID)
usart_write("DS18S20/DS1820");
else usart_write("DS18B20");
usart_write(" mit ");
if ( DS18X20_get_power_status( &gSensorIDs[i][0] ) ==
DS18X20_POWER_PARASITE )
usart_write( "parasitaerer" );
else usart_write( "externer" );
usart_write( " Spannungsversorgung. " );
// T messen
if ( DS18X20_start_meas( DS18X20_POWER_PARASITE, &gSensorIDs[i][0] ) == DS18X20_OK ) {
_delay_ms(DS18B20_TCONV_12BIT);
if ( DS18X20_read_meas( &gSensorIDs[i][0], &subzero,
&cel, &cel_frac_bits) == DS18X20_OK ) {
DS18X20_show_id_uart( &gSensorIDs[i][0], OW_ROMCODE_SIZE );
TWert = DS18X20_temp_to_decicel(subzero, cel, cel_frac_bits);
usart_write(" %i %i.%4i C %i",subzero, cel, cel_frac_bits,TWert);
}
else usart_write(" CRC Error (lost connection?)");
}
else usart_write(" *** Messung fehlgeschlagen. (Kurzschluss?) ***");
}
#endif
return 0;
}
/*-----------------------------------------------------------------------------
* Main Program
*---------------------------------------------------------------------------*/
int main(void) {
#if defined(USE_DS18S20)
uint8_t nSensors, i;
uint8_t subzero, cel, cel_frac_bits;
uint32_t timeStamp_DS = 0, timeStamp_DS_del = 0;
/* This is to identify and give the sensors correct ID
* TODO read ds18s20 serial id and that way give the "can id" */
uint16_t sensor_ds_id[] = {TEMPSENSORID_1, TEMPSENSORID_2, TEMPSENSORID_3, TEMPSENSORID_4};
#endif
#if defined(USE_TC1047)
uint32_t tcTemperature = 0, timeStamp_TC = 0;
adcTemperatureInit();
#endif
#if defined(USE_LDR)
uint32_t timeStamp_LDR = 0;
uint8_t ldr;
LDR_SensorInit();
#endif
sei();
Timebase_Init();
Can_Message_t txMsg;
txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) | (NODE_ID << CAN_SHIFT_NMT_SID);
txMsg.DataLength = 4;
txMsg.RemoteFlag = 0;
txMsg.ExtendedFlag = 1;
txMsg.Data.words[0] = APP_TYPE;
txMsg.Data.words[1] = APP_VERSION;
BIOS_CanSend(&txMsg);
#if defined(USE_DS18S20)
/* Make sure there is no more then 4 DS-sensors. */
nSensors = search_sensors();
#endif
txMsg.DataLength = 2;
/* main loop */
while (1) {
#if defined(USE_DS18S20)
/* check temperature and send on CAN */
if( Timebase_PassedTimeMillis(timeStamp_DS) >= DS_SEND_PERIOD ){
timeStamp_DS = Timebase_CurrentTime();
if ( DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL ) == DS18X20_OK) {
delay_ms(DS18B20_TCONV_12BIT);
for ( i=0; i<nSensors; i++ ) {
if ( DS18X20_read_meas( &gSensorIDs[i][0], &subzero, &cel, &cel_frac_bits) == DS18X20_OK ) {
if (subzero) {
txMsg.Data.bytes[0] = -cel-1;
txMsg.Data.bytes[1] = ~(cel_frac_bits<<4);
}else{
txMsg.Data.bytes[0] = cel;
txMsg.Data.bytes[1] = (cel_frac_bits<<4);
}
}
/* Delay */
timeStamp_DS_del = Timebase_CurrentTime();
while(Timebase_PassedTimeMillis(timeStamp_DS_del) < DS_SEND_DELAY){}
/* send txMsg */
txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) | (SNS_TYPE_TEMPERATURE << CAN_SHIFT_SNS_TYPE) | (NODE_ID << CAN_SHIFT_SNS_SID));
txMsg.Id |= ( sensor_ds_id[i] << CAN_SHIFT_SNS_ID); /* Set sensor id */
BIOS_CanSend(&txMsg);
}
}
}
#endif
#if defined(USE_TC1047)
#error tc1047 id is still not correct // FIXME
/* check temperature and send on CAN */
if( bios->timebase_get() - timeStamp_TC >= TC_SEND_PERIOD ){
timeStamp_TC = bios->timebase_get();
tcTemperature = getTC1047temperature();
txMsg.Data.bytes[0] = tcTemperature & 0x00FF;
txMsg.Data.bytes[1] = (tcTemperature & 0xFF00)>>8;
txMsg.DataLength = 2;
txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) | (SNS_TYPE_TEMPERATURE << CAN_SHIFT_SNS_TYPE) | (NODE_ID << CAN_SHIFT_SNS_SID));
txMsg.Id |= (TEMPSENSORID_5 << CAN_SHIFT_SNS_ID); // sätt korrekt sensorid
BIOS_CanSend(&txMsg);
}
#endif
#if defined(USE_LDR)
/* check light and send on CAN */
if( Timebase_PassedTimeMillis(timeStamp_LDR) >= LDR_SEND_PERIOD ){
timeStamp_LDR = Timebase_CurrentTime();
ldr = (uint8_t)LDR_GetData(0);
txMsg.Data.bytes[0] = ldr;
txMsg.DataLength = 1;
txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) | (SNS_TYPE_LIGHT << CAN_SHIFT_SNS_TYPE) | (LIGHTSENSORID_1 << CAN_SHIFT_SNS_ID) | (NODE_ID << CAN_SHIFT_SNS_SID));
BIOS_CanSend(&txMsg);
}
#endif
}
int main(void)
{
//Konfiguration der Ausgänge bzw. Eingänge
//definition erfolgt in der config.h
DDRA = OUTA;
#if USE_SER_LCD
DDRC = OUTC;
#else
DDRC = OUTC;
#if PORTD_SCHALT
DDRD = OUTD;
#endif
#endif
// RoBue:
// Pullups einschalten
PORTA = (1 << PORTA0) | (1 << PORTA1) | (1 << PORTA2) | (1 << PORTA3) | (1 << PORTA4) | (1 << PORTA5) | (1 << PORTA6);
unsigned long a;
#if USE_SERVO
servo_init ();
#endif //USE_SERVO
usart_init(BAUDRATE); // setup the UART
#if USE_ADC
ADC_Init();
#endif
usart_write("\n\rSystem Ready\n\r");
usart_write("Compiliert am "__DATE__" um "__TIME__"\r\n");
usart_write("Compiliert mit GCC Version "__VERSION__"\r\n");
for(a=0;a<1000000;a++){asm("nop");};
//Applikationen starten
stack_init();
httpd_init();
telnetd_init();
//Spielerrei mit einem LCD
#if USE_SER_LCD
udp_lcd_init();
lcd_init();
// RoBue:
// LCD-Ausgaben:
lcd_clear();
lcd_print(0,0,"*AVR-NET-IO "Version"*");
lcd_print(2,0,"Counter: ");
lcd_print(3,0,"Zeit:");
#endif
//Ethernetcard Interrupt enable
ETH_INT_ENABLE;
#if USE_SER_LCD
// RoBue:
// IP auf LCD
lcd_print(1,0,"%1i.%1i.%1i.%1i",myip[0],myip[1],myip[2],myip[3]);
#endif
//Globale Interrupts einschalten
sei();
#if USE_CAM
#if USE_SER_LCD
lcd_print(1,0,"CAMERA INIT");
#endif //USE_SER_LCD
for(a=0;a<2000000;a++){asm("nop");};
cam_init();
max_bytes = cam_picture_store(CAM_RESELUTION);
#if USE_SER_LCD
back_light = 0;
lcd_print(1,0,"CAMERA READY");
#endif //USE_SER_LCD
#endif // -> USE_CAM
#if USE_NTP
ntp_init();
ntp_request();
#endif //USE_NTP
#if USE_WOL
wol_init();
#endif //USE_WOL
#if USE_MAIL
mail_client_init();
#endif //USE_MAIL
// Startwerte für ow_array setzen
#if USE_OW
uint8_t i = 0;
for (i=0;i<MAXSENSORS;i++){
ow_array[i]=OW_START;
}
for (i=MAXSENSORS;i<MAXSENSORS*3;i++){
ow_array[i]=OW_MINMAX;
}
DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL );
for(a=0;a<1000000;a++){asm("nop");};
auslesen = 0;
minmax = 1;
#endif
//Hauptschlfeife
// *************
while(1)
{
#if USE_ADC
ANALOG_ON;
#endif
eth_get_data();
//Terminalcommandos auswerten
if (usart_status.usart_ready){
usart_write("\r\n");
if(extract_cmd(&usart_rx_buffer[0]))
{
usart_write("Ready\r\n\r\n");
}
else
{
usart_write("ERROR\r\n\r\n");
}
usart_status.usart_ready =0;
}
// RoBue:
// Counter ausgeben
#if USE_SER_LCD
lcd_print(2,9,"%4i",var_array[MAX_VAR_ARRAY-1]);
#endif
// RoBue:
// Uhrzeit bestimmen und auf LCD ausgeben
hh = (time/3600)%24;
mm = (time/60)%60;
ss = time%60;
#if USE_SER_LCD
lcd_print(3,7,"%2i:%2i:%2i",hh,mm,ss);
#endif
#if USE_HIH4000
var_array[VA_OUT_HIH4000] = ((var_array[VA_IN_HIH4000]-160)/6);
#endif
#if USE_OW
// RoBue:
// Zurücksetzen der Min/Max-Werte um 00:00 Uhr einschalten
if (( hh == 00 )&&( mm == 00 )) {
minmax = 1;
}
#endif
// ******************************************************************
// RoBue:
// 1-Wire-Temperatursensoren (DS18B20) abfragen
// ******************************************************************
#if USE_OW
uint8_t i = 0;
uint8_t subzero, cel, cel_frac_bits;
uint8_t tempID[OW_ROMCODE_SIZE];
// Messen bei ss=5,15,25,35,45,55
if ( ss%10 == 5 ) {
// Messen?
if ( messen == 1 ) {
// RoBue Anmerkung:
// Hiermit werden ALLE Sensoren zum Messen aufgefordert.
// Aufforderung nur bestimmter Sensoren:
// "NULL" durch "tempID" ersetzen
// RoBue Testausgabe UART:
// usart_write("Starte Messvorgang ...\r\n");
DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL );
// Kein Messen mehr bis ss=5,15,25,35,45,55
messen = 0;
// Jetzt kann ausgelesen werden
auslesen = 1;
} // -> if messen
} // -> if ss
// Auslesen bei ss=8,18,28,38,48,58
if ( ss%10 == 8 ) {
// Auslesen?
if ( auslesen == 1 ) {
// (erste) ID ins RAM holen
memcpy_P(tempID,DS18B20IDs[0],OW_ROMCODE_SIZE);
while ( tempID[0] != 0 ) {
//while ( tempID[0] == 0x10 ) {
// RoBue Anmerkung:
// Hiermit wird jeweils ein einzelner Sensor ausgelesen
// und die Temperatur in ow_array abgelegt.
// Achtung:
// Pro Sekunde können max. ca. 10 Sensoren ausgelesen werden!
if ( DS18X20_read_meas( tempID, &subzero,&cel, &cel_frac_bits) == DS18X20_OK ) {
ow_array[i] = DS18X20_temp_to_decicel(subzero, cel, cel_frac_bits);
// Minuswerte:
if ( subzero )
ow_array[i] *= (-1);
// min/max:
if ( minmax == 1 ) {
// Zurücksetzen der Min/Max_Werte 1x/Tag
// auf die gerade aktuellen Temperaturen
ow_array[i+MAXSENSORS] = ow_array[i];
ow_array[i+MAXSENSORS*2] = ow_array[i];
}
else {
// Abgleich der Temp. mit den gespeicherten Min/Max-Werten
if (ow_array[i] < ow_array[i+MAXSENSORS])
ow_array[i+MAXSENSORS] = ow_array[i];
if (ow_array[i] > ow_array[i+MAXSENSORS*2])
ow_array[i+MAXSENSORS*2] = ow_array[i];
}
//TWert = DS18X20_temp_to_decicel(subzero, cel, cel_frac_bits);
//ow_array[i] = TWert;
// RoBue:
// Testausgabe UART:
// usart_write("%2i:%2i:%2i: Temperatur: %3i Grad\r\n",hh,mm,ss,ow_array[i]/10);
} // -> if
else {
usart_write("\r\nCRC Error (lost connection?) ");
DS18X20_show_id_uart( tempID, OW_ROMCODE_SIZE );
} // -> else
// nächste ID ins RAM holen
memcpy_P(tempID,DS18B20IDs[++i],OW_ROMCODE_SIZE);
} // -> while
// RoBue:
// Temperatur auf LCD ausgeben (IP von Startausgabe (s.o.) wird Überschrieben)
#if USE_SER_LCD
lcd_print(1,0,"Tmp: ");
lcd_print(1,5,"%i C",ow_array[0]/10);
lcd_print(1,11,"%i C",ow_array[1]/10);
#endif
} // -> if auslesen
auslesen = 0; // Auslesen vorläufig abschalten
messen = 1; // Messen wieder ermöglichen
minmax = 0; // Min/Max-Werte vergleichen
} // -> if ss
#endif
// **********************************************************
// RoBue:
// Schalten der Ports (PORTC) durch bestimmte Bedingungen
// - Temperatur (1-Wire -> PORTA7) mit/ohne Lüftungsautomatik
// - digital, analog (-> PORTA0-6)
// - Zeit
// **********************************************************
// Automatik eingeschaltet?
if ( var_array[9] == 1 ) {
if ( ss%10 == 1 ) {
schalten = 1;
}
// Abfrage bei ss =0,10,20,30,40,50
if ( ss%10 == 0 ) {
if ( schalten == 1 ) {
// RoBue Testausgabe UART:
// usart_write("%2i:%2i: Schaltfunktionen testen ...\r\n",hh,mm);
// PORTC0:
// Über Temperatur: var_array[10] - Sensor0
if (( ow_array[0]/10 < var_array[10] ) || ( ow_array[0] < 0 )) {
PORTC |= (1 << PC0); // ein
//
// Über Temperatur: var_array[10] - Sensor0 - PORTA0
// if ((PINA&0b00000001) == 0 ) { // PORTA0: Fenster geschlossen?
// if (( ow_array[0]/10 < var_array[10] ) || ( ow_array[0] < 0 )) {
// PORTC |= (1 << PC0); // ein
// }
// else {
// PORTC &= ~(1 << PC0); // aus
// }
}
else {
PORTC &= ~(1 << PC0); // aus
}
// PORTC1:
// Über Temperatur: var_array[11] - Sensor1
// if (( ow_array[1]/10 < var_array[11] ) || ( ow_array[1] < 0 )) {
// PORTC |= (1 << PC1); // ein
//
// Über Temperatur: var_array[11] - Sensor1 - PORTA1
if ((PINA&0b00000010) == 0 ) { // PORTA1: Fenster geschlossen?
if (( ow_array[1]/10 < var_array[11] ) || ( ow_array[1] < 0 )) {
PORTC |= (1 << PC1); // ein
}
else {
PORTC &= ~(1 << PC1); // aus
}
}
else {
PORTC &= ~(1 << PC1); // aus
}
// PORTC2:
// Über Temperatur: var_array[12] - Sensor2
// if (( ow_array[2]/10 < var_array[12] ) || ( ow_array[2] < 0 )) {
// PORTC |= (1 << PC2); // ein
// Über Temperatur: var_array[12] - Sensor2 - PORTA2
// if ((PINA&0b00000100) == 0 ) { // PORTA2: Fenster geschlossen?
// if (( ow_array[2]/10 < var_array[12] ) || ( ow_array[2] < 0 )) {
// PORTC |= (1 << PC2); // ein
// }
// else {
// PORTC &= ~(1 << PC2); // aus
// }
//}
//else {
// PORTC &= ~(1 << PC2); // aus
//}
// PORTC4:
// Über 2 Temperaturen (Differenz)
// var_array[13] - Sensor3 Vorlauf, Sensor4 Ruecklauf
//
// z.B. Zirkulationspumpe für Warmwasser
// Achtung: Temp. von Sensor3 MUSS höher/gleich sein als Temp. von Sensor4
// Ansonsten laeuft die Pumpe immer
//
if ( (ow_array[3]/10 - ow_array[4]/10) >= var_array[14] ) {
PORTC |= (1 << PC4); // ein
}
else {
PORTC &= ~(1 << PC4); // aus
}
// PORTC6:
// Über Analogwert:
if ( var_array[6] > var_array[18] ) {
PORTC |= (1 << PC6); // ein
}
else {
PORTC &= ~(1 << PC6); // aus
}
// PORTC7:
// Über Zeit: ein/aus
if ( hh == var_array[20] ) {
if ( mm == var_array[21] ) {
PORTC |= (1 << PC7); // ein
}
}
if ( hh == var_array[22] ) {
if ( mm == var_array[23] ) {
PORTC &= ~(1 << PC7); // aus
}
}
schalten = 0; // Vorerst nicht mehr schalten
} // -> schalten == 1
} // -> if ss == ...
} // -> if var_array == 1
//Wetterdaten empfangen (Testphase)
#if GET_WEATHER
http_request ();
#endif
//Empfang von Zeitinformationen
#if USE_NTP
if(!ntp_timer){
ntp_timer = NTP_REFRESH;
ntp_request();
}
#endif //USE_NTP
//Versand von E-Mails
#if USE_MAIL
if (mail_enable == 1)
{
mail_enable = 0;
mail_send();
}
#endif //USE_MAIL
//Rechner im Netzwerk aufwecken
#if USE_WOL
if (wol_enable == 1)
{
wol_enable = 0;
wol_request();
}
#endif //USE_WOL
//USART Daten für Telnetanwendung?
telnetd_send_data();
}
return(0);
}
