patrick/zephyr
1
0
Fork 0
Code Issues Pull requests Actions 8 Packages Projects Releases Wiki Activity

mgmt/osdp: Refactor struct osdp_cmd members for readability

Browse source 
Some of the names used in `struct osdp_cmd` where directly as in the
specification. Initially it appealed to keep them like that but with
time, a little more consistent naming of members helps if you haven't
read the specification document very recently.

Signed-off-by: Siddharth Chandrasekaran <siddharth@embedjournal.com>
This commit is contained in:
Siddharth Chandrasekaran 2020-09-03 18:25:48 +05:30 committed by Carles Cufí
parent 4c9b0ae928
commit ee99c34fb6
4 changed files with 85 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
include/mgmt/osdp.h
View file

@ -17,6 +17,7 @@ extern "C" {
#endif
#define OSDP_CMD_TEXT_MAX_LEN 32
#define OSDP_CMD_KEYSET_KEY_MAX_LEN 32
/**
* @brief Various card formats that a PD can support. This is sent to CP
@ -41,12 +42,12 @@ enum osdp_card_formats_e {
* 4 - set the permanent state to ON, allow timed operation to complete
* 5 - set the temporary state to ON, resume perm state on timeout
* 6 - set the temporary state to OFF, resume permanent state on timeout
* @param tmr_count Time in units of 100 ms
* @param timer_count Time in units of 100 ms
*/
struct osdp_cmd_output {
uint8_t output_no;
uint8_t control_code;
uint16_t tmr_count;
uint16_t timer_count;
};
/**
@ -77,7 +78,7 @@ enum osdp_led_color_e {
* @param off_count The OFF duration of the flash, in units of 100 ms
* @param on_color Color to set during the ON timer (enum osdp_led_color_e)
* @param off_color Color to set during the OFF timer (enum osdp_led_color_e)
* @param timer Time in units of 100 ms (only for temporary mode)
* @param timer_count Time in units of 100 ms (only for temporary mode)
*/
struct osdp_cmd_led_params {
uint8_t control_code;
@ -85,7 +86,7 @@ struct osdp_cmd_led_params {
uint8_t off_count;
uint8_t on_color;
uint8_t off_color;
uint16_t timer;
uint16_t timer_count;
};
/**
@ -107,14 +108,14 @@ struct osdp_cmd_led {
* @brief Sent from CP to control the behaviour of a buzzer in the PD.
*
* @param reader 0 = First Reader, 1 = Second Reader, etc.
* @param tone_code 0: no tone, 1: off, 2: default tone, 3+ is TBD.
* @param control_code 0: no tone, 1: off, 2: default tone, 3+ is TBD.
* @param on_count The ON duration of the flash, in units of 100 ms
* @param off_count The OFF duration of the flash, in units of 100 ms
* @param rep_count The number of times to repeat the ON/OFF cycle; 0: forever
*/
struct osdp_cmd_buzzer {
uint8_t reader;
uint8_t tone_code;
uint8_t control_code;
uint8_t on_count;
uint8_t off_count;
uint8_t rep_count;
@ -124,7 +125,7 @@ struct osdp_cmd_buzzer {
* @brief Command to manuplate any display units that the PD supports.
*
* @param reader 0 = First Reader, 1 = Second Reader, etc.
* @param cmd One of the following:
* @param control_code One of the following:
* 1 - permanent text, no wrap
* 2 - permanent text, with wrap
* 3 - temp text, no wrap
@ -137,7 +138,7 @@ struct osdp_cmd_buzzer {
*/
struct osdp_cmd_text {
uint8_t reader;
uint8_t cmd;
uint8_t control_code;
uint8_t temp_time;
uint8_t offset_row;
uint8_t offset_col;
@ -149,27 +150,27 @@ struct osdp_cmd_text {
* @brief Sent in response to a COMSET command. Set communication parameters to
* PD. Must be stored in PD non-volatile memory.
*
* @param addr Unit ID to which this PD will respond after the change takes
* @param address Unit ID to which this PD will respond after the change takes
* effect.
* @param baud baud rate value 9600/38400/115200
* @param baud_rate baud rate value 9600/38400/115200
*/
struct osdp_cmd_comset {
uint8_t addr;
uint32_t baud;
uint8_t address;
uint32_t baud_rate;
};
/**
* @brief This command transfers an encryption key from the CP to a PD.
*
* @param key_type Type of keys:
* - 0x01 – Secure Channel Base Key
* @param len Number of bytes of key data - (Key Length in bits + 7) / 8
* @param type Type of keys:
* - 0x01 – Secure Channel Base Key
* @param length Number of bytes of key data - (Key Length in bits + 7) / 8
* @param data Key data
*/
struct osdp_cmd_keyset {
uint8_t key_type;
uint8_t len;
uint8_t data[32];
uint8_t type;
uint8_t length;
uint8_t data[OSDP_CMD_KEYSET_KEY_MAX_LEN];
};
/**
@ -199,7 +200,7 @@ enum osdp_cmd_e {
*/
struct osdp_cmd {
sys_snode_t node;
int id;
enum osdp_cmd_e id;
union {
struct osdp_cmd_led led;
struct osdp_cmd_buzzer buzzer;
@ -213,7 +214,7 @@ struct osdp_cmd {
#ifdef CONFIG_OSDP_MODE_PD
/**
* @param cmd pointer to a command structure that would be filled by the driver.
* @param cmd pointer to a command structure that was received by the driver.
*
* @retval 0 on success.
* @retval -1 on failure.

2
samples/subsys/mgmt/osdp/src/cp_main.c
View file

@ -67,7 +67,7 @@ void main(void)
struct osdp_cmd_output pulse_output = {
.output_no = 0, /* First output */
.control_code = 5, /* Temporarily turn on output */
.tmr_count = 10, /* Timer: 10 * 100ms = 1 second */
.timer_count = 10, /* Timer: 10 * 100ms = 1 second */
};
dev = device_get_binding(LED0);

50
subsys/mgmt/osdp/src/osdp_cp.c
View file

@ -154,8 +154,8 @@ static int cp_build_command(struct osdp_pd *pd, uint8_t *buf, int max_len)
buf[len++] = pd->cmd_id;
buf[len++] = cmd->output.output_no;
buf[len++] = cmd->output.control_code;
buf[len++] = BYTE_0(cmd->output.tmr_count);
buf[len++] = BYTE_1(cmd->output.tmr_count);
buf[len++] = BYTE_0(cmd->output.timer_count);
buf[len++] = BYTE_1(cmd->output.timer_count);
ret = 0;
break;
case CMD_LED:
@ -172,8 +172,8 @@ static int cp_build_command(struct osdp_pd *pd, uint8_t *buf, int max_len)
buf[len++] = cmd->led.temporary.off_count;
buf[len++] = cmd->led.temporary.on_color;
buf[len++] = cmd->led.temporary.off_color;
buf[len++] = BYTE_0(cmd->led.temporary.timer);
buf[len++] = BYTE_1(cmd->led.temporary.timer);
buf[len++] = BYTE_0(cmd->led.temporary.timer_count);
buf[len++] = BYTE_1(cmd->led.temporary.timer_count);
buf[len++] = cmd->led.permanent.control_code;
buf[len++] = cmd->led.permanent.on_count;
@ -189,7 +189,7 @@ static int cp_build_command(struct osdp_pd *pd, uint8_t *buf, int max_len)
cmd = (struct osdp_cmd *)pd->cmd_data;
buf[len++] = pd->cmd_id;
buf[len++] = cmd->buzzer.reader;
buf[len++] = cmd->buzzer.tone_code;
buf[len++] = cmd->buzzer.control_code;
buf[len++] = cmd->buzzer.on_count;
buf[len++] = cmd->buzzer.off_count;
buf[len++] = cmd->buzzer.rep_count;
@ -202,7 +202,7 @@ static int cp_build_command(struct osdp_pd *pd, uint8_t *buf, int max_len)
}
buf[len++] = pd->cmd_id;
buf[len++] = cmd->text.reader;
buf[len++] = cmd->text.cmd;
buf[len++] = cmd->text.control_code;
buf[len++] = cmd->text.temp_time;
buf[len++] = cmd->text.offset_row;
buf[len++] = cmd->text.offset_col;
@ -486,19 +486,6 @@ static int cp_process_reply(struct osdp_pd *pd)
return cp_decode_response(pd, pd->rx_buf, pd->rx_buf_len);
}
static int cp_alloc_command(struct osdp_pd *pd, struct osdp_cmd **cmd)
{
void *p;
p = osdp_cmd_alloc(pd);
if (p == NULL) {
LOG_WRN(TAG "Failed to alloc cmd");
return -1;
}
*cmd = p;
return 0;
}
static void cp_flush_command_queue(struct osdp_pd *pd)
{
struct osdp_cmd *cmd;
@ -620,7 +607,8 @@ static int cp_cmd_dispatcher(struct osdp_pd *pd, int cmd)
return 0;
}
if (cp_alloc_command(pd, &c)) {
c = osdp_cmd_alloc(pd);
if (c == NULL) {
return OSDP_CP_ERR_GENERIC;
}
@ -723,7 +711,7 @@ int osdp_cp_set_callback_card_read(
{
struct osdp *ctx = osdp_get_ctx();
ctx->cp->notifier.cardread = cb;
TO_CP(ctx)->notifier.cardread = cb;
return 0;
}
@ -733,6 +721,10 @@ int osdp_cp_send_cmd_output(int pd, struct osdp_cmd_output *p)
struct osdp *ctx = osdp_get_ctx();
struct osdp_cmd *cmd;
if (TO_PD(ctx, pd)->state != OSDP_CP_STATE_ONLINE) {
LOG_WRN(TAG "PD not online");
return -1;
}
if (pd < 0 || pd >= NUM_PD(ctx)) {
LOG_ERR(TAG "Invalid PD number");
return -1;
@ -754,6 +746,10 @@ int osdp_cp_send_cmd_led(int pd, struct osdp_cmd_led *p)
struct osdp *ctx = osdp_get_ctx();
struct osdp_cmd *cmd;
if (TO_PD(ctx, pd)->state != OSDP_CP_STATE_ONLINE) {
LOG_WRN(TAG "PD not online");
return -1;
}
if (pd < 0 || pd >= NUM_PD(ctx)) {
LOG_ERR(TAG "Invalid PD number");
return -1;
@ -775,6 +771,10 @@ int osdp_cp_send_cmd_buzzer(int pd, struct osdp_cmd_buzzer *p)
struct osdp *ctx = osdp_get_ctx();
struct osdp_cmd *cmd;
if (TO_PD(ctx, pd)->state != OSDP_CP_STATE_ONLINE) {
LOG_WRN(TAG "PD not online");
return -1;
}
if (pd < 0 || pd >= NUM_PD(ctx)) {
LOG_ERR(TAG "Invalid PD number");
return -1;
@ -796,6 +796,10 @@ int osdp_cp_send_cmd_text(int pd, struct osdp_cmd_text *p)
struct osdp *ctx = osdp_get_ctx();
struct osdp_cmd *cmd;
if (TO_PD(ctx, pd)->state != OSDP_CP_STATE_ONLINE) {
LOG_WRN(TAG "PD not online");
return -1;
}
if (pd < 0 || pd >= NUM_PD(ctx)) {
LOG_ERR(TAG "Invalid PD number");
return -1;
@ -817,6 +821,10 @@ int osdp_cp_send_cmd_comset(int pd, struct osdp_cmd_comset *p)
struct osdp *ctx = osdp_get_ctx();
struct osdp_cmd *cmd;
if (TO_PD(ctx, pd)->state != OSDP_CP_STATE_ONLINE) {
LOG_WRN(TAG "PD not online");
return -1;
}
if (pd < 0 || pd >= NUM_PD(ctx)) {
LOG_ERR(TAG "Invalid PD number");
return -1;

66
subsys/mgmt/osdp/src/osdp_pd.c
View file

@ -164,8 +164,8 @@ static void pd_decode_command(struct osdp_pd *pd, uint8_t *buf, int len)
cmd->id = OSDP_CMD_OUTPUT;
cmd->output.output_no = buf[pos++];
cmd->output.control_code = buf[pos++];
cmd->output.tmr_count = buf[pos++];
cmd->output.tmr_count |= buf[pos++] << 8;
cmd->output.timer_count = buf[pos++];
cmd->output.timer_count |= buf[pos++] << 8;
osdp_cmd_enqueue(pd, cmd);
pd->reply_id = REPLY_ACK;
ret = 0;
@ -188,8 +188,8 @@ static void pd_decode_command(struct osdp_pd *pd, uint8_t *buf, int len)
cmd->led.temporary.off_count = buf[pos++];
cmd->led.temporary.on_color = buf[pos++];
cmd->led.temporary.off_color = buf[pos++];
cmd->led.temporary.timer = buf[pos++];
cmd->led.temporary.timer |= buf[pos++] << 8;
cmd->led.temporary.timer_count = buf[pos++];
cmd->led.temporary.timer_count |= buf[pos++] << 8;
cmd->led.permanent.control_code = buf[pos++];
cmd->led.permanent.on_count = buf[pos++];
@ -210,11 +210,11 @@ static void pd_decode_command(struct osdp_pd *pd, uint8_t *buf, int len)
break;
}
cmd->id = OSDP_CMD_BUZZER;
cmd->buzzer.reader = buf[pos++];
cmd->buzzer.tone_code = buf[pos++];
cmd->buzzer.on_count = buf[pos++];
cmd->buzzer.off_count = buf[pos++];
cmd->buzzer.rep_count = buf[pos++];
cmd->buzzer.reader = buf[pos++];
cmd->buzzer.control_code = buf[pos++];
cmd->buzzer.on_count = buf[pos++];
cmd->buzzer.off_count = buf[pos++];
cmd->buzzer.rep_count = buf[pos++];
osdp_cmd_enqueue(pd, cmd);
pd->reply_id = REPLY_ACK;
ret = 0;
@ -229,12 +229,12 @@ static void pd_decode_command(struct osdp_pd *pd, uint8_t *buf, int len)
break;
}
cmd->id = OSDP_CMD_TEXT;
cmd->text.reader = buf[pos++];
cmd->text.cmd = buf[pos++];
cmd->text.temp_time = buf[pos++];
cmd->text.offset_row = buf[pos++];
cmd->text.offset_col = buf[pos++];
cmd->text.length = buf[pos++];
cmd->text.reader = buf[pos++];
cmd->text.control_code = buf[pos++];
cmd->text.temp_time = buf[pos++];
cmd->text.offset_row = buf[pos++];
cmd->text.offset_col = buf[pos++];
cmd->text.length = buf[pos++];
if (cmd->text.length > OSDP_CMD_TEXT_MAX_LEN ||
((len - CMD_TEXT_DATA_LEN) < cmd->text.length) ||
cmd->text.length > OSDP_CMD_TEXT_MAX_LEN) {
@ -258,16 +258,18 @@ static void pd_decode_command(struct osdp_pd *pd, uint8_t *buf, int len)
break;
}
cmd->id = OSDP_CMD_COMSET;
cmd->comset.addr = buf[pos++];
cmd->comset.baud = buf[pos++];
cmd->comset.baud |= buf[pos++] << 8;
cmd->comset.baud |= buf[pos++] << 16;
cmd->comset.baud |= buf[pos++] << 24;
if (cmd->comset.addr >= 0x7F || (cmd->comset.baud != 9600 &&
cmd->comset.baud != 38400 && cmd->comset.baud != 115200)) {
LOG_ERR("COMSET Failed! command discarded.");
cmd->comset.addr = pd->address;
cmd->comset.baud = pd->baud_rate;
cmd->comset.address = buf[pos++];
cmd->comset.baud_rate = buf[pos++];
cmd->comset.baud_rate |= buf[pos++] << 8;
cmd->comset.baud_rate |= buf[pos++] << 16;
cmd->comset.baud_rate |= buf[pos++] << 24;
if (cmd->comset.address >= 0x7F ||
(cmd->comset.baud_rate != 9600 &&
cmd->comset.baud_rate != 38400 &&
cmd->comset.baud_rate != 115200)) {
LOG_ERR(TAG "COMSET Failed! command discarded");
cmd->comset.address = pd->address;
cmd->comset.baud_rate = pd->baud_rate;
}
osdp_cmd_enqueue(pd, cmd);
pd->reply_id = REPLY_COM;
@ -405,14 +407,14 @@ static int pd_build_reply(struct osdp_pd *pd, uint8_t *buf, int max_len)
}
buf[len++] = pd->reply_id;
buf[len++] = cmd->comset.addr;
buf[len++] = BYTE_0(cmd->comset.baud);
buf[len++] = BYTE_1(cmd->comset.baud);
buf[len++] = BYTE_2(cmd->comset.baud);
buf[len++] = BYTE_3(cmd->comset.baud);
buf[len++] = cmd->comset.address;
buf[len++] = BYTE_0(cmd->comset.baud_rate);
buf[len++] = BYTE_1(cmd->comset.baud_rate);
buf[len++] = BYTE_2(cmd->comset.baud_rate);
buf[len++] = BYTE_3(cmd->comset.baud_rate);
pd->address = (int)cmd->comset.addr;
pd->baud_rate = (int)cmd->comset.baud;
pd->address = (int)cmd->comset.address;
pd->baud_rate = (int)cmd->comset.baud_rate;
LOG_INF("COMSET Succeeded! New PD-Addr: %d; Baud: %d",
pd->address, pd->baud_rate);
ret = 0;