Subversion Repositories HomeAutomation

Rev

Rev 167 | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | SVN | RSS feed

Rev 167 Rev 169
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 
#include <inttypes.h>
 - 
 
31 
 
 30 
 
32 
#include <eqlazer_funcdefs.h>
 - 
 
- 
 
 31 
 
33 
 
 32 
 
34 
#define MAXSENSORS 4
 33 
#define MAXSENSORS 4
35 
 
 34 
 
36 
uint8_t gSensorIDs[MAXSENSORS][OW_ROMCODE_SIZE];
 35 
uint8_t gSensorIDs[MAXSENSORS][OW_ROMCODE_SIZE];
37 
 
 36 
 
38 
uint8_t search_sensors(void)
 37 
uint8_t search_sensors(void)
39 
{
 38 
{
40 
    uint8_t i;
 39 
    uint8_t i;
41 
    uint8_t id[OW_ROMCODE_SIZE];
 40 
    uint8_t id[OW_ROMCODE_SIZE];
42 
    uint8_t diff, nSensors;
 41 
    uint8_t diff, nSensors;
43 
   
 42 
   
44 
    printf( "\nScanning Bus for DS18X20\n" );
 43 
    printf( "\nScanning Bus for DS18X20\n" );
45 
   
 44 
   
46 
    nSensors = 0;
 45 
    nSensors = 0;
47 
   
 46 
   
48 
    for( diff = OW_SEARCH_FIRST;
 47 
    for( diff = OW_SEARCH_FIRST;
49 
        diff != OW_LAST_DEVICE && nSensors < MAXSENSORS ; )
 48 
        diff != OW_LAST_DEVICE && nSensors < MAXSENSORS ; )
50 
    {
 49 
    {
51 
        DS18X20_find_sensor( &diff, &id[0] );
 50 
        DS18X20_find_sensor( &diff, &id[0] );
52 
       
 51 
       
53 
        if( diff == OW_PRESENCE_ERR ) {
 52 
        if( diff == OW_PRESENCE_ERR ) {
54 
            printf( "No Sensor found\n" );
 53 
            printf( "No Sensor found\n" );
55 
            break;
 54 
            break;
56 
        }
 55 
        }
57 
       
 56 
       
58 
        if( diff == OW_DATA_ERR ) {
 57 
        if( diff == OW_DATA_ERR ) {
59 
            printf( "Bus Error\n" );
 58 
            printf( "Bus Error\n" );
60 
            break;
 59 
            break;
61 
        }
 60 
        }
62 
       
 61 
       
63 
        for (i=0;i<OW_ROMCODE_SIZE;i++)
 62 
        for (i=0;i<OW_ROMCODE_SIZE;i++)
64 
            gSensorIDs[nSensors][i]=id[i];
 63 
            gSensorIDs[nSensors][i]=id[i];
65 
       
 64 
       
66 
        nSensors++;
 65 
        nSensors++;
67 
    }
 66 
    }
68 
   
 67 
   
69 
    return nSensors;
 68 
    return nSensors;
70 
}
 69 
}
- 
 
 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 
    Timebase_Init();
 80 
    Timebase_Init();
81 
    Serial_Init();
 81 
    Serial_Init();
82 
    sei();
 82 
    sei();
83 
   
 83 
   
84 
    printf( "\nDS18X20 1-Wire-Reader\n" );
 84 
    printf( "\nDS18X20 1-Wire-Reader\n" );
85 
    printf( "-----------------------" );
 85 
    printf( "-----------------------" );
86 
    nSensors = search_sensors();
 86 
    nSensors = search_sensors();
87 
    printf( "%i DS18X20 Sensor(s) available:\n", (int) nSensors );
 87 
    printf( "%i DS18X20 Sensor(s) available:\n", (int) nSensors );
88 
   
 88 
   
