WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/CanDS18S20/main.c


/**
 * DS18S20 over CAN program.
 *
 * @target  AVR
 * @date    2006-12-09
 * @author  Jimmy Myhrman, Anders Runeson
 *  
 * Högst experimentell, decimaldel fel vid negativ temperatur?
 * negativ temperatur helt otestad!
 *
 */
 
/*-----------------------------------------------------------------------------
 * Includes
 *---------------------------------------------------------------------------*/
/* system files */
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <stdio.h>
/* lib files */
#include <can.h>
#include <uart.h>
#include <timebase.h>
 
#include <onewire.h>
#include <ds18x20.h>
 
#include <delay.h>
 
 
 
#define MAXSENSORS 4
 
uint8_t gSensorIDs[MAXSENSORS][OW_ROMCODE_SIZE];
 
uint8_t search_sensors(void)
{
    uint8_t i;
    uint8_t id[OW_ROMCODE_SIZE];
    uint8_t diff, nSensors;
   
    printf( "\nScanning Bus for DS18X20\n" );
   
    nSensors = 0;
   
    for( diff = OW_SEARCH_FIRST;
        diff != OW_LAST_DEVICE && nSensors < MAXSENSORS ; )
    {
        DS18X20_find_sensor( &diff, &id[0] );
       
        if( diff == OW_PRESENCE_ERR ) {
            printf( "No Sensor found\n" );
            break;
        }
       
        if( diff == OW_DATA_ERR ) {
            printf( "Bus Error\n" );
            break;
        }
       
        for (i=0;i<OW_ROMCODE_SIZE;i++)
            gSensorIDs[nSensors][i]=id[i];
       
        nSensors++;
    }
   
    return nSensors;
}
 
 
 
