void sendMemLoc(uint32_t * ptr) { printLF(); printser_string("Address [0x"); printser_uint32ToHex((uint32_t) ptr); printser_string("] = Value 0x"); printser_uint32ToHex(&ptr); }
void sendCPUInfo() { printLF(); printser_string("CPU ID: 0x"); printser_uint32ToHex(SCB->CPUID); }
void odp_canraw_printParam(UBaseType_t msgType, void *data, printChar_cbf printchar) { param_data *args = data; extern bus_paramPrint actBus_paramPrint; if (args->args[ARG_CMD] == PARAM_INFO && args->args[ARG_VALUE_1] == VALUE_PARAM_INFO_VERSION) { printser_string("0 - Raw CAN"); printLF(); printEOT(); } else { createCommandResultMsg(FBID_PROTOCOL_GENERIC, FBID_PROTOCOL_GENERIC, 0, ERR_CODE_OS_UNKNOWN_COMMAND_TEXT); } }
void print_telegram(UBaseType_t msgType, void *data, printChar_cbf printchar) { static data_packet *dp; dp = data; printser_string("# "); printser_int(dp->timestamp * portTICK_PERIOD_MS, 10); printser_string(" 0x"); printser_int(dp->recv, 16); printser_string(" 0x"); printser_int(dp->err, 16); printser_string(" "); printser_int(dp->len, 10); printser_string(" "); int i; for (i = 0; i < dp->len; i++) { printser_uint8ToHex(dp->data[i]); printser_string(" "); } printLF(); }
void obp_canraw(void *pvParameters) { //>>>> oobdtemple protocol initmain >>>> int keeprunning = 1; data_packet *dp; data_packet actDataPacket; UBaseType_t busToUse = *(UBaseType_t *) pvParameters; /* function pointers to the bus interface */ extern bus_init actBus_init; extern bus_send actBus_send; extern bus_flush actBus_flush; extern bus_param actBus_param; extern bus_close actBus_close; extern QueueHandle_t protocolQueue; extern QueueHandle_t outputQueue; extern QueueHandle_t inputQueue; MsgData *msg; MsgData *ownMsg; param_data *args; extern SemaphoreHandle_t protocollBinarySemaphore; UBaseType_t msgType; UBaseType_t timeout = 0; int i; //catch the "Protocoll is running" Semaphore xSemaphoreTake(protocollBinarySemaphore, portMAX_DELAY); /* activate the bus... */ odbarr[busToUse] (); actBus_init(); ODPBuffer *protocolBuffer; protocolBuffer = NULL; // start with the protocol specific initalisation //<<<< oobdtemple protocol initmain <<<< extern print_cbf printdata_CAN; UBaseType_t stateMachine_state = 0; UBaseType_t actBufferPos = 0; /* tell the Rx-ISR about the function to use for received data */ busControl(ODB_CMD_RECV, odp_canraw_recvdata); protocolBuffer = createODPBuffer(CANRAWBUFFERSIZE); if (protocolBuffer == NULL) { keeprunning = 0; } else { protocolBuffer->len = 0; } extern protocolConfigPtr actProtConfigPtr; struct CanRawConfig *protocolConfig; protocolConfig = pvPortMalloc(sizeof(struct CanRawConfig)); if (protocolConfig == NULL) { keeprunning = 0; } else { actProtConfigPtr = protocolConfig; protocolConfig->recvID = 0x7DF; protocolConfig->separationTime = 0; protocolConfig->showBusTransfer = 0; } //>>>> oobdtemple protocol mainloop_start >>>> for (; keeprunning;) { if (MSG_NONE != (msgType = waitMsg(protocolQueue, &msg, portMAX_DELAY))) // portMAX_DELAY /* handle message */ { switch (msgType) { //<<<< oobdtemple protocol mainloop_start <<<< //>>>> oobdtemple protocol MSG_BUS_RECV >>>> case MSG_BUS_RECV: dp = msg->addr; //<<<< oobdtemple protocol MSG_BUS_RECV <<<< if (protocolConfig->showBusTransfer > 0) { odp_canraw_dumpFrame(dp, printdata_CAN); } // no more action, Raw CAN does not manage any answers from the bus //>>>> oobdtemple protocol MSG_SERIAL_DATA >>>> break; case MSG_SERIAL_DATA: //<<<< oobdtemple protocol MSG_SERIAL_DATA <<<< if (stateMachine_state == SM_CANRAW_STANDBY) { /* only if just nothing to do */ dp = (data_packet *) msg->addr; // data block received from serial input which need to be handled now if (((protocolBuffer->len) + dp->len) <= CANRAWBUFFERSIZE) { /* copy the data into the uds- buffer */ for (i = 0; i < dp->len; i++) { protocolBuffer->data[protocolBuffer->len++] = dp->data[i]; } } else { createCommandResultMsg (FBID_PROTOCOL_GENERIC, ERR_CODE_CANRAW_DATA_TOO_LONG_ERR, (protocolBuffer->len) + dp->len, ERR_CODE_CANRAW_DATA_TOO_LONG_ERR_TEXT); } } //>>>> oobdtemple protocol MSG_SERIAL_PARAM_1 >>>> break; case MSG_SERIAL_PARAM: args = (UBaseType_t *) msg->addr; /* * DEBUGPRINT("protocol parameter received %ld %ld %ld\n", args->args[ARG_RECV], args->args[ARG_CMD], args->args[ARG_VALUE_1]); */ switch (args->args[ARG_RECV]) { case FBID_PROTOCOL_GENERIC: /* * DEBUGPRINT ("generic protocol parameter received %ld %ld\n", args->args[ARG_CMD], args->args[ARG_VALUE_1]); */ switch (args->args[ARG_CMD]) { case PARAM_INFO: //<<<< oobdtemple protocol MSG_SERIAL_PARAM_1 <<<< CreateParamOutputMsg(args, odp_canraw_printParam); //>>>> oobdtemple protocol MSG_SERIAL_PARAM_2 >>>> break; // and here we proceed all command parameters case PARAM_LISTEN: xTickCurrent = 0; // set current Timestamp to "0" if Listen mode ist activated protocolConfig->showBusTransfer = args->args[ARG_VALUE_1]; createCommandResultMsg(FBID_PROTOCOL_GENERIC, ERR_CODE_NO_ERR, 0, NULL); break; default: createCommandResultMsg (FBID_PROTOCOL_GENERIC, ERR_CODE_OS_UNKNOWN_COMMAND, 0, ERR_CODE_OS_UNKNOWN_COMMAND_TEXT); break; } break; //<<<< oobdtemple protocol MSG_SERIAL_PARAM_2 <<<< case FBID_PROTOCOL_SPEC: //DEBUGPRINT ("can raw protocol parameter received %ld %ld\n", args->args[ARG_CMD], args->args[ARG_VALUE_1]); switch (args->args[ARG_CMD]) { // first we commend out all parameters which are not used to generate the right "unknown parameter" message in the default - area /* case PARAM_ECHO: break; case PARAM_TIMEOUT_PENDING: break; case PARAM_BLOCKSIZE: break; */ case PARAM_CANRAW_FRAME_DELAY: protocolConfig->separationTime = args->args[ARG_VALUE_1] + 1; createCommandResultMsg(FBID_PROTOCOL_SPEC, ERR_CODE_NO_ERR, 0, NULL); break; case PARAM_CANRAW_SENDID: protocolConfig->recvID = args->args[ARG_VALUE_1]; createCommandResultMsg(FBID_PROTOCOL_SPEC, ERR_CODE_NO_ERR, 0, NULL); break; default: createCommandResultMsg(FBID_PROTOCOL_SPEC, ERR_CODE_OS_UNKNOWN_COMMAND, 0, ERR_CODE_OS_UNKNOWN_COMMAND_TEXT); break; } break; //>>>> oobdtemple protocol MSG_OTHERS >>>> case FBID_BUS_GENERIC: case FBID_BUS_SPEC: actBus_param(args); /* forward the received params to the underlying bus. */ break; default: createCommandResultMsg(FBID_PROTOCOL_SPEC, ERR_CODE_OS_UNKNOWN_COMMAND, 0, ERR_CODE_OS_UNKNOWN_COMMAND_TEXT); break; } //<<<< oobdtemple protocol MSG_OTHERS <<<< //>>>> oobdtemple protocol MSG_INIT >>>> case MSG_INIT: if (protocolBuffer != NULL) { protocolBuffer->len = 0; } //<<<< oobdtemple protocol MSG_INIT <<<< //>>>> oobdtemple protocol MSG_PROTOCOL_STOP >>>> break; case MSG_PROTOCOL_STOP: keeprunning = 0; break; //<<<< oobdtemple protocol MSG_PROTOCOL_STOP <<<< //>>>> oobdtemple protocol MSG_SEND_BUFFER >>>> case MSG_SEND_BUFFER: /* let's Dance: Starting the transfer protocol */ //<<<< oobdtemple protocol MSG_SEND_BUFFER <<<< if (protocolBuffer->len > 0) { actBufferPos = 0; for (; sendMoreFrames(protocolBuffer, &actBufferPos, &protocolConfig->showBusTransfer, &stateMachine_state, &timeout, printdata_CAN, actBus_send);); // fire all in one shot. //>>>> oobdtemple protocol MSG_SEND_BUFFER_2 >>>> } else { /* no data to send? */ createCommandResultMsg (FBID_PROTOCOL_GENERIC, ERR_CODE_NO_ERR, 0, NULL); /* just release the input again */ if (pdPASS != sendMsg(MSG_SERIAL_RELEASE, inputQueue, NULL)) { printser_string("Input queue is full!"); DEBUGPRINT ("FATAL ERROR: input queue is full!\n", 'a'); } } break; //<<<< oobdtemple protocol MSG_SEND_BUFFER_2 <<<< //>>>> oobdtemple protocol MSG_TICK >>>> case MSG_TICK: //<<<< oobdtemple protocol MSG_TICK <<<< if (timeout > 0) { /* we just waiting for the next frame to send */ if (timeout == 1) { /* time's gone... */ for (; sendMoreFrames(protocolBuffer, &actBufferPos, &protocolConfig->showBusTransfer, &stateMachine_state, &timeout, printdata_CAN, actBus_send);); // fire all in one shot. if (timeout < 2) { // protocolBuffer->len = 0; createCommandResultMsg (FBID_PROTOCOL_GENERIC, ERR_CODE_NO_ERR, 0, NULL); stateMachine_state = SM_CANRAW_STANDBY; if (pdPASS != sendMsg(MSG_SERIAL_RELEASE, inputQueue, NULL)) { printser_string("INPQUE_FULL"); DEBUGPRINT ("FATAL ERROR: input queue is full!\n", 'a'); } } } timeout--; } //>>>> oobdtemple protocol final >>>> break; } disposeMsg(msg); } /* vTaskDelay (5000 / portTICK_PERIOD_MS); */ } /* Do all cleanup here to finish task */ actBus_close(); vPortFree(protocolConfig); freeODPBuffer(protocolBuffer); xSemaphoreGive(protocollBinarySemaphore); vTaskDelete(NULL); }
void odp_canraw_recvdata(data_packet * p, UBaseType_t callFromISR) { extern print_cbf printdata_CAN; extern printChar_cbf printChar; extern protocolConfigPtr actProtConfigPtr; struct CanRawConfig *protocolConfig; short ByteCnt; if (callFromISR) xTickNew = (uint16_t) xTaskGetTickCountFromISR(); else xTickNew = (uint16_t) xTaskGetTickCount(); if (xTickNew < xTickOld) // check for xTick overflow xTickOld = 0; if (xTickCurrent >= 59999) // limit timestamp to 0-59999 tick (ms) xTickCurrent = 0; xTickCurrent = xTickCurrent + (xTickNew - xTickOld); xTickOld = xTickNew; // set latest value to xTickOld for next duration p->timestamp = xTickCurrent; protocolConfig = actProtConfigPtr; if (protocolConfig != NULL) { if (protocolConfig->showBusTransfer == 1) { //normal output MsgData *msg; extern QueueHandle_t protocolQueue; if (NULL != (msg = createDataMsg(p))) { UBaseType_t res = 0; if (callFromISR) { res = sendMsgFromISR(MSG_BUS_RECV, protocolQueue, msg); } else { res = sendMsg(MSG_BUS_RECV, protocolQueue, msg); } if (res != pdPASS) { disposeMsg(msg); DEBUGPRINT("FATAL ERROR: protocol queue is full!\n", 'a'); } } else { DEBUGPRINT("FATAL ERROR: Out of Heap space!l\n", 'a'); } } if (protocolConfig->showBusTransfer == 2) { //normal output, but straight from the ISR printdata_CAN(MSG_BUS_RECV, p, printChar); } if (protocolConfig->showBusTransfer == 3) { // Lawicel format: Estimated out of http://lxr.free-electrons.com/source/drivers/net/can/slcan.c line 110 cc. if (p->recv & 0x80000000) { // Bit 32 set, so it's an extended CAN ID printser_string("T"); printser_uint32ToHex(p->recv & 0x1FFFFFFF); } else { printser_string("t"); printser_int((p->recv & 0x700) >> 8, 10); printser_uint8ToHex(p->recv & 0x00FF); } printser_int(p->len, 10); ByteCnt = 0; while (ByteCnt != p->len) { printser_uint8ToHex(p->data[ByteCnt]); ByteCnt++; } if (p->err == 0x01) printser_string("FFFF"); // if error occurs set timestamp to 0xFFFF else printser_uint16ToHex(p->timestamp * portTICK_PERIOD_MS & 0xFFFF); //reduce down to 16 bit = 65536 ms = ~ 1 min printLF(); } if (protocolConfig->showBusTransfer == 4) { printser_uint8ToRaw(255); //startbyte printser_uint8ToRaw((p->len & 0xF) | // bit 0-3: DLC ((p->err & 3) << 4) | //bit 4-5 : Error flag (((p->recv & 0x80000000) ? 1 : 0) << 5) //bit 6: Extended CAN ID ); //Status flag printser_uint16ToRawCoded(p->timestamp * portTICK_PERIOD_MS & 0xFFFF); //reduce down to 16 bit = 65536 ms = ~ 1 min if ((p->recv & 0x80000000)) { // Bit 32 set, so it's an exended CAN ID printser_uint32ToRawCoded(p->recv & 0x1FFFFFFF); } else { printser_uint16ToRawCoded(p->recv & 0x1FFFFFFF); } int i; for (i = 0; i < p->len; i++) { printser_uint8ToRawCoded(p->data[i]); } } } }
/*-----------------------------------------------------------*/ void bus_param_can_generic_Print(UBaseType_t msgType, void *data, printChar_cbf printchar) { param_data *args = data; uint8_t FiltCntr; DEBUGPRINT("can Parameter receiced %ld-%ld\n", args->args[ARG_RECV], args->args[ARG_CMD]); if (args->args[ARG_CMD] == PARAM_INFO) { CAN_GetCanConfig(canConfig); switch (args->args[ARG_VALUE_1]) { case VALUE_PARAM_INFO_VERSION: printser_string("CAN Bus"); printLF(); printEOT(); break; case VALUE_PARAM_INFO_BUS_MODE: switch (canConfig->mode) { case VALUE_BUS_MODE_SILENT: printser_string("0 - CAN Transceiver in 'Silent Mode'"); printLF(); break; case VALUE_BUS_MODE_LOOP_BACK: printser_string("1 - CAN Transceiver in 'Loop Back Mode'"); printLF(); break; case VALUE_BUS_MODE_LOOP_BACK_WITH_SILENT: printser_string ("2 - CAN Transceiver in 'Loop Back combined with Silent Mode'"); printLF(); break; case VALUE_BUS_MODE_NORMAL: printser_string("3 - CAN Transceiver in 'Normal Mode'"); printLF(); break; } switch (canConfig->state) { case STATE_REQUEST_CAN_ERROR_ACTIVE: printser_string("0 - Bus Active"); printLF(); break; case STATE_REQUEST_CAN_ERROR_WARNING: printser_string("1 - Bus Active, a few errors"); printLF(); break; case STATE_REQUEST_CAN_ERROR_PASSIVE: printser_string("2 - Bus Passive, many errors"); printLF(); break; case STATE_REQUEST_CAN_BUS_OFF: printser_string("3 - Bus Off, too many errors"); printLF(); break; case STATE_REQUEST_CAN_STOPPED: printser_string("4 - Bus offline"); printLF(); break; case STATE_REQUEST_CAN_SLEEPING: printser_string("5 - Bus sleeping"); printLF(); break; case STATE_REQUEST_CAN_UNKNOWN: printser_string("6 - no feedback from device"); printLF(); break; } printEOT(); break; case VALUE_PARAM_INFO_BUS_CONFIG: switch (canConfig->busConfig) { case VALUE_BUS_CONFIG_11bit_125kbit: printser_string("1 = ISO 15765-4, CAN 11bit ID/125kBaud"); printLF(); printEOT(); break; case VALUE_BUS_CONFIG_11bit_250kbit: printser_string("2 = ISO 15765-4, CAN 11bit ID/250kBaud"); printLF(); printEOT(); break; case VALUE_BUS_CONFIG_11bit_500kbit: printser_string("3 = ISO 15765-4, CAN 11bit ID/500kBaud"); printLF(); printEOT(); break; case VALUE_BUS_CONFIG_11bit_1000kbit: printser_string("4 - ISO 15765-4, CAN 11bit ID/1000kBaud"); printLF(); printEOT(); break; case VALUE_BUS_CONFIG_29bit_125kbit: printser_string("5 - ISO 15765-4, CAN 29bit ID/125kBaud"); printLF(); printEOT(); break; case VALUE_BUS_CONFIG_29bit_250kbit: printser_string("6 - ISO 15765-4, CAN 29bit ID/250kBaud"); printLF(); printEOT(); break; case VALUE_BUS_CONFIG_29bit_500kbit: printser_string("7 - ISO 15765-4, CAN 29bit ID/500kBaud"); printLF(); printEOT(); break; case VALUE_BUS_CONFIG_29bit_1000kbit: printser_string("8 - ISO 15765-4, CAN 29bit ID/1000kBaud"); printLF(); printEOT(); break; } break; case VALUE_PARAM_INFO_BUS_ERROR: if (VALUE_PARAM_INFO_BUS_ERROR_READ == args->args[ARG_VALUE_2]) { printser_int(bus_rx_count_can(), 10); printser_string(" "); printser_int(bus_rx_error_can(), 10); printser_string(" "); printser_int(bus_rec_can(), 10); printser_string(" "); printser_int(bus_tx_count_can(), 10); printser_string(" "); printser_int(bus_tx_error_can(), 10); printser_string(" "); printser_int(bus_rec_can(), 10); printser_string(" "); printser_int(bus_tec_can(), 10); printser_string(" "); printser_int(bus_busoff_error_can(), 10); printser_string(" "); printser_int(bus_warning_error_can(), 10); printser_string(" "); printser_int(bus_passive_error_can(), 10); } else if (VALUE_PARAM_INFO_BUS_ERROR_DEL == args->args[ARG_VALUE_2]) { /* delete counters if parameter is requested with option "1" */ bus_clear_rx_error_can(); bus_clear_tx_error_can(); bus_clear_rx_count_can(); bus_clear_tx_count_can(); } else printser_string("Missing parameter!"); printLF(); printEOT(); break; case VALUE_PARAM_INFO_Can11FilterID: for (FiltCntr = 0; FiltCntr < MAXCANFILTER; FiltCntr++) { printser_string("0x"); printser_int(CAN_GetFilterReg16(FiltCntr, 1, 0), 16); printser_string(" 0x"); printser_int(CAN_GetFilterReg16(FiltCntr, 1, 1), 16); printser_string(" 0x"); printser_int(CAN_GetFilterReg16(FiltCntr, 2, 0), 16); printser_string(" 0x"); printser_int(CAN_GetFilterReg16(FiltCntr, 2, 1), 16); printLF(); } printLF(); printEOT(); break; case VALUE_PARAM_INFO_Can29FilterID: for (FiltCntr = 0; FiltCntr < MAXCANFILTER; FiltCntr++) { printser_string("0x"); printser_int(CAN_GetFilterReg32(FiltCntr, 1), 16); printser_string(" 0x"); printser_int(CAN_GetFilterReg32(FiltCntr, 2), 16); printLF(); } printLF(); printEOT(); break; default: evalResult(FBID_BUS_GENERIC, ERR_CODE_OS_UNKNOWN_COMMAND, 0, ERR_CODE_OS_UNKNOWN_COMMAND_TEXT); break; } } else { evalResult(FBID_BUS_GENERIC, ERR_CODE_OS_UNKNOWN_COMMAND, 0, ERR_CODE_OS_UNKNOWN_COMMAND_TEXT); } }