89 
    for (i=0; i<nSensors; i++) {
 89 
    for (i=0; i<nSensors; i++) {
90 
        printf("Sensor# %i is a ", (int) i+1);
 90 
        printf("Sensor# %i is a ", (int) i+1);
91 
        if ( gSensorIDs[i][0] == DS18S20_ID)
 91 
        if ( gSensorIDs[i][0] == DS18S20_ID)
92 
            printf("DS18S20/DS1820");
 92 
            printf("DS18S20/DS1820");
93 
        else printf("DS18B20");
 93 
        else printf("DS18B20");
94 
        printf(" which is ");
 94 
        printf(" which is ");
95 
        if ( DS18X20_get_power_status( &gSensorIDs[i][0] ) ==
 95 
        if ( DS18X20_get_power_status( &gSensorIDs[i][0] ) ==
96 
            DS18X20_POWER_PARASITE )
 96 
            DS18X20_POWER_PARASITE )
97 
            printf( "parasite" );
 97 
            printf( "parasite" );
98 
        else printf( "externally" );
 98 
        else printf( "externally" );
99 
        printf( " powered\n" );
 99 
        printf( " powered\n" );
100 
    }
 100 
    }
101 
   
 101 
   
102 
    printf("CanInit...\n");
 102 
    printf("CanInit...\n");
103 
    if (Can_Init() != CAN_OK) {
 103 
    if (Can_Init() != CAN_OK) {
104 
        printf("FAILED!\n");
 104 
        printf("FAILED!\n");
105 
    }
 105 
    }
106 
    else {
 106 
    else {
107 
        printf("OK!\n");
 107 
        printf("OK!\n");
108 
    }
 108 
    }
109 
 
 109 
   
110 
    uint32_t timeStamp = 0;
 110 
    uint32_t timeStamp = 0;
111 
   
 111 
   
112 
    Can_Message_t txMsg;
 112 
    Can_Message_t txMsg;
113 
    Can_Message_t rxMsg;
 113 
    Can_Message_t rxMsg;
114 
   
 114 
   
115 
    txMsg.DataLength = 2;
 115 
    txMsg.DataLength = 2;
116 
    txMsg.Id = 0;
 116 
    txMsg.Id = 0;
117 
    txMsg.RemoteFlag = 0;
 117 
    txMsg.RemoteFlag = 0;
118 
    txMsg.ExtendedFlag = 1;
 118 
    txMsg.ExtendedFlag = 1;
119 
 
 - 
 
120 
//    txMsg.Id = txMsg.Id | NODE_SENSOR_1 | (NID << 9) | (FUNCC_SENSORS_TEMPERATURE_INSIDE << 15) | (FUNCT_SENSORS << 25);
 - 
 
121 
//    txMsg.Id = 0x02010A0F;
 - 
 
122 
 
 119 
   
123 
    /* main loop */
 120 
    /* main loop */
