gex/gex-core
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

1wire cleaning, added 1w UU, renamed some error messages

Browse Source
This commit is contained in:
MightyPork
2018-02-01 17:20:25 +01:00
parent 0e378b6547
commit b6f7060516
9 changed files with 311 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files
units/1wire/_ow_checksum.c
+2 -2
View File
@@ -24,10 +24,10 @@ static uint8_t crc8_add(uint8_t cksum, uint8_t byte)
return crc8_bits(byte ^ cksum);
}
uint8_t ow_checksum(const uint8_t *buff, uint16_t len)
uint8_t ow_checksum(const uint8_t *buff, uint32_t len)
{
uint8_t cksum = 0;
for(uint16_t i = 0; i < len; i++) {
for(uint32_t i = 0; i < len; i++) {
cksum = crc8_add(cksum, buff[i]);
}
return cksum;
units/1wire/_ow_checksum.h
+1 -1
View File
@@ -18,6 +18,6 @@
* @param[in] len - buffer length
* @return checksum
*/
uint8_t ow_checksum(const uint8_t *buf, uint16_t len);
uint8_t ow_checksum(const uint8_t *buf, uint32_t len);
#endif //GEX_F072_OW_CHECKSUM_H
units/1wire/_ow_search.c
+15 -6
View File
@@ -25,12 +25,13 @@ void ow_search_init(Unit *unit, uint8_t command, bool test_checksums)
state->prev_last_fork = 64;
memset(state->prev_code, 0, 8);
state->status = OW_SEARCH_MORE;
state->error = E_SUCCESS;
state->command = command;
state->first = true;
state->test_checksums = test_checksums;
}
uint16_t ow_search_run(Unit *unit, ow_romcode_t *codes, uint16_t capacity)
uint32_t ow_search_run(Unit *unit, ow_romcode_t *codes, uint32_t capacity)
{
if (unit->driver != &UNIT_1WIRE)
trap("Wrong unit type - %s", unit->driver->name);
@@ -42,7 +43,7 @@ uint16_t ow_search_run(Unit *unit, ow_romcode_t *codes, uint16_t capacity)
if (state->status != OW_SEARCH_MORE) return 0;
uint16_t found_devices = 0;
uint32_t found_devices = 0;
while (found_devices < capacity) {
uint8_t index = 0;
@@ -52,6 +53,7 @@ uint16_t ow_search_run(Unit *unit, ow_romcode_t *codes, uint16_t capacity)
// Start a new transaction. Devices respond to reset
if (!ow_reset(unit)) {
state->status = OW_SEARCH_FAILED;
state->error = E_HW_TIMEOUT;
goto done;
}
// Send the search command (SEARCH_ROM, SEARCH_ALARM)
@@ -83,6 +85,7 @@ uint16_t ow_search_run(Unit *unit, ow_romcode_t *codes, uint16_t capacity)
else if (p && n) {
// No devices left connected - this doesn't normally happen
state->status = OW_SEARCH_FAILED;
state->error = E_BUS_FAULT;
goto done;
}
@@ -98,12 +101,18 @@ uint16_t ow_search_run(Unit *unit, ow_romcode_t *codes, uint16_t capacity)
memcpy(state->prev_code, code, 8);
if (!state->test_checksums || 0 == ow_checksum(code, 8)) {
// Record a found address
memcpy(codes[found_devices], code, 8);
found_devices++;
if (state->test_checksums) {
if (0 != ow_checksum(code, 8)) {
state->status = OW_SEARCH_FAILED;
state->error = E_CHECKSUM_MISMATCH;
goto done;
}
}
// Record a found address
memcpy(codes[found_devices], code, 8);
found_devices++;
// Stop condition
if (last_fork == -1) {
state->status = OW_SEARCH_DONE;
units/1wire/_ow_search.h
+2 -1
View File
@@ -51,6 +51,7 @@ struct ow_search_state {
enum ow_search_result status;
bool first;
bool test_checksums;
error_t error;
};
/**
@@ -76,6 +77,6 @@ void ow_search_init(Unit *unit, uint8_t command, bool test_checksums);
* @param[in] capacity - buffer capacity
* @return number of romcodes found. Search status is stored in state->status
*/
uint16_t ow_search_run(Unit *unit, ow_romcode_t *codes, uint16_t capacity);
uint32_t ow_search_run(Unit *unit, ow_romcode_t *codes, uint32_t capacity);
#endif //GEX_F072_OW_SEARCH_H
units/1wire/unit_1wire.c
+201 -121
View File
@@ -98,7 +98,6 @@ static void U1WIRE_TimerCb(TimerHandle_t xTimer)
uint32_t time = PTIM_GetTime();
if (time - priv->busyStart > 1000) {
// dbg("Wait timed out. Stopping polling timer.");
xTimerStop(xTimer, 100);
com_respond_error(priv->busyRequestId, E_HW_TIMEOUT);
priv->busy = false;
@@ -176,6 +175,170 @@ static void U1WIRE_deInit(Unit *unit)
// ------------------------------------------------------------------------
/**
* Check if there are any units present on the bus
*
* @param[in,out] unit
* @param[out] presence - any devices present
* @return success
*/
error_t UU_1WIRE_CheckPresence(Unit *unit, bool *presence)
{
CHECK_TYPE(unit, &UNIT_1WIRE);
// reset
*presence = ow_reset(unit);
return E_SUCCESS;
}
/**
* Read a device's address (use only with a single device attached)
*
* @param[in,out] unit
* @param[out] address - the device's address, 0 on error or CRC mismatch
* @return success
*/
error_t UU_1WIRE_ReadAddress(Unit *unit, uint64_t *address)
{
CHECK_TYPE(unit, &UNIT_1WIRE);
*address = 0;
if (!ow_reset(unit)) return E_HW_TIMEOUT;
// command
ow_write_u8(unit, OW_ROM_READ);
// read the ROM code
*address = ow_read_u64(unit);
const uint8_t *addr_as_bytes = (void*)address;
if (0 != ow_checksum(addr_as_bytes, 8)) {
*address = 0;
return E_CHECKSUM_MISMATCH; // checksum mismatch
}
return E_SUCCESS;
}
/**
* Write bytes to a device / devices
*
* @param[in,out] unit
* @param[in] address - device address, 0 to skip match (single device or broadcast)
* @param[in] buff - bytes to write
* @param[in] len - buffer length
* @return success
*/
error_t UU_1WIRE_Write(Unit *unit, uint64_t address, const uint8_t *buff, uint32_t len)
{
CHECK_TYPE(unit, &UNIT_1WIRE);
if (!ow_reset(unit)) return E_HW_TIMEOUT;
// MATCH_ROM+addr, or SKIP_ROM
if (address != 0) {
ow_write_u8(unit, OW_ROM_MATCH);
ow_write_u64(unit, address);
} else {
ow_write_u8(unit, OW_ROM_SKIP);
}
// write the payload;
for (uint32_t i = 0; i < len; i++) {
ow_write_u8(unit, *buff++);
}
return E_SUCCESS;
}
/**
* Read bytes from a device / devices, first writing a query
*
* @param[in,out] unit
* @param[in] address - device address, 0 to skip match (single device ONLY!)
* @param[in] request_buff - bytes to write before reading a response
* @param[in] request_len - number of bytes to write
* @param[out] response_buff - buffer for storing the read response
* @param[in] response_len - number of bytes to read
* @param[in] check_crc - verify CRC
* @return success
*/
error_t UU_1WIRE_Read(Unit *unit, uint64_t address,
const uint8_t *request_buff, uint32_t request_len,
uint8_t *response_buff, uint32_t response_len, bool check_crc)
{
CHECK_TYPE(unit, &UNIT_1WIRE);
if (!ow_reset(unit)) return E_HW_TIMEOUT;
uint8_t *rb = response_buff;
// MATCH_ROM+addr, or SKIP_ROM
if (address != 0) {
ow_write_u8(unit, OW_ROM_MATCH);
ow_write_u64(unit, address);
} else {
ow_write_u8(unit, OW_ROM_SKIP);
}
// write the payload;
for (uint32_t i = 0; i < request_len; i++) {
ow_write_u8(unit, *request_buff++);
}
// read the requested number of bytes
for (uint32_t i = 0; i < response_len; i++) {
*rb++ = ow_read_u8(unit);
}
if (check_crc) {
if (0 != ow_checksum(response_buff, response_len)) {
return E_CHECKSUM_MISMATCH;
}
}
return E_SUCCESS;
}
/**
* Perform a ROM search operation.
* The algorithm is on a depth-first search without backtracking,
* taking advantage of the open-drain topology.
*
* This function either starts the search, or continues it.
*
* @param[in,out] unit
* @param[in] with_alarm - true to match only devices in alarm state
* @param[in] restart - true to restart the search (search from the lowest address)
* @param[out] buffer - buffer for storing found addresses
* @param[in] capacity - buffer capacity in address entries (8 bytes)
* @param[out] real_count - real number of found addresses (for which the CRC matched)
* @param[out] have_more - flag indicating there are more devices to be found
* @return success
*/
error_t UU_1WIRE_Search(Unit *unit, bool with_alarm, bool restart,
uint64_t *buffer, uint32_t capacity, uint32_t *real_count,
bool *have_more)
{
CHECK_TYPE(unit, &UNIT_1WIRE);
struct priv *priv = unit->data;
if (restart) {
uint8_t search_cmd = (uint8_t) (with_alarm ? OW_ROM_ALM_SEARCH : OW_ROM_SEARCH);
ow_search_init(unit, search_cmd, true);
}
*real_count = ow_search_run(unit, (ow_romcode_t *) buffer, capacity);
// resolve the code
switch (priv->searchState.status) {
case OW_SEARCH_MORE:
*have_more = priv->searchState.status == OW_SEARCH_MORE;
case OW_SEARCH_DONE:
return E_SUCCESS;
case OW_SEARCH_FAILED:
return priv->searchState.error;
}
return E_FAILURE;
}
enum PinCmd_ {
CMD_CHECK_PRESENCE = 0, // simply tests that any devices are attached
CMD_SEARCH_ADDR = 1, // perform a scan of the bus, retrieving all found device ROMs
@@ -183,29 +346,14 @@ enum PinCmd_ {
CMD_SEARCH_CONTINUE = 3, // continue the previously started scan, retrieving more devices
CMD_READ_ADDR = 4, // read the ROM code from a single device (for single-device bus)
CMD_SKIP_WRITE = 10, // write multiple bytes using the SKIP_ROM command
CMD_SKIP_READ = 11, // write and read multiple bytes using the SKIP_ROM command
CMD_MATCH_WRITE = 12, // write multiple bytes using a ROM address
CMD_MATCH_READ = 13, // write and read multiple bytes using a ROM address
CMD_WRITE = 10, // write multiple bytes using the SKIP_ROM command
CMD_READ = 11, // write multiple bytes using a ROM address
CMD_POLL_FOR_1 = 20,
CMD_TEST = 100,
};
/** send the match-rom with address from a payload parser, or skip-rom */
static void cmd_match_skip(Unit *unit, uint8_t command, PayloadParser *pp)
{
uint64_t addr;
if (command == CMD_MATCH_WRITE || command == CMD_MATCH_READ) {
addr = pp_u64(pp);
ow_write_u8(unit, OW_ROM_MATCH);
ow_write_u64(unit, addr);
}
else {
ow_write_u8(unit, OW_ROM_SKIP);
}
}
/** Handle a request message */
static error_t U1WIRE_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command, PayloadParser *pp)
@@ -214,62 +362,54 @@ static error_t U1WIRE_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command,
bool presence;
uint64_t addr;
int remain;
uint32_t remain;
const uint8_t *tail;
if (priv->busy) return E_BUSY;
uint8_t search_cmd = OW_ROM_SEARCH;
bool with_alarm = false;
bool search_reset = false;
switch (command) {
case CMD_SEARCH_ALARM:
search_cmd = OW_ROM_ALM_SEARCH;
// pass-through
with_alarm = true;
// fall-through
case CMD_SEARCH_ADDR:
ow_search_init(unit, search_cmd, true);
// pass through
search_reset = true;
// fall-through
case CMD_SEARCH_CONTINUE:;
ow_romcode_t *codes = (void *) unit_tmp512;
uint16_t count = ow_search_run(unit, codes, UNIT_TMP_LEN/8);
uint32_t found_count = 0;
bool have_more = false;
if (priv->searchState.status == OW_SEARCH_FAILED) {
return E_HW_FAULT;
}
// First byte of the response is a flag whether there are more devices
// to be found using CMD_SEARCH_CONTINUE
uint8_t status_code = (uint8_t) (priv->searchState.status == OW_SEARCH_MORE);
TRY(UU_1WIRE_Search(unit, with_alarm, search_reset,
(void *) unit_tmp512, UNIT_TMP_LEN/8, &found_count,
&have_more));
// use multipart to avoid allocating extra buffer
uint8_t status_code = (uint8_t) have_more;
TF_Msg msg = {
.frame_id = frame_id,
.type = MSG_SUCCESS,
.len = (TF_LEN) (count * 8 + 1),
.len = (TF_LEN) (found_count * 8 + 1),
};
TF_Respond_Multipart(comm, &msg);
TF_Multipart_Payload(comm, &status_code, 1);
// the codes are back-to-back stored inside the buffer, we send it directly
// (it's already little-endian, as if built by PayloadBuilder)
TF_Multipart_Payload(comm, (uint8_t *) unit_tmp512, (uint32_t) (count * 8));
TF_Multipart_Payload(comm, (uint8_t *) unit_tmp512, found_count * 8);
TF_Multipart_Close(comm);
return E_SUCCESS;
/** Simply check presence of any devices on the bus. Responds with SUCCESS or HW_TIMEOUT */
case CMD_CHECK_PRESENCE:
// reset
presence = ow_reset(unit);
// build response
TRY(UU_1WIRE_CheckPresence(unit, &presence));
com_respond_u8(frame_id, (uint8_t) presence);
return E_SUCCESS;
/** Read address of the single device on the bus - returns u64 */
case CMD_READ_ADDR:
// reset
presence = ow_reset(unit);
if (!presence) return E_HW_FAULT;
// command
ow_write_u8(unit, OW_ROM_READ);
// read the ROM code
addr = ow_read_u64(unit);
TRY(UU_1WIRE_ReadAddress(unit, &addr));
// build response
PayloadBuilder pb = pb_start(unit_tmp512, UNIT_TMP_LEN, NULL);
@@ -284,20 +424,10 @@ static error_t U1WIRE_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command,
* - Match variant: addr:u64, rest:write_data
* - Skip variant: all:write_data
*/
case CMD_MATCH_WRITE:
case CMD_SKIP_WRITE:
// reset
presence = ow_reset(unit);
if (!presence) return E_HW_FAULT;
// MATCH_ROM+addr, or SKIP_ROM
cmd_match_skip(unit, command, pp);
// write the rest of the payload
remain = pp_length(pp);
for (int i = 0; i < remain; i++) {
ow_write_u8(unit, pp_u8(pp));
}
case CMD_WRITE:
addr = pp_u64(pp);
tail = pp_tail(pp, &remain);
TRY(UU_1WIRE_Write(unit, addr, tail, remain));
return E_SUCCESS;
/**
@@ -307,31 +437,19 @@ static error_t U1WIRE_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command,
* - Match variant: addr:u64, read_len:u16, rest:write_data
* - Skip variant: read_len:u16, rest:write_data
*/
case CMD_MATCH_READ:
case CMD_SKIP_READ:;
// reset
presence = ow_reset(unit);
if (!presence) return E_HW_FAULT;
// MATCH_ROM+addr, or SKIP_ROM
cmd_match_skip(unit, command, pp);
// paylod prefix - number of bytes to read
case CMD_READ:;
addr = pp_u64(pp);
uint16_t rcount = pp_u16(pp);
bool test_crc = pp_bool(pp);
tail = pp_tail(pp, &remain);
// write the rest of the payload
remain = pp_length(pp);
for (int i = 0; i < remain; i++) {
ow_write_u8(unit, pp_u8(pp));
}
// read the requested number of bytes
for (int i = 0; i < rcount; i++) {
unit_tmp512[i] = ow_read_u8(unit);
}
TRY(UU_1WIRE_Read(unit, addr,
tail, remain,
(uint8_t *) unit_tmp512, rcount,
test_crc));
// build response
com_respond_buf(frame_id, MSG_SUCCESS, (const uint8_t *) unit_tmp512, rcount);
com_respond_buf(frame_id, MSG_SUCCESS, (uint8_t *) unit_tmp512, rcount);
return E_SUCCESS;
/**
@@ -341,6 +459,7 @@ static error_t U1WIRE_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command,
* Non-parasitic: Returns SUCCESS after device responds '1', HW_TIMEOUT after 1s
*/
case CMD_POLL_FOR_1:
// This can't be exposed via the UU API, due to being async
if (priv->parasitic) {
assert_param(pdPASS == xTimerChangePeriod(priv->busyWaitTimer, 750, 100));
} else {
@@ -353,45 +472,6 @@ static error_t U1WIRE_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command,
priv->busyRequestId = frame_id;
return E_SUCCESS; // We will respond when the timer expires
//
// case CMD_TEST:;
// bool presence = ow_reset(unit);
// if (!presence) return E_HW_TIMEOUT;
//
// ow_write_u8(unit, OW_ROM_SKIP);
//
// ow_write_u8(unit, OW_DS1820_CONVERT_T);
// while (!ow_read_bit(unit));
//
// // TODO use knowledge of the use/non-use of parasitic mode to pick the optimal strategy (non-parasitic allows polling)
//
// // osDelay(750);
// // TODO this will be done with an async timer
// // If parasitive power is not used, we could poll and check the status bit
//
// presence = ow_reset(unit);
// if (!presence) return E_HW_TIMEOUT;
// ow_write_u8(unit, OW_ROM_SKIP);
//
// ow_write_u8(unit, OW_DS1820_READ_SCRATCH);
//
// uint16_t temp = ow_read_u16(unit);
// uint16_t threg = ow_read_u16(unit);
// uint16_t reserved = ow_read_u16(unit);
// uint8_t cnt_remain = ow_read_u8(unit);
// uint8_t cnt_per_c = ow_read_u8(unit);
// uint8_t crc = ow_read_u8(unit);
// // TODO check CRC
//
// pb = pb_start(unit_tmp512, UNIT_TMP_LEN, NULL);
// pb_u16(&pb, temp);
// pb_u8(&pb, cnt_remain);
// pb_u8(&pb, cnt_per_c);
//
// dbg("respond ...");
// com_respond_buf(frame_id, MSG_SUCCESS, pb.start, pb_length(&pb));
// return E_SUCCESS;
default:
return E_UNKNOWN_COMMAND;
}
units/1wire/unit_1wire.h
+65
View File
@@ -11,4 +11,69 @@
extern const UnitDriver UNIT_1WIRE;
/**
* Check if there are any units present on the bus
*
* @param[in,out] unit
* @param[out] presence - any devices present
* @return success
*/
error_t UU_1WIRE_CheckPresence(Unit *unit, bool *presence);
/**
* Read a device's address (use only with a single device attached)
*
* @param[in,out] unit
* @param[out] address - the device's address, 0 on error or CRC mismatch
* @return success
*/
error_t UU_1WIRE_ReadAddress(Unit *unit, uint64_t *address);
/**
* Write bytes to a device / devices
*
* @param[in,out] unit
* @param[in] address - device address, 0 to skip match (single device or broadcast)
* @param[in] buff - bytes to write
* @param[in] len - buffer length
* @return success
*/
error_t UU_1WIRE_Write(Unit *unit, uint64_t address, const uint8_t *buff, uint32_t len);
/**
* Read bytes from a device / devices, first writing a query
*
* @param[in,out] unit
* @param[in] address - device address, 0 to skip match (single device ONLY!)
* @param[in] request_buff - bytes to write before reading a response
* @param[in] request_len - number of bytes to write
* @param[out] response_buff - buffer for storing the read response
* @param[in] response_len - number of bytes to read
* @param[in] check_crc - verify CRC
* @return success
*/
error_t UU_1WIRE_Read(Unit *unit, uint64_t address,
const uint8_t *request_buff, uint32_t request_len,
uint8_t *response_buff, uint32_t response_len, bool check_crc);
/**
* Perform a ROM search operation.
* The algorithm is on a depth-first search without backtracking,
* taking advantage of the open-drain topology.
*
* This function either starts the search, or continues it.
*
* @param[in,out] unit
* @param[in] with_alarm - true to match only devices in alarm state
* @param[in] restart - true to restart the search (search from the lowest address)
* @param[out] buffer - buffer for storing found addresses
* @param[in] capacity - buffer capacity in address entries (8 bytes)
* @param[out] real_count - real number of found addresses (for which the CRC matched)
* @param[out] have_more - flag indicating there are more devices to be found
* @return success
*/
error_t UU_1WIRE_Search(Unit *unit, bool with_alarm, bool restart,
uint64_t *buffer, uint32_t capacity, uint32_t *real_count,
bool *have_more);
#endif //GEX_F072_UNIT_1WIRE_H