void get_send_timeout_count(const ComType com, const GetSendTimeoutCount *data) {
#ifdef BRICK_CAN_BE_MASTER
if(data->communication_method > COM_WIFI2) {
#else
if(data->communication_method > COM_SPI_STACK) {
#endif
com_return_error(data, sizeof(GetSendTimeoutCountReturn), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com);
logblete("Communication Method %d does not exist (get_send_timeout_count)\n\r", data->communication_method);
return;
}
GetSendTimeoutCountReturn gtcr;
gtcr.header = data->header;
gtcr.header.length = sizeof(GetSendTimeoutCountReturn);
gtcr.timeout_count = com_timeout_count[data->communication_method];
send_blocking_with_timeout(>cr, sizeof(GetSendTimeoutCountReturn), com);
}
#ifdef BRICK_HAS_CO_MCU_SUPPORT
void set_spitfp_baudrate(const ComType com, const SetSPITFPBaudrate *data) {
uint8_t port = tolower((uint8_t)data->bricklet_port) - 'a';
if(port >= BRICKLET_NUM) {
com_return_error(data, sizeof(GetSPITFPErrorCountReturn), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com);
logblete("Bricklet Port %d does not exist (set_spitfp_baudrate)\n\r", port);
return;
}
if(bricklet_attached[port] == BRICKLET_INIT_CO_MCU) {
bricklet_spitfp_baudrate[port] = BETWEEN(CO_MCU_MINIMUM_BAUDRATE, data->baudrate, CO_MCU_MAXIMUM_BAUDRATE);
}
com_return_setter(com, data);
}
bool com_route_message_brick(const char *data, const uint16_t length, const ComType com) {
com_info.current = com;
MessageHeader *header = (MessageHeader*)data;
if(header->uid == 0) {
const ComMessage *com_message = get_com_from_header(header);
if(com_message != NULL && com_message->reply_func != NULL) {
com_message->reply_func(com, (void*)data);
}
#ifdef BRICK_HAS_CO_MCU_SUPPORT
for(uint8_t i = 0; i < BRICKLET_NUM; i++) {
if(bricklet_attached[i] == BRICKLET_INIT_CO_MCU) {
bricklet_co_mcu_send(i, (void*)data, length);
}
}
#endif
return false;
} else if(header->uid == com_info.uid) {
const ComMessage *com_message = get_com_from_header(header);
if(com_message != NULL && com_message->reply_func != NULL) {
com_message->reply_func(com, (void*)data);
return true;
} else {
com_return_error(data, sizeof(MessageHeader), MESSAGE_ERROR_CODE_NOT_SUPPORTED, com);
}
return false;
}
for(uint8_t i = 0; i < BRICKLET_NUM; i++) {
if(bs[i].uid == header->uid) {
#ifdef BRICK_HAS_CO_MCU_SUPPORT
if(bricklet_attached[i] == BRICKLET_INIT_CO_MCU) {
bricklet_co_mcu_send(i, (void*)data, length);
} else
#endif
if(header->fid == FID_GET_IDENTITY) {
const ComMessage *com_message = get_com_from_header(header);
if(com_message != NULL && com_message->reply_func != NULL) {
com_message->reply_func(com, (void*)data);
return true;
} else {
com_return_error(data, sizeof(MessageHeader), MESSAGE_ERROR_CODE_NOT_SUPPORTED, com);
}
} else {
baddr[i].entry(BRICKLET_TYPE_INVOCATION, com, (void*)data);
return true;
}
}
}
return false;
}
void get_spitfp_error_count(const ComType com, const GetSPITFPErrorCount *data) {
uint8_t port = tolower((uint8_t)data->bricklet_port) - 'a';
if(port >= BRICKLET_NUM) {
com_return_error(data, sizeof(GetSPITFPErrorCountReturn), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com);
logblete("Bricklet Port %d does not exist (get_spitfp_error_count)\n\r", port);
return;
}
GetSPITFPErrorCountReturn gsecr;
gsecr.header = data->header;
gsecr.header.length = sizeof(GetSPITFPErrorCountReturn);
if(bricklet_attached[port] == BRICKLET_INIT_CO_MCU) {
gsecr.error_count_ack_checksum = CO_MCU_DATA(port)->error_count.error_count_ack_checksum;
gsecr.error_count_message_checksum = CO_MCU_DATA(port)->error_count.error_count_message_checksum;
gsecr.error_count_frame = CO_MCU_DATA(port)->error_count.error_count_frame;
} else {
gsecr.error_count_ack_checksum = 0;
gsecr.error_count_message_checksum = 0;
gsecr.error_count_frame = 0;
}
// There is no overflow in SPITFP on master side possible
// We keep it to here to be able to use the same API between Co-MCU Bricklets and Bricks
gsecr.error_count_overflow = 0;
send_blocking_with_timeout(&gsecr, sizeof(GetSPITFPErrorCountReturn), com);
}
void com_adc_calibrate(const ComType com, const ADCCalibrate *data) {
uint8_t port = (uint8_t)(tolower((uint8_t)data->bricklet_port) - 'a');
if(port >= BRICKLET_NUM) {
com_return_error(data, sizeof(MessageHeader), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com);
logblete("Bricklet Port %d does not exist (adc calibrate)\n\r", port);
return;
}
adc_calibrate(bs[port].adc_channel);
adc_write_calibration_to_flash();
com_return_setter(com, data);
logd("ADC Calibrate (port %c)\n\r", data->bricklet_port);
}
void set_step_configuration(const ComType com, const SetStepConfiguration *data) {
if(data->step_resolution > 8) {
com_return_error(data, sizeof(MessageHeader), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com);
return;
}
tmc2130_reg_chopconf.bit.mres = data->step_resolution;
tmc2130_reg_chopconf.bit.intpol = data->interpolation;
tcm2130_register_to_write_mask |= TMC2130_REG_CHOPCONF_BIT;
tcm2130_handle_register_read_and_write();
com_return_setter(com, data);
}
void set_spreadcycle_configuration(const ComType com, const SetSpreadcycleConfiguration *data) {
if((data->slow_decay_duration > 15) ||
(data->fast_decay_duration > 15) ||
(data->hysteresis_start_value > 7) ||
(data->hysteresis_end_value < -3 || data->hysteresis_end_value > 12) ||
(data->sinewave_offset < -3 || data->sinewave_offset > 12) ||
(data->chopper_mode > 1) ||
(data->comperator_blank_time > 3)) {
com_return_error(data, sizeof(MessageHeader), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com);
return;
}
tmc2130_reg_chopconf.bit.toff = data->slow_decay_duration;
tmc2130_reg_chopconf.bit.rndtf = data->enable_random_slow_decay;
if(data->chopper_mode) {
tmc2130_reg_chopconf.bit.hstrt = data->fast_decay_duration & 0b111;
tmc2130_reg_chopconf.bit.fd3 = (data->fast_decay_duration >> 3) & 0b1;
tmc2130_reg_chopconf.bit.hend = data->sinewave_offset; // TODO: handle signednes correctly!
} else {
void get_spitfp_baudrate(const ComType com, const GetSPITFPBaudrate *data) {
uint8_t port = tolower((uint8_t)data->bricklet_port) - 'a';
if(port >= BRICKLET_NUM) {
com_return_error(data, sizeof(GetSPITFPErrorCountReturn), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com);
logblete("Bricklet Port %d does not exist (get_spitfp_baudrate)\n\r", port);
return;
}
GetSPITFPBaudrateReturn gsbr;
gsbr.header = data->header;
gsbr.header.length = sizeof(GetSPITFPBaudrateReturn);
if(bricklet_attached[port] == BRICKLET_INIT_CO_MCU) {
gsbr.baudrate = bricklet_spitfp_baudrate[port];
} else {
gsbr.baudrate = 0;
}
send_blocking_with_timeout(&gsbr, sizeof(GetSPITFPBaudrateReturn), com);
}
void get_protocol1_bricklet_name(const ComType com, const GetProtocol1BrickletName *data) {
uint8_t port = tolower((uint8_t)data->port) - 'a';
if(port >= BRICKLET_NUM) {
com_return_error(data, sizeof(GetProtocol1BrickletName), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com);
logblete("Bricklet Port %d does not exist (get_protocol1_bricklet_name)\n\r", port);
return;
}
GetProtocol1BrickletNameReturn gp1bnr = MESSAGE_EMPTY_INITIALIZER;
gp1bnr.header = data->header;
gp1bnr.header.length = sizeof(GetProtocol1BrickletNameReturn);
gp1bnr.protocol_version = bricklet_attached[port];
if(gp1bnr.protocol_version == BRICKLET_INIT_PROTOCOL_VERSION_1) {
baddr[port].entry(BRICKLET_TYPE_INFO,
0,
(uint8_t*)&gp1bnr.firmware_version);
}
send_blocking_with_timeout(&gp1bnr, sizeof(GetProtocol1BrickletNameReturn), com);
logbleti("get_protocol1_bricklet_name: %s (%d)\n\r", gp1bnr.name, gp1bnr.protocol_version);
}
void set_basic_configuration(const ComType com, const SetBasicConfiguration *data) {
if((data->standstill_current > 31) ||
(data->motor_run_current > 31) ||
(data->standstill_delay_time > 15)) {
com_return_error(data, sizeof(MessageHeader), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com);
return;
}
tmc2130_reg_ihold_run.bit.ihold = data->standstill_current;
tmc2130_reg_ihold_run.bit.irun = data->motor_run_current;
tmc2130_reg_ihold_run.bit.ihold_delay = data->standstill_delay_time;
tmc2130_reg_tpowerdown.bit.delay = data->power_down_time;
tmc2130_reg_tpwmthrs.bit.velocity = MIN(TCP2130_CLOCK_FREQUENCY/(data->stealth_threshold*256), 0xfffff);
tmc2130_reg_tcoolthrs.bit.velocity = MIN(TCP2130_CLOCK_FREQUENCY/(data->coolstep_threshold*256), 0xfffff);
tmc2130_reg_thigh.bit.velocity = MIN(TCP2130_CLOCK_FREQUENCY/(data->classic_threshold*256), 0xfffff);
tmc2130_reg_chopconf.bit.vhighchm = data->high_velocity_chopper_mode;
tcm2130_register_to_write_mask |= (TMC2130_REG_IHOLD_IRUN_BIT | TMC2130_REG_TPOWERDOWN_BIT | TMC2130_REG_TPWMTHRS_BIT | TMC2130_REG_TCOOLTHRS_BIT | TMC2130_REG_THIGH_BIT | TMC2130_REG_CHOPCONF_BIT);
tcm2130_handle_register_read_and_write();
com_return_setter(com, data);
}
