211 lines
7.4 KiB
C
211 lines
7.4 KiB
C
/*
|
||
* UART-мост DS2480B для операций 1-Wire: сброс, обмен битами и байтами, поиск устройств и
|
||
* управление питанием. После ошибки связи состояние готовности сбрасывается, чтобы следующий
|
||
* обмен не продолжался в неизвестном режиме моста.
|
||
*/
|
||
|
||
#include "ds2480.h"
|
||
|
||
static ds2480_status fault(ds2480 *bus, ds2480_status status)
|
||
{
|
||
bus->ready = 0;
|
||
return status;
|
||
}
|
||
|
||
static ds2480_status exchange(ds2480 *bus, uint8_t command, uint8_t *reply)
|
||
{
|
||
uint8_t mode = 0xE3;
|
||
if (!bus || !reply) return DS2480_ARGUMENT;
|
||
if (!bus->ready) return DS2480_NOT_READY;
|
||
if (bus->power_active && command != 0xF1) return DS2480_BUSY;
|
||
if (bus->data_mode) {
|
||
if (bus->port.write(bus->port.user, &mode, 1, bus->timeout_ms))
|
||
return fault(bus, DS2480_IO);
|
||
bus->data_mode = 0;
|
||
}
|
||
if (bus->port.write(bus->port.user, &command, 1, bus->timeout_ms) ||
|
||
bus->port.read(bus->port.user, reply, 1, bus->timeout_ms))
|
||
return fault(bus, DS2480_IO);
|
||
return DS2480_OK;
|
||
}
|
||
|
||
ds2480_status ds2480_init(ds2480 *bus, const ds2480_port *port, uint32_t timeout_ms)
|
||
{
|
||
uint8_t calibration = 0xC1, reply;
|
||
ds2480_status status;
|
||
ds2480_port copy;
|
||
if (!bus) return DS2480_ARGUMENT;
|
||
if (!port || !port->prepare || !port->write || !port->read ||
|
||
!port->delay_ms || !timeout_ms) {
|
||
bus->ready = 0;
|
||
return DS2480_ARGUMENT;
|
||
}
|
||
copy = *port; /* Also permit reinitialization with &bus->port. */
|
||
bus->ready = 0;
|
||
bus->power_active = 0;
|
||
bus->data_mode = 0;
|
||
bus->port = copy;
|
||
bus->timeout_ms = timeout_ms;
|
||
if (copy.prepare(copy.user) ||
|
||
copy.write(copy.user, &calibration, 1, timeout_ms)) return DS2480_IO;
|
||
/* First C1 calibrates only: there is NO response byte. */
|
||
copy.delay_ms(copy.user, 2);
|
||
bus->ready = 1;
|
||
/* Strong pullup duration = infinite, command-mode operations only. */
|
||
status = exchange(bus, 0x3F, &reply);
|
||
if (status != DS2480_OK) return status;
|
||
if (reply != 0x3E) return fault(bus, DS2480_PROTOCOL);
|
||
return DS2480_OK;
|
||
}
|
||
|
||
ds2480_status ds2480_reset(ds2480 *bus)
|
||
{
|
||
uint8_t reply;
|
||
ds2480_status status = exchange(bus, 0xC1, &reply);
|
||
if (status != DS2480_OK) return status;
|
||
/* DS2480B revision pattern from table 2; bit 5 is unspecified. */
|
||
if ((reply & 0xDC) != 0xCC) return fault(bus, DS2480_PROTOCOL);
|
||
switch (reply & 3) {
|
||
case 0: return DS2480_SHORT;
|
||
case 3: return DS2480_NO_PRESENCE;
|
||
default: return DS2480_OK; /* Ordinary or alarming presence. */
|
||
}
|
||
}
|
||
|
||
static ds2480_status slot(ds2480 *bus, uint8_t bit, uint8_t power, uint8_t *received)
|
||
{
|
||
uint8_t reply, command = (uint8_t)(0x81 | (bit ? 0x10 : 0) | (power ? 2 : 0));
|
||
ds2480_status status = exchange(bus, command, &reply);
|
||
if (status != DS2480_OK) return status;
|
||
if ((reply & 0xFC) != (command & 0xFC) ||
|
||
((reply & 3) != 0 && (reply & 3) != 3))
|
||
return fault(bus, DS2480_PROTOCOL);
|
||
*received = reply & 1;
|
||
return DS2480_OK;
|
||
}
|
||
|
||
ds2480_status ds2480_bit(ds2480 *bus, uint8_t bit, uint8_t *received)
|
||
{
|
||
if (!received) return DS2480_ARGUMENT;
|
||
return slot(bus, bit, 0, received);
|
||
}
|
||
|
||
ds2480_status ds2480_byte(ds2480 *bus, uint8_t value, uint8_t *received)
|
||
{
|
||
uint8_t mode = 0xE1, reply;
|
||
if (!bus || !received) return DS2480_ARGUMENT;
|
||
if (!bus->ready) return DS2480_NOT_READY;
|
||
if (bus->power_active) return DS2480_BUSY;
|
||
if (!bus->data_mode) {
|
||
if (bus->port.write(bus->port.user, &mode, 1, bus->timeout_ms))
|
||
return fault(bus, DS2480_IO);
|
||
bus->data_mode = 1;
|
||
}
|
||
if (bus->port.write(bus->port.user, &value, 1, bus->timeout_ms))
|
||
return fault(bus, DS2480_IO);
|
||
if (value == 0xE3 && bus->port.write(bus->port.user, &value, 1, bus->timeout_ms))
|
||
return fault(bus, DS2480_IO);
|
||
if (bus->port.read(bus->port.user, &reply, 1, bus->timeout_ms))
|
||
return fault(bus, DS2480_IO);
|
||
*received = reply;
|
||
return DS2480_OK;
|
||
}
|
||
|
||
ds2480_status ds2480_power_begin(ds2480 *bus, uint8_t value)
|
||
{
|
||
uint8_t i, bit, echoed = 0;
|
||
ds2480_status status;
|
||
if (!bus) return DS2480_ARGUMENT;
|
||
for (i = 0; i < 8; ++i) {
|
||
status = slot(bus, (uint8_t)((value >> i) & 1), (uint8_t)(i == 7), &bit);
|
||
if (status != DS2480_OK) {
|
||
/* A lost reply may leave an infinite pulse active: reset hardware. */
|
||
if (i == 7 && !bus->ready) (void)bus->port.prepare(bus->port.user);
|
||
return status;
|
||
}
|
||
echoed |= (uint8_t)(bit << i);
|
||
}
|
||
bus->power_active = 1;
|
||
if (echoed != value) {
|
||
status = ds2480_power_end(bus);
|
||
return status == DS2480_OK ? DS2480_DATA : status;
|
||
}
|
||
return DS2480_OK;
|
||
}
|
||
|
||
ds2480_status ds2480_power_end(ds2480 *bus)
|
||
{
|
||
uint8_t reply;
|
||
ds2480_status status;
|
||
if (!bus) return DS2480_ARGUMENT;
|
||
if (!bus->ready) return DS2480_NOT_READY;
|
||
if (!bus->power_active) return DS2480_OK;
|
||
status = exchange(bus, 0xF1, &reply);
|
||
if (status == DS2480_OK && reply != 0xEC && reply != 0xEF)
|
||
status = fault(bus, DS2480_PROTOCOL);
|
||
if (status != DS2480_OK) (void)bus->port.prepare(bus->port.user);
|
||
bus->power_active = 0;
|
||
return status;
|
||
}
|
||
|
||
ds2480_status ds2480_power_byte(ds2480 *bus, uint8_t value, uint32_t hold_ms)
|
||
{
|
||
ds2480_status status;
|
||
if (!hold_ms || hold_ms > 1000) return DS2480_ARGUMENT;
|
||
status = ds2480_power_begin(bus, value);
|
||
if (status != DS2480_OK) return status;
|
||
bus->port.delay_ms(bus->port.user, hold_ms);
|
||
return ds2480_power_end(bus);
|
||
}
|
||
|
||
uint8_t ds2480_crc8(const uint8_t *data, uint32_t size)
|
||
{
|
||
uint8_t crc = 0, bit;
|
||
uint32_t i;
|
||
for (i = 0; i < size; ++i) {
|
||
crc ^= data[i];
|
||
for (bit = 0; bit < 8; ++bit)
|
||
crc = (uint8_t)((crc >> 1) ^ ((crc & 1) ? 0x8C : 0));
|
||
}
|
||
return crc;
|
||
}
|
||
|
||
ds2480_status ds2480_search_next(ds2480 *bus, ds2480_search *search)
|
||
{
|
||
ds2480_search next;
|
||
ds2480_status status;
|
||
uint8_t pos, a, b, direction, ignored, last_zero = 0;
|
||
if (!bus || !search || search->discrepancy > 64) return DS2480_ARGUMENT;
|
||
if (search->done) return DS2480_DONE;
|
||
next = *search;
|
||
status = ds2480_reset(bus);
|
||
if (status != DS2480_OK) return status;
|
||
status = ds2480_byte(bus, 0xF0, &ignored);
|
||
if (status != DS2480_OK) return status;
|
||
for (pos = 1; pos <= 64; ++pos) {
|
||
uint8_t index = (uint8_t)((pos - 1) / 8);
|
||
uint8_t mask = (uint8_t)(1U << ((pos - 1) % 8));
|
||
status = ds2480_bit(bus, 1, &a);
|
||
if (status != DS2480_OK) return status;
|
||
status = ds2480_bit(bus, 1, &b);
|
||
if (status != DS2480_OK) return status;
|
||
if (a && b) return DS2480_DATA; /* Devices disappeared mid-search. */
|
||
if (a != b) direction = a;
|
||
else {
|
||
direction = pos < search->discrepancy ? (uint8_t)!!(search->rom[index] & mask)
|
||
: (uint8_t)(pos == search->discrepancy);
|
||
if (!direction) last_zero = pos;
|
||
}
|
||
if (direction) next.rom[index] |= mask;
|
||
else next.rom[index] &= (uint8_t)~mask;
|
||
status = ds2480_bit(bus, direction, &ignored);
|
||
if (status != DS2480_OK) return status;
|
||
}
|
||
if (!next.rom[0]) return DS2480_DATA;
|
||
if (ds2480_crc8(next.rom, 8)) return DS2480_CRC;
|
||
next.discrepancy = last_zero;
|
||
next.done = (uint8_t)(last_zero == 0);
|
||
*search = next;
|
||
return DS2480_OK;
|
||
}
|