int serial_buffer_rx(struct serial_buffer *sb,
const size_t ms_delay)
{
const size_t available = sb->length - sb->curr_len;
char *ptr = sb->buffer + sb->curr_len;
size_t msg_len = 0;
while (!msg_len) {
const int read = serial_get_line_wait(
sb->serial, ptr, available, msToTicks(ms_delay));
if (!read) {
pr_trace("[serial_buffer] msg timeout\r\n");
return 0;
}
ctrl_char_strip(ptr);
msg_len = strlen(ptr);
}
pr_trace("[serial_buffer] Msg (offset = ");
pr_trace_int(sb->curr_len);
pr_trace("): \"");
pr_trace(ptr);
pr_trace("\"\r\n");
sb->curr_len += msg_len + 1;
return msg_len + 1;
}
char* serial_buffer_rx(struct serial_buffer *sb,
const size_t ms_delay)
{
const size_t available = sb->length - sb->curr_len;
if (!available)
return NULL;
char *ptr = sb->buffer + sb->curr_len;
size_t msg_len = 0;
int read;
while (!msg_len) {
read = serial_read_line_wait(sb->serial, ptr, available - 1,
msToTicks(ms_delay));
if (read < 1)
return NULL;
msg_len = serial_msg_strlen(ptr);
}
/* Check for overflow and warn */
if (read == available)
pr_warning(LOG_PFX "Serial buffer overflow!\r\n");
/* If here, got a non-empty msg. Terminate it and add the length */
ptr[read] = 0;
sb->curr_len += ++read;
return ptr;
}
void OBD2Task(void *pvParameters)
{
pr_info("Start OBD2 task\r\n");
size_t max_obd2_samplerate = msToTicks((TICK_RATE_HZ / MAX_OBD2_SAMPLE_RATE));
LoggerConfig *config = getWorkingLoggerConfig();
OBD2Config *oc = &config->OBD2Configs;
while(1) {
while(oc->enabled && oc->enabledPids > 0) {
for (size_t i = 0; i < oc->enabledPids; i++) {
PidConfig *pidCfg = &oc->pids[i];
int value;
unsigned char pid = pidCfg->pid;
if (OBD2_request_PID(pid, &value, OBD2_PID_DEFAULT_TIMEOUT_MS)) {
OBD2_set_current_PID_value(i, value);
if (TRACE_LEVEL) {
pr_trace("read OBD2 PID ");
pr_trace_int(pid);
pr_trace("=")
pr_trace_int(value);
pr_trace("\r\n");
}
} else {
pr_warning_int_msg("OBD2: PID read fail: ", pid);
}
delayTicks(max_obd2_samplerate);
}
}
delayMs(OBD2_FEATURE_DISABLED_DELAY_MS);
}
}
os_timerHandle_t os_timerTaskNew(os_timerConfig_t* conf, uint16_t initDelay)
{
bool ret = false;
os_timerHandle_t handle = calloc(1, sizeof(struct os_timerHandle));
handle->timerHandle = xTimerCreate(conf->name,
msToTicks(conf->period),
!conf->oneShot,
NULL,
conf->callback);
if(handle->timerHandle && !conf->startLater) {
ret = xTimerStart(handle->timerHandle, initDelay);
if(ret) {
return handle;
} else {
xTimerDelete(handle->timerHandle, 0);
free(handle);
return NULL;
}
} else if(conf->startLater) {
handle->initDelay = initDelay;
return handle;
} else {
free(handle);
return NULL;
}
}
void sleep(struct pcb* process, unsigned int milliseconds){
int ticks = msToTicks(milliseconds);
//kprintf("ticks = %d\n",ticks);
addToSleepQueue(process,ticks);
}
static void setup_debug_tools()
{
/* Only enable this code if we are doing debug work */
#if ! (ASL_DEBUG)
return;
#endif
const size_t timer_ticks = msToTicks(CHAR_CHECK_PERIOD_MS);
const signed char* timer_name = (signed char*) "Dropped Char Check Timer";
xTimerHandle timer_handle = xTimerCreate(timer_name, timer_ticks,
true, NULL, dropped_char_timer_cb);
xTimerStart(timer_handle, timer_ticks);
}
int CAN_device_tx_msg(uint8_t channel, CAN_msg * msg, unsigned int timeoutMs)
{
CanTxMsg TxMessage;
/* Transmit Structure preparation */
if (msg->isExtendedAddress) {
TxMessage.ExtId = msg->addressValue;
TxMessage.IDE = CAN_ID_EXT;
} else {
TxMessage.StdId = msg->addressValue;
TxMessage.IDE = CAN_ID_STD;
}
TxMessage.RTR = CAN_RTR_DATA;
TxMessage.DLC = msg->dataLength;
memcpy(TxMessage.Data, msg->data, msg->dataLength);
CAN_TypeDef* chan = channel == 0 ? CAN1 : CAN2;
const uint8_t mailbox = CAN_Transmit(chan, &TxMessage);
/*
* Then they don't want to wait. Ok. Let caller know if they
* got a mailbox then. If not, message was unable to be sent.
*/
if (0 == timeoutMs)
return mailbox != CAN_TxStatus_NoMailBox;
/* Using ticks avoids a race-condition */
size_t ticks = getCurrentTicks();
const size_t trigger = ticks + msToTicks(timeoutMs);
uint8_t status = CAN_TxStatus_Failed;
while(ticks <= trigger) {
status = CAN_TransmitStatus(chan, mailbox);
if (CAN_TxStatus_Pending != status)
break;
/*
* Not using yield here as it will cause lower priority tasks
* to starve. Yield only allows tasks of equal or greater
* priority to run.
*/
delayTicks(1);
ticks = getCurrentTicks();
}
if (CAN_TxStatus_Pending == status)
CAN_CancelTransmit(chan, mailbox);
return status == CAN_TxStatus_Ok;
}
static int readModemWait(Serial *serial, size_t delay)
{
int c = serial->get_line_wait(g_cellBuffer, g_bufferLen, msToTicks(delay));
if (c > 2) {
/*
* Cell messages always end with a newline. This also ignores
* the messages that are simply stupid short.
*/
pr_debug("Cell: read ");
pr_debug(g_cellBuffer);
}
return c;
}
int CAN_device_rx_msg(uint8_t channel, CAN_msg * msg, unsigned int timeoutMs)
{
CanRxMsg rxMsg;
if (xQueueReceive(channel == 0 ? xCan1Rx : xCan2Rx, &rxMsg, msToTicks(timeoutMs)) == pdTRUE) {
msg->isExtendedAddress = rxMsg.IDE == CAN_ID_EXT ? 1 : 0;
msg->addressValue = msg->isExtendedAddress ? rxMsg.ExtId : rxMsg.StdId;
memcpy(msg->data, rxMsg.Data, rxMsg.DLC);
msg->dataLength = rxMsg.DLC;
return 1;
} else {
pr_debug("timeout rx CAN msg\r\n");
return 0;
}
}
void os_timerDelay(uint32_t ms)
{
vTaskDelay(msToTicks(ms));
}
