Programming a 'custom' button

component points                    "hal userspace component to plot XY points";

pin in float xposition              "Receives current position from Xpos";
pin in float yposition              "Receives current position from Ypos";

pin in bit savepoints = 0           "Trigger to save current XY co-ordinates";
pin in bit previous = 0             "Trigger to move current points back one";
pin in bit next = 0             "Trigger to move current points forward one";
pin in bit loadfile = 0             "Load XY co-ordinates from file";
pin in bit writefile = 0            "Write XY co-ordinates to file";

pin out float xout-##[8] = 0        "X Output values";
pin out float yout-##[8] = 0        "Y Output values";

pin in bit gotoXY-##[8] = 0         "Trigger pin to goto points in array";
pin out bit select-##[8] = 0        "pin to light led to indicate which points current";

option singleton yes;               
option userspace yes;

author "ArcEye - 2013";
license "GPL";
;;

/**********************************************************************
NB.  This file is intended to be compiled with my own version of comp
which creates the struct __comp_state *inst as a global
to allow direct manipulation of pin values etc

comp.patch

--- /usr/bin/comp-orig	2012-10-10 16:11:00.000000000 +0100
+++ /usr/bin/comp	2013-04-13 12:42:51.000000000 +0100
@@ -653,7 +653,8 @@
         print >>f, "#define true (1)"
         print >>f, "#undef false"
         print >>f, "#define false (0)"
-
+## altered to expose the struct for use in comp files
+    print >>f, "struct __comp_state *inst;"
     print >>f
     if has_personality:
         print >>f, "static int export(char *prefix, long extra_arg, long personality) {"
@@ -664,7 +665,7 @@
     if has_array:
         print >>f, "    int j = 0;"
     print >>f, "    int sz = sizeof(struct __comp_state) + __comp_get_data_size();"
-    print >>f, "    struct __comp_state *inst = hal_malloc(sz);"
+    print >>f, "    inst = hal_malloc(sz);"
     print >>f, "    memset(inst, 0, sz);"
     if has_data:
         print >>f, "    inst->_data = (char*)inst + sizeof(struct __comp_state);"

***********************************************************************/

#include <stdio.h>    /* Standard input/output definitions */
#include <stdlib.h> 
#include <stdint.h>   /* Standard types */
#include <string.h>   /* String function definitions */
#include <unistd.h>   /* UNIX standard function definitions */
#include <fcntl.h>    /* File control definitions */
#include <errno.h>    /* Error number definitions */
#include <signal.h>

int done = 0;

void adios(int sig)
{
    done = 1;
}


void user_mainloop(void)
{
char points_file[] = "/usr/share/linuxcnc/points.txt";

char buffX[80];
char buffY[80];
char buff_cmd[120];

int j = 0;
int point_index = 0;
int saved, loaded, written, next_pressed, previous_pressed, go_pressed;
int retval = 1;

    signal(SIGINT, adios);
    signal(SIGTERM, adios);
    
    // flags to prevent cycling whilst button depressed 
    saved = loaded = written = next_pressed = previous_pressed = go_pressed = 0;
    
    bzero(buffX, 80);
    bzero(buffY, 80);    
    bzero(buff_cmd, 120);
    
        while(!done)
            {
            usleep(100000);
            FOR_ALL_INSTS()  
                { 
                ////////////////////////////////////////////////////////////////////////////
                // button pressed to save current points 
                if(savepoints && !saved)            
                    {
                    if(point_index == 8)  // if array full go back to start
                        point_index = 0; 
                    *(inst->xout[point_index]) = xposition;
                    *(inst->yout[point_index]) = yposition;
                    point_index++;
                    saved = 1;
                    }
                ////////////////////////////////////////////////////////////////////////////
                // button pressed to load points from file
                if(loadfile && !loaded)         
                    {
                    FILE *fptr1;
                    fptr1 = fopen(points_file, "r");
                    if(fptr1 != NULL)
                        {                    
                        point_index = 0;
                        retval = 1;
                        while(retval && (point_index < 8))
                            {
                            if(fgets(buffX, 80, fptr1) != NULL )
                                *(inst->xout[point_index]) =  atof(buffX);
                            else
                                retval = 0;
                                
                            if(fgets(buffY, 80, fptr1) != NULL )
                                *(inst->yout[point_index]) = atof(buffY); 
                            else
                                retval = 0;   
                            point_index++;
                            }
                        point_index--;  // it will be one higher than it should be
                        fclose(fptr1);
                        loaded = 1;
                        printf("Points loaded from %s\n",points_file);
                        }
                    else
                        printf("Failed to open %s\n", points_file);
                    }
                //////////////////////////////////////////////////////////////////////////////    
                // button pressed to write points to file
                if(writefile && !written)          
                    {
                    FILE *fptr2;
                    fptr2 = fopen(points_file, "w");
                    if(fptr2 != NULL)
                        {
                        for(j = 0; j < 8; j++)
                            {
                            fprintf(fptr2, "%09.04f\n", *(inst->xout[j])); 
                            fprintf(fptr2, "%09.04f\n", *(inst->yout[j]));   
                            }
                        written  = 1;
                        fclose(fptr2);
                        printf("Points written to %s\n",points_file);
                        }
                    else
                        printf("Failed to open %s\n", points_file);
                    }             
                ////////////////////////////////////////////////////////////////////
                // next and previous points buttons
                if(next && !next_pressed)
                    {
                    point_index++;
                    next_pressed = 1;
                    }
                if(previous && !previous_pressed)
                    {
                    point_index--;
                    previous_pressed = 1;
                    }
                ////////////////////////////////////////////////////////////////////
                // update current points LED
                if(point_index > 7) 
                        point_index = point_index - 8; 
                if(point_index < 0) 
                        point_index = point_index + 8; 
                
                for(j = 0; j < 8; j++)
                    {
                    if(j == point_index)
                        *(inst->select[j]) = 1;
                    else
                        *(inst->select[j]) = 0;                                      
                    }
                ///////////////////////////////////////////////////////////////////    
                // check for goto button activation
                if(!go_pressed)
                    {
                    for(j = 0; j < 8; j++)
                        {
                        if(*(inst->gotoXY[j]))
                            {
                            go_pressed = 1;
                            sprintf(buff_cmd, "axis-remote --mdi 'G53 G00 X%9.4f Y%9.4f'", *(inst->xout[j]), *(inst->yout[j]) );
                            system(buff_cmd);
                            bzero(buff_cmd, 120);
                            break;
                            }
                        }
                    }
                     
                ///////////////////////////////////////////////////////////////
                // zero the flags if the relevant button has been released                  
                if(!savepoints && saved) saved = 0;
                if(!loadfile && loaded) loaded = 0;
                if(!writefile && written) written = 0;
                if(!next && next_pressed) next_pressed = 0;
                if(!previous && previous_pressed) previous_pressed = 0;
                
                if(go_pressed)
                    {
                    go_pressed = 0;
                    for(j = 0; j < 8; j++)
                        {
                        if(*(inst->gotoXY[j]))
                            {
                            go_pressed = 1;
                            break;
                            }
                        }
                    } 
                //////////////////////////////////////////////////////////////
                                   
                } // FOR_ALL_INSTS          
            }// while(!done)
    
    exit(0);
}