static eOresult_t s_eo_appTheNVmapRef_tables_create(EOappTheNVmapRef* p, eOappTheNVmapRef_cfg_t *cfg)
{
uint8_t i;
//joint
p->jointMaxNumber = eo_appTheDB_GetNumeberOfConnectedJoints(eo_appTheDB_GetHandle);
p->jointsList = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(void**),
p->jointMaxNumber);
for(i = 0; i<p->jointMaxNumber; i++)
{
p->jointsList[i] = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit,
sizeof(void*), eOappNVmapRef_jointNVindex_TOTALnumber);
}
//motor
p->motortMaxNumber = eo_cfg_nvsEP_mc_motor_numbermax_Get((eOcfg_nvsEP_mc_endpoint_t)p->cfg.mc_endpoint);
p->motorsList = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(void**),
p->motorMaxNumber);
for(i = 0; i<p->motortMaxNumber; i++)
{
p->motortsList[i] = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit,
sizeof(void*), eOappNVmapRef_motorNVindex_TOTALnumber);
}
return(eores_OK);
}
extern void eo_fifo_Delete(EOfifo * fifo)
{
if(NULL == fifo)
{ // invalid fifo
return;
}
if(NULL == fifo->dek)
{
return;
}
if(NULL != fifo->mutex)
{
eov_mutex_Take(fifo->mutex, eok_reltimeINFINITE);
}
eo_fifo_Clear(fifo, eok_reltimeINFINITE);
eo_mempool_Delete(eo_mempool_GetHandle(), fifo->dek);
fifo->dek = NULL;
if(NULL != fifo->mutex)
{
//eov_mutex_Release(fifo->mutex);
// however, if someone is waiting for this mutex, then there is a crash ... so, maybe better not to release
}
memset(fifo, 0, sizeof(EOfifo));
eo_mempool_Delete(eo_mempool_GetHandle(), fifo);
return;
}
extern void eo_nvsetbrdbuilder_Delete(EOnvsetBRDbuilder* p)
{
if(NULL == p)
{
return;
}
if(NULL == p->epcfg_vector)
{
return;
}
p->brdcfg->epcfg_constvect = NULL;
eo_mempool_Delete(eo_mempool_GetHandle(), p->brdcfg);
memset(p->brdcfg, 0, sizeof(eOnvset_BRDcfg_t));
eo_vector_Delete(p->epcfg_vector);
p->epcfg_vector = NULL;
eo_mempool_Delete(eo_mempool_GetHandle(), p);
return;
}
static eOresult_t s_eo_nvset_DeinitEPs(EOnvSet* p)
{
eOnvset_brd_t* theBoard = &p->theboard;
uint16_t i = 0;
uint16_t endpointsnum = 0;
if(NULL == theBoard->theendpoints)
{ // already deinitted
return(eores_OK);
}
endpointsnum = eo_vector_Size(theBoard->theendpoints);
for(i=0; i<endpointsnum; i++)
{
eOnvset_ep_t **ppep = (eOnvset_ep_t **)eo_vector_At(theBoard->theendpoints, i);
eOnvset_ep_t *theEndpoint = *ppep;
// now i erase memory associated with this endpoint
eo_mempool_Delete(eo_mempool_GetHandle(), theEndpoint->epram);
// and i dissociates that from from the internals of the eoprot library
eoprot_config_endpoint_ram(theBoard->boardnum, theEndpoint->epcfg.endpoint, NULL, 0);
// i also de-init the number of entities for that endpoint
eoprot_config_endpoint_entities(theBoard->boardnum, theEndpoint->epcfg.endpoint, NULL);
// now i delete all data associated to the mutex protection
if(NULL != theEndpoint->mtx_endpoint)
{
eov_mutex_Delete(theEndpoint->mtx_endpoint);
}
if(NULL != theEndpoint->themtxofthenvs)
{
uint16_t size = eo_vector_Size(theEndpoint->themtxofthenvs);
int j = 0;
for(j=0; j<size; j++)
{
EOVmutexDerived** pmtx = (EOVmutexDerived**)eo_vector_At(theEndpoint->themtxofthenvs, j);
eov_mutex_Delete(*pmtx);
}
eo_vector_Delete(theEndpoint->themtxofthenvs);
}
// now i erase the memory of the entire eOnvset_ep_t entry
eo_mempool_Delete(eo_mempool_GetHandle(), theEndpoint);
}
// so that we dont get in here inside again
theBoard->theendpoints = NULL;
return(eores_OK);
}
extern EOmotors* eo_motors_New(uint8_t nMotors, eOemscontroller_board_t board)
{
if (!nMotors) return NULL;
if (nMotors > MAX_NAXLES) nMotors = MAX_NAXLES;
EOmotors *o = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOmotors), 1);
if (o)
{
o->board = board;
o->nMotors = nMotors;
o->Jok = eobool_false;
MOTORS(m)
{
o->motor_state_watchdog[m] = 0;
o->motor_fault_mask2[m] = 0;
JOINTS(j)
{
o->J[m][j] = o->Ji[m][j] = 0;
}
}
}
return o;
}
extern EOabsCalibratedEncoder* eo_absCalibratedEncoder_New(uint8_t ID)
{
EOabsCalibratedEncoder *o = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOabsCalibratedEncoder), 1);
if (o)
{
o->ID = ID;
o->distance = 0;
o->position_last = 0;
o->position_sure = 0;
#ifndef USE_2FOC_FAST_ENCODER
o->velocity = 0;
#endif
o->offset = 0;
o->sign = 0;
o->delta = 0;
o->invalid_fault_cnt = 0;
o->timeout_fault_cnt = 0;
o->first_valid_data = 0;
o->state_mask = SM_NOT_READY;
}
return o;
}
extern void eo_rop_Delete(EOrop *p)
{
if(NULL == p)
{
return;
}
if(0 != p->stream.capacity)
{
eo_mempool_Delete(eo_mempool_GetHandle(), p->stream.data);
}
memset(p, 0, sizeof(EOrop));
eo_mempool_Delete(eo_mempool_GetHandle(), p);
return;
}
extern EOconfirmationManager* eo_confman_New(const eOconfman_cfg_t *cfg)
{
EOconfirmationManager *retptr = NULL;
if(NULL == cfg)
{
cfg = &eOconfman_cfg_default;
}
if(eoconfman_mode_disabled == cfg->mode)
{
return(NULL);
}
// i get the memory for the object
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOconfirmationManager), 1);
memcpy(&retptr->config, cfg, sizeof(eOconfman_cfg_t));
retptr->confrequests = (0 == cfg->maxnumberofconfreqrops) ? (NULL) : (eo_vector_New(sizeof(eOropdescriptor_t), cfg->maxnumberofconfreqrops, NULL, 0, NULL, NULL));
retptr->mtx = (NULL == cfg->mutex_fn_new) ? (NULL) : (cfg->mutex_fn_new());
return(retptr);
}
extern EOrop* eo_rop_New(uint16_t capacity)
{
EOrop *retptr = NULL;
// i get the memory for the object
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOrop), 1);
retptr->stream.capacity = capacity;
if(0 != capacity)
{
retptr->stream.data = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_08bit, sizeof(uint8_t), capacity);
}
eo_rop_Reset(retptr);
return(retptr);
}
extern EOtransceiver* eo_transceiver_New(const eOtransceiver_cfg_t *cfg)
{
EOtransceiver *retptr = NULL;
eo_receiver_cfg_t rec_cfg;
eo_transmitter_cfg_t tra_cfg;
if(NULL == cfg)
{
cfg = &eo_transceiver_cfg_default;
}
memcpy(&rec_cfg, &eo_receiver_cfg_default, sizeof(eo_receiver_cfg_t));
rec_cfg.capacityofropframereply = cfg->capacityofropframereplies;
rec_cfg.capacityofropinput = cfg->capacityofrop;
rec_cfg.capacityofropreply = cfg->capacityofrop;
rec_cfg.nvscfg = cfg->nvscfg;
memcpy(&tra_cfg, &eo_transmitter_cfg_default, sizeof(eo_transmitter_cfg_t));
tra_cfg.capacityoftxpacket = cfg->capacityoftxpacket;
tra_cfg.capacityofropframeregulars = cfg->capacityofropframeregulars;
tra_cfg.capacityofropframeoccasionals = cfg->capacityofropframeoccasionals;
tra_cfg.capacityofropframereplies = cfg->capacityofropframereplies;
tra_cfg.capacityofrop = cfg->capacityofrop;
tra_cfg.maxnumberofregularrops = cfg->maxnumberofregularrops;
tra_cfg.ipv4addr = cfg->remipv4addr; // it is the address of the remote host: we filter incoming packet with this address and sends packets only to it
tra_cfg.ipv4port = cfg->remipv4port; // it is the remote port where to send packets
tra_cfg.nvscfg = cfg->nvscfg;
tra_cfg.mutex_fn_new = cfg->mutex_fn_new;
tra_cfg.protection = (eo_trans_protection_none == cfg->protection) ? (eo_transmitter_protection_none) : (eo_transmitter_protection_total);
// i get the memory for the object
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOtransceiver), 1);
memcpy(&retptr->cfg, cfg, sizeof(eOtransceiver_cfg_t));
retptr->receiver = eo_receiver_New(&rec_cfg);
retptr->transmitter = eo_transmitter_New(&tra_cfg);
#if defined(USE_DEBUG_EOTRANSCEIVER)
memset(&retptr->debug, 0, sizeof(EOtransceiverDEBUG_t));
#endif
// if((eo_trans_protection_enabled == cfg->protection) && (NULL != cfg->mutex_fn_new))
// {
// retptr->mtx_tx_replies = cfg->mutex_fn_new();
// retptr->mtx_tx_regulars = cfg->mutex_fn_new();
// retptr->mtx_tx_occasionals = cfg->mutex_fn_new();
// }
return(retptr);
}
extern EOCurrentsWatchdog* eo_currents_watchdog_Initialise(void)
{
uint8_t m;
//reserve memory for the number of thresholds needed
s_eo_currents_watchdog.numberofmotors = eo_entities_NumOfMotors(eo_entities_GetHandle());
if (s_eo_currents_watchdog.numberofmotors == 0)
return NULL;
s_eo_currents_watchdog.themotors = (eOmc_motor_t**) eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(eOmc_motor_t*), s_eo_currents_watchdog.numberofmotors);
// retrieve pointers to motors
for(m=0; m<s_eo_currents_watchdog.numberofmotors; m++)
{
s_eo_currents_watchdog.themotors[m] = eo_entities_GetMotor(eo_entities_GetHandle(), m);
}
s_eo_currents_watchdog.nominalCurrent2 = (float*) eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(float), s_eo_currents_watchdog.numberofmotors);
memset(s_eo_currents_watchdog.nominalCurrent2, 0, s_eo_currents_watchdog.numberofmotors*sizeof(float));
s_eo_currents_watchdog.I2T_threshold = (float*) eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(float), s_eo_currents_watchdog.numberofmotors);
memset(s_eo_currents_watchdog.I2T_threshold, 0, s_eo_currents_watchdog.numberofmotors*sizeof(float));
s_eo_currents_watchdog.avgCurrent = (eoCurrentWD_averageData_t*) eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(eoCurrentWD_averageData_t), s_eo_currents_watchdog.numberofmotors);
memset(s_eo_currents_watchdog.avgCurrent, 0, s_eo_currents_watchdog.numberofmotors*sizeof(eoCurrentWD_averageData_t));
s_eo_currents_watchdog.accomulatorEp = (float*) eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(float), s_eo_currents_watchdog.numberofmotors);
memset(s_eo_currents_watchdog.accomulatorEp, 0, s_eo_currents_watchdog.numberofmotors*sizeof(float));
s_eo_currents_watchdog.motorinI2Tfault = (eObool_t*) eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(eObool_t), s_eo_currents_watchdog.numberofmotors);
memset(s_eo_currents_watchdog.motorinI2Tfault, 0, s_eo_currents_watchdog.numberofmotors*sizeof(eObool_t)); //all motors are not in I2t fault
s_eo_currents_watchdog.initted = eobool_true;
suppliedVoltage_counter = 0;
nv_controller_ptr = (eOmc_controller_t*) eoprot_entity_ramof_get(eoprot_board_localboard, eoprot_endpoint_motioncontrol, eoprot_entity_mc_controller, 0);
if(nv_controller_ptr == NULL)
return NULL;
return(&s_eo_currents_watchdog);
}
extern EOnvsetBRDbuilder* eo_nvsetbrdbuilder_New(eOnvBRD_t board)
{
EOnvsetBRDbuilder *p = NULL;
// uint8_t i = 0;
// i get the memory for the object
p = eo_mempool_New(eo_mempool_GetHandle(), 1*sizeof(EOnvsetBRDbuilder));
p->epcfg_vector = eo_vector_New(sizeof(eOprot_EPcfg_t), eo_vectorcapacity_dynamic, NULL, 0, NULL, NULL);
p->brdcfg = eo_mempool_New(eo_mempool_GetHandle(), 1*sizeof(eOnvset_BRDcfg_t));
p->brdcfg->boardnum = board;
p->brdcfg->epcfg_constvect = eo_constvector_Load(p->epcfg_vector);
return(p);
}
extern EOfakeStorage* eo_fakestrg_New(uint32_t id, uint32_t capacity, const void *defvalue, EOVmutexDerived *mtx)
{
EOfakeStorage *retptr = NULL;
eov_strg_memmap_t *strgmem = NULL;
// i get the memory for the object
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOfakeStorage), 1);
eo_errman_Assert(eo_errman_GetHandle(), (0 != capacity), s_eobj_ownname, "capacity cannot be zero");
// get the base object
retptr->storage = eov_strg_hid_New(id, capacity, defvalue, mtx);
// pass to it the virtual table
eov_strg_hid_SetVTABLE(retptr->storage,
(eOres_fp_voidp_uint32_uint32_cvoidp_t) s_eo_fakestrg_set,
(eOres_fp_voidp_uint32_uint32_voidp_t) s_eo_fakestrg_get);
// now initialise the derived object
strgmem = s_eo_fakestrg_get_storagememory(retptr->storage);
if((NULL == strgmem) || (id != strgmem->id))
{
// create new memory partition, mark it with id and capacity, set its content to defvalue
strgmem = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(uint32_t) + sizeof(uint32_t) + capacity, 1);
strgmem->id = id;
strgmem->capacity = capacity;
memcpy(strgmem->data, defvalue, strgmem->capacity);
}
// assign the partition to the object
retptr->ram = (void*)strgmem;
return(retptr);
}
extern void eov_mutex_hid_Delete(EOVmutex *p)
{
if(NULL == p)
{
return;
}
memset(p, 0, sizeof(EOVmutex));
eo_mempool_Delete(eo_mempool_GetHandle(), p);
return;
}
extern void eo_receiver_Delete(EOreceiver *p)
{
if(NULL == p)
{
return;
}
if(NULL == p->ropinput)
{
return;
}
eo_mempool_Delete(eo_mempool_GetHandle(), p->bufferropframereply);
eo_rop_Delete(p->ropreply);
eo_rop_Delete(p->ropinput);
eo_ropframe_Delete(p->ropframereply);
eo_ropframe_Delete(p->ropframeinput);
memset(p, 0, sizeof(EOreceiver));
eo_mempool_Delete(eo_mempool_GetHandle(), p);
return;
}
extern EOnvSet* eo_nvset_New(eOnvset_protection_t prot, eov_mutex_fn_mutexderived_new mtxnew)
{
EOnvSet *p = NULL;
// i get the memory for the object
p = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(EOnvSet), 1);
// i dont initialise yet the device. i simply rely on the fact that it contains all zero data.
p->theboard.ipaddress = 0;
p->mtxderived_new = mtxnew;
p->protection = (NULL == mtxnew) ? (eo_nvset_protection_none) : (prot);
return(p);
}
extern void eo_nvset_Delete(EOnvSet* p)
{
if(NULL == p)
{
return;
}
eo_nvset_DeinitBRD(p);
memset(p, 0, sizeof(EOnvSet));
eo_mempool_Delete(eo_mempool_GetHandle(), p);
return;
}
extern EOCurrentsWatchdog* eo_currents_watchdog_Initialise(void)
{
uint8_t m;
//reserve memory for the number of thresholds needed
s_eo_currents_watchdog.numberofmotors = eo_entities_NumOfJoints(eo_entities_GetHandle());
if (s_eo_currents_watchdog.numberofmotors == 0)
return NULL;
s_eo_currents_watchdog.themotors = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(eOmc_motor_t*), s_eo_currents_watchdog.numberofmotors);
// retrieve pointers to motors
for(m=0; m<s_eo_currents_watchdog.numberofmotors; m++)
{
s_eo_currents_watchdog.themotors[m] = eoprot_entity_ramof_get(eoprot_board_localboard, eoprot_endpoint_motioncontrol, eoprot_entity_mc_motor, m);
}
s_eo_currents_watchdog.nominalCurrent2 = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(float), s_eo_currents_watchdog.numberofmotors);
memset(s_eo_currents_watchdog.nominalCurrent2, 0, s_eo_currents_watchdog.numberofmotors*sizeof(float));
s_eo_currents_watchdog.I2T_threshold = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(float), s_eo_currents_watchdog.numberofmotors);
memset(s_eo_currents_watchdog.I2T_threshold, 0, s_eo_currents_watchdog.numberofmotors*sizeof(float));
//s_eo_currents_watchdog.filter_reg = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(float), s_eo_currents_watchdog.numberofmotors);
//memset(s_eo_currents_watchdog.filter_reg, 0, s_eo_currents_watchdog.numberofmotors*sizeof(float));
s_eo_currents_watchdog.avgCurrent = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(eoCurrentWD_averageData_t), s_eo_currents_watchdog.numberofmotors);
memset(s_eo_currents_watchdog.avgCurrent, 0, s_eo_currents_watchdog.numberofmotors*sizeof(eoCurrentWD_averageData_t));
s_eo_currents_watchdog.accomulatorEp = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_auto, sizeof(float), s_eo_currents_watchdog.numberofmotors);
memset(s_eo_currents_watchdog.accomulatorEp, 0, s_eo_currents_watchdog.numberofmotors*sizeof(float));
s_eo_currents_watchdog.initted = eobool_true;
return(&s_eo_currents_watchdog);
}
extern EOsm * eo_sm_New(const eOsm_cfg_t * cfg)
{
EOsm *retptr = NULL;
// verify that we have a non NULL cfg
eo_errman_Assert(eo_errman_GetHandle(), (NULL != cfg), "eo_sm_New(): NULL cfg", s_eobj_ownname, &eo_errman_DescrWrongParamLocal);
// i get the memory for the object. no need to check versus NULL because the memory pool already does it
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOsm), 1);
// now the obj has valid memory. i need to initialise it with other user-defined data, by means of cfg.
s_eo_sm_Specialise(retptr, cfg);
return(retptr);
}
extern EOfifoWord* eo_fifoword_New(eOsizecntnr_t capacity, EOVmutexDerived *mutex)
{
EOfifoWord *retptr = NULL;
// i get memory for a fifoword. it can never be NULL
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOfifoWord), 1);
eo_errman_Assert(eo_errman_GetHandle(), (0 != capacity), "eo_fifoword_New(): 0 capacity", s_eobj_ownname, &eo_errman_DescrWrongParamLocal);
// now i create a mutexfifo made of word (no ctor or dtor!) and i fill it into the fifo of
// the fifoword. it can never be NULL
retptr->fifo = eo_fifo_New(4, capacity, NULL, 0, NULL, NULL, mutex);
// ok, done
return(retptr);
}
extern void eo_deque_Delete(EOdeque * deque)
{
if(NULL == deque)
{ // invalid deque
return;
}
if(NULL == deque->stored_items)
{
return;
}
eo_deque_Clear(deque);
memset(deque, 0, sizeof(EOdeque));
eo_mempool_Delete(eo_mempool_GetHandle(), deque);
return;
}
extern EOVmutex* eov_mutex_hid_New(void)
{
EOVmutex *retptr = NULL;
// i get the memory for the object
retptr = (EOVmutex*) eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOVmutex), 1);
// now the obj has valid memory. i need to initialise it with user-defined data
// vtable
retptr->vtable[VF00_take] = NULL;
retptr->vtable[VF01_release] = NULL;
retptr->vtable[VF02_delete] = NULL;
// other stuff
return(retptr);
}
extern void eo_fifoword_Delete(EOfifoWord *fifoword)
{
if(NULL == fifoword)
{
return;
}
if(NULL == fifoword->fifo)
{
return;
}
eo_fifoword_Clear(fifoword, eok_reltimeINFINITE);
eo_fifo_Delete(fifoword->fifo);
memset(fifoword, 0, sizeof(EOfifoWord));
eo_mempool_Delete(eo_mempool_GetHandle(), fifoword);
return;
}
extern EOYmutex* eoy_mutex_New(void)
{
EOYmutex *retptr = NULL;
// i get the memory for the yarp mutex object
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOYmutex), 1);
// i get the base mutex
retptr->mutex = eov_mutex_hid_New();
// init its vtable
eov_mutex_hid_SetVTABLE(retptr->mutex, s_eoy_mutex_take, s_eoy_mutex_release, s_eoy_mutex_delete);
// i get a new yarp mutex
retptr->acemutex = ace_mutex_new();
// need to check because yarp may return NULL
eo_errman_Assert(eo_errman_GetHandle(), (NULL != retptr->acemutex), s_eobj_ownname, "eoy_mutex_New(): ace cannot give a mutex", &eo_errman_DescrRuntimeErrorLocal);
return(retptr);
}
extern void eo_confman_Delete(EOconfirmationManager *p)
{
if(NULL == p)
{
return;
}
if(NULL != p->mtx)
{
eov_mutex_Delete(p->mtx);
}
if(NULL != p->confrequests)
{
eo_vector_Delete(p->confrequests);
}
memset(p, 0, sizeof(EOconfirmationManager));
eo_mempool_Delete(eo_mempool_GetHandle(), p);
return;
}
extern void eoy_mutex_Delete(EOYmutex *m)
{
if(NULL == m)
{
return;
}
if(NULL == m->acemutex)
{
return;
}
//#warning -> marco.accame: must uncomment the following but only after ace_mutex_delete() is implemented
//ace_mutex_delete(m->acemutex);
eov_mutex_hid_Delete(m->mutex);
memset(m, 0, sizeof(EOYmutex));
eo_mempool_Delete(eo_mempool_GetHandle(), m);
return;
}
extern EOfifo * eo_fifo_New(eOsizeitem_t item_size, eOsizecntnr_t capacity,
eOres_fp_voidp_uint32_t item_init, uint32_t init_arg,
eOres_fp_voidp_voidp_t item_copy, eOres_fp_voidp_t item_clear,
EOVmutexDerived *mutex)
{
EOfifo *retptr = NULL;
// i get memory for a mutexfifo. it will never be null
retptr = (EOfifo*) eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOfifo), 1);
eo_errman_Assert(eo_errman_GetHandle(), (0 != item_size), "eo_fifo_New(): 0 item_size", s_eobj_ownname, &eo_errman_DescrWrongParamLocal);
eo_errman_Assert(eo_errman_GetHandle(), (0 != capacity), "eo_fifo_New(): 0 capacity", s_eobj_ownname, &eo_errman_DescrWrongParamLocal);
// now i fill the mutexfifo with a deque
retptr->dek = eo_deque_New(item_size, capacity, item_init, init_arg, item_copy, item_clear);
// now i copy the passed mutex into mutexfifo. beware for future use, ... it may be NULL
retptr->mutex = mutex;
// ok, done
return(retptr);
}
extern EOconstLookupTbl * eo_constLookupTbl_New(eOsizecntnr_t capacity, uint16_t offset , eOres_fp_voidp_t exceptionMngFn, const void* itemsList)
{
EOconstLookupTbl *retptr = NULL;
if(NULL == itemsList)
{
return(retptr);
}
// i get the memory for the object. no need to check versus NULL because the memory pool already does it
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOconstLookupTbl), 1);
// now the obj has valid memory. i need to initialise it with user-defined data,
eo_errman_Assert(eo_errman_GetHandle(), (0 != capacity), s_eobj_ownname, "capacity is zero");
retptr->capacity = capacity;
retptr->offset = offset;
retptr->exceptionMngFn = exceptionMngFn;
retptr->itemsList = itemsList;
return(retptr);
}
extern EOreceiver* eo_receiver_New(const eOreceiver_cfg_t *cfg)
{
EOreceiver *retptr = NULL;
if(NULL == cfg)
{
cfg = &eo_receiver_cfg_default;
}
// i get the memory for the object
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOreceiver), 1);
retptr->ropframeinput = eo_ropframe_New();
retptr->ropframereply = eo_ropframe_New();
retptr->ropinput = eo_rop_New(cfg->sizes.capacityofropinput);
retptr->ropreply = eo_rop_New(cfg->sizes.capacityofropreply);
retptr->agent = cfg->agent;
retptr->ipv4addr = 0;
retptr->ipv4port = 0;
retptr->bufferropframereply = (0 == cfg->sizes.capacityofropframereply) ? (NULL) : (eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, cfg->sizes.capacityofropframereply, 1));
retptr->rx_seqnum = eok_uint64dummy;
retptr->tx_ageofframe = eok_uint64dummy;
memset(&retptr->error_seqnumber, 0, sizeof(retptr->error_seqnumber)); // even if it is already zero.
memset(&retptr->error_invalidframe, 0, sizeof(retptr->error_invalidframe)); // even if it is already zero.
retptr->on_error_seqnumber = cfg->extfn.onerrorseqnumber;
retptr->on_error_invalidframe = cfg->extfn.onerrorinvalidframe;
// now we need to allocate the buffer for the ropframereply
#if defined(USE_DEBUG_EORECEIVER)
memset(&retptr->debug, 0, sizeof(EOreceiverDEBUG_t));
#endif
eo_ropframe_Load(retptr->ropframereply, retptr->bufferropframereply, eo_ropframe_sizeforZEROrops, cfg->sizes.capacityofropframereply);
eo_ropframe_Clear(retptr->ropframereply);
return(retptr);
}
extern EOtransmitter* eo_transmitter_New(const eo_transmitter_cfg_t *cfg)
{
EOtransmitter *retptr = NULL;
if(NULL == cfg)
{
cfg = &eo_transmitter_cfg_default;
}
// i get the memory for the object
retptr = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, sizeof(EOtransmitter), 1);
retptr->txpacket = eo_packet_New(cfg->capacityoftxpacket);
retptr->ropframereadytotx = eo_ropframe_New();
retptr->ropframeregulars = eo_ropframe_New();
retptr->ropframeoccasionals = eo_ropframe_New();
retptr->ropframereplies = eo_ropframe_New();
retptr->roptmp = eo_rop_New(cfg->capacityofrop);
retptr->nvscfg = cfg->nvscfg;
retptr->theagent = eo_agent_Initialise(NULL);
retptr->ipv4addr = cfg->ipv4addr;
retptr->ipv4port = cfg->ipv4port;
retptr->bufferropframeregulars = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, cfg->capacityofropframeregulars, 1);
retptr->bufferropframeoccasionals = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, cfg->capacityofropframeoccasionals, 1);
retptr->bufferropframereplies = eo_mempool_GetMemory(eo_mempool_GetHandle(), eo_mempool_align_32bit, cfg->capacityofropframereplies, 1);
retptr->listofregropinfo = (0 == cfg->maxnumberofregularrops) ? (NULL) : (eo_list_New(sizeof(eo_transm_regrop_info_t), cfg->maxnumberofregularrops, NULL, 0, NULL, NULL));
retptr->currenttime = 0;
retptr->tx_seqnum = 0;
eo_ropframe_Load(retptr->ropframeregulars, retptr->bufferropframeregulars, eo_ropframe_sizeforZEROrops, cfg->capacityofropframeregulars);
eo_ropframe_Clear(retptr->ropframeregulars);
eo_ropframe_Load(retptr->ropframeoccasionals, retptr->bufferropframeoccasionals, eo_ropframe_sizeforZEROrops, cfg->capacityofropframeoccasionals);
eo_ropframe_Clear(retptr->ropframeoccasionals);
eo_ropframe_Load(retptr->ropframereplies, retptr->bufferropframereplies, eo_ropframe_sizeforZEROrops, cfg->capacityofropframereplies);
eo_ropframe_Clear(retptr->ropframereplies);
{ // we set the content of ropframereadytotx with the same memory used by txpacket, so that when we operate on
// ropframereadytotx then we prepare the txpacket.
uint8_t *data;
uint16_t size;
uint16_t capacity;
eo_packet_Payload_Get(retptr->txpacket, &data, &size);
eo_packet_Capacity_Get(retptr->txpacket, &capacity);
eo_ropframe_Load(retptr->ropframereadytotx, data, eo_ropframe_sizeforZEROrops, capacity); // dont use size because size is now zero.
eo_ropframe_Clear(retptr->ropframereadytotx);
if(eobool_true != eo_ropframe_IsValid(retptr->ropframereadytotx))
{
eo_errman_Error(eo_errman_GetHandle(), eo_errortype_fatal, s_eobj_ownname, "the ropframeready2tx is not valid... cannot continue");
}
// the destination ipv4addr and ipv4port are constant and are the ones passed through configuration
eo_packet_Addressing_Set(retptr->txpacket, retptr->ipv4addr, retptr->ipv4port);
}
if((NULL != cfg->mutex_fn_new) && (eo_transmitter_protection_total == cfg->protection))
{
retptr->mtx_replies = cfg->mutex_fn_new();
retptr->mtx_regulars = cfg->mutex_fn_new();
retptr->mtx_occasionals = cfg->mutex_fn_new();
}
else
{
retptr->mtx_replies = NULL;
retptr->mtx_regulars = NULL;
retptr->mtx_occasionals = NULL;
}
#if defined(USE_DEBUG_EOTRANSMITTER)
// DEBUG
retptr->debug.txropframeistoobigforthepacket = 0;
#endif
return(retptr);
}
