int rtapi_app_main(void) {
int res=0;
comp_id = hal_init("pumakins");
if (comp_id < 0) return comp_id;
haldata = hal_malloc(sizeof(struct haldata));
if (!haldata) goto error;
if((res = hal_pin_float_new("pumakins.A2", HAL_IO, &(haldata->a2), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("pumakins.A3", HAL_IO, &(haldata->a3), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("pumakins.D3", HAL_IO, &(haldata->d3), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("pumakins.D4", HAL_IO, &(haldata->d4), comp_id)) < 0) goto error;
PUMA_A2 = DEFAULT_PUMA560_A2;
PUMA_A3 = DEFAULT_PUMA560_A3;
PUMA_D3 = DEFAULT_PUMA560_D3;
PUMA_D4 = DEFAULT_PUMA560_D4;
hal_ready(comp_id);
return 0;
error:
hal_exit(comp_id);
return res;
}
int rtapi_app_main(void) {
int result;
comp_id = hal_init(name);
if(comp_id < 0) return comp_id;
vtable_id = hal_export_vtable(name, VTVERSION, &vtk, comp_id);
if (vtable_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"%s: ERROR: hal_export_vtable(%s,%d,%p) failed: %d\n",
name, name, VTVERSION, &vtk, vtable_id );
return -ENOENT;
}
haldata = hal_malloc(sizeof(struct haldata));
result = hal_pin_float_new("maxkins.pivot-length", HAL_IO, &(haldata->pivot_length), comp_id);
if(result < 0) goto error;
*(haldata->pivot_length) = 0.666;
hal_ready(comp_id);
return 0;
error:
hal_exit(comp_id);
return result;
}
int rtapi_app_main(void)
{
int retval = 0;
comp_id = hal_init("lineardeltakins");
if(comp_id < 0) retval = comp_id;
if(retval == 0)
{
haldata = hal_malloc(sizeof(struct haldata));
retval = !haldata;
}
if(retval == 0)
retval = hal_pin_float_newf(HAL_IN, &haldata->r, comp_id,
"lineardeltakins.R");
if(retval == 0)
retval = hal_pin_float_newf(HAL_IN, &haldata->l, comp_id,
"lineardeltakins.L");
if(retval == 0)
{
*haldata->r = DELTA_RADIUS;
*haldata->l = DELTA_DIAGONAL_ROD;
}
if(retval == 0)
{
hal_ready(comp_id);
}
return retval;
}
int rtapi_app_main(void) {
int res = 0;
comp_id = hal_init(name);
if(comp_id < 0) return comp_id;
vtable_id = hal_export_vtable(name, VTVERSION, &vtk, comp_id);
if (vtable_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"%s: ERROR: hal_export_vtable(%s,%d,%p) failed: %d\n",
name, name, VTVERSION, &vtk, vtable_id );
return -ENOENT;
}
haldata = hal_malloc(sizeof(struct haldata));
if(!haldata) goto error;
if((res = hal_pin_float_new("tripodkins.Bx", HAL_IO, &(haldata->bx), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("tripodkins.Cx", HAL_IO, &(haldata->cx), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("tripodkins.Cy", HAL_IO, &(haldata->cy), comp_id)) < 0) goto error;
Bx = Cx = Cy = 1.0;
hal_ready(comp_id);
return 0;
error:
hal_exit(comp_id);
return res;
}
int rtapi_app_main(void)
{
int n, retval, i;
if(num_chan && names[0]) {
rtapi_print_msg(RTAPI_MSG_ERR,"num_chan= and names= are mutually exclusive\n");
return -EINVAL;
}
if(!num_chan && !names[0]) num_chan = default_num_chan;
if(num_chan) {
howmany = num_chan;
} else {
for(i=0; names[i]; i++) {howmany = i+1;}
}
/* test for number of channels */
if ((howmany <= 0) || (howmany > MAX_CHAN)) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SIGGEN: ERROR: invalid number of channels: %d\n", howmany);
return -1;
}
/* have good config info, connect to the HAL */
comp_id = hal_init("siggen");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "SIGGEN: ERROR: hal_init() failed\n");
return -1;
}
/* allocate shared memory for siggen data */
siggen_array = hal_malloc(howmany * sizeof(hal_siggen_t));
if (siggen_array == 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SIGGEN: ERROR: hal_malloc() failed\n");
hal_exit(comp_id);
return -1;
}
/* export variables and functions for each siggen */
i = 0; // for names= items
for (n = 0; n < howmany; n++) {
/* export everything for this loop */
if(num_chan) {
char buf[HAL_NAME_LEN + 1];
rtapi_snprintf(buf, sizeof(buf), "siggen.%d", n);
retval = export_siggen(n, &(siggen_array[n]),buf);
} else {
retval = export_siggen(n, &(siggen_array[n]),names[i++]);
}
if (retval != 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SIGGEN: ERROR: siggen %d var export failed\n", n);
hal_exit(comp_id);
return -1;
}
}
rtapi_print_msg(RTAPI_MSG_INFO,
"SIGGEN: installed %d signal generators\n", howmany);
hal_ready(comp_id);
return 0;
}
int rtapi_app_main(void)
{
int res = 0;
comp_id = hal_init(name);
if (comp_id < 0) return comp_id;
haldata = hal_malloc(sizeof(struct haldata));
if (((res = hal_pin_newf(HAL_FLOAT, HAL_IN, (void **) &(haldata->Tool_offset),
comp_id, "%s.Tool-offset", name)) < 0) ||
((res = hal_pin_newf(HAL_FLOAT, HAL_IN, (void **) &(haldata->Y_offset),
comp_id, "%s.Y-offset", name)) < 0) ||
((res = hal_pin_newf(HAL_FLOAT, HAL_IN, (void **) &(haldata->Z_offset),
comp_id, "%s.Z-offset", name)) < 0))
goto error;
vtable_id = hal_export_vtable(name, VTVERSION, &vtk, comp_id);
if (vtable_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"%s: ERROR: hal_export_vtable(%s,%d,%p) failed: %d\n",
name, name, VTVERSION, &vtk, vtable_id );
return -ENOENT;
}
hal_ready(comp_id);
return 0;
error:
hal_exit(comp_id);
return res;
}
int rtapi_app_main(void) {
comp_id = hal_init("miller_kins");
if(comp_id > 0) {
hal_ready(comp_id);
return 0;
}
return comp_id;
}
int rtapi_app_main(void) {
comp_id = hal_init("scorbot-kins");
if (comp_id < 0) {
return comp_id;
}
hal_ready(comp_id);
return 0;
}
int rtapi_app_main(void)
{
int n, numchan, max_depth, retval;
fifo_t tmp_fifo[MAX_SAMPLERS];
/* validate config info */
for ( n = 0 ; n < MAX_SAMPLERS ; n++ ) {
if (( cfg[n] == NULL ) || ( *cfg == '\0' ) || ( depth[n] <= 0 )) {
break;
}
tmp_fifo[n].num_pins = parse_types(&(tmp_fifo[n]), cfg[n]);
if ( tmp_fifo[n].num_pins == 0 ) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SAMPLER: ERROR: bad config string '%s'\n", cfg[n]);
return -EINVAL;
}
/* allow one extra "slot" for the sample number */
max_depth = MAX_SHMEM / (sizeof(shmem_data_t) * (tmp_fifo[n].num_pins + 1));
if ( depth[n] > max_depth ) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SAMPLER: ERROR: depth too large, max is %d\n", max_depth);
return -ENOMEM;
}
tmp_fifo[n].depth = depth[n];
}
if ( n == 0 ) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SAMPLER: ERROR: no channels specified\n");
return -EINVAL;
}
numchan = n;
/* clear shmem IDs */
for ( n = 0 ; n < MAX_SAMPLERS ; n++ ) {
shmem_id[n] = -1;
}
/* have good config info, connect to the HAL */
comp_id = hal_init("sampler");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "SAMPLER: ERROR: hal_init() failed\n");
return -EINVAL;
}
/* create the samplers - allocate memory, export pins, etc. */
for (n = 0; n < numchan; n++) {
retval = init_sampler(n, &(tmp_fifo[n]));
if (retval != 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SAMPLER: ERROR: sampler %d init failed\n", n);
hal_exit(comp_id);
return retval;
}
}
rtapi_print_msg(RTAPI_MSG_INFO,
"SAMPLER: installed %d data samplers\n", numchan);
hal_ready(comp_id);
return 0;
}
int rtapi_app_main(void)
{
comp_id = hal_xinit(TYPE_RT, 0, 0, instantiate_lutn, NULL, compname);
if (comp_id < 0)
return -1;
hal_ready(comp_id);
return 0;
}
int rtapi_app_main(void)
{
char name[HAL_NAME_LEN + 2];
int n, retval;
/* only one port at the moment */
num_ports = 1;
n = 0; /* port number */
/* STEP 1: initialise the driver */
comp_id = hal_init("hal_skeleton");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SKELETON: ERROR: hal_init() failed\n");
return -1;
}
/* STEP 2: allocate shared memory for skeleton data */
port_data_array = hal_malloc(num_ports * sizeof(skeleton_t));
if (port_data_array == 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SKELETON: ERROR: hal_malloc() failed\n");
hal_exit(comp_id);
return -1;
}
/* STEP 3: export the pin(s) */
rtapi_snprintf(name, HAL_NAME_LEN, "skeleton.%d.pin-%02d-out", n, 1);
retval =
hal_pin_u32_new(name, HAL_IN, &(port_data_array->data_out), comp_id);
if (retval < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SKELETON: ERROR: port %d var export failed with err=%i\n", n,
retval);
hal_exit(comp_id);
return -1;
}
/* STEP 4: export write function */
rtapi_snprintf(name, HAL_NAME_LEN, "skeleton.%d.write", n);
retval =
hal_export_funct(name, write_port, &(port_data_array[n]), 0, 0,
comp_id);
if (retval < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SKELETON: ERROR: port %d write funct export failed\n", n);
hal_exit(comp_id);
return -1;
}
rtapi_print_msg(RTAPI_MSG_INFO,
"SKELETON: installed driver for %d ports\n", num_ports);
hal_ready(comp_id);
return 0;
}
int rtapi_app_main(void)
{
if ((comp_id = hal_init(name)) < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"%s: ERROR: hal_init() failed: %d\n",
name, comp_id);
return -1;
}
hal_ready(comp_id);
rtapi_print_msg(RTAPI_MSG_DBG,
"%s git=" GIT_VERSION " nanopb=" VERSION "\n", name);
return 0;
}
int rtapi_app_main(void)
{
int n, retval;
/* test for too many delays asked for */
if ((num_delays <= 0) || (num_delays > MAX_DELAYS)) {
rtapi_print_msg(RTAPI_MSG_ERR, "TIMEDELAY: ERROR: Invalid number of bit delays\n");
return -1;
}
/* have good config info, connect to the HAL */
comp_id = hal_init("timedelay");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"TIMEDELAY: ERROR: hal_init() failed\n");
return -1;
}
/* allocate shared memory for delay array */
delay_array = hal_malloc(num_delays * sizeof(bit_delay_t));
if (delay_array == 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"TIMEDELAY: ERROR: hal_malloc() failed\n");
hal_exit(comp_id);
return -1;
}
/* export pins/params for all delays */
for (n = 0; n < num_delays; n++) {
/* export all vars */
retval = export_delay(n, &(delay_array[n]));
if (retval != 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"TIMEDELAY: ERROR: group %d export failed\n", n);
hal_exit(comp_id);
return -1;
}
}
/* export update function */
retval = hal_export_funct("process_delays", process_delays, delay_array, 1, 0, comp_id);
if (retval != 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"TIMEDELAY: ERROR: process_delays funct export failed\n");
return -1;
}
rtapi_print_msg(RTAPI_MSG_INFO,
"TIMEDELAY: installed %d time delays\n", num_delays);
hal_ready(comp_id);
return 0;
}
int rtapi_app_main(void)
{
int retval;
void *shm_base;
long skip;
/* connect to the HAL */
comp_id = hal_init("scope_rt");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "SCOPE: ERROR: hal_init() failed\n");
return -1;
}
/* connect to scope shared memory block */
skip = (sizeof(scope_shm_control_t) + 3) & ~3;
shm_size = skip + num_samples * sizeof(scope_data_t);
shm_id = rtapi_shmem_new(SCOPE_SHM_KEY, comp_id, shm_size);
if (shm_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SCOPE RT: ERROR: failed to get shared memory (key=0x%x, size=%lu)\n",
SCOPE_SHM_KEY,
shm_size
);
hal_exit(comp_id);
return -1;
}
retval = rtapi_shmem_getptr(shm_id, &shm_base);
if (retval < 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SCOPE: ERROR: failed to map shared memory\n");
rtapi_shmem_delete(shm_id, comp_id);
hal_exit(comp_id);
return -1;
}
/* init control structure */
ctrl_rt = &ctrl_struct;
init_rt_control_struct(shm_base);
/* export scope data sampling function */
retval = hal_export_funct("scope.sample", sample, NULL, 0, 0, comp_id);
if (retval != 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SCOPE_RT: ERROR: sample funct export failed\n");
hal_exit(comp_id);
return -1;
}
rtapi_print_msg(RTAPI_MSG_DBG, "SCOPE_RT: installed sample function\n");
hal_ready(comp_id);
return 0;
}
int
rtapi_app_main(void)
{
int i;
Plc *pComp;
// Connect to the HAL.
component.id = hal_init("boss_plc");
if (component.id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "BOSS_PLC: ERROR: hal_init() failed\n");
return(-1);
}
for(i = 0; i < MAX_DEVICES; i++){
component.plcTable[i] = NULL;
}
if(count > MAX_DEVICES)
count = MAX_DEVICES;
for(i = 0; i < count; i++){
// Allocate memory for device object.
pComp = hal_malloc(sizeof(Plc));
if (pComp == NULL) {
rtapi_print_msg(RTAPI_MSG_ERR, "BOSS_PLC: ERROR: hal_malloc() failed\n");
hal_exit(component.id);
return(-1);
}
// Save pointer to device object.
component.plcTable[i] = pComp;
// Initialize device.
if(Plc_Init(pComp)){
hal_exit(component.id);
return(-1);
}
// Export pins, parameters, and functions.
if(Plc_Export(pComp, component.id, i)){
hal_exit(component.id);
return(-1);
}
}
hal_ready(component.id);
return(0);
}
int rtapi_app_main(void) {
int res=0;
#if (TRACE!=0)
dptrace = fopen("art_scarakins.log","w");
#endif
DP ("begin\n");
comp_id = hal_init("art_scarakins");
if (comp_id < 0) return comp_id;
haldata = hal_malloc(sizeof(*haldata));
if (!haldata) goto error;
if((res = hal_pin_float_new("scarakins.D1", HAL_IO, &(haldata->d1), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("scarakins.D2", HAL_IO, &(haldata->d2), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("scarakins.D3", HAL_IO, &(haldata->d3), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("scarakins.D4", HAL_IO, &(haldata->d4), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("scarakins.D5", HAL_IO, &(haldata->d5), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("scarakins.D6", HAL_IO, &(haldata->d6), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("scarakins.PPD", HAL_IO, &(haldata->ppd), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("scarakins.SING", HAL_IO, &(haldata->sing), comp_id)) < 0) goto error;
DPS("D1=%f ", D1);
DPS("D2=%f ", D2);
DPS("D3=%f ", D3);
DPS("D4=%f ", D4);
DPS("D5=%f ", D5);
DPS("D6=%f ", D6);
DPS("PPD=%f ", PPD);
DPS("SINGU=%f ", SINGU);
DPS("\n");
// D1 = DEFAULT_D1;
// D2 = DEFAULT_D2;
// D3 = DEFAULT_D3;
// D4 = DEFAULT_D4;
// D5 = DEFAULT_D5;
// D6 = DEFAULT_D6;
hal_ready(comp_id);
DP ("success\n");
return 0;
error:
hal_exit(comp_id);
#if (TRACE!=0)
fclose(dptrace);
#endif
return res;
}
int
rtapi_app_main(void)
{
int i;
Pid *pComp;
// Check number of channels.
if((num_chan <= 0) || (num_chan > MAX_CHANNELS)){
rtapi_print_msg(RTAPI_MSG_ERR,
"PID: ERROR: invalid num_chan: %d\n", num_chan);
return(-1);
}
// Connect to the HAL.
component.id = hal_init("at_pid");
if(component.id < 0){
rtapi_print_msg(RTAPI_MSG_ERR, "PID: ERROR: hal_init() failed\n");
return(-1);
}
// Allocate memory for pid objects.
component.pidTable = hal_malloc(num_chan * sizeof(*pComp));
if(component.pidTable == NULL){
rtapi_print_msg(RTAPI_MSG_ERR, "PID: ERROR: hal_malloc() failed\n");
hal_exit(component.id);
return(-1);
}
pComp = component.pidTable;
for(i = 0; i < num_chan; i++, pComp++){
// Initialize pid.
if(Pid_Init(pComp)){
hal_exit(component.id);
return(-1);
}
// Export pins, parameters, and functions.
if(Pid_Export(pComp, component.id, i)){
hal_exit(component.id);
return(-1);
}
}
hal_ready(component.id);
return(0);
}
int rtapi_app_main(void) {
int res = 0;
comp_id = hal_init("bipodkins");
if(comp_id < 0) return comp_id;
haldata = hal_malloc(sizeof(*haldata));
if(!haldata) goto error;
Bx = 1.0;
if((res = hal_param_float_new("bipodkins.Bx", HAL_RW, &haldata->bx, comp_id)) < 0) goto error;
hal_ready(comp_id);
return 0;
error:
hal_exit(comp_id);
return res;
}
int rtapi_app_main(void) {
int res = 0;
comp_id = hal_init("millkins");
if(comp_id < 0) return comp_id;
do {
haldata = hal_malloc(sizeof(struct haldata));
if(!haldata) break;
res = hal_pin_float_new("millkins.skew", HAL_IN, &(haldata->skew), comp_id);
if (res < 0) break;
hal_ready(comp_id);
return 0;
} while (0);
hal_exit(comp_id);
return comp_id;
}
int rtapi_app_main(void)
{
int res = 0;
#if (TRACE!=0)
dptrace = fopen("alignmentkins.log","w");
#endif
comp_id = hal_init("alignmentkins");
if (comp_id < 0) {
// ERROR
return comp_id;
}
align_pins = hal_malloc(sizeof(align_pins_t));
if (!align_pins) goto error;
if ((res = hal_pin_float_new("alignmentkins.theta", HAL_IN, &(align_pins->theta), comp_id)) < 0) goto error;
THETA = 0;
// center based on g5x coordinate
if ((res = hal_pin_float_new("alignmentkins.x-cent", HAL_IN, &(align_pins->x_cent), comp_id)) < 0) goto error;
X_CENT = 0;
if ((res = hal_pin_float_new("alignmentkins.y-cent", HAL_IN, &(align_pins->y_cent), comp_id)) < 0) goto error;
Y_CENT = 0;
if ((res = hal_pin_float_new("alignmentkins.x-offset", HAL_IN, &(align_pins->x_offset), comp_id)) < 0) goto error;
// g5x offset
X_OFFSET = 0;
if ((res = hal_pin_float_new("alignmentkins.y-offset", HAL_IN, &(align_pins->y_offset), comp_id)) < 0) goto error;
Y_OFFSET = 0;
// align_pins->theta = 0;
// align_pins->theta = 0.78539815; // 45 degree
hal_ready(comp_id);
DP ("success\n");
return 0;
error:
hal_exit(comp_id);
#if (TRACE!=0)
fclose(dptrace);
#endif
return res;
}
int rtapi_app_main(void) {
int ans;
comp_id = hal_init("rosekins");
if(comp_id < 0) return comp_id;
haldata = hal_malloc(sizeof(struct haldata));
if((ans = hal_pin_float_new("rosekins.revolutions",
HAL_OUT, &(haldata->revolutions), comp_id)) < 0) goto error;
if((ans = hal_pin_float_new("rosekins.theta_degrees",
HAL_OUT, &(haldata->theta_degrees), comp_id)) < 0) goto error;
if((ans = hal_pin_float_new("rosekins.bigtheta_degrees",
HAL_OUT, &(haldata->bigtheta_degrees), comp_id)) < 0) goto error;
hal_ready(comp_id);
return 0;
error:
return ans;
}
int rtapi_app_main(void) {
int r;
comp_id = hal_init("probe_parport");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "PROBE_PARPORT: ERROR: hal_init() failed\n");
return -1;
}
r = pnp_register_driver (&parport_pc_pnp_driver);
if (r >= 0) {
pnp_registered_parport = 1;
} else {
rtapi_print_msg(RTAPI_MSG_WARN, "PROBE_PARPORT: no PnPBIOS parports were detected (%d)\n", r);
}
hal_ready(comp_id);
return 0;
}
int rtapi_app_main(void) {
int i;
comp_id = hal_init("trivkins");
if(comp_id < 0) return comp_id;
data = hal_malloc(sizeof(struct data));
for(i=0; i<EMCMOT_MAX_JOINTS; i++) {
data->joints[i] = next_axis_number();
}
switch (*kinstype) {
case 'b': case 'B': ktype = KINEMATICS_BOTH; break;
case 'f': case 'F': ktype = KINEMATICS_FORWARD_ONLY; break;
case 'i': case 'I': ktype = KINEMATICS_INVERSE_ONLY; break;
case '1': default: ktype = KINEMATICS_IDENTITY;
}
hal_ready(comp_id);
return 0;
}
int rtapi_app_main(void) {
int res=0;
comp_id = hal_init("riderkins");
if (comp_id < 0) return comp_id;
haldata = hal_malloc(sizeof(*haldata));
if (!haldata) goto error;
if((res = hal_pin_float_new("riderkins.top", HAL_IO, &(haldata->d1), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("riderkins.middle", HAL_IO, &(haldata->d2), comp_id)) < 0) goto error;
if((res = hal_pin_float_new("riderkins.bottom", HAL_IO, &(haldata->d3), comp_id)) < 0) goto error;
hal_ready(comp_id);
return 0;
error:
hal_exit(comp_id);
return res;
}
int rtapi_app_main(void)
{
int retval = 0;
comp_id = hal_init("rotarydeltakins");
if(comp_id < 0) retval = comp_id;
if(retval == 0)
{
haldata = hal_malloc(sizeof(struct haldata));
retval = !haldata;
}
if(retval == 0)
retval = hal_pin_float_newf(HAL_IN, &haldata->pfr, comp_id,
"rotarydeltakins.platformradius");
if(retval == 0)
retval = hal_pin_float_newf(HAL_IN, &haldata->tl, comp_id,
"rotarydeltakins.thighlength");
if(retval == 0)
retval = hal_pin_float_newf(HAL_IN, &haldata->sl, comp_id,
"rotarydeltakins.shinlength");
if(retval == 0)
retval = hal_pin_float_newf(HAL_IN, &haldata->fr, comp_id,
"rotarydeltakins.footradius");
if(retval == 0)
{
*haldata->pfr = RDELTA_PFR;
*haldata->tl = RDELTA_TL;
*haldata->sl = RDELTA_SL;
*haldata->fr = RDELTA_FR;
}
if(retval == 0)
{
hal_ready(comp_id);
}
return retval;
}
int rtapi_app_main(void)
{
int n, retval;
/* test for number of channels */
if ((num_chan <= 0) || (num_chan > MAX_CHAN)) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SIGGEN: ERROR: invalid num_chan: %d\n", num_chan);
return -1;
}
/* have good config info, connect to the HAL */
comp_id = hal_init("siggen");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "SIGGEN: ERROR: hal_init() failed\n");
return -1;
}
/* allocate shared memory for siggen data */
siggen_array = hal_malloc(num_chan * sizeof(hal_siggen_t));
if (siggen_array == 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SIGGEN: ERROR: hal_malloc() failed\n");
hal_exit(comp_id);
return -1;
}
/* export variables and functions for each siggen */
for (n = 0; n < num_chan; n++) {
/* export everything for this loop */
retval = export_siggen(n, &(siggen_array[n]));
if (retval != 0) {
rtapi_print_msg(RTAPI_MSG_ERR,
"SIGGEN: ERROR: siggen %d var export failed\n", n);
hal_exit(comp_id);
return -1;
}
}
rtapi_print_msg(RTAPI_MSG_INFO,
"SIGGEN: installed %d signal generators\n", num_chan);
hal_ready(comp_id);
return 0;
}
int rtapi_app_main(void)
{
int n, retval;
comp_id = hal_init("streamer");
if (comp_id < 0) {
rtapi_print_msg(RTAPI_MSG_ERR, "STREAMER: ERROR: hal_init() failed\n");
return -EINVAL;
}
streams = hal_malloc(MAX_STREAMERS * sizeof(streamer_t));
/* validate config info */
for ( n = 0 ; n < MAX_STREAMERS ; n++ ) {
if (( cfg[n] == NULL ) || ( *cfg == '\0' ) || ( depth[n] <= 0 )) {
break;
}
retval = hal_stream_create(&streams[n].fifo, comp_id, STREAMER_SHMEM_KEY+n, depth[n], cfg[n]);
if(retval < 0) {
goto fail;
}
nstreamers++;
retval = init_streamer(n, &streams[n]);
}
if ( n == 0 ) {
rtapi_print_msg(RTAPI_MSG_ERR,
"STREAMER: ERROR: no channels specified\n");
retval = -EINVAL;
goto fail;
}
hal_ready(comp_id);
return 0;
fail:
for(n=0; n<nstreamers; n++) hal_stream_destroy(&streams[n].fifo);
hal_exit(comp_id);
return retval;
}
signed int get_hal_int(const char *udi, const char *key, int optional)
{
int ret;
DBusError error;
if (!hal_ready())
return -1;
dbus_error_init(&error);
ret = libhal_device_get_property_int (hal_ctx, udi, key, &error);
if (!dbus_error_is_set(&error)) {
return ret;
} else {
if (!optional) {
fprintf(stderr, "error: libhal_device_get_property_int: %s: %s\n",
error.name, error.message);
}
dbus_error_free(&error);
return -1;
}
}
int main( int argc, char *argv[] )
{
int used=0, NumRung;
static int old_level ;
bindtextdomain("linuxcnc", EMC2_PO_DIR);
setlocale(LC_MESSAGES,"");
setlocale(LC_CTYPE,"");
textdomain("linuxcnc");
old_level = rtapi_get_msg_level();
compId=hal_init("classicladder"); //emc
if (compId<0) return -1; //emc
signal(SIGTERM,do_exit); //emc
InitModbusMasterBeforeReadConf( );
if (ClassicLadder_AllocAll())
{
char ProjectLoadedOk=TRUE;
process_options (argc, argv);
if (nogui==TRUE)
{
rtapi_print(_("INFO CLASSICLADDER- No ladder GUI requested-Realtime runs till HAL closes.\n"));
ClassicLadder_InitAllDatas( );
ProjectLoadedOk = LoadProjectFiles( InfosGene->CurrentProjectFileName );
if (pathswitch){ strcpy( InfosGene->CurrentProjectFileName, NewPath ); }
InfosGene->LadderState = STATE_RUN;
ClassicLadder_FreeAll(TRUE);
hal_ready(compId);
hal_exit(compId);
return 0;
} else {
for(NumRung=0;NumRung<NBR_RUNGS;NumRung++) { if ( RungArray[NumRung].Used ) used++; }
if((used==0) || ( (argc - optind) != 0) )
{
ClassicLadder_InitAllDatas( );
ProjectLoadedOk = LoadProjectFiles( InfosGene->CurrentProjectFileName );
InitGtkWindows( argc, argv );
UpdateAllGtkWindows();
if (pathswitch){ strcpy( InfosGene->CurrentProjectFileName, NewPath ); }
UpdateWindowTitleWithProjectName( );
MessageInStatusBar( ProjectLoadedOk?_("Project loaded and running"):_("Project failed to load..."));
if (!ProjectLoadedOk)
{
ClassicLadder_InitAllDatas( );
if (modmaster) { PrepareModbusMaster( ); }
}
}else{
InitGtkWindows( argc, argv );
UpdateAllGtkWindows();
if (pathswitch){ strcpy( InfosGene->CurrentProjectFileName, NewPath ); }
UpdateWindowTitleWithProjectName( );
MessageInStatusBar(_("GUI reloaded with existing ladder program"));
if (modmaster) { PrepareModbusMaster( ); }
}
if (modslave) { InitSocketServer( 0/*UseUdpMode*/, ModbusServerPort/*PortNbr*/); }
InfosGene->LadderState = STATE_RUN;
hal_ready(compId);
gtk_main();
rtapi_print(_("INFO CLASSICLADDER- Ladder GUI closed. Realtime runs till HAL closes\n"));
ClassicLadder_FreeAll(TRUE);
hal_exit(compId);
return 0;
}
}
rtapi_print(_("ERROR CLASSICLADDER- Ladder memory allocation error\n"));
ClassicLadder_FreeAll(TRUE);
rtapi_set_msg_level(old_level);
hal_exit(compId);
return 0;
}
int main(int argc, char **argv)
{
int n, channel, retval, size, line;
char *cp, *cp2;
void *shmem_ptr;
fifo_t *fifo;
shmem_data_t *data, *dptr;
char buf[BUF_SIZE];
const char *errmsg;
int tmpin, newin;
struct timespec delay;
/* set return code to "fail", clear it later if all goes well */
exitval = 1;
channel = 0;
for ( n = 1 ; n < argc ; n++ ) {
cp = argv[n];
if ( *cp != '-' ) {
break;
}
switch ( *(++cp) ) {
case 'c':
if (( *(++cp) == '\0' ) && ( ++n < argc )) {
cp = argv[n];
}
channel = strtol(cp, &cp2, 10);
if (( *cp2 ) || ( channel < 0 ) || ( channel >= MAX_STREAMERS )) {
fprintf(stderr,"ERROR: invalid channel number '%s'\n", cp );
exit(1);
}
break;
default:
fprintf(stderr,"ERROR: unknown option '%s'\n", cp );
exit(1);
break;
}
}
if(n < argc) {
int fd;
if(argc > n+1) {
fprintf(stderr, "ERROR: At most one filename may be specified\n");
exit(1);
}
// make stdin be the named file
fd = open(argv[n], O_RDONLY);
close(0);
dup2(fd, 0);
}
/* register signal handlers - if the process is killed
we need to call hal_exit() to free the shared memory */
signal(SIGINT, quit);
signal(SIGTERM, quit);
signal(SIGPIPE, SIG_IGN);
/* connect to HAL */
/* create a unique module name, to allow for multiple streamers */
snprintf(comp_name, sizeof(comp_name), "halstreamer%d", getpid());
/* connect to the HAL */
ignore_sig = 1;
comp_id = hal_init(comp_name);
ignore_sig = 0;
/* check result */
if (comp_id < 0) {
fprintf(stderr, "ERROR: hal_init() failed: %d\n", comp_id );
goto out;
}
hal_ready(comp_id);
/* open shmem for user/RT comms (fifo) */
/* initial size is unknown, assume only the fifo structure */
shmem_id = rtapi_shmem_new(STREAMER_SHMEM_KEY+channel, comp_id, sizeof(fifo_t));
if ( shmem_id < 0 ) {
fprintf(stderr, "ERROR: couldn't allocate user/RT shared memory\n");
goto out;
}
retval = rtapi_shmem_getptr(shmem_id, &shmem_ptr);
if ( retval < 0 ) {
fprintf(stderr, "ERROR: couldn't map user/RT shared memory\n");
goto out;
}
fifo = shmem_ptr;
if ( fifo->magic != FIFO_MAGIC_NUM ) {
fprintf(stderr, "ERROR: channel %d realtime part is not loaded\n", channel );
goto out;
}
/* now use data in fifo structure to calculate proper shmem size */
size = sizeof(fifo_t) + fifo->num_pins * fifo->depth * sizeof(shmem_data_t);
/* close shmem, re-open with proper size */
rtapi_shmem_delete(shmem_id, comp_id);
shmem_id = rtapi_shmem_new(STREAMER_SHMEM_KEY+channel, comp_id, size);
if ( shmem_id < 0 ) {
fprintf(stderr, "ERROR: couldn't re-allocate user/RT shared memory\n");
goto out;
}
retval = rtapi_shmem_getptr(shmem_id, &shmem_ptr);
if ( retval < 0 ) {
fprintf(stderr, "ERROR: couldn't re-map user/RT shared memory\n");
goto out;
}
line = 1;
fifo = shmem_ptr;
data = fifo->data;
while ( fgets(buf, BUF_SIZE, stdin) ) {
/* calculate _next_ value for in */
tmpin = fifo->in;
newin = tmpin + 1;
if ( newin >= fifo->depth ) {
newin = 0;
}
/* wait until there is space in the buffer */
while ( newin == fifo->out ) {
/* fifo full, sleep for 10mS */
delay.tv_sec = 0;
delay.tv_nsec = 10000000;
nanosleep(&delay,NULL);
}
/* make pointer fifo entry */
dptr = &data[tmpin*fifo->num_pins];
/* parse input line, write results to fifo */
cp = buf;
errmsg = NULL;
for ( n = 0 ; n < fifo->num_pins ; n++ ) {
/* strip leading whitespace */
while ( isspace(*cp) ) {
cp++;
}
switch ( fifo->type[n] ) {
case HAL_FLOAT:
dptr->f = strtod(cp, &cp2);
break;
case HAL_BIT:
if ( *cp == '0' ) {
dptr->b = 0;
cp2 = cp + 1;
} else if ( *cp == '1' ) {
dptr->b = 1;
cp2 = cp + 1;
} else {
errmsg = "bit value not 0 or 1";
cp2 = cp;
}
break;
case HAL_U32:
dptr->u = strtoul(cp, &cp2, 10);
break;
case HAL_S32:
dptr->s = strtol(cp, &cp2, 10);
break;
default:
/* better not happen */
goto out;
}
if ( errmsg == NULL ) {
/* no error yet, check for other possibilties */
/* whitespace separates fields, and there is a newline
at the end... so if there is not space or newline at
the end of a field, something is wrong. */
if ( *cp2 == '\0' ) {
errmsg = "premature end of line";
} else if ( ! isspace(*cp2) ) {
errmsg = "bad character";
}
}
/* test for any error */
if ( errmsg != NULL ) {
/* abort loop on error */
break;
}
/* advance pointers for next field */
dptr++;
cp = cp2;
}
if ( errmsg != NULL ) {
/* print message */
fprintf (stderr, "line %d, field %d: %s, skipping the line\n", line, n, errmsg );
/** TODO - decide whether to skip this line and continue, or
abort the program. Right now it skips the line. */
} else {
/* good data, keep it */
fifo->in = newin;
}
line++;
}
/* run was succesfull */
exitval = 0;
out:
ignore_sig = 1;
if ( shmem_id >= 0 ) {
rtapi_shmem_delete(shmem_id, comp_id);
}
if ( comp_id >= 0 ) {
hal_exit(comp_id);
}
return exitval;
}
