static int instantiate_lutn(const char *name, const int argc, const char**argv) { struct inst_data *ip; int i, inst_id; if ((inputs < 1) || (inputs > 5)) { hal_print_msg(RTAPI_MSG_ERR, "%s: invalid parameter inputs=%d, valid range=1..5", name, inputs); return -1; } if ((function == 0) || (function == -1)) { hal_print_msg(RTAPI_MSG_ERR, "%s: function=0x%x does not make sense", name, function); return -1; } if ((inst_id = hal_inst_create(name, comp_id, sizeof(struct inst_data) + inputs * sizeof(hal_bit_t *), (void **)&ip)) < 0) return -1; hal_print_msg(RTAPI_MSG_DBG, "%s: name='%s' inputs=%d function=0x%x ip=%p", __FUNCTION__, name, inputs, function, ip); // record instance params ip->inputs = inputs; ip->function = function; // export per-instance HAL objects for (i = 0; i < ip->inputs; i++) if (hal_pin_bit_newf(HAL_IN, &(ip->in[i]), inst_id, "%s.in%d", name, i)) return -1; if (hal_pin_bit_newf(HAL_OUT, &(ip->out), inst_id, "%s.out", name)) return -1; if (hal_export_functf(lutn, ip, 0, 0, inst_id, "%s.funct", name)) return -1; return 0; }
// init HAL objects static int export_halobjs(struct inst_data *ip, int owner_id, const char *name) { if (hal_pin_float_newf(HAL_OUT, &ip->out, owner_id, "%s.out", name)) return -1; if (hal_pin_float_newf(HAL_IN, &ip->in, owner_id, "%s.in", name)) return -1; if (hal_param_s32_newf(HAL_RO, &ip->iter,owner_id, "%s.iter", name)) return -1; // unittest observer pins, per instance if (hal_pin_s32_newf(HAL_OUT, &ip->repeat_value, owner_id, "%s.repeat_value", name)) return -1; if (hal_pin_s32_newf(HAL_OUT, &ip->prefix_len, owner_id, "%s.prefix_len", name)) return -1; // export a thread function, passing the pointer to the instance's HAL memory blob if (hal_export_functf(funct, ip, 0, 0, owner_id, "%s.funct", name)) return -1; return 0; }
static int export_delayline(int n) { int retval, nr_of_samples, i; char *str_type; // determine the required size of the ringbuffer nr_of_samples = return_instance_samples(n); size_t sample_size = sizeof(sample_t) + (nr_of_samples * sizeof(hal_data_u)); // add some headroom to be sure we dont overrun size_t rbsize = record_space(sample_size) * max_delay[n] * RB_HEADROOM; // create the delay queue if ((retval = hal_ring_newf(rbsize, sizeof(hal_delayline_t), ALLOC_HALMEM, "%s.samples", names[n])) < 0) { hal_print_msg(RTAPI_MSG_ERR, "%s: failed to create new ring '%s.samples': %d\n", cname, names[n], retval); return retval; } // use the per-using component ring access structure as the instance data, // which will also give us a handle on the scratchpad which we use for // HAL pins and other shared data if ((instance[n] = hal_malloc(sizeof(ringbuffer_t))) == NULL) return -1; if ((retval = hal_ring_attachf(instance[n], NULL, "%s.samples", names[n]))) { hal_print_msg(RTAPI_MSG_ERR, "%s: attach to ring '%s.samples' failed: %d\n", cname, names[n], retval); return -1; } // fill in instance data hal_delayline_t *hd = instance[n]->scratchpad; strncpy(hd->name, names[n], sizeof(hd->name)); hd->nsamples = nr_of_samples; hd->sample_size = sample_size; hd->max_delay = max_delay[n]; // set delay standard to value of zero hd->delay = 0; hd->output_ts = 0; hd->input_ts = hd->delay; // init pins, and at the same time fill the puntype array with // the type of pin[i] so we can later dereference proper char character; for (i = 0; i < hd->nsamples; i++) { character = samples[n][i]; rtapi_print_msg(RTAPI_MSG_DBG, "\"samples=\" string = %s" " character %d = %c \n", samples[n], i, character); // determine type hal_type_t type = HAL_TYPE_UNSPECIFIED; switch (character) { case 'b': case 'B': type = HAL_BIT; break; case 'f': case 'F': type = HAL_FLOAT; break; case 's': type = HAL_S32; break; case 'u': type = HAL_U32; break; case 'S': type = HAL_S64; break; case 'U': type = HAL_U64; break; default: hal_print_msg(RTAPI_MSG_ERR, "%s: invalid type '%c' for pin %d\n", cname, character, i); return -EINVAL; } hd->pintype[i] = type; switch (type) { case HAL_BIT: str_type = "bit"; break; case HAL_FLOAT: str_type = "flt"; break; case HAL_U32: str_type = "u32"; break; case HAL_S32: str_type = "s32"; break; case HAL_S64: str_type = "s64"; break; case HAL_U64: str_type = "u64"; break; case HAL_TYPE_MAX: case HAL_TYPE_UNSPECIFIED: // do nothing break; } // create pins of type as requested if (((retval = hal_pin_newf(type, HAL_IN, (void **) &hd->pins_in[i], comp_id, "%s.in%d-%s", hd->name, i, str_type)) < 0) || ((retval = hal_pin_newf(type, HAL_OUT, (void **) &hd->pins_out[i], comp_id, "%s.out%d-%s", hd->name, i, str_type)) < 0)) { return retval; } // post hal_pin_new(), pins are guaranteed to be set to zero } // create other pins if (((retval = hal_pin_bit_newf(HAL_IN, &(hd->enable), comp_id, "%s.enable", hd->name))) || ((retval = hal_pin_bit_newf(HAL_IN, &(hd->abort), comp_id, "%s.abort", hd->name))) || ((retval = hal_pin_u32_newf(HAL_IN, &(hd->pin_delay), comp_id, "%s.delay", hd->name))) || ((retval = hal_pin_u32_newf(HAL_OUT, &(hd->write_fail), comp_id, "%s.write-fail", hd->name))) || ((retval = hal_pin_u32_newf(HAL_OUT, &(hd->read_fail), comp_id, "%s.too-old", hd->name))) || ((retval = hal_pin_u32_newf(HAL_OUT, &(hd->too_old), comp_id, "%s.read-fail", hd->name)))) return retval; // export thread functions if (((retval = hal_export_functf(write_sample_to_ring, instance[n], 1, 0, comp_id, "%s.sample", hd->name)) < 0) || ((retval = hal_export_functf(read_sample_from_ring, instance[n], 1, 0, comp_id, "%s.output", hd->name)) < 0)) { return retval; } return 0; }
int hal_export_funct(const char *name, void (*funct) (void *, long), void *arg, int uses_fp, int reentrant, int owner_id) { return hal_export_functf(funct, arg, uses_fp, reentrant, owner_id, name); }