/*-----------------------------------------------------------------------------
 * 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;
}
 

Rev 202	Rev 221
1	/**	1	/**
2	* DS18S20 over CAN program.	2	* DS18S20 over CAN program.
3	*	3	*
4	* @target AVR	4	* @target AVR
5	* @date 2006-12-09	5	* @date 2006-12-09
6	* @author Jimmy Myhrman, Anders Runeson	6	* @author Jimmy Myhrman, Anders Runeson
7	*	7	*
8	* Högst experimentell, decimaldel fel vid negativ temperatur?	8	* Högst experimentell, decimaldel fel vid negativ temperatur?
9	* negativ temperatur helt otestad!	9	* negativ temperatur helt otestad!
10	*	10	*
11	*/	11	*/
12		12
13	/*-----------------------------------------------------------------------------	13	/*-----------------------------------------------------------------------------
14	* Includes	14	* Includes
15	---------------------------------------------------------------------------/	15	---------------------------------------------------------------------------/
16	/* system files */	16	/* system files */
17	#include <avr/io.h>	17	#include <avr/io.h>
18	#include <avr/interrupt.h>	18	#include <avr/interrupt.h>
19	#include <avr/wdt.h>	19	#include <avr/wdt.h>
20	#include <stdio.h>	20	#include <stdio.h>
21	/* lib files */	21	/* lib files */
22	#include <can.h>	22	#include <can.h>
23	#include <uart.h>	23	#include <uart.h>
24	#include <timebase.h>	24	#include <timebase.h>
25		25
26	#include <onewire.h>	26	#include <onewire.h>
27	#include <ds18x20.h>	27	#include <ds18x20.h>
28		28
29	#include <delay.h>	29	#include <delay.h>
30		30
31		31
32		32
33	#define MAXSENSORS 4	33	#define MAXSENSORS 4
34		34
35	uint8_t gSensorIDs[MAXSENSORS][OW_ROMCODE_SIZE];	35	uint8_t gSensorIDs[MAXSENSORS][OW_ROMCODE_SIZE];
36		36
37	uint8_t search_sensors(void)	37	uint8_t search_sensors(void)
38	{	38	{
39	uint8_t i;	39	uint8_t i;
40	uint8_t id[OW_ROMCODE_SIZE];	40	uint8_t id[OW_ROMCODE_SIZE];
41	uint8_t diff, nSensors;	41	uint8_t diff, nSensors;
42		42
43	printf( "\nScanning Bus for DS18X20\n" );	43	printf( "\nScanning Bus for DS18X20\n" );
44		44
45	nSensors = 0;	45	nSensors = 0;
46		46
47	for( diff = OW_SEARCH_FIRST;	47	for( diff = OW_SEARCH_FIRST;
48	diff != OW_LAST_DEVICE && nSensors < MAXSENSORS ; )	48	diff != OW_LAST_DEVICE && nSensors < MAXSENSORS ; )
49	{	49	{
50	DS18X20_find_sensor( &diff, &id[0] );	50	DS18X20_find_sensor( &diff, &id[0] );
51		51
52	if( diff == OW_PRESENCE_ERR ) {	52	if( diff == OW_PRESENCE_ERR ) {
53	printf( "No Sensor found\n" );	53	printf( "No Sensor found\n" );
54	break;	54	break;
55	}	55	}
56		56
57	if( diff == OW_DATA_ERR ) {	57	if( diff == OW_DATA_ERR ) {
58	printf( "Bus Error\n" );	58	printf( "Bus Error\n" );
59	break;	59	break;
60	}	60	}
61		61
62	for (i=0;i<OW_ROMCODE_SIZE;i++)	62	for (i=0;i<OW_ROMCODE_SIZE;i++)
63	gSensorIDs[nSensors][i]=id[i];	63	gSensorIDs[nSensors][i]=id[i];
64		64
65	nSensors++;	65	nSensors++;
66	}	66	}
67		67
68	return nSensors;	68	return nSensors;
69	}	69	}
70		70
71		71
72		72
73	/*-----------------------------------------------------------------------------	73	/*-----------------------------------------------------------------------------
74	* Main Program	74	* Main Program
75	---------------------------------------------------------------------------/	75	---------------------------------------------------------------------------/
76	int main(void) {	76	int main(void) {
77	uint8_t nSensors, i;	77	uint8_t nSensors, i;
78	uint8_t subzero, cel, cel_frac_bits;	78	uint8_t subzero, cel, cel_frac_bits;
79		79
-		80	Mcu_Init();
80	Timebase_Init();	81	Timebase_Init();
81	Serial_Init();	82	Serial_Init();
82	#if defined(__AVR_ATmega88__)	-
83	// set the clock speed to 8MHz	-
84	// set the clock prescaler. First write CLKPCE to enable setting of clock the	-
85	// next four instructions.	-
86	CLKPR=(1<<CLKPCE);	-
87	CLKPR=0; // 8 MHZ	-
88	#endif	-
89		83
90	sei();	84	sei();
91		85
92	printf( "\nDS18X20 1-Wire-Reader\n" );	86	printf( "\nDS18X20 1-Wire-Reader\n" );
93	printf( "-----------------------" );	87	printf( "-----------------------" );
94	nSensors = search_sensors();	88	nSensors = search_sensors();
95	printf( "%i DS18X20 Sensor(s) available:\n", (int) nSensors );	89	printf( "%i DS18X20 Sensor(s) available:\n", (int) nSensors );
96		90
97	for (i=0; i<nSensors; i++) {	91	for (i=0; i<nSensors; i++) {
98	printf("Sensor# %i is a ", (int) i+1);	92	printf("Sensor# %i is a ", (int) i+1);
99	if ( gSensorIDs[i][0] == DS18S20_ID)	93	if ( gSensorIDs[i][0] == DS18S20_ID)
100	printf("DS18S20/DS1820");	94	printf("DS18S20/DS1820");
101	else printf("DS18B20");	95	else printf("DS18B20");
102	printf(" which is ");	96	printf(" which is ");
103	if ( DS18X20_get_power_status( &gSensorIDs[i][0] ) ==	97	if ( DS18X20_get_power_status( &gSensorIDs[i][0] ) ==
104	DS18X20_POWER_PARASITE )	98	DS18X20_POWER_PARASITE )
105	printf( "parasite" );	99	printf( "parasite" );
106	else printf( "externally" );	100	else printf( "externally" );
107	printf( " powered\n" );	101	printf( " powered\n" );
108	}	102	}
109		103
110	printf("CanInit...\n");	104	printf("CanInit...\n");
111	if (Can_Init() != CAN_OK) {	105	if (Can_Init() != CAN_OK) {
112	printf("FAILED!\n");	106	printf("FAILED!\n");
113	}	107	}
114	else {	108	else {
115	printf("OK!\n");	109	printf("OK!\n");
116	}	110	}
117		111
118	uint32_t timeStamp = 0;	112	uint32_t timeStamp = 0;
119		113
120	Can_Message_t txMsg;	114	Can_Message_t txMsg;
121	Can_Message_t rxMsg;	115	Can_Message_t rxMsg;
122		116
123	txMsg.DataLength = 2;	117	txMsg.DataLength = 2;
124	txMsg.Id = 0;	118	txMsg.Id = 0;
125	txMsg.RemoteFlag = 0;	119	txMsg.RemoteFlag = 0;
126	txMsg.ExtendedFlag = 1;	120	txMsg.ExtendedFlag = 1;
127		121
128	/* main loop */	122	/* main loop */
129	while (1) {	123	while (1) {
130	/* service the CAN routines */	124	/* service the CAN routines */
131	Can_Service();	125	Can_Service();
132		126
133	/* check if any messages have been received */	127	/* check if any messages have been received */
134	while (Can_Receive(&rxMsg) == CAN_OK) {	128	while (Can_Receive(&rxMsg) == CAN_OK) {
135		129
136	}	130	}
137		131
138	/* check temperature and send on CAN once every other second */	132	/* check temperature and send on CAN once every other second */
139	if (Timebase_PassedTimeMillis(timeStamp) >= 2000) {	133	if (Timebase_PassedTimeMillis(timeStamp) >= 2000) {
140	timeStamp = Timebase_CurrentTime();	134	timeStamp = Timebase_CurrentTime();
141		135
142	if ( DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL ) == DS18X20_OK) {	136	if ( DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL ) == DS18X20_OK) {
143	printf("Measuring temperature... ");	137	printf("Measuring temperature... ");
144	delay_ms(DS18B20_TCONV_12BIT);	138	delay_ms(DS18B20_TCONV_12BIT);
145	for ( i=0; i<nSensors; i++ ) {	139	for ( i=0; i<nSensors; i++ ) {
146	if ( DS18X20_read_meas( &gSensorIDs[i][0], &subzero,	140	if ( DS18X20_read_meas( &gSensorIDs[i][0], &subzero,
147	&cel, &cel_frac_bits) == DS18X20_OK ) {	141	&cel, &cel_frac_bits) == DS18X20_OK ) {
148		142
149	//txMsg.Data.bytes[0] = subzero;	143	//txMsg.Data.bytes[0] = subzero;
150	if (subzero) {	144	if (subzero) {
151	txMsg.Data.bytes[i*2] = -cel;	145	txMsg.Data.bytes[i*2] = -cel;
152	txMsg.Data.bytes[i*2+1] = ~(cel_frac_bits<<4);	146	txMsg.Data.bytes[i*2+1] = ~(cel_frac_bits<<4);
153	} else {	147	} else {
154	txMsg.Data.bytes[i*2] = cel;	148	txMsg.Data.bytes[i*2] = cel;
155	txMsg.Data.bytes[i*2+1] = (cel_frac_bits<<4);	149	txMsg.Data.bytes[i*2+1] = (cel_frac_bits<<4);
156	}	150	}
157		151
158	}	152	}
159	else printf("CRC Error (lost connection?)\n");	153	else printf("CRC Error (lost connection?)\n");
160	}	154	}
161		155
162	txMsg.DataLength = nSensors*2;	156	txMsg.DataLength = nSensors*2;
163	printf("sending...\n");	157	printf("sending...\n");
164	/* send txMsg */	158	/* send txMsg */
165	Can_Send(&txMsg);	159	Can_Send(&txMsg);
166	}	160	}
167	else printf("Start meas. failed (short circuit?)\n");	161	else printf("Start meas. failed (short circuit?)\n");
168		162
169	}	163	}
170	}	164	}
171		165
172	return 0;	166	return 0;
173	}	167	}
174		168

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/CanDS18S20/main.c @ 261 – Rev 202 → 221