#include "DS2482_HAL.h" #include #define DS2482_CMD_RESET 0xF0 #define DS2482_CMD_SET_READ_PTR 0xE1 #define DS2482_CMD_WRITE_CONFIG 0xD2 #define DS2482_CMD_1W_RESET 0xB4 #define DS2482_CMD_1W_SINGLE_BIT 0x87 #define DS2482_CMD_1W_WRITE_BYTE 0xA5 #define DS2482_CMD_1W_READ_BYTE 0x96 #define DS2482_CMD_1W_TRIPLET 0x78 #define DS2482_STATUS 0xF0 #define DS2482_READ_DATA 0xE1 #define DS2482_CONFIG 0xC3 #define DS2482_CONFIG_APU 1 << 0 #define DS2482_CONFIG_SPU 1 << 2 #define DS2482_CONFIG_1WS 1 << 3 typedef struct { uint8_t BUSY : 1; uint8_t PPD : 1; uint8_t SHORT : 1; uint8_t LL : 1; uint8_t RST : 1; uint8_t SBR : 1; uint8_t TSB : 1; uint8_t DIR : 1; } DS2482_Status; #define hi2c ds2482->hi2c #define DS2482_I2C_ADDR ds2482->address HAL_StatusTypeDef ds2482_init(ds2482_t* const ds2482) { HAL_StatusTypeDef status = ds2482_reset(ds2482); if (status != HAL_OK) { return status; } status = ds2482_write_config(ds2482, DS2482_CONFIG_APU); if (status != HAL_OK) { return status; } uint8_t config; status = HAL_I2C_Master_Receive(hi2c, DS2482_I2C_ADDR, &config, 1, DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } else if (config != DS2482_CONFIG_APU) { return HAL_ERROR; } return HAL_OK; } HAL_StatusTypeDef ds2482_reset(ds2482_t* const ds2482) { uint8_t data[1] = {DS2482_CMD_RESET}; return HAL_I2C_Master_Transmit(hi2c, DS2482_I2C_ADDR, data, sizeof(data), DS2482_TIMEOUT_I2C); } HAL_StatusTypeDef ds2482_write_config(ds2482_t * const ds2482, uint8_t config) { uint8_t data[2] = {DS2482_CMD_WRITE_CONFIG, config | (~config << 4)}; return HAL_I2C_Master_Transmit(hi2c, DS2482_I2C_ADDR, data, sizeof(data), DS2482_TIMEOUT_I2C); } HAL_StatusTypeDef ds2482_set_read_ptr(ds2482_t * const ds2482, uint8_t read_ptr) { uint8_t data[2] = {DS2482_CMD_SET_READ_PTR, read_ptr}; return HAL_I2C_Master_Transmit(hi2c, DS2482_I2C_ADDR, data, sizeof(data), DS2482_TIMEOUT_I2C); } HAL_StatusTypeDef ds2482_1w_reset(ds2482_t * const ds2482, bool* presence) { uint8_t data[1] = {DS2482_CMD_1W_RESET}; HAL_StatusTypeDef status = HAL_I2C_Master_Transmit(hi2c, DS2482_I2C_ADDR, data, sizeof(data), DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } DS2482_Status status_reg = {.BUSY = 1}; uint32_t timeout = HAL_GetTick() + DS2482_TIMEOUT_1W; do { status = HAL_I2C_Master_Receive(hi2c, DS2482_I2C_ADDR, (uint8_t*)&status_reg, 1, DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } if (HAL_GetTick() > timeout) { return HAL_TIMEOUT; } } while (status_reg.BUSY); if (status_reg.SHORT) { return HAL_ERROR; } if (presence != NULL) { *presence = status_reg.PPD; } return HAL_OK; } HAL_StatusTypeDef ds2482_1w_write_byte(ds2482_t * const ds2482, uint8_t byte) { uint8_t data[2] = {DS2482_CMD_1W_WRITE_BYTE, byte}; HAL_StatusTypeDef status = HAL_I2C_Master_Transmit(hi2c, DS2482_I2C_ADDR, data, sizeof(data), DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } DS2482_Status status_reg = {.BUSY = 1}; uint32_t timeout = HAL_GetTick() + DS2482_TIMEOUT_1W; do { status = HAL_I2C_Master_Receive(hi2c, DS2482_I2C_ADDR, (uint8_t*)&status_reg, 1, DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } if (HAL_GetTick() > timeout) { return HAL_TIMEOUT; } } while (status_reg.BUSY); return HAL_OK; } HAL_StatusTypeDef ds2482_1w_read_byte(ds2482_t * const ds2482, uint8_t* byte) { uint8_t data[1] = {DS2482_CMD_1W_READ_BYTE}; HAL_StatusTypeDef status = HAL_I2C_Master_Transmit(hi2c, DS2482_I2C_ADDR, data, sizeof(data), DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } DS2482_Status status_reg = {.BUSY = 1}; uint32_t timeout = HAL_GetTick() + DS2482_TIMEOUT_1W; do { status = HAL_I2C_Master_Receive(hi2c, DS2482_I2C_ADDR, (uint8_t*)&status_reg, 1, DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } if (HAL_GetTick() > timeout) { return HAL_TIMEOUT; } } while (status_reg.BUSY); status = ds2482_set_read_ptr(ds2482, DS2482_READ_DATA); if (status != HAL_OK) { return status; } return HAL_I2C_Master_Receive(hi2c, DS2482_I2C_ADDR, byte, 1, DS2482_TIMEOUT_I2C); } HAL_StatusTypeDef ds2482_1w_triplet(ds2482_t * const ds2482, uint8_t dir) { uint8_t data[2] = {DS2482_CMD_1W_TRIPLET, dir ? 0xFF : 0x00}; return HAL_I2C_Master_Transmit(hi2c, DS2482_I2C_ADDR, data, sizeof(data), DS2482_TIMEOUT_I2C); } HAL_StatusTypeDef ds2482_1w_write_bit(ds2482_t * const ds2482, bool bit) { uint8_t data[2] = {DS2482_CMD_1W_SINGLE_BIT, bit ? 0xFF : 0x00}; HAL_StatusTypeDef status = HAL_I2C_Master_Transmit(hi2c, DS2482_I2C_ADDR, data, sizeof(data), DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } DS2482_Status status_reg = {.BUSY = 1}; uint32_t timeout = HAL_GetTick() + DS2482_TIMEOUT_1W; do { status = HAL_I2C_Master_Receive(hi2c, DS2482_I2C_ADDR, (uint8_t*)&status_reg, 1, DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } if (HAL_GetTick() > timeout) { return HAL_TIMEOUT; } } while (status_reg.BUSY); return HAL_OK; } HAL_StatusTypeDef ds2482_1w_read_bit(ds2482_t * const ds2482, bool* bit) { uint8_t data[2] = {DS2482_CMD_1W_SINGLE_BIT, 0xFF}; HAL_StatusTypeDef status = HAL_I2C_Master_Transmit(hi2c, DS2482_I2C_ADDR, data, sizeof(data), DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } DS2482_Status status_reg = {.BUSY = 1}; uint32_t timeout = HAL_GetTick() + DS2482_TIMEOUT_1W; do { status = HAL_I2C_Master_Receive(hi2c, DS2482_I2C_ADDR, (uint8_t*)&status_reg, 1, DS2482_TIMEOUT_I2C); if (status != HAL_OK) { return status; } if (HAL_GetTick() > timeout) { return HAL_TIMEOUT; } } while (status_reg.BUSY); *bit = status_reg.SBR; return HAL_OK; } // // From https://www.maximintegrated.com/en/design/technical-documents/app-notes/1/187.html // // global search state static uint8_t ROM_NO[8]; static int LastDiscrepancy; static int LastFamilyDiscrepancy; static bool LastDeviceFlag; static uint8_t crc8; //-------------------------------------------------------------------------- // Setup the search to find the device type 'family_code' on the next call // to OWNext() if it is present. // [[maybe_unused]] static void OWTargetSetup(uint8_t family_code) { int i; // set the search state to find SearchFamily type devices ROM_NO[0] = family_code; for (i = 1; i < 8; i++) ROM_NO[i] = 0; LastDiscrepancy = 64; LastFamilyDiscrepancy = 0; LastDeviceFlag = false; } //-------------------------------------------------------------------------- // Setup the search to skip the current device type on the next call // to OWNext(). // [[maybe_unused]] static void OWFamilySkipSetup() { // set the Last discrepancy to last family discrepancy LastDiscrepancy = LastFamilyDiscrepancy; LastFamilyDiscrepancy = 0; // check for end of list if (LastDiscrepancy == 0) LastDeviceFlag = true; } //-------------------------------------------------------------------------- // 1-Wire Functions to be implemented for a particular platform //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // Reset the 1-Wire bus and return the presence of any device // Return true : device present // false : no device present // static bool OWReset(ds2482_t* const ds2482) { bool presence; (void)ds2482_1w_reset(ds2482, &presence); return presence; } //-------------------------------------------------------------------------- // Send 8 bits of data to the 1-Wire bus // static inline void OWWriteByte(ds2482_t * const ds2482, uint8_t byte_value) { (void)ds2482_1w_write_byte(ds2482, byte_value); } //-------------------------------------------------------------------------- // Send 1 bit of data to teh 1-Wire bus // static inline void OWWriteBit(ds2482_t * const ds2482, uint8_t bit_value) { (void)ds2482_1w_write_bit(ds2482, bit_value); } //-------------------------------------------------------------------------- // Read 1 bit of data from the 1-Wire bus // Return 1 : bit read is 1 // 0 : bit read is 0 // static inline uint8_t OWReadBit(ds2482_t* const ds2482) { bool bit; (void)ds2482_1w_read_bit(ds2482, &bit); return bit; } // TEST BUILD static uint8_t dscrc_table[] = { 0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65, 157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220, 35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98, 190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255, 70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7, 219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154, 101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36, 248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185, 140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205, 17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80, 175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238, 50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115, 202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139, 87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22, 233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168, 116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53}; //-------------------------------------------------------------------------- // Calculate the CRC8 of the byte value provided with the current // global 'crc8' value. // Returns current global crc8 value // static uint8_t docrc8(uint8_t value) { crc8 = dscrc_table[crc8 ^ value]; return crc8; } //-------------------------------------------------------------------------- // Perform the 1-Wire Search Algorithm on the 1-Wire bus using the existing // search state. // Return true : device found, ROM number in ROM_NO buffer // false : device not found, end of search // static bool OWSearch(ds2482_t* const ds2482) { int id_bit_number; int last_zero, rom_byte_number, search_result; int id_bit, cmp_id_bit; uint8_t rom_byte_mask, search_direction; // initialize for search id_bit_number = 1; last_zero = 0; rom_byte_number = 0; rom_byte_mask = 1; search_result = 0; crc8 = 0; // if the last call was not the last one if (!LastDeviceFlag) { // 1-Wire reset if (!OWReset(ds2482)) { // reset the search LastDiscrepancy = 0; LastDeviceFlag = false; LastFamilyDiscrepancy = 0; return false; } // issue the search command OWWriteByte(ds2482, 0xF0); // loop to do the search do { // read a bit and its complement id_bit = OWReadBit(ds2482); cmp_id_bit = OWReadBit(ds2482); // check for no devices on 1-wire if ((id_bit == 1) && (cmp_id_bit == 1)) break; else { // all devices coupled have 0 or 1 if (id_bit != cmp_id_bit) search_direction = id_bit; // bit write value for search else { // if this discrepancy if before the Last Discrepancy // on a previous next then pick the same as last time if (id_bit_number < LastDiscrepancy) search_direction = ((ROM_NO[rom_byte_number] & rom_byte_mask) > 0); else // if equal to last pick 1, if not then pick 0 search_direction = (id_bit_number == LastDiscrepancy); // if 0 was picked then record its position in LastZero if (search_direction == 0) { last_zero = id_bit_number; // check for Last discrepancy in family if (last_zero < 9) LastFamilyDiscrepancy = last_zero; } } // set or clear the bit in the ROM byte rom_byte_number // with mask rom_byte_mask if (search_direction == 1) ROM_NO[rom_byte_number] |= rom_byte_mask; else ROM_NO[rom_byte_number] &= ~rom_byte_mask; // serial number search direction write bit OWWriteBit(ds2482, search_direction); // increment the byte counter id_bit_number // and shift the mask rom_byte_mask id_bit_number++; rom_byte_mask <<= 1; // if the mask is 0 then go to new SerialNum byte rom_byte_number and reset mask if (rom_byte_mask == 0) { docrc8(ROM_NO[rom_byte_number]); // accumulate the CRC rom_byte_number++; rom_byte_mask = 1; } } } while (rom_byte_number < 8); // loop until through all ROM bytes 0-7 // if the search was successful then if (!((id_bit_number < 65) || (crc8 != 0))) { // search successful so set LastDiscrepancy,LastDeviceFlag,search_result LastDiscrepancy = last_zero; // check for last device if (LastDiscrepancy == 0) LastDeviceFlag = true; search_result = true; } } // if no device found then reset counters so next 'search' will be like a first if (!search_result || !ROM_NO[0]) { LastDiscrepancy = 0; LastDeviceFlag = false; LastFamilyDiscrepancy = 0; search_result = false; } return search_result; } //-------------------------------------------------------------------------- // Find the 'first' devices on the 1-Wire bus // Return true : device found, ROM number in ROM_NO buffer // false : no device present // static bool OWFirst(ds2482_t* const ds2482) { // reset the search state LastDiscrepancy = 0; LastDeviceFlag = false; LastFamilyDiscrepancy = 0; return OWSearch(ds2482); } //-------------------------------------------------------------------------- // Find the 'next' devices on the 1-Wire bus // Return true : device found, ROM number in ROM_NO buffer // false : device not found, end of search // static inline bool OWNext(ds2482_t* const ds2482) { return OWSearch(ds2482); } // Verify the device with the ROM number in ROM_NO buffer is present. HAL_StatusTypeDef ds2482_1w_verify_device(ds2482_t * const ds2482, uint64_t device, bool* present) { uint8_t rom_backup[8]; int i, rslt; for (int i = 0; i < 8; i++) { ROM_NO[i] = (device >> (i * 8)) & 0xFF; rom_backup[i] = ROM_NO[i]; } // set search to find the same device LastDiscrepancy = 64; LastDeviceFlag = false; if (OWSearch(ds2482)) { // check if same device found rslt = true; for (i = 0; i < 8; i++) { if (rom_backup[i] != ROM_NO[i]) { rslt = false; break; } } } else rslt = false; // return the result of the verify return rslt; } HAL_StatusTypeDef ds2482_1w_search(ds2482_t * const ds2482, uint16_t max_devices, uint64_t devices[static max_devices]) { OWFirst(ds2482); uint16_t count = 0; do { uint64_t device = 0; for (int i = 0; i < 8; i++) { device |= (uint64_t)ROM_NO[i] << (i * 8); } devices[count++] = device; } while (OWNext(ds2482) && count < max_devices); return HAL_OK; }