djsundog/circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #3466 from jepler/canbus-api-changes

Browse Source 
Canbus: api changes
This commit is contained in:
Scott Shawcroft 2020-09-30 11:43:08 -07:00 committed by GitHub
commit 2ac2f627d5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 462 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
locale/circuitpython.pot
View File

@ -8,7 +8,7 @@ msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-09-29 11:11+0530\n"
"POT-Creation-Date: 2020-09-29 20:14-0500\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
@ -1530,6 +1530,10 @@ msgstr ""
msgid "Refresh too soon"
msgstr ""
#: shared-bindings/canio/RemoteTransmissionRequest.c
msgid "RemoteTransmissionRequests limited to 8 bytes"
msgstr ""
#: shared-bindings/aesio/aes.c
msgid "Requested AES mode is unsupported"
msgstr ""
@ -2412,10 +2416,14 @@ msgstr ""
msgid "exceptions must derive from BaseException"
msgstr ""
#: shared-bindings/canio/CAN.c shared-bindings/canio/Listener.c
#: shared-bindings/canio/CAN.c
msgid "expected '%q' but got '%q'"
msgstr ""
#: shared-bindings/canio/CAN.c
msgid "expected '%q' or '%q' but got '%q'"
msgstr ""
#: py/objstr.c
msgid "expected ':' after format specifier"
msgstr ""
@ -3275,10 +3283,6 @@ msgstr ""
msgid "source palette too large"
msgstr ""
#: shared-bindings/canio/Message.c
msgid "specify size or data, but not both"
msgstr ""
#: py/objstr.c
msgid "start/end indices"
msgstr ""

34
ports/atmel-samd/common-hal/canio/CAN.c
View File

