extern eOresult_t eo_transmitter_regular_rops_Refresh(EOtransmitter *p) { if(NULL == p) { return(eores_NOK_nullpointer); } if(NULL == p->listofregropinfo) { // in such a case there is room for regular rops (for instance because the cfg->maxnumberofregularrops is zero) return(eores_OK); } eov_mutex_Take(p->mtx_regulars, eok_reltimeINFINITE); if(eobool_true == eo_list_Empty(p->listofregropinfo)) { eov_mutex_Release(p->mtx_regulars); return(eores_OK); } p->currenttime = eov_sys_LifeTimeGet(eov_sys_GetHandle()); // for each element in the list ... i do: ... see function eo_list_ForEach(p->listofregropinfo, s_eo_transmitter_list_updaterop_in_ropframe, p); eov_mutex_Release(p->mtx_regulars); return(eores_OK); }
extern eOresult_t eo_candiscovery2_Stop(EOtheCANdiscovery2 *p) { if(NULL == p) { return(eores_NOK_nullpointer); } // there are four possible situations: // 1. all boards are found and they all have correct fw version: OK // if we have this situation we are not in timeout expiry. // i must: stop the timer, send up a confirmation OK, reset status. // 2. all boards are found but at least one has an incorrect fw version: NOK_allfound_fwerror // if we have this situation we are not in timeout expiry. // i must: stop the timer, send up a confirmation NOK_allfound_fwerror, send up diagnostics with list of error in fw version, reset status. // 3. at least one board is not found. the ones found have correct fw version: NOK_notfound_fwok // if we have this situation we are in timeout expiry. // i must: stop the timer, send up a confirmation NOK_notfound_fwok, send up diagnostics with list of missing boards, reset status. // 4. at least one board is not found. at least one found have wrong fw version: NOK_notfound_fwko // if we have this situation we are in timeout expiry. // i must: stop the timer, send up a confirmation NOK_notfound_fwko, send up diagnostics with list of missing boards, send up diagnostics with list of error in fw version, reset status. uint64_t endtime = eov_sys_LifeTimeGet(eov_sys_GetHandle()); uint64_t delta = endtime - s_eo_thecandiscovery2.searchstatus.timeofstart; delta /= 1000; s_eo_thecandiscovery2.detection.duration = (uint16_t)delta; #if defined(EOCANDISCOVERY2_TRACE) snprintf(s_trace_string, sizeof(s_trace_string), "EOtheCANdiscovery2: stop() after %d ms from start", (uint32_t)delta); hal_trace_puts(s_trace_string); #endif // uint8_t mode = 0; // 0 is ok, 1 is NOK_allfound_fwerror, 2 is NOK_notfound_fwok, 3 is NOK_notfound_fwko eObool_t allboardsareok = (eobool_false == s_eo_thecandiscovery2.detection.atleastonereplyisincompatible) ? (eobool_true) : (eobool_false); if((eobool_true == s_eo_thecandiscovery2.detection.allhavereplied) && (eobool_true == allboardsareok)) { eo_timer_Stop(s_eo_thecandiscovery2.discoverytimer); s_eo_candiscovery2_sendDiagnosticsToHost(eobool_true, eobool_true); s_eo_candiscovery2_resetSearchStatus(); } else { eo_timer_Stop(s_eo_thecandiscovery2.discoverytimer); s_eo_candiscovery2_sendDiagnosticsToHost(s_eo_thecandiscovery2.detection.allhavereplied, allboardsareok); s_eo_candiscovery2_resetSearchStatus(); } // put it in heres, so that we can call a _Start() inside the callback .... if(NULL != s_eo_thecandiscovery2.onstop.function) { eObool_t allisok = s_eo_thecandiscovery2.detection.allhavereplied && allboardsareok; s_eo_thecandiscovery2.onstop.function(s_eo_thecandiscovery2.onstop.parameter, &s_eo_thecandiscovery2, allisok); } return(eores_OK); }
extern eOresult_t eo_candiscovery2_OneBoardIsFound(EOtheCANdiscovery2 *p, eObrd_canlocation_t loc, eObool_t match, eObrd_info_t *detected) { if((NULL == p) || (NULL == detected)) { return(eores_NOK_nullpointer); } // use the information inside loc to mark that a can board has replied. eo_common_hlfword_bitset(&s_eo_thecandiscovery2.detection.replies[loc.port], loc.addr); // put inside detected what the board has told memcpy(&s_eo_thecandiscovery2.detection.boards[loc.port][loc.addr].info, detected, sizeof(eObrd_info_t)); // set the rx time s_eo_thecandiscovery2.detection.boards[loc.port][loc.addr].time = (eov_sys_LifeTimeGet(eov_sys_GetHandle()) - s_eo_thecandiscovery2.searchstatus.timeofstart)/1000; // now mark success or failure of the query. the success depends on what we want to do with board-type, prot-version, appl-version. // so far we use the strict rule: // - the board must be the same, // - the prot-version must be the same (if the expected is not 0.0), // - the appl-version must be the same (if the expected is not 0.0). eObool_t itisok = s_eo_candiscovery2_IsDetectionOK(p, loc, match, detected); // mark a failure if(eobool_false == itisok) { s_eo_thecandiscovery2.detection.atleastonereplyisincompatible = eobool_true; eo_common_hlfword_bitset(&s_eo_thecandiscovery2.detection.incompatibilities[loc.port], loc.addr); } // now i verify if every board i was looking for has replied. if so, i can stop procedure. s_eo_thecandiscovery2.detection.allhavereplied = s_eo_candiscovery2_AllBoardsAreFound(p); #if defined(EOCANDISCOVERY2_TRACE) snprintf(s_trace_string, sizeof(s_trace_string), "EOtheCANdiscovery2: FOUND board at CAN%d ID%d after %d ms from start", loc.port+1, loc.addr, s_eo_thecandiscovery2.detection.boards[loc.port][loc.addr].time); hal_trace_puts(s_trace_string); #endif if(eobool_true == s_eo_thecandiscovery2.detection.allhavereplied) { eo_candiscovery2_Stop(p); } return(eores_OK); }
extern eOresult_t eo_candiscovery2_Tick(EOtheCANdiscovery2 *p) { if(NULL == p) { return(eores_NOK_nullpointer); } // i execute only if the tick is enabled if(eobool_false == s_eo_thecandiscovery2.searchstatus.tickingenabled) { return(eores_OK); } // i execute only if the search is enabled if(eobool_false == s_eo_thecandiscovery2.searchstatus.searching) { return(eores_OK); } #if defined(EOCANDISCOVERY2_TRACE) uint64_t now = eov_sys_LifeTimeGet(eov_sys_GetHandle()); uint64_t delta = (now - s_eo_thecandiscovery2.searchstatus.timeofstart) / 1000; snprintf(s_trace_string, sizeof(s_trace_string), "EOtheCANdiscovery2: tick() after %d ms from start", (uint32_t)delta); hal_trace_puts(s_trace_string); #endif // i check if there is a forced stop, which means that we have reached the max number of attempts if(eobool_true == s_eo_thecandiscovery2.searchstatus.forcestop) { // ... stop everything. the stop operation also sends up diagnostics or ack/nak return(eo_candiscovery2_Stop(p)); } // otherwise i trigger a further search s_eo_candiscovery2_search(); return(eores_OK); }
extern eOresult_t eo_transmitter_outpacket_Get(EOtransmitter *p, EOpacket **outpkt) { uint16_t size; if((NULL == p) || (NULL == outpkt)) { return(eores_NOK_nullpointer); } // now add the age of the frame eo_ropframe_age_Set(p->ropframereadytotx, eov_sys_LifeTimeGet(eov_sys_GetHandle())); // add sequence number p->tx_seqnum++; eo_ropframe_seqnum_Set(p->ropframereadytotx, p->tx_seqnum); // now set the size of the packet according to what is inside the ropframe. eo_ropframe_Size_Get(p->ropframereadytotx, &size); eo_packet_Size_Set(p->txpacket, size); #if defined(USE_DEBUG_EOTRANSMITTER) { // DEBUG uint16_t capacity = 0; eo_packet_Capacity_Get(p->txpacket, &capacity); if(size > capacity) { p->debug.txropframeistoobigforthepacket ++; } } #endif // finally gives back the packet *outpkt = p->txpacket; return(eores_OK); }
extern void eom_emsapplcfg_hid_userdef_OnError(eOerrmanErrorType_t errtype, const char *info, eOerrmanCaller_t *caller, const eOerrmanDescriptor_t *des) { const char empty[] = "EO?"; const char *err = eo_errman_ErrorStringGet(eo_errman_GetHandle(), errtype); char str[128]; EOMtheEMSapplCfg *emsapplcfg = eom_emsapplcfg_GetHandle(); const char *eobjstr = (NULL != caller) ? (caller->eobjstr) : (empty); uint32_t taskid = (NULL != caller) ? (caller->taskid) : (0); if(emsapplcfg->errmng_haltrace_enabled) { uint64_t tt = eov_sys_LifeTimeGet(eov_sys_GetHandle()); uint32_t sec = tt/(1000*1000); uint32_t msec = tt%(1000*1000); msec /= 1000; snprintf(str, sizeof(str), "[%s] at s%d m%d %s in tsk %d: %s", err, sec, msec, eobjstr, taskid, info); hal_trace_puts(str); } if(errtype <= eo_errortype_error) { return; } eov_sys_Stop(eov_sys_GetHandle()); // init leds s_overridden_appl_led_error_init(); // compute the mask of led to be toggled. uint8_t ledmask = 0xff; if((NULL != caller) && (NULL != caller->eobjstr)) { if(0 == strcmp(caller->eobjstr, "HAL")) { eo_common_byte_bitclear(&ledmask, 0); } else if(0 == strcmp(caller->eobjstr, "OSAL")) { eo_common_byte_bitclear(&ledmask, 1); } else if(0 == strcmp(caller->eobjstr, "IPAL")) { eo_common_byte_bitclear(&ledmask, 2); } } for(;;) { hal_sys_delay(100); if(eobool_true == eo_common_byte_bitcheck(ledmask, 0)) { hal_led_toggle(hal_led0); } if(eobool_true == eo_common_byte_bitcheck(ledmask, 1)) { hal_led_toggle(hal_led1); } if(eobool_true == eo_common_byte_bitcheck(ledmask, 2)) { hal_led_toggle(hal_led2); } hal_led_toggle(hal_led3); hal_led_toggle(hal_led4); hal_led_toggle(hal_led5); } }
extern eOresult_t eo_candiscovery2_Start(EOtheCANdiscovery2 *p, const eOcandiscovery_target_t *target, eOcandiscovery_onstop_t* onstop) { if((NULL == p) || (NULL == target)) { return(eores_NOK_nullpointer); } // if a search is active, i must call the stop if(eobool_true == s_eo_thecandiscovery2.searchstatus.searching) { eo_candiscovery2_Stop(p); } // reset target of previous search s_eo_candiscovery2_resetTarget(); s_eo_candiscovery2_resetDetection(); // reset search status s_eo_candiscovery2_resetSearchStatus(); // copy the new target of boards memcpy(&s_eo_thecandiscovery2.target, target, sizeof(eOcandiscovery_target_t)); // copy onstop memcpy(&s_eo_thecandiscovery2.onstop, onstop, sizeof(eOcandiscovery_onstop_t)); // now start the procedure s_eo_thecandiscovery2.searchstatus.searching = eobool_true; s_eo_thecandiscovery2.searchstatus.tickingenabled = eobool_false; s_eo_thecandiscovery2.searchstatus.forcestop = eobool_false; s_eo_thecandiscovery2.detection.atleastonereplyisincompatible = eobool_false; s_eo_thecandiscovery2.detection.allhavereplied = eobool_false; s_eo_thecandiscovery2.searchstatus.timeofstart = eov_sys_LifeTimeGet(eov_sys_GetHandle()); #if defined(EOCANDISCOVERY2_TRACE) uint64_t start = s_eo_thecandiscovery2.searchstatus.timeofstart/1000; snprintf(s_trace_string, sizeof(s_trace_string), "EOtheCANdiscovery2: starts @ lifetime %d ms", (uint32_t)start); hal_trace_puts(s_trace_string); #endif s_eo_candiscovery2_start(); if(eobool_false == s_eo_thecandiscovery2.detection.allhavereplied) { EOaction_strg astg = {0}; EOaction *action = (EOaction*)&astg; // the action depends on the state of the application. // if we are in config mode, then we send an event to the config task. // else if we are in run mode we just set an enable flag for teh control-loop to exec _Tick(). eo_action_SetCallback(action, s_eo_candiscovery2_on_timer_expiry, p, eov_callbackman_GetTask(eov_callbackman_GetHandle())); eo_timer_Start(s_eo_thecandiscovery2.discoverytimer, eok_abstimeNOW, s_eo_thecandiscovery2.config.period, eo_tmrmode_FOREVER, action); } return(eores_OK); }