124 
    while (1) {
 121 
    while (1) {
125 
        /* service the CAN routines */
 122 
        /* service the CAN routines */
126 
        Can_Service();
 123 
        Can_Service();
127 
 
 124 
 
128 
        /* check if any messages have been received */
 125 
        /* check if any messages have been received */
129 
        while (Can_Receive(&rxMsg) == CAN_OK) {
 126 
        while (Can_Receive(&rxMsg) == CAN_OK) {
130 
/*          printf("MSG Received: ID=%lx, DLC=%u, EXT=%u, RTR=%u, ", rxMsg.Id, (uint16_t)(rxMsg.DataLength), (uint16_t)(rxMsg.ExtendedFlag), (uint16_t)(rxMsg.RemoteFlag));
 - 
 
131 
            printf("data={ ");
 127 
           
132 
            for (uint8_t i=0; i<rxMsg.DataLength; i++) {
 - 
 
133 
                printf("%x ", rxMsg.Data.bytes[i]);
 - 
 
134 
            }
 128 
        }
135 
            printf("}\n");
 - 
 
136 
*/      }
 - 
 
137 
 
 129 
 
138 
        /* check temperature and send on CAN once every other second */
 130 
        /* check temperature and send on CAN once every other second */
139 
        if (Timebase_PassedTimeMillis(timeStamp) >= 2000) {
 131 
        if (Timebase_PassedTimeMillis(timeStamp) >= 2000) {
140 
            timeStamp = Timebase_CurrentTime();
 132 
            timeStamp = Timebase_CurrentTime();
141 
           
 133 
           
142 
            if ( DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL ) == DS18X20_OK) {
 134 
            if ( DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL ) == DS18X20_OK) {
143 
                printf("Measuring temperature... \n");
 135 
                printf("Measuring temperature... ");
144 
                delay_ms(DS18B20_TCONV_12BIT);
 136 
                delay_ms(DS18B20_TCONV_12BIT);
145 
                for ( i=0; i<nSensors; i++ ) {
 137 
                for ( i=0; i<nSensors; i++ ) {
146 
                    if ( DS18X20_read_meas( &gSensorIDs[i][0], &subzero,
 138 
                    if ( DS18X20_read_meas( &gSensorIDs[i][0], &subzero,
147 
                            &cel, &cel_frac_bits) == DS18X20_OK ) {
 139 
                            &cel, &cel_frac_bits) == DS18X20_OK ) {
148 
                       
 140 
                       
149 
                        //txMsg.Data.bytes[0] = subzero;
 141 
                        //txMsg.Data.bytes[0] = subzero;
150 
                        if (subzero) {
 142 
                        if (subzero) {
151 
                            txMsg.Data.bytes[0] = -cel;
 143 
                            txMsg.Data.bytes[i*2] = -cel;
152 
                        } else {
 - 
 
153 
                            txMsg.Data.bytes[0] = cel;
 - 
 
154 
                        }
 - 
 
155 
/*                      if (subzero) {
 - 
 
156 
                            txMsg.Data.bytes[i*2] = -cel;
 144 
                            txMsg.Data.bytes[i*2+1] = ~(cel_frac_bits<<4);
157 
                        } else {
 145 
                        } else {
158 
                            txMsg.Data.bytes[i*2] = cel;
 146 
                            txMsg.Data.bytes[i*2] = cel;
- 
 
 147 
                            txMsg.Data.bytes[i*2+1] = (cel_frac_bits<<4);
159 
                        }
 148 
                        }
160 
*/                      //hur göra med decimaldelen???
 149 
                       
161 
                        txMsg.Data.bytes[1] = (cel_frac_bits<<4);
 - 
 
162 
//                      txMsg.Data.bytes[i*2+1] = (cel_frac_bits<<4);
 - 
 
163 
                        if(i==0){ // freezer
 150 
                    }
164 
                            txMsg.Id = 0x02020A0F;
 - 
 
165 
//                            printf("freezer\n");
 - 
 
166 
                        }else if(i==1){ // outside
 - 
 
167 
                            txMsg.Id = 0x0201FA0F;
 - 
 
168 
//                            printf("outside\n");
 151 
                    else printf("CRC Error (lost connection?)\n");
169 
                        }else if(i==2){ // inside
 - 
 
170 
                            txMsg.Id = 0x02010A0F;
 - 
 
171 
//                            printf("inside\n");
 - 
 
172 
                        }else{
 - 
 
173 
                            txMsg.Id = 0x00000003;
 - 
 
174 
                        }
 152 
                }
175 
 
 153 
               
- 
 
 154 
                txMsg.DataLength = nSensors*2;
176 
                        printf("sending...\n");
 155 
                printf("sending...\n");
- 
 
 156 
                /* send txMsg */
177 
                        Can_Send(&txMsg);
 157 
                Can_Send(&txMsg);
178 
                    }
 - 
 
179 
                    else printf("CRC Error (lost connection?)\n");
 - 
 
180 
                }
 - 
 
181 
            }
 158 
            }
182 
            else printf("Start meas. failed (short circuit?)\n");
 159 
            else printf("Start meas. failed (short circuit?)\n");
183 
 
 160 
 
184 
//          txMsg.DataLength = nSensors*2;
 - 
 
185 
//          printf("sending...\n");
 - 
 
186 
            /* send txMsg */
 - 
 
187 
//          Can_Send(&txMsg);
 - 
 
188 
        }
 161 
        }
189 
    }
 162 
    }
190 
   
 163 
   
191 
    return 0;
 164 
    return 0;
192 
}
 165 
}
193 
 
 166