[32] STM32F4 - DS18B20, wiele czujników, obsługa alarmu

Ten post chciałbym poświęcić na opisanie sposobu podłączenia wielu czujników na linii One Wire oraz obsługę alarmu od czujnika DS18B20.

[Źródło: http://www.st.com/en/evaluation-tools/stm32f4discovery.html]

Program:

Tutaj należy zmodyfikować kilka funkcji z poprzedniej biblioteki oraz dodać kilka nowych do biblioteki.

Funkcja uruchamiająca czujniki wygląda następująco:

1. uint8_t ds18b20Init(uint8_t mode)
2. {
3.     int i = 0, j=0;
4.     uint8_t deviceDat[8];
6.     /* If skip rom then we adress all devices on one line
7.      * with the same setting */
8.     if(mode == SKIP_ROM)
9.     {
10.         /* Send Reset pulse then wait for Presence Pulse */
11.         if(ds18b20ResetDevice() != 1)
12.         {
13.             return 0;
14.         }
16.         ds18b20WriteByte(COM_SKIP_ROM);
18.         ds18b20WriteByte(COM_WRITE_SCRATCHPAD);
19.         /* Set Th high temp alarm for 50 */
20.         ds18b20WriteByte(0x32);
21.         /* Set Tl low temp alarm for -10 */
22.         ds18b20WriteByte(0x8A);
23.         ds18b20WriteByte(RESOLUTION_12BIT);
24.     }
25.     else if(mode == NO_SKIP_ROM)
26.     {
27.         /* find devices, read ROM */
28.         for(i=1;i<=DS18B20_CONNECTED_DEV;i++)
29.         {
30.             if(ds18b20SearchRom(deviceDat))
31.             {
32.                 ds18b20_data.Dev_Cnt++;
33.                 memcpy(ds18b20_data.Dev_ID[ds18b20_data.Dev_Cnt-1],deviceDat,sizeof(deviceDat));
34.             }
35.             else
36.             {
37.                 break;
38.             }
39.         }
41.         /* pass all settings to devices on line */
42.         for(i=1;i<=ds18b20_data.Dev_Cnt;i++)
43.         {
45.             if(ds18b20ResetDevice() != 1)
46.             {
47.                 return 0;
48.             }
50.             /* Use for adres one of connected sensors */
51.             ds18b20WriteByte(COM_MATCH_ROM);
53.             for(j=0;j<=7;j++)
54.             {
55.                 ds18b20WriteByte(ds18b20_data.Dev_ID[i-1][j]);
56.             }
58.             ds18b20WriteByte(COM_WRITE_SCRATCHPAD);
59.             /* Set Th high temp alarm for 50 */
60.             ds18b20WriteByte(0x32);
61.             /* Set Tl low temp alarm for -10 */
62.             ds18b20WriteByte(0x8A);
63.             ds18b20WriteByte(RESOLUTION_12BIT);
64.         }
65.     }
66.     return 1;
67. }

Tutaj wprowadzona została modyfikacja. Pierwsza część adresująca wszystkie urządzenia nie została zmieniona. Doszła natomiast druga część dotycząca ustawienia konkretnych danych dla każdego z czujników. Wyszukiwanie odbywa się za pomocą funkcji SEARCH ROM. Następnie do układu przesyłana jest komenda MATCH ROM. Jej zadaniem jest zaadresowanie konkretnego urządzenia. Na jej wywołanie ma odpowiedzieć układ, którego adres ROM zostanie wysłany. Każde inne podłączone układy podrzędne będą czekać na sygnał RESET PULSE.

Modyfikacji uległa także funkcja przesyłająca komendą READ SCRATCHPAD:

Tutaj tak jak poprzednio wpisujemy adres ROM układu który nas interesuje. Po czym przechodzimy do wpisania komendy READ SCRATCHPAD i odczytania umieszczonych w nim wartości:

1. void ds18b20ReadScratchpad(uint8_t mode, uint8_t *data, uint8_t deviceNumber)
2. {
3.     uint8_t i;
5.     ds18b20ResetDevice();
7.     if(mode == SKIP_ROM)
8.     {
9.         ds18b20WriteByte(COM_SKIP_ROM);
10.     }
11.     else if(mode == NO_SKIP_ROM)
12.     {
13.         ds18b20WriteByte(COM_MATCH_ROM);
14.        
15.         for(i=0;i<=7;i++)
16.         {
17.             ds18b20WriteByte(ds18b20_data.Dev_ID[deviceNumber-1][i]);
18.         }
19.     }
21.     ds18b20WriteByte(COM_READ_SCRATCHPAD);
23.     for(i=0;i<8;i++)
24.     {
25.         data[i] = ds18b20ReadByte();
26.     }
27. }

W przypadku funkcji odpowiedzialnej za konwersję temperatury również należy przygotować wersję odczytującą adres ROM układu.

1. void ds18b20DevConTemp(uint8_t mode, uint8_t deviceNumber)
2. {
3.     uint8_t i = 0;
5.     ds18b20ResetDevice();
7.     if(mode == SKIP_ROM)
8.     {
9.         ds18b20WriteByte(COM_SKIP_ROM);
10.     }
11.     else if(mode == NO_SKIP_ROM)
12.     {
13.         ds18b20WriteByte(COM_MATCH_ROM);
14.        
15.         for(i=0;i<=7;i++)
16.         {
17.             ds18b20WriteByte(ds18b20_data.Dev_ID[deviceNumber-1][i]);
18.         }
19.     }
20.     ds18b20WriteByte(COM_CONVERT_T);
22.     /*
23.      * Delay to wait for convert temperature finish.
24.      * With resolution of 12, time to end is give or take 750ms
25.      * */
26.     HAL_Delay(800);
27. }

Ustawianie alarmu dla wybranego czujnika:

1. uint8_t ds18b20SetAlarm(uint8_t Dev[DS18B20_CONNECTED_DEV][8], uint8_t sensor, uint8_t highAlarm, uint8_t lowAlarm)
2. {
3.     uint8_t j=0;
5.     if(ds18b20ResetDevice() != 1)
6.     {
7.         return 0;
8.     }
10.     ds18b20WriteByte(COM_MATCH_ROM);
12.     for(j=0;j<=7;j++)
13.     {
14.         ds18b20WriteByte(ds18b20_data.Dev_ID[sensor][j]);
15.     }
17.     ds18b20WriteByte(COM_WRITE_SCRATCHPAD);
18.     /* Set Th high temp alarm */
19.     ds18b20WriteByte(highAlarm);
20.     /* Set Tl low temp alarm */
21.     ds18b20WriteByte(lowAlarm);
22.     ds18b20WriteByte(RESOLUTION_12BIT);
24.     return 1;
25. }

Funkcja powyżej pobiera urządzenie, które zostało wcześniej odczytane. Na linie przesyłana jest komenda MATCH ROM. Po niej zostanie przesłany adres konkretnego układu. Wobec tego tylko on przyjmie kolejne komendy jak i ustawienie poszczególnych alarmów.

Po ustaleniu wybranego czujnika na generowanie alarmu należy sprawdzić czy dany czujnik wywołał alarm. Można tego dokonać w podobny sposób jak wywoływanie komendy SEARCH ROM. Jedyną różnicą w tym przypadku jest to, że przy wywołaniu komendy ALARM SEARCH odpowie tylko czujnik, który wygenerował alarm.

1. uint8_t ds18b20Search(uint8_t *Addr, uint8_t command)
2. {
3.       uint8_t id_bit_number = 1;
4.       uint8_t last_zero = 0;
5.       uint8_t rom_byte_number = 0;
6.       uint8_t search_result = 0;
7.       uint8_t id_bit = 0;
8.       uint8_t cmp_id_bit = 0;
9.       uint8_t rom_byte_mask = 1;
10.       uint8_t search_direction = 0;
12.       /* If last call was not the last one */
13.       if (!ds18b20_data.LastDeviceFlag)
14.       {
15.           /* 1-Wire reset */
16.           if(ds18b20ResetDevice() == 1)
17.           {
18.               ds18b20WriteByte(command);
19.           }
20.       }
22.       /* loop for search */
23.       do
24.       {
25.           /* read a bit */
26.           id_bit = ds18b20ReadBit();
27.           cmp_id_bit = ds18b20ReadBit();
29.           /* check for no devices on one wire line */
30.           if ((id_bit == 1) && (cmp_id_bit == 1))
31.           {
32.               break;
33.           }
34.           else
35.           {
36.               /* all coupled devices have 0 or 1 */
37.               if (id_bit != cmp_id_bit)
38.               {
39.                   /* write bit value for search */
40.                   search_direction = id_bit;
41.               }
42.               else
43.               {
44.                   if (id_bit_number < ds18b20_data.LastDiscrepancy)
45.                   {
46.                       search_direction = ((ds18b20_data.ROM_NO[rom_byte_number] & rom_byte_mask) > 0);
47.                   }
48.                   else
49.                   {
50.                       search_direction = (id_bit_number == ds18b20_data.LastDiscrepancy);
51.                   }
53.                   if (search_direction == 0)
54.                   {
55.                       last_zero = id_bit_number;
57.                       /* Check for last family disperancy */
58.                       if (last_zero < 9)
59.                       {
60.                           ds18b20_data.LastFamilyDiscrepancy = last_zero;
61.                       }
62.                   }
63.               }
65.               /* set or clear the bit in the ROM byte, with mask  */
66.               if (search_direction == 1)
67.               {
68.                   ds18b20_data.ROM_NO[rom_byte_number] |= rom_byte_mask;
69.               }
70.               else
71.               {
72.                   ds18b20_data.ROM_NO[rom_byte_number] &= ~rom_byte_mask;
73.               }
75.               /* serial number, search direction */
76.               ds18b20WriteBit(search_direction);
78.               /*
79.                * increment byte counter
80.                * next shift mask
81.                * */
82.               id_bit_number++;
83.               rom_byte_mask <<= 1;
85.               if (rom_byte_mask == 0)
86.               {
87.                   rom_byte_number++;
88.                   rom_byte_mask = 1;
89.               }
90.           }
91.       }while(rom_byte_number < 8);
93.       /* If the search was successful */
94.       if (!(id_bit_number < 65))
95.       {
96.           ds18b20_data.LastDiscrepancy = last_zero;
97.           /* check last device */
99.           if (ds18b20_data.LastDiscrepancy == 0)
100.           {
101.               ds18b20_data.LastDeviceFlag = 1;
102.           }
103.           search_result = 1;
104.       }
106.       if (!search_result || !ds18b20_data.ROM_NO[0])
107.       {
108.           ds18b20_data.LastDiscrepancy = 0;
109.           ds18b20_data.LastDeviceFlag = 0;
110.           ds18b20_data.LastFamilyDiscrepancy = 0;
111.           search_result = 0;
112.       }
113.       else
114.       {
115.           for (int i = 0; i < 8; i++)
116.           {
117.               Addr[i] = ds18b20_data.ROM_NO[i];
118.           }
120.           /* If there is alarm then display ROM RAW of device */
121.           if(command == COM_ALARM_SEARCH)
122.           {
123.               sprintf(str1,"Device deploy alarm: %02X %02X %02X %02X %02X %02X %02X %02X\r\n",
124.                       Addr[0], Addr[1], Addr[2], Addr[3], Addr[4], Addr[5], Addr[6], Addr[7]);
125.               HAL_UART_Transmit(&huart2,(uint8_t*)str1,strlen(str1),0x1000);
126.           }
127.       }
128.       return search_result;
129. }

Funkcje wywoływane w pętli głównej wyglądają następująco:

1. void ds18b20InitReadData(void)
2. {
3.     uint8_t buffer[60];
4.     uint8_t status = 0;
5.     uint8_t i = 0;
7.     /* Init all sensors */
8.     status = ds18b20Init(NO_SKIP_ROM);
10.     if(status == 1)
11.     {
12.         sprintf((char*)buffer,"Initialization status OK\r\n");
13.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
14.     }
15.     else
16.     {
17.         sprintf((char*)buffer,"Initialization status Error\r\n");
18.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
19.     }
21.     sprintf((char*)buffer,"Number of devices on line: %d\r\n", ds18b20_data.Dev_Cnt);
22.     HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
24.     /* Get device informations */
25.     for(i=1;i<=ds18b20_data.Dev_Cnt;i++)
26.     {
27.         sprintf((char*)buffer,"Device number: %d\r\n", i);
28.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
30.         sprintf((char*)buffer,"ROM RAW: %02X %02X %02X %02X %02X %02X %02X %02X\r\n",
31.             ds18b20_data.Dev_ID[i-1][0], ds18b20_data.Dev_ID[i-1][1], ds18b20_data.Dev_ID[i-1][2], ds18b20_data.Dev_ID[i-1][3],
32.             ds18b20_data.Dev_ID[i-1][4], ds18b20_data.Dev_ID[i-1][5], ds18b20_data.Dev_ID[i-1][6], ds18b20_data.Dev_ID[i-1][7]);
33.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
35.         sprintf((char*)buffer,"Family CODE: 0x%02X\r\n", ds18b20_data.Dev_ID[i-1][0]);
36.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
38.         sprintf((char*)buffer,"ROM CODE: 0x%02X%02X%02X%02X%02X%02X\r\n",
39.                 ds18b20_data.Dev_ID[i-1][6], ds18b20_data.Dev_ID[i-1][5],
40.                 ds18b20_data.Dev_ID[i-1][4], ds18b20_data.Dev_ID[i-1][3],
41.                 ds18b20_data.Dev_ID[i-1][2], ds18b20_data.Dev_ID[i-1][1]);
42.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
44.         sprintf((char*)buffer,"CRC: 0x%02X\r\n", ds18b20_data.Dev_ID[i-1][7]);
45.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
46.     }
48.     /* set alarm on one device */
49.     ds18b20SetAlarm(ds18b20_data.Dev_ID, 0x01, 0x14, 0x8A);
50. }
52. void ds18b20ReadTempFromDev(void)
53. {
54.     uint8_t buffer[60];
55.     uint8_t i;
56.     uint8_t device[8];
57.     uint16_t readDataRaw;
58.     float tempValue;
59.     char sign;
61.     for(i=1;i<=ds18b20_data.Dev_Cnt;i++)
62.     {
63.         ds18b20DevConTemp(NO_SKIP_ROM, i);
64.     }
66.     for(i=1;i<=ds18b20_data.Dev_Cnt;i++)
67.     {
68.         ds18b20ReadScratchpad(NO_SKIP_ROM, device, i);
70.         sprintf((char*)buffer,"READ SCRATCHPAD SEN:%d - %02X %02X %02X %02X %02X %02X %02X %02X; ",
71.                 i, device[0], device[1], device[2], device[3], device[4], device[5], device[6], device[7]);
73.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
74.         readDataRaw = ((uint16_t)device[1]<<8)|device[0];
76.         if(ds18b20ReadSign(readDataRaw))    {   sign='-';   }
77.         else                                {   sign='+';   }
79.         tempValue = ds18b20GetTemp(readDataRaw);
80.         sprintf((char*)buffer,"RegVal: 0x%04X - %c%.2f\r\n", readDataRaw, sign, tempValue);
81.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
82.     }
83. }
85. void ds18b20AlarmSearch(void)
86. {
87.     uint8_t device[8];
88.     uint8_t buffer[60];
90.     while(ds18b20Search(device, COM_ALARM_SEARCH))
91.     {
92.         sprintf((char*)buffer,"Alarm deploy!\r\n");
93.         HAL_UART_Transmit(&huart2,(uint8_t*)buffer,strlen((char*)buffer),0x1000);
94.     }
95. }

Funkcja ds18b20InitReadData odczytuje parametry z czujników, dodatkowo ustawiając alarmy oraz rozdzielczość. Następnie funkcja ds18b20ReadTempFromDev odczytuje scratchpada oraz pobiera temperaturę. No i na końcu sprawdzenie czy któryś z podłączonych czujników wywołał alarm ds18b20AlarmSearch.

Ilość podłączonych czujników definiuje się w pliku ds18b20.h:

1. #define DS18B20_CONNECTED_DEV 2

Dane przechowywane są w strukturze:

1. typedef struct ds18b20SensorsData_t{
2.     uint8_t LastDeviceFlag;
3.     uint8_t LastDiscrepancy;
4.     uint8_t LastFamilyDiscrepancy;
5.     uint8_t ROM_NO[8];
6.     uint8_t Dev_ID[DS18B20_CONNECTED_DEV][8];
7.     uint8_t Dev_Cnt;
8. }ds18b20SD_t;
10. ds18b20SD_t ds18b20_data;

Po uruchomieniu programu testowego i poprawnym podłączeniu na komputer będą wysyłane następujące informacje:

Bibliotekę można pobrać pod tym linkiem. Po jego otwarciu należy wejście w folder STM32 a następnie STM32F4_Discovery.