@ -275,21 +275,6 @@ int common_hal_canio_can_receive_error_count_get(canio_can_obj_t *self)
return self->hw->ECR.bit.REC;
}
int common_hal_canio_can_error_warning_state_count_get(canio_can_obj_t *self)
{
return self->error_warning_state_count;
}
int common_hal_canio_can_error_passive_state_count_get(canio_can_obj_t *self)
{
return self->error_passive_state_count;
}
int common_hal_canio_can_bus_off_state_count_get(canio_can_obj_t *self)
{
return self->bus_off_state_count;
}
canio_bus_state_t common_hal_canio_can_state_get(canio_can_obj_t *self) {
CAN_PSR_Type psr = self->hw->PSR;
if (psr.bit.BO) {
@ -328,16 +313,18 @@ static void maybe_auto_restart(canio_can_obj_t *self) {
}
}
void common_hal_canio_can_send(canio_can_obj_t *self, canio_message_obj_t *message)
void common_hal_canio_can_send(canio_can_obj_t *self, mp_obj_t message_in)
{
maybe_auto_restart(self);
canio_message_obj_t *message = message_in;;
// We have just one dedicated TX buffer, use it!
canio_can_tx_buffer_t *ent = &self->state->tx_buffer[0];
bool rtr = message->base.type == &canio_remote_transmission_request_type;
ent->txb0.bit.ESI = false;
ent->txb0.bit.XTD = message->extended;
ent->txb0.bit.RTR = message->rtr;
ent->txb0.bit.RTR = rtr;
if (message->extended) {
ent->txb0.bit.ID = message->id;
} else {
@ -350,7 +337,7 @@ void common_hal_canio_can_send(canio_can_obj_t *self, canio_message_obj_t *messa
ent->txb1.bit.BRS = 0; // No bit rate switching
ent->txb1.bit.DLC = message->size;
if (!message->rtr) {
if (!rtr) {
memcpy(ent->data, message->data, message->size);
}
@ -417,17 +404,6 @@ STATIC void can_handler(int i) {
Can *hw = can_insts[i];
uint32_t ir = hri_can_read_IR_reg(hw);
/* Count up errors*/
if (ir & CAN_IE_EWE) {
self->error_warning_state_count += 1;
}
if (ir & CAN_IE_EPE) {
self->error_passive_state_count += 1;
}
if (ir & CAN_IE_BOE) {
self->bus_off_state_count += 1;
}
/* Acknowledge interrupt */
hri_can_write_IR_reg(hw, ir);
}

73
ports/atmel-samd/common-hal/canio/Listener.c
View File

@ -32,6 +32,7 @@
#include "common-hal/canio/__init__.h"
#include "common-hal/canio/Listener.h"
#include "shared-bindings/canio/Listener.h"
#include "shared-bindings/util.h"
#include "supervisor/shared/tick.h"
#include "component/can.h"
@ -58,8 +59,8 @@ STATIC void static_assertions(void) {
MP_STATIC_ASSERT(CAN_XIDFE_0_EFEC_STF0M_Val + 1 == CAN_XIDFE_0_EFEC_STF1M_Val);
}
STATIC bool single_address_filter(canio_match_obj_t *match) {
return match->mask == 0 || match->mask == match->address;
STATIC bool single_id_filter(canio_match_obj_t *match) {
return match->mask == 0 || match->mask == match->id;
}
STATIC bool standard_filter_in_use(CanMramSidfe *filter) {
@ -76,7 +77,7 @@ STATIC size_t num_filters_needed(size_t nmatch, canio_match_obj_t **matches, boo
if (extended != matches[i]->extended) {
continue;
}
if (single_address_filter(matches[i])) {
if (single_id_filter(matches[i])) {
num_half_filters_needed += 1;
} else {
num_half_filters_needed += 2;
@ -191,7 +192,7 @@ STATIC void install_extended_filter(CanMramXidfe *extended, int id1, int id2, in
}
#define NO_ADDRESS (-1)
#define NO_ID (-1)
void set_filters(canio_listener_obj_t *self, size_t nmatch, canio_match_obj_t **matches) {
int fifo = self->fifo_idx;
@ -207,31 +208,31 @@ void set_filters(canio_listener_obj_t *self, size_t nmatch, canio_match_obj_t **
CanMramSidfe *standard = next_standard_filter(self, NULL);
CanMramXidfe *extended = next_extended_filter(self, NULL);
int first_address = NO_ADDRESS;
int first_id = NO_ID;
// step 1: single address standard matches
// step 1: single id standard matches
// we have to gather up pairs and stuff them in a single filter entry
for(size_t i = 0; i<nmatch; i++) {
canio_match_obj_t *match = matches[i];
if (match->extended) {
continue;
}
if (!single_address_filter(match)) {
if (!single_id_filter(match)) {
continue;
}
if (first_address != NO_ADDRESS) {
install_standard_filter(standard, first_address, match->address, CAN_SIDFE_0_SFEC_STF0M_Val + fifo, CAN_SIDFE_0_SFT_DUAL_Val);
first_address = NO_ADDRESS;
if (first_id != NO_ID) {
install_standard_filter(standard, first_id, match->id, CAN_SIDFE_0_SFEC_STF0M_Val + fifo, CAN_SIDFE_0_SFT_DUAL_Val);
first_id = NO_ID;
standard = next_standard_filter(self, standard);
} else {
first_address = match->address;
first_id = match->id;
}
}
// step 1.5. odd single address standard match
if (first_address != NO_ADDRESS) {
install_standard_filter(standard, first_address, first_address, CAN_SIDFE_0_SFEC_STF0M_Val + fifo, CAN_SIDFE_0_SFT_DUAL_Val);
// step 1.5. odd single id standard match
if (first_id != NO_ID) {
install_standard_filter(standard, first_id, first_id, CAN_SIDFE_0_SFEC_STF0M_Val + fifo, CAN_SIDFE_0_SFT_DUAL_Val);
standard = next_standard_filter(self, standard);
first_address = NO_ADDRESS;
first_id = NO_ID;
}
// step 2: standard mask filter
@ -240,36 +241,36 @@ void set_filters(canio_listener_obj_t *self, size_t nmatch, canio_match_obj_t **
if (match->extended) {
continue;
}
if (single_address_filter(match)) {
if (single_id_filter(match)) {
continue;
}
install_standard_filter(standard, match->address, match->mask, CAN_SIDFE_0_SFEC_STF0M_Val + fifo, CAN_SIDFE_0_SFT_CLASSIC_Val);
install_standard_filter(standard, match->id, match->mask, CAN_SIDFE_0_SFEC_STF0M_Val + fifo, CAN_SIDFE_0_SFT_CLASSIC_Val);
standard = next_standard_filter(self, standard);
}
// step 3: single address extended matches
// step 3: single id extended matches
// we have to gather up pairs and stuff them in a single filter entry
for(size_t i = 0; i<nmatch; i++) {
canio_match_obj_t *match = matches[i];
if (!match->extended) {
continue;
}
if (!single_address_filter(match)) {
if (!single_id_filter(match)) {
continue;
}
if (first_address != NO_ADDRESS) {
install_extended_filter(extended, first_address, match->address, CAN_XIDFE_0_EFEC_STF0M_Val + fifo, CAN_XIDFE_1_EFT_DUAL_Val);
first_address = NO_ADDRESS;
if (first_id != NO_ID) {
install_extended_filter(extended, first_id, match->id, CAN_XIDFE_0_EFEC_STF0M_Val + fifo, CAN_XIDFE_1_EFT_DUAL_Val);
first_id = NO_ID;
extended = next_extended_filter(self, extended);
} else {
first_address = match->address;
first_id = match->id;
}
}
// step 3.5. odd single address standard match
if (first_address != NO_ADDRESS) {
install_extended_filter(extended, first_address, first_address, CAN_XIDFE_0_EFEC_STF0M_Val + fifo, CAN_XIDFE_1_EFT_DUAL_Val);
// step 3.5. odd single id standard match
if (first_id != NO_ID) {
install_extended_filter(extended, first_id, first_id, CAN_XIDFE_0_EFEC_STF0M_Val + fifo, CAN_XIDFE_1_EFT_DUAL_Val);
extended = next_extended_filter(self, extended);
first_address = NO_ADDRESS;
first_id = NO_ID;
}
// step 4: extended mask filters
@ -278,10 +279,10 @@ void set_filters(canio_listener_obj_t *self, size_t nmatch, canio_match_obj_t **
if (!match->extended) {
continue;
}
if (single_address_filter(match)) {
if (single_id_filter(match)) {
continue;
}
install_extended_filter(extended, match->address, match->mask, CAN_XIDFE_0_EFEC_STF0M_Val + fifo, CAN_XIDFE_1_EFT_CLASSIC_Val);
install_extended_filter(extended, match->id, match->mask, CAN_XIDFE_0_EFEC_STF0M_Val + fifo, CAN_XIDFE_1_EFT_CLASSIC_Val);
extended = next_extended_filter(self, extended);
}
@ -348,30 +349,32 @@ int common_hal_canio_listener_in_waiting(canio_listener_obj_t *self) {
return self->hw->RXFS.bit.F0FL;
}
bool common_hal_canio_listener_readinto(canio_listener_obj_t *self, canio_message_obj_t *message) {
mp_obj_t common_hal_canio_listener_receive(canio_listener_obj_t *self) {
if (!common_hal_canio_listener_in_waiting(self)) {
uint64_t deadline = supervisor_ticks_ms64() + self->timeout_ms;
do {
if (supervisor_ticks_ms64() > deadline) {
return false;
return NULL;
}
} while (!common_hal_canio_listener_in_waiting(self));
}
int index = self->hw->RXFS.bit.F0GI;
canio_can_rx_fifo_t *hw_message = &self->fifo[index];
bool rtr = hw_message->rxf0.bit.RTR;
canio_message_obj_t *message = m_new_obj(canio_message_obj_t);
message->base.type = rtr ? &canio_remote_transmission_request_type : &canio_message_type;
message->extended = hw_message->rxf0.bit.XTD;
if (message->extended) {
message->id = hw_message->rxf0.bit.ID;
} else {
message->id = hw_message->rxf0.bit.ID >> 18; // short addresses are left-justified
message->id = hw_message->rxf0.bit.ID >> 18; // short ids are left-justified
}
message->rtr = hw_message->rxf0.bit.RTR;
message->size = hw_message->rxf1.bit.DLC;
if (!message->rtr) {
if (!rtr) {
memcpy(message->data, hw_message->data, message->size);
}
self->hw->RXFA.bit.F0AI = index;
return true;
return message;
}
void common_hal_canio_listener_deinit(canio_listener_obj_t *self) {

10
ports/atmel-samd/common-hal/canio/Listener.h
View File

@ -35,7 +35,7 @@ typedef struct {
__IO CAN_RXF0A_Type RXFA; /**< \brief (R/W 32) Rx FIFO n Acknowledge */
} canio_rxfifo_reg_t;
typedef struct {
typedef struct canio_listener_obj {
mp_obj_base_t base;
canio_can_obj_t *can;
canio_can_rx_fifo_t *fifo;
@ -43,11 +43,3 @@ typedef struct {
uint32_t timeout_ms;
uint8_t fifo_idx;
} canio_listener_obj_t;
void common_hal_canio_listener_construct(canio_listener_obj_t *self, canio_can_obj_t *can, size_t nmatch, canio_match_obj_t **matches, float timeout);
void common_hal_canio_listener_check_for_deinit(canio_listener_obj_t *self);
void common_hal_canio_listener_deinit(canio_listener_obj_t *self);
bool common_hal_canio_listener_readinto(canio_listener_obj_t *self, canio_message_obj_t *message);
int common_hal_canio_listener_in_waiting(canio_listener_obj_t *self);
float common_hal_canio_listener_get_timeout(canio_listener_obj_t *self);
void common_hal_canio_listener_set_timeout(canio_listener_obj_t *self, float timeout);

1
py/circuitpy_defns.mk
View File

@ -411,6 +411,7 @@ SRC_SHARED_MODULE_ALL = \
_bleio/ScanResults.c \
canio/Match.c \
canio/Message.c \
canio/RemoteTransmissionRequest.c \
_eve/__init__.c \
_pixelbuf/PixelBuf.c \
_pixelbuf/__init__.c \

80
shared-bindings/canio/CAN.c
View File

@ -171,59 +171,8 @@ STATIC const mp_obj_property_t canio_can_receive_error_count_obj = {
(mp_obj_t)mp_const_none},
};
//| error_warning_state_count: int
//| """The number of times the controller enterted the Error Warning state (read-only). This number wraps around to 0 after an implementation-defined number of errors."""
//|
STATIC mp_obj_t canio_can_error_warning_state_count_get(mp_obj_t self_in) {
canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
common_hal_canio_can_check_for_deinit(self);
return MP_OBJ_NEW_SMALL_INT(common_hal_canio_can_error_warning_state_count_get(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(canio_can_error_warning_state_count_get_obj, canio_can_error_warning_state_count_get);
STATIC const mp_obj_property_t canio_can_error_warning_state_count_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&canio_can_error_warning_state_count_get_obj,
(mp_obj_t)mp_const_none,
(mp_obj_t)mp_const_none},
};
//| error_passive_state_count: int
//| """The number of times the controller enterted the Error Passive state (read-only). This number wraps around to 0 after an implementation-defined number of errors."""
//|
STATIC mp_obj_t canio_can_error_passive_state_count_get(mp_obj_t self_in) {
canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
common_hal_canio_can_check_for_deinit(self);
return MP_OBJ_NEW_SMALL_INT(common_hal_canio_can_error_passive_state_count_get(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(canio_can_error_passive_state_count_get_obj, canio_can_error_passive_state_count_get);
STATIC const mp_obj_property_t canio_can_error_passive_state_count_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&canio_can_error_passive_state_count_get_obj,
(mp_obj_t)mp_const_none,
(mp_obj_t)mp_const_none},
};
//| bus_off_state_count: int
//| """The number of times the controller enterted the Bus Off state (read-only). This number wraps around to 0 after an implementation-defined number of errors."""
//|
STATIC mp_obj_t canio_can_bus_off_state_count_get(mp_obj_t self_in) {
canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
common_hal_canio_can_check_for_deinit(self);
return MP_OBJ_NEW_SMALL_INT(common_hal_canio_can_bus_off_state_count_get(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(canio_can_bus_off_state_count_get_obj, canio_can_bus_off_state_count_get);
STATIC const mp_obj_property_t canio_can_bus_off_state_count_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&canio_can_bus_off_state_count_get_obj,
(mp_obj_t)mp_const_none,
(mp_obj_t)mp_const_none},
};
//| state: State
//| """The current state of the bus."""
//| """The current state of the bus. (read-only)"""
STATIC mp_obj_t canio_can_state_get(mp_obj_t self_in) {
canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
common_hal_canio_can_check_for_deinit(self);
@ -252,7 +201,7 @@ STATIC mp_obj_t canio_can_restart(mp_obj_t self_in) {
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_can_restart_obj, canio_can_restart);
//| def listen(self, match: Optional[Sequence[Match]]=None, *, timeout: float=10) -> Listener:
//| def listen(self, matches: Optional[Sequence[Match]]=None, *, timeout: float=10) -> Listener:
//| """Start receiving messages that match any one of the filters.
//|
//| Creating a listener is an expensive operation and can interfere with reception of messages by other listeners.
@ -265,16 +214,16 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_can_restart_obj, canio_can_restart);
//|
//| An empty filter list causes all messages to be accepted.
//|
//| Timeout dictates how long readinto, read and next() will block."""
//| Timeout dictates how long receive() and next() will block."""
//| ...
//|
STATIC mp_obj_t canio_can_listen(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
canio_can_obj_t *self = MP_OBJ_TO_PTR(pos_args[0]);
common_hal_canio_can_check_for_deinit(self);
enum { ARG_match, ARG_timeout, NUM_ARGS };
enum { ARG_matches, ARG_timeout, NUM_ARGS };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_match, MP_ARG_OBJ, {.u_obj = 0} },
{ MP_QSTR_matches, MP_ARG_OBJ, {.u_obj = 0} },
{ MP_QSTR_timeout, MP_ARG_OBJ, {.u_obj = 0} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
@ -285,8 +234,8 @@ STATIC mp_obj_t canio_can_listen(size_t n_args, const mp_obj_t *pos_args, mp_map
size_t nmatch = 0;
mp_obj_t *match_objects = NULL;
if (args[ARG_match].u_obj) {
mp_obj_get_array(args[ARG_match].u_obj, &nmatch, &match_objects);
if (args[ARG_matches].u_obj) {
mp_obj_get_array(args[ARG_matches].u_obj, &nmatch, &match_objects);
}
canio_match_obj_t *matches[nmatch];
@ -307,7 +256,8 @@ STATIC mp_obj_t canio_can_listen(size_t n_args, const mp_obj_t *pos_args, mp_map
MP_DEFINE_CONST_FUN_OBJ_KW(canio_can_listen_obj, 1, canio_can_listen);
//| loopback: bool
//| """True if the device was created in loopback mode, False otherwise"""
//| """True if the device was created in loopback mode, False
//| otherwise (read-only)"""
//|
STATIC mp_obj_t canio_can_loopback_get(mp_obj_t self_in) {
canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
@ -324,7 +274,7 @@ STATIC const mp_obj_property_t canio_can_loopback_obj = {
};
//| def send(message: Message) -> None:
//| def send(message: Union[RemoteTransmissionRequest, Message]) -> None:
//| """Send a message on the bus with the given data and id.
//| If the message could not be sent due to a full fifo or a bus error condition, RuntimeError is raised.
//| """
@ -334,8 +284,8 @@ STATIC mp_obj_t canio_can_send(mp_obj_t self_in, mp_obj_t message_in) {
canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
common_hal_canio_can_check_for_deinit(self);
mp_obj_type_t *message_type = mp_obj_get_type(message_in);
if (message_type != &canio_message_type) {
mp_raise_TypeError_varg(translate("expected '%q' but got '%q'"), MP_QSTR_Message, message_type->name);
if (message_type != &canio_message_type && message_type != &canio_remote_transmission_request_type) {
mp_raise_TypeError_varg(translate("expected '%q' or '%q' but got '%q'"), MP_QSTR_Message, MP_QSTR_RemoteTransmissionRequest, message_type->name);
}
canio_message_obj_t *message = message_in;
@ -345,7 +295,8 @@ STATIC mp_obj_t canio_can_send(mp_obj_t self_in, mp_obj_t message_in) {
MP_DEFINE_CONST_FUN_OBJ_2(canio_can_send_obj, canio_can_send);
//| silent: bool
//| """True if the device was created in silent mode, False otherwise"""
//| """True if the device was created in silent mode, False
//| otherwise (read-only)"""
//|
STATIC mp_obj_t canio_can_silent_get(mp_obj_t self_in) {
canio_can_obj_t *self = MP_OBJ_TO_PTR(self_in);
@ -399,10 +350,7 @@ STATIC const mp_rom_map_elem_t canio_can_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&canio_can_exit_obj) },
{ MP_ROM_QSTR(MP_QSTR_auto_restart), MP_ROM_PTR(&canio_can_auto_restart_obj) },
{ MP_ROM_QSTR(MP_QSTR_baudrate), MP_ROM_PTR(&canio_can_baudrate_obj) },
{ MP_ROM_QSTR(MP_QSTR_bus_off_state_count), MP_ROM_PTR(&canio_can_bus_off_state_count_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&canio_can_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_error_passive_state_count), MP_ROM_PTR(&canio_can_error_passive_state_count_obj) },
{ MP_ROM_QSTR(MP_QSTR_error_warning_state_count), MP_ROM_PTR(&canio_can_error_warning_state_count_obj) },
{ MP_ROM_QSTR(MP_QSTR_listen), MP_ROM_PTR(&canio_can_listen_obj) },
{ MP_ROM_QSTR(MP_QSTR_loopback), MP_ROM_PTR(&canio_can_loopback_obj) },
{ MP_ROM_QSTR(MP_QSTR_receive_error_count), MP_ROM_PTR(&canio_can_receive_error_count_obj) },

6
shared-bindings/canio/CAN.h
View File

@ -28,6 +28,7 @@
#include "py/obj.h"
#include "shared-bindings/microcontroller/Pin.h"
#include "shared-bindings/canio/__init__.h"
#include "shared-bindings/canio/Message.h"
extern const mp_obj_type_t canio_can_type;
@ -38,9 +39,6 @@ void common_hal_canio_can_construct(canio_can_obj_t *self, mcu_pin_obj_t *tx, mc
bool common_hal_canio_can_auto_restart_get(canio_can_obj_t *self);
bool common_hal_canio_can_deinited(canio_can_obj_t *self);
int common_hal_canio_can_baudrate_get(canio_can_obj_t *self);
int common_hal_canio_can_bus_off_state_count_get(canio_can_obj_t *self);
int common_hal_canio_can_error_passive_state_count_get(canio_can_obj_t *self);
int common_hal_canio_can_error_warning_state_count_get(canio_can_obj_t *self);
bool common_hal_canio_can_loopback_get(canio_can_obj_t *self);
int common_hal_canio_can_receive_error_count_get(canio_can_obj_t *self);
canio_bus_state_t common_hal_canio_can_state_get(canio_can_obj_t *self);
@ -50,5 +48,5 @@ void common_hal_canio_can_auto_restart_set(canio_can_obj_t *self, bool auto_rest
void common_hal_canio_can_check_for_deinit(canio_can_obj_t *self);
void common_hal_canio_can_deinit(canio_can_obj_t *self);
void common_hal_canio_can_restart(canio_can_obj_t *self);
void common_hal_canio_can_send(canio_can_obj_t *self, canio_message_obj_t *message);
void common_hal_canio_can_send(canio_can_obj_t *self, mp_obj_t message);
void common_hal_canio_reset(void);

67
shared-bindings/canio/Listener.c
View File

@ -34,51 +34,39 @@
//| class Listener:
//| """Listens for CAN message
//|
//| canio.Listener is not constructed directly, but instead by calling the
//| Listen method of a canio.CAN object."""
//| `canio.Listener` is not constructed directly, but instead by calling
//| `canio.CAN.listen`.
//|
//| In addition to using the `receive` method to retrieve a message or
//| the `in_waiting` method to check for an available message, a
//| listener can be used as an iterable, yielding messages until no
//| message arrives within ``self.timeout`` seconds."""
//|
//| def read(self) -> Optional[Message]:
//| """Reads a message, after waiting up to self.timeout seconds
//| def receive(self) -> Optional[Union[RemoteTransmissionRequest,Message]]:
//| """Reads a message, after waiting up to ``self.timeout`` seconds
//|
//| If no message is received in time, None is returned. Otherwise,
//| a Message is returned."""
//| If no message is received in time, `None` is returned. Otherwise,
//| a `Message` or `RemoteTransmissionRequest` is returned."""
//| ...
//|
STATIC mp_obj_t canio_listener_read(mp_obj_t self_in) {
STATIC mp_obj_t canio_listener_receive(mp_obj_t self_in) {
canio_listener_obj_t *self = MP_OBJ_TO_PTR(self_in);
common_hal_canio_listener_check_for_deinit(self);
canio_message_obj_t *message = m_new_obj(canio_message_obj_t);
message->base.type = &canio_message_type;
mp_obj_t message = common_hal_canio_listener_receive(self);
// note: receive fills out the type field of the message
if (common_hal_canio_listener_readinto(self, message)) {
if (message) {
return message;
} else {
m_free(message); // message did not escape into vm
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_listener_read_obj, canio_listener_read);
//| def readinto(self, message: Message) -> bool:
//| """Returns True (and modifies message) if a message was received
//| before ``timeout`` seconds elapsed, False otherwise."""
//| ...
//|
STATIC mp_obj_t canio_listener_readinto(mp_obj_t self_in, mp_obj_t message) {
canio_listener_obj_t *self = MP_OBJ_TO_PTR(self_in);
mp_obj_type_t *type = mp_obj_get_type(message);
if (type != &canio_message_type) {
mp_raise_TypeError_varg(translate("expected '%q' but got '%q'"), MP_QSTR_Message, type->name);
}
common_hal_canio_listener_check_for_deinit(self);
return mp_obj_new_bool(common_hal_canio_listener_readinto(self, message));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(canio_listener_readinto_obj, canio_listener_readinto);
STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_listener_receive_obj, canio_listener_receive);
//| def in_waiting(self) -> int:
//| """Returns the number of messages waiting"""
//| """Returns the number of messages (including remote
//| transmission requests) waiting"""
//| ...
//|
STATIC mp_obj_t canio_listener_in_waiting(mp_obj_t self_in) {
@ -88,19 +76,25 @@ STATIC mp_obj_t canio_listener_in_waiting(mp_obj_t self_in) {
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(canio_listener_in_waiting_obj, canio_listener_in_waiting);
//| def __iter__(self):
//| """Returns self, unless the object is deinitialized"""
//| def __iter__(self) -> Listener:
//| """Returns self
//|
//| This method exists so that `Listener` can be used as an
//| iterable"""
//| ...
//|
//| def __next__(self):
//| def __next__(self) -> Union[RemoteTransmissionRequest,Message]:
//| """Reads a message, after waiting up to self.timeout seconds
//|
//| If no message is received in time, raises StopIteration. Otherwise,
//| a Message is returned."""
//| a Message or is returned.
//|
//| This method enables the `Listener` to be used as an
//| iterable, for instance in a for-loop."""
//| ...
//|
STATIC mp_obj_t canio_iternext(mp_obj_t self_in) {
mp_obj_t result = canio_listener_read(self_in);
mp_obj_t result = canio_listener_receive(self_in);
if (result == mp_const_none) {
return MP_OBJ_STOP_ITERATION;
}
@ -170,8 +164,7 @@ STATIC const mp_rom_map_elem_t canio_listener_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&canio_listener_exit_obj) },
{ MP_ROM_QSTR(MP_QSTR_deinit), MP_ROM_PTR(&canio_listener_deinit_obj) },
{ MP_ROM_QSTR(MP_QSTR_in_waiting), MP_ROM_PTR(&canio_listener_in_waiting_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&canio_listener_read_obj) },
{ MP_ROM_QSTR(MP_QSTR_readinto), MP_ROM_PTR(&canio_listener_readinto_obj) },
{ MP_ROM_QSTR(MP_QSTR_receive), MP_ROM_PTR(&canio_listener_receive_obj) },
{ MP_ROM_QSTR(MP_QSTR_timeout), MP_ROM_PTR(&canio_listener_timeout_obj) },
};
STATIC MP_DEFINE_CONST_DICT(canio_listener_locals_dict, canio_listener_locals_dict_table);

12
shared-bindings/canio/Listener.h
View File

@ -27,5 +27,17 @@
#pragma once
#include "py/obj.h"
#include "shared-bindings/canio/CAN.h"
#include "shared-bindings/canio/Match.h"
extern const mp_obj_type_t canio_listener_type;
typedef struct canio_listener_obj canio_listener_obj_t;
void common_hal_canio_listener_construct(canio_listener_obj_t *self, canio_can_obj_t *can, size_t nmatch, canio_match_obj_t **matches, float timeout);
void common_hal_canio_listener_check_for_deinit(canio_listener_obj_t *self);
void common_hal_canio_listener_deinit(canio_listener_obj_t *self);
mp_obj_t common_hal_canio_listener_receive(canio_listener_obj_t *self);
int common_hal_canio_listener_in_waiting(canio_listener_obj_t *self);
float common_hal_canio_listener_get_timeout(canio_listener_obj_t *self);
void common_hal_canio_listener_set_timeout(canio_listener_obj_t *self, float timeout);

50
shared-bindings/canio/Match.c
View File

@ -33,20 +33,20 @@
//| """Describe CAN bus messages to match"""
//|
//|
//| def __init__(self, address: int, *, mask: int = 0, extended: bool = False):
//| def __init__(self, id: int, *, mask: Optional[int] = None, extended: bool = False):
//| """Construct a Match with the given properties.
//|
//| If mask is nonzero, then the filter is for any sender which matches all
//| the nonzero bits in mask. Otherwise, it matches exactly the given address.
//| If extended is true then only extended addresses are matched, otherwise
//| only standard addresses are matched."""
//| If mask is not None, then the filter is for any id which matches all
//| the nonzero bits in mask. Otherwise, it matches exactly the given id.
//| If extended is true then only extended ids are matched, otherwise
//| only standard ids are matched."""
//|
STATIC mp_obj_t canio_match_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_address, ARG_mask, ARG_extended, NUM_ARGS };
enum { ARG_id, ARG_mask, ARG_extended, NUM_ARGS };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_address, MP_ARG_INT | MP_ARG_REQUIRED },
{ MP_QSTR_mask, MP_ARG_INT, {.u_int = 0} },
{ MP_QSTR_id, MP_ARG_INT | MP_ARG_REQUIRED },
{ MP_QSTR_mask, MP_ARG_OBJ, {.u_obj = mp_const_none } },
{ MP_QSTR_extended, MP_ARG_BOOL, {.u_bool = false} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
@ -54,44 +54,44 @@ STATIC mp_obj_t canio_match_make_new(const mp_obj_type_t *type, size_t n_args, c
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
int address_bits = args[ARG_extended].u_bool ? 0x1fffffff : 0x7ff;
int address = args[ARG_address].u_int;
int mask = args[ARG_mask].u_int;
int id_bits = args[ARG_extended].u_bool ? 0x1fffffff : 0x7ff;
int id = args[ARG_id].u_int;
int mask = args[ARG_mask].u_obj == mp_const_none ? id_bits : mp_obj_get_int(args[ARG_mask].u_obj);
if (address & ~address_bits) {
mp_raise_ValueError_varg(translate("%q out of range"), MP_QSTR_address);
if (id & ~id_bits) {
mp_raise_ValueError_varg(translate("%q out of range"), MP_QSTR_id);
}
if (mask & ~address_bits) {
if (mask & ~id_bits) {
mp_raise_ValueError_varg(translate("%q out of range"), MP_QSTR_mask);
}
canio_match_obj_t *self = m_new_obj(canio_match_obj_t);
self->base.type = &canio_match_type;
common_hal_canio_match_construct(self, args[ARG_address].u_int, args[ARG_mask].u_int, args[ARG_extended].u_bool);
common_hal_canio_match_construct(self, id, mask, args[ARG_extended].u_bool);
return self;
}
//| address: int
//| """The address to match"""
//| id: int
//| """The id to match"""
//|
STATIC mp_obj_t canio_match_address_get(mp_obj_t self_in) {
STATIC mp_obj_t canio_match_id_get(mp_obj_t self_in) {
canio_match_obj_t *self = self_in;
return MP_OBJ_NEW_SMALL_INT(common_hal_canio_match_get_address(self));
return MP_OBJ_NEW_SMALL_INT(common_hal_canio_match_get_id(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(canio_match_address_get_obj, canio_match_address_get);
MP_DEFINE_CONST_FUN_OBJ_1(canio_match_id_get_obj, canio_match_id_get);
const mp_obj_property_t canio_match_address_obj = {
const mp_obj_property_t canio_match_id_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&canio_match_address_get_obj,
.proxy = {(mp_obj_t)&canio_match_id_get_obj,
(mp_obj_t)&mp_const_none_obj,
(mp_obj_t)&mp_const_none_obj},
};
//|
//| mask: int
//| """The optional mask of addresses to match"""
//| """The optional mask of ids to match"""
//|
STATIC mp_obj_t canio_match_mask_get(mp_obj_t self_in) {
@ -108,7 +108,7 @@ const mp_obj_property_t canio_match_mask_obj = {
};
//| extended: bool
//| """True to match extended addresses, False to match standard addresses"""
//| """True to match extended ids, False to match standard ides"""
//|
STATIC mp_obj_t canio_match_extended_get(mp_obj_t self_in) {
@ -125,7 +125,7 @@ const mp_obj_property_t canio_match_extended_obj = {
};
STATIC const mp_rom_map_elem_t canio_match_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_address), MP_ROM_PTR(&canio_match_address_obj) },
{ MP_ROM_QSTR(MP_QSTR_id), MP_ROM_PTR(&canio_match_id_obj) },
{ MP_ROM_QSTR(MP_QSTR_mask), MP_ROM_PTR(&canio_match_mask_obj) },
{ MP_ROM_QSTR(MP_QSTR_extended), MP_ROM_PTR(&canio_match_extended_obj) },
};

4
shared-bindings/canio/Match.h
View File

@ -31,7 +31,7 @@
extern const mp_obj_type_t canio_match_type;
void common_hal_canio_match_construct(canio_match_obj_t *self, int address, int mask, bool extended);
int common_hal_canio_match_get_address(const canio_match_obj_t *self);
void common_hal_canio_match_construct(canio_match_obj_t *self, int id, int mask, bool extended);
int common_hal_canio_match_get_id(const canio_match_obj_t *self);
int common_hal_canio_match_get_mask(const canio_match_obj_t *self);
bool common_hal_canio_match_get_extended(const canio_match_obj_t *self);

75
shared-bindings/canio/Message.c
View File

@ -31,28 +31,22 @@
#include "py/runtime.h"
//| class Message:
//| def __init__(self, id: int=0, data: Optional[bytes] = None, *, size: Optional[int] = None, rtr: bool = False, extended: bool = False):
//| """Construct a Message to use with a CAN bus. Provide arguments to create a message to send. Otherwise, use Listener.readinto() to read a message.
//| def __init__(self, id: int, data: bytes, *, extended: bool = False):
//| """Construct a Message to send on a CAN bus.
//|
//| :param int id: The numeric ID of the message
//| :param bytes data: The content of the message
//| :param int size: The amount of data requested, for an rtr
//| :param bool rtr: True if the message represents an rtr (Remote Transmission Request)
//| :param bool extended: True if the message has an extended identifier, False if it has a standard identifier
//|
//| In CAN, messages can have a size from 0 to 8 bytes.
//|
//| For a non-rtr message, specify ``data``. For an rtr-message, specify either ``data`` (a dummy buffer of the requested size) or ``size``.
//| In CAN, messages can have a length from 0 to 8 bytes.
//| """
//| ...
//|
STATIC mp_obj_t canio_message_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_id, ARG_data, ARG_size, ARG_rtr, ARG_extended, NUM_ARGS };
enum { ARG_id, ARG_data, ARG_extended, NUM_ARGS };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_INT, {.u_obj = 0} },
{ MP_QSTR_data, MP_ARG_OBJ, {.u_obj = 0} },
{ MP_QSTR_size, MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_rtr, MP_ARG_BOOL, {.u_bool = false} },
{ MP_QSTR_id, MP_ARG_INT | MP_ARG_REQUIRED },
{ MP_QSTR_data, MP_ARG_OBJ | MP_ARG_REQUIRED },
{ MP_QSTR_extended, MP_ARG_BOOL, {.u_bool = false} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
@ -60,26 +54,8 @@ STATIC mp_obj_t canio_message_make_new(const mp_obj_type_t *type, size_t n_args,
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
bool rtr = args[ARG_rtr].u_bool;
bool extended = args[ARG_extended].u_bool;
size_t size = (size_t)args[ARG_size].u_int;
bool specified_size = (size != (size_t)-1);
bool specified_data = (args[ARG_data].u_obj != NULL);
if (specified_size && specified_data) {
mp_raise_TypeError(translate("specify size or data, but not both"));
}
mp_buffer_info_t data;
if (specified_data) {
mp_get_buffer_raise(args[ARG_data].u_obj, &data, MP_BUFFER_READ);
} else if (specified_size) {
data.buf = 0;
data.len = size;
} else {
data.buf = 0;
data.len = 0;
}
mp_get_buffer_raise(args[ARG_data].u_obj, &data, MP_BUFFER_READ);
if (data.len > 8) {
mp_raise_ValueError(translate("Messages limited to 8 bytes"));
@ -87,7 +63,7 @@ STATIC mp_obj_t canio_message_make_new(const mp_obj_type_t *type, size_t n_args,
canio_message_obj_t *self = m_new_obj(canio_message_obj_t);
self->base.type = &canio_message_type;
common_hal_canio_message_construct(self, args[ARG_id].u_int, data.buf, data.len, rtr, extended);
common_hal_canio_message_construct(self, args[ARG_id].u_int, data.buf, data.len, args[ARG_extended].u_bool);
return self;
}
@ -115,13 +91,11 @@ STATIC const mp_obj_property_t canio_message_id_obj = {
};
//| data: bytes
//| """The content of the message, or dummy content in the case of an rtr.
//|
//| Assigning to data also sets the length and clears the rtr flag."""
//| """The content of the message"""
//|
STATIC mp_obj_t canio_message_data_get(const mp_obj_t self_in) {
canio_message_obj_t *self = self_in;
return mp_obj_new_bytes((const byte*)common_hal_canio_message_get_data(self), common_hal_canio_message_get_size(self));
return mp_obj_new_bytes((const byte*)common_hal_canio_message_get_data(self), common_hal_canio_message_get_length(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(canio_message_data_get_obj, canio_message_data_get);
@ -147,7 +121,7 @@ STATIC const mp_obj_property_t canio_message_data_obj = {
//| extended: bool
//| """True if the message represents a remote transmission request (RTR)"""
//| """True if the message's id is an extended id"""
//|
STATIC mp_obj_t canio_message_extended_get(const mp_obj_t self_in) {
canio_message_obj_t *self = self_in;
@ -170,36 +144,9 @@ STATIC const mp_obj_property_t canio_message_extended_obj = {
(mp_obj_t)&mp_const_none_obj},
};
//| rtr: bool
//| """True if the message represents a remote transmission request (RTR). Setting rtr to true zeros out data"""
//|
STATIC mp_obj_t canio_message_rtr_get(const mp_obj_t self_in) {
canio_message_obj_t *self = self_in;
return mp_obj_new_bool(common_hal_canio_message_get_rtr(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(canio_message_rtr_get_obj, canio_message_rtr_get);
STATIC mp_obj_t canio_message_rtr_set(const mp_obj_t self_in, const mp_obj_t rtr) {
canio_message_obj_t *self = self_in;
common_hal_canio_message_set_rtr(self, mp_obj_is_true(rtr));
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(canio_message_rtr_set_obj, canio_message_rtr_set);
STATIC const mp_obj_property_t canio_message_rtr_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&canio_message_rtr_get_obj,
(mp_obj_t)&canio_message_rtr_set_obj,
(mp_obj_t)&mp_const_none_obj},
};
STATIC const mp_rom_map_elem_t canio_message_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_id), MP_ROM_PTR(&canio_message_id_obj) },
{ MP_ROM_QSTR(MP_QSTR_data), MP_ROM_PTR(&canio_message_data_obj) },
{ MP_ROM_QSTR(MP_QSTR_rtr), MP_ROM_PTR(&canio_message_rtr_obj) },
{ MP_ROM_QSTR(MP_QSTR_extended), MP_ROM_PTR(&canio_message_extended_obj) },
};
STATIC MP_DEFINE_CONST_DICT(canio_message_locals_dict, canio_message_locals_dict_table);

8
shared-bindings/canio/Message.h
View File

@ -30,15 +30,13 @@
#include "shared-module/canio/Message.h"
extern const mp_obj_type_t canio_message_type;
extern const mp_obj_type_t canio_remote_transmission_request_type;
void common_hal_canio_message_construct(canio_message_obj_t *self, int id, void *data, size_t size, bool rtr, bool extended);
void common_hal_canio_message_construct(canio_message_obj_t *self, int id, void *data, size_t size, bool extended);
const void *common_hal_canio_message_get_data(const canio_message_obj_t *self);
void common_hal_canio_message_set_data(canio_message_obj_t *self, const void *data, size_t size);
bool common_hal_canio_message_get_extended(const canio_message_obj_t *self);
void common_hal_canio_message_set_extended(canio_message_obj_t *self, bool extended);
int common_hal_canio_message_get_id(const canio_message_obj_t *self);
void common_hal_canio_message_set_id(canio_message_obj_t *self, int id);
bool common_hal_canio_message_get_rtr(const canio_message_obj_t *self);
void common_hal_canio_message_set_rtr(canio_message_obj_t *self, bool rtr);
size_t common_hal_canio_message_get_size(const canio_message_obj_t *self);
void common_hal_canio_message_set_size(canio_message_obj_t *self, size_t size);
size_t common_hal_canio_message_get_length(const canio_message_obj_t *self);

156
shared-bindings/canio/RemoteTransmissionRequest.c Normal file
View File

@ -0,0 +1,156 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2020 Jeff Epler for Adafruit Industries
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "shared-bindings/canio/RemoteTransmissionRequest.h"
#include "py/obj.h"
#include "py/objproperty.h"
#include "py/runtime.h"
//| class RemoteTransmissionRequest:
//| def __init__(self, id: int, length: int, *, extended: bool = False):
//| """Construct a RemoteTransmissionRequest to send on a CAN bus.
//|
//| :param int id: The numeric ID of the requested message
//| :param int length: The length of the requested message
//| :param bool extended: True if the message has an extended identifier, False if it has a standard identifier
//|
//| In CAN, messages can have a length from 0 to 8 bytes.
//| """
//| ...
//|
STATIC mp_obj_t canio_remote_transmission_request_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_id, ARG_length, ARG_extended, NUM_ARGS };
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_id, MP_ARG_INT | MP_ARG_REQUIRED },
{ MP_QSTR_length, MP_ARG_INT | MP_ARG_REQUIRED },
{ MP_QSTR_extended, MP_ARG_BOOL, {.u_bool = false} },
};
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
MP_STATIC_ASSERT( MP_ARRAY_SIZE(allowed_args) == NUM_ARGS );
mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
int length = args[ARG_length].u_int;
if (length < 0 || length > 8) {
mp_raise_ValueError(translate("RemoteTransmissionRequests limited to 8 bytes"));
}
canio_remote_transmission_request_obj_t *self = m_new_obj(canio_remote_transmission_request_obj_t);
self->base.type = &canio_remote_transmission_request_type;
common_hal_canio_remote_transmission_request_construct(self, args[ARG_id].u_int, length, args[ARG_extended].u_bool);
return self;
}
//| id: int
//| """The numeric ID of the message"""
//|
STATIC mp_obj_t canio_remote_transmission_request_id_get(const mp_obj_t self_in) {
canio_remote_transmission_request_obj_t *self = self_in;
return MP_OBJ_NEW_SMALL_INT(common_hal_canio_remote_transmission_request_get_id(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(canio_remote_transmission_request_id_get_obj, canio_remote_transmission_request_id_get);
STATIC mp_obj_t canio_remote_transmission_request_id_set(const mp_obj_t self_in, const mp_obj_t id) {
canio_remote_transmission_request_obj_t *self = self_in;
common_hal_canio_remote_transmission_request_set_id(self, mp_obj_get_int(id));
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(canio_remote_transmission_request_id_set_obj, canio_remote_transmission_request_id_set);
STATIC const mp_obj_property_t canio_remote_transmission_request_id_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&canio_remote_transmission_request_id_get_obj,
(mp_obj_t)&canio_remote_transmission_request_id_set_obj,
(mp_obj_t)&mp_const_none_obj},
};
//| extended: bool
//| """True if the message's id is an extended id"""
//|
STATIC mp_obj_t canio_remote_transmission_request_extended_get(const mp_obj_t self_in) {
canio_remote_transmission_request_obj_t *self = self_in;
return mp_obj_new_bool(common_hal_canio_remote_transmission_request_get_extended(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(canio_remote_transmission_request_extended_get_obj, canio_remote_transmission_request_extended_get);
STATIC mp_obj_t canio_remote_transmission_request_extended_set(const mp_obj_t self_in, const mp_obj_t extended) {
canio_remote_transmission_request_obj_t *self = self_in;
common_hal_canio_remote_transmission_request_set_extended(self, mp_obj_is_true(extended));
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(canio_remote_transmission_request_extended_set_obj, canio_remote_transmission_request_extended_set);
STATIC const mp_obj_property_t canio_remote_transmission_request_extended_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&canio_remote_transmission_request_extended_get_obj,
(mp_obj_t)&canio_remote_transmission_request_extended_set_obj,
(mp_obj_t)&mp_const_none_obj},
};
//| length: int
//| """The length of the requested message."""
//|
STATIC mp_obj_t canio_remote_transmission_request_length_get(const mp_obj_t self_in) {
canio_remote_transmission_request_obj_t *self = self_in;
return MP_OBJ_NEW_SMALL_INT(common_hal_canio_remote_transmission_request_get_length(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(canio_remote_transmission_request_length_get_obj, canio_remote_transmission_request_length_get);
STATIC mp_obj_t canio_remote_transmission_request_length_set(const mp_obj_t self_in, const mp_obj_t length_in) {
canio_remote_transmission_request_obj_t *self = self_in;
int length = mp_obj_get_int(length_in);
if (length < 0 || length > 8) {
mp_raise_ValueError(translate("RemoteTransmissionRequests limited to 8 bytes"));
}
common_hal_canio_remote_transmission_request_set_length(self, length);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(canio_remote_transmission_request_length_set_obj, canio_remote_transmission_request_length_set);
STATIC const mp_obj_property_t canio_remote_transmission_request_length_obj = {
.base.type = &mp_type_property,
.proxy = {(mp_obj_t)&canio_remote_transmission_request_length_get_obj,
(mp_obj_t)&canio_remote_transmission_request_length_set_obj,
(mp_obj_t)&mp_const_none_obj},
};
STATIC const mp_rom_map_elem_t canio_remote_transmission_request_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_id), MP_ROM_PTR(&canio_remote_transmission_request_id_obj) },
{ MP_ROM_QSTR(MP_QSTR_length), MP_ROM_PTR(&canio_remote_transmission_request_length_obj) },
{ MP_ROM_QSTR(MP_QSTR_extended), MP_ROM_PTR(&canio_remote_transmission_request_extended_obj) },
};
STATIC MP_DEFINE_CONST_DICT(canio_remote_transmission_request_locals_dict, canio_remote_transmission_request_locals_dict_table);
const mp_obj_type_t canio_remote_transmission_request_type = {
{ &mp_type_type },
.name = MP_QSTR_RemoteTransmissionRequest,
.make_new = canio_remote_transmission_request_make_new,
.locals_dict = (mp_obj_t)&canio_remote_transmission_request_locals_dict,
};

42
shared-bindings/canio/RemoteTransmissionRequest.h Normal file
View File

@ -0,0 +1,42 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2020 Jeff Epler for Adafruit Industries
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#pragma once
#include "py/obj.h"
#include "shared-module/canio/RemoteTransmissionRequest.h"
extern const mp_obj_type_t canio_remote_transmission_request_type;
void common_hal_canio_remote_transmission_request_construct(canio_remote_transmission_request_obj_t *self, int id, size_t size, bool extended);
const void *common_hal_canio_remote_transmission_request_get_data(const canio_remote_transmission_request_obj_t *self);
void common_hal_canio_remote_transmission_request_set_data(canio_remote_transmission_request_obj_t *self, const void *data, size_t size);
bool common_hal_canio_remote_transmission_request_get_extended(const canio_remote_transmission_request_obj_t *self);
void common_hal_canio_remote_transmission_request_set_extended(canio_remote_transmission_request_obj_t *self, bool extended);
int common_hal_canio_remote_transmission_request_get_id(const canio_remote_transmission_request_obj_t *self);
void common_hal_canio_remote_transmission_request_set_id(canio_remote_transmission_request_obj_t *self, int id);
size_t common_hal_canio_remote_transmission_request_get_length(const canio_remote_transmission_request_obj_t *self);
void common_hal_canio_remote_transmission_request_set_length(canio_remote_transmission_request_obj_t *self, size_t length);

5
shared-bindings/canio/__init__.c
View File

@ -40,8 +40,8 @@
//| from board import *
//|
//| can = canio.CAN(board.CAN_RX, board.CAN_TX, baudrate=1000000)
//| message = canio.Message(id=0x0408, data="adafruit"
//| can.write(message))
//| message = canio.Message(id=0x0408, data=b"adafruit")
//| can.send(message)
//| can.deinit()
//|
//| This example will write the data 'adafruit' onto the CAN bus to any
@ -113,6 +113,7 @@ STATIC const mp_rom_map_elem_t canio_module_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR_Listener), MP_ROM_PTR(&canio_listener_type) },
{ MP_ROM_QSTR(MP_QSTR_Match), MP_ROM_PTR(&canio_match_type) },
{ MP_ROM_QSTR(MP_QSTR_Message), MP_ROM_PTR(&canio_message_type) },
{ MP_ROM_QSTR(MP_QSTR_RemoteTransmissionRequest), MP_ROM_PTR(&canio_remote_transmission_request_type) },
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__canio) },
};

8
shared-module/canio/Match.c
View File

@ -26,14 +26,14 @@
#include "shared-module/canio/Match.h"
void common_hal_canio_match_construct(canio_match_obj_t *self, int address, int mask, bool extended) {
self->address = address;
void common_hal_canio_match_construct(canio_match_obj_t *self, int id, int mask, bool extended) {
self->id = id;
self->mask = mask;
self->extended = extended;
}
int common_hal_canio_match_get_address(const canio_match_obj_t *self) {
return self->address;
int common_hal_canio_match_get_id(const canio_match_obj_t *self) {
return self->id;
}
int common_hal_canio_match_get_mask(const canio_match_obj_t *self) {
return self->mask;

2
shared-module/canio/Match.h
View File

@ -30,7 +30,7 @@
typedef struct {
mp_obj_base_t base;
int address;
int id;
int mask;
bool extended;
} canio_match_obj_t;

28
shared-module/canio/Message.c
View File

@ -28,16 +28,13 @@
#include <string.h>
void common_hal_canio_message_construct(canio_message_obj_t *self, int id, void *data, size_t size, bool rtr, bool extended)
void common_hal_canio_message_construct(canio_message_obj_t *self, int id, void *data, size_t size, bool extended)
{
self->id = id;
self->size = size;
self->rtr = rtr;
self->extended = extended;
if (data) {
memcpy(self->data, data, size);
} else {
memset(self->data, 0, size);
}
}
@ -59,37 +56,16 @@ const void *common_hal_canio_message_get_data(const canio_message_obj_t *self)
const void common_hal_canio_message_set_data(canio_message_obj_t *self, const void *data, size_t size)
{
self->rtr = false;
self->size = size;
memcpy(self->data, data, size);
}
size_t common_hal_canio_message_get_size(const canio_message_obj_t *self)
size_t common_hal_canio_message_get_length(const canio_message_obj_t *self)
{
return self->size;
}
void common_hal_canio_message_set_size(canio_message_obj_t *self, size_t size)
{
memset(self->data, 0, size);
self->size = size;
}
bool common_hal_canio_message_get_rtr(const canio_message_obj_t *self)
{
return self->rtr;
}
void common_hal_canio_message_set_rtr(canio_message_obj_t *self, bool rtr)
{
self->rtr = rtr;
if (rtr) {
memset(self->data, 0, self->size);
}
}
bool common_hal_canio_message_get_extended(const canio_message_obj_t *self)
{
return self->extended;

1
shared-module/canio/Message.h
View File

@ -33,6 +33,5 @@ typedef struct {
int id;
uint8_t data[8];
size_t size:4;
bool rtr:1;
bool extended:1;
} canio_message_obj_t;

67
shared-module/canio/RemoteTransmissionRequest.c Normal file
View File

@ -0,0 +1,67 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2020 Jeff Epler for Adafruit Industries
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "shared-module/canio/RemoteTransmissionRequest.h"
#include "shared-bindings/canio/RemoteTransmissionRequest.h"
#include <string.h>
void common_hal_canio_remote_transmission_request_construct(canio_remote_transmission_request_obj_t *self, int id, size_t size, bool extended)
{
self->id = id;
self->size = size;
self->extended = extended;
}
int common_hal_canio_remote_transmission_request_get_id(const canio_remote_transmission_request_obj_t *self)
{
return self->id;
}
void common_hal_canio_remote_transmission_request_set_id(canio_remote_transmission_request_obj_t *self, int id)
{
self->id = id;
}
size_t common_hal_canio_remote_transmission_request_get_length(const canio_remote_transmission_request_obj_t *self)
{
return self->size;
}
void common_hal_canio_remote_transmission_request_set_length(canio_remote_transmission_request_obj_t *self, size_t size)
{
self->size = size;
}
bool common_hal_canio_remote_transmission_request_get_extended(const canio_remote_transmission_request_obj_t *self)
{
return self->extended;
}
void common_hal_canio_remote_transmission_request_set_extended(canio_remote_transmission_request_obj_t *self, bool extended)
{
self->extended = extended;
}

33
shared-module/canio/RemoteTransmissionRequest.h Normal file
View File

@ -0,0 +1,33 @@
/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2020 Jeff Epler for Adafruit Industries
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#pragma once
#include "py/obj.h"
#include "shared-bindings/canio/Message.h"
typedef canio_message_obj_t canio_remote_transmission_request_obj_t;