X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=ucs2-afb%2Fucs_binding.c;h=ee1bce67628c412fc934910fa7ed258ecd26677d;hb=1f25b3a06ec284ee132bae8a81e183bb2a9ec819;hp=ba49e2088403dc52d1073b0c0800b85142195eb5;hpb=b64500c1e9bc55e273bb57b8423b8c3d4f0ead83;p=apps%2Fagl-service-unicens.git

diff --git a/ucs2-afb/ucs_binding.c b/ucs2-afb/ucs_binding.c
index ba49e20..ee1bce6 100644
--- a/ucs2-afb/ucs_binding.c
+++ b/ucs2-afb/ucs_binding.c
@@ -23,6 +23,7 @@
 
 #define BUFFER_FRAME_COUNT 10 /* max frames in buffer */
 #define WAIT_TIMER_US 1000000 /* default waiting timer 1s */
+#define I2C_MAX_DATA_SZ    32 /* max. number of bytes to be written to i2c */
 
 #include <systemd/sd-event.h>
 #include <sys/types.h>
@@ -34,12 +35,11 @@
 #include <time.h>
 #include <assert.h>
 #include <errno.h>
+#include <dirent.h> 
 
 #include "ucs_binding.h"
 #include "ucs_interface.h"
 
-
-
 #define MAX_FILENAME_LEN (100)
 #define RX_BUFFER (64)
 
@@ -59,17 +59,29 @@ typedef struct {
   CdevData_t rx;
   CdevData_t tx;
   UCSI_Data_t ucsiData;
-  UCSI_channelsT *channels;
 } ucsContextT;
 
+typedef struct {
+    struct afb_event node_event;
+    
+} EventData_t;
+
 static ucsContextT *ucsContextS;
+static EventData_t *eventData = NULL;
 
 PUBLIC void UcsXml_CB_OnError(const char format[], uint16_t vargsCnt, ...) {
-    /*DEBUG (afbIface, format, args); */
+    /*AFB_DEBUG (afbIface, format, args); */
     va_list args;
     va_start (args, vargsCnt);
     vfprintf (stderr, format, args);
     va_end(args);
+    
+    va_list argptr;
+    char outbuf[300];
+    va_start(argptr, vargsCnt);
+    vsprintf(outbuf, format, argptr);
+    va_end(argptr);
+    AFB_WARNING (outbuf);
 }
 
 PUBLIC uint16_t UCSI_CB_OnGetTime(void *pTag) {
@@ -99,19 +111,29 @@ STATIC int onTimerCB (sd_event_source* source,uint64_t timer, void* pTag) {
 PUBLIC void UCSI_CB_OnSetServiceTimer(void *pTag, uint16_t timeout) {
   uint64_t usec;
   /* set a timer with  250ms accuracy */
-  sd_event_now(afb_daemon_get_event_loop(afbIface->daemon), CLOCK_BOOTTIME, &usec);
-  sd_event_add_time(afb_daemon_get_event_loop(afbIface->daemon), NULL, CLOCK_MONOTONIC, usec + (timeout*1000), 250, onTimerCB, pTag);
+  sd_event_now(afb_daemon_get_event_loop(), CLOCK_BOOTTIME, &usec);
+  sd_event_add_time(afb_daemon_get_event_loop(), NULL, CLOCK_MONOTONIC, usec + (timeout*1000), 250, onTimerCB, pTag);
 
 }
 
-/** Callback when ever UNICENS forms a human readable message. */
-void UCSI_CB_OnUserMessage(void *pTag, const char format[],
+/**
+ * \brief Callback when ever an Unicens forms a human readable message.
+ *        This can be error events or when enabled also debug messages.
+ * \note This function must be implemented by the integrator
+ * \param pTag - Pointer given by the integrator by UCSI_Init
+ * \param format - Zero terminated format string (following printf rules)
+ * \param vargsCnt - Amount of parameters stored in "..."
+ */
+void UCSI_CB_OnUserMessage(void *pTag, bool isError, const char format[],
     uint16_t vargsCnt, ...) {
-    //DEBUG (afbIface, format, args);
-    va_list args;
-    va_start (args, format);
-    vfprintf (stderr, format, args);
-    va_end(args);
+    va_list argptr;
+    char outbuf[300];
+    pTag = pTag;
+    va_start(argptr, vargsCnt);
+    vsprintf(outbuf, format, argptr);
+    va_end(argptr);
+    if (isError)
+        AFB_NOTICE (outbuf);
 }
 
 /** UCSI_Service cannot be called directly within UNICENS context, need to service stack through mainloop */
@@ -127,29 +149,11 @@ STATIC int OnServiceRequiredCB (sd_event_source *source, uint64_t usec, void *pT
 PUBLIC void UCSI_CB_OnServiceRequired(void *pTag) {
 
    /* push an asynchronous request for loopback to call UCSI_Service */
-   sd_event_add_time(afb_daemon_get_event_loop(afbIface->daemon), NULL, CLOCK_MONOTONIC, 0, 0, OnServiceRequiredCB, pTag);
+   sd_event_add_time(afb_daemon_get_event_loop(), NULL, CLOCK_MONOTONIC, 0, 0, OnServiceRequiredCB, pTag);
 }
 
-
-/**
- * \brief Callback when ever a MOST error message was received.
- * \note This function must be implemented by the integrator
- * \param pTag - Pointer given by the integrator by UCSI_Init
- * \note All following parameters belong to the usual MOST message
- */
-PUBLIC void UCSI_CB_OnMostError(void *pTag, uint16_t sourceAddr,
-    uint8_t fblock, uint8_t inst, uint16_t function, uint8_t op,
-    const uint8_t *pPayload, uint32_t payloadLen) {
-
-    // Error to send to syslog
-    DEBUG (afbIface, "OnMostError source=0x%x", sourceAddr);
-}
-
-
-
 /* Callback when ever this UNICENS wants to send a message to INIC. */
-PUBLIC void UCSI_CB_SendMostMessage(void *pTag, const uint8_t *pData, uint32_t len) {
-
+PUBLIC void UCSI_CB_OnTxRequest(void *pTag, const uint8_t *pData, uint32_t len) {
     ucsContextT *ucsContext = (ucsContextT*) pTag;
     CdevData_t *cdevTx = &ucsContext->tx;
     uint32_t total = 0;
@@ -181,21 +185,49 @@ PUBLIC void UCSI_CB_SendMostMessage(void *pTag, const uint8_t *pData, uint32_t l
  * \param pTag - Pointer given by the integrator by UCSI_Init
  */
 void UCSI_CB_OnStop(void *pTag) {
-    NOTICE (afbIface, "UNICENS stopped");
+    AFB_NOTICE ("UNICENS stopped");
 
 }
 
-/**
- * \brief Callback on Unicens management results.
- * \note This function must be implemented by the integrator
- * \param pTag - Pointer given by the integrator by UCSI_Init
- * \param code - Result code
- * \param nodeAddress - Node address of the device causing this event
- * \param pNode - Pointer to node structure holding details of changed node
- */
-extern void UCSI_CB_OnMgrReport(void *pTag, Ucs_MgrReport_t code, uint16_t nodeAddress, Ucs_Rm_Node_t *pNode) {
+/** This callback will be raised, when ever an applicative message on the control channel arrived */
+void UCSI_CB_OnAmsMessageReceived(void *pTag)
+{
+	/* If not interested, just ignore this event.
+	   Otherwise UCSI_GetAmsMessage may now be called asynchronous (mainloop) to get the content. 
+	   Don't forget to call UCSI_ReleaseAmsMessage after that */
+}
+
+void UCSI_CB_OnRouteResult(void *pTag, uint16_t routeId, bool isActive)
+{
+}
+
+void UCSI_CB_OnGpioStateChange(void *pTag, uint16_t nodeAddress, uint8_t gpioPinId, bool isHighState)
+{
+}
 
-    DEBUG (afbIface, "OnMgrReport: Ucs_MgrReport_t=%d nodeAdresse=0x%x", code, nodeAddress);
+PUBLIC void UCSI_CB_OnMgrReport(void *pTag, Ucs_MgrReport_t code, uint16_t nodeAddress, Ucs_Rm_Node_t *pNode){
+
+    bool available;
+    
+    if (code == UCS_MGR_REP_AVAILABLE) {
+        available = true;
+    }
+    else if (code == UCS_MGR_REP_NOT_AVAILABLE) {
+        available = false;
+    }
+    else {
+        /*untracked event - just exit*/
+        return;
+    }
+    
+    if (eventData) {
+        
+        json_object *j_event_info = json_object_new_object();
+        json_object_object_add(j_event_info, "node", json_object_new_int(nodeAddress));
+        json_object_object_add(j_event_info, "available", json_object_new_boolean(available));
+        
+        afb_event_push(eventData->node_event, j_event_info);
+    }     
 }
 
 bool Cdev_Init(CdevData_t *d, const char *fileName, bool read, bool write)
@@ -240,10 +272,11 @@ int onReadCB (sd_event_source* src, int fileFd, uint32_t revents, void* pTag) {
     int ok;
 
     len = read (ucsContext->rx.fileHandle, &pBuffer, sizeof(pBuffer));
-
+    if (0 == len)
+        return 0;
     ok= UCSI_ProcessRxData(&ucsContext->ucsiData, pBuffer, (uint16_t)len);
     if (!ok) {
-        DEBUG (afbIface, "Buffer overrun (not handle)");
+        AFB_DEBUG ("Buffer overrun (not handle)");
         /* Buffer overrun could replay pBuffer */
     }
     return 0;
@@ -276,7 +309,7 @@ STATIC UcsXmlVal_t* ParseFile(struct afb_req request) {
     xmlBuffer[readSize] = '\0'; /* In any case, terminate it. */
 
     if (readSize != fdStat.st_size)  {
-        afb_req_fail_f (request, "fileread-fail", "File to read fullfile '%s' size(%d!=%d)", filename, readSize, fdStat.st_size);
+        afb_req_fail_f (request, "fileread-fail", "File to read fullfile '%s' size(%d!=%d)", filename, (int)readSize, (int)fdStat.st_size);
         goto OnErrorExit;
     }
 
@@ -292,186 +325,267 @@ STATIC UcsXmlVal_t* ParseFile(struct afb_req request) {
     return NULL;
 }
 
-STATIC int volOnSvcCB (sd_event_source* source,uint64_t timer, void* pTag) {
-    ucsContextT *ucsContext = (ucsContextT*) pTag;
-
-    sd_event_source_unref(source);
-    UCSI_Vol_Service(&ucsContext->ucsiData);
-
-    return 0;
-}
-
-/* This callback is fire each time an volume event wait in the queue */
-void volumeCB (uint16_t timeout) {
-    uint64_t usec;
-    sd_event_now(afb_daemon_get_event_loop(afbIface->daemon), CLOCK_BOOTTIME, &usec);
-    sd_event_add_time(afb_daemon_get_event_loop(afbIface->daemon), NULL, CLOCK_MONOTONIC, usec + (timeout*1000), 250, volOnSvcCB, ucsContextS);
-}
-
-STATIC int volSndCmd (struct afb_req request, struct json_object *commandJ, ucsContextT *ucsContext) {
-    int numid, vol, err;
-    struct json_object *nameJ, *channelJ, *volJ;
-
-    enum json_type jtype= json_object_get_type(commandJ);
-    switch (jtype) {
-        case json_type_array:
-            if (!sscanf (json_object_get_string (json_object_array_get_idx(commandJ, 0)), "%d", &numid)) {
-                afb_req_fail_f (request, "channel-invalid","command=%s channel is not an integer", json_object_get_string (channelJ));
-                goto OnErrorExit;
-            }
-            if (!sscanf (json_object_get_string (json_object_array_get_idx(commandJ, 1)), "%d", &vol)) {
-                afb_req_fail_f (request, "vol-invalid","command=%s vol is not an integer", json_object_get_string (channelJ));
-                goto OnErrorExit;
-            }
-            break;
+PUBLIC void ucs2_initialise (struct afb_req request) {
+    static UcsXmlVal_t *ucsConfig;
+    static ucsContextT ucsContext;
 
-        case json_type_object:
-            if (json_object_object_get_ex (commandJ, "numid", &channelJ)) {
-                if (!sscanf (json_object_get_string (channelJ), "%d", &numid)) {
-                    afb_req_fail_f (request, "channel-invalid","command=%s numid is not an integer", json_object_get_string (channelJ));
-                    goto OnErrorExit;
-                }
-            } else {
-                if (json_object_object_get_ex (commandJ, "channel", &nameJ)) {
-                    int idx;
-                    const char *name = json_object_get_string(nameJ);
-
-                    for (idx =0; ucsContext->channels[idx].name != NULL; idx++) {
-                        if (!strcasecmp(ucsContext->channels[idx].name, name)) {
-                            numid = ucsContext->channels[idx].numid;
-                            break;
-                        }
-                    }
-                    if (ucsContext->channels[idx].name == NULL) {
-                        afb_req_fail_f (request, "channel-invalid","command=%s channel name does not exist", name);
-                        goto OnErrorExit;
-                    }
-                } else {
-                    afb_req_fail_f (request, "channel-invalid","command=%s no valid channel name or channel", json_object_get_string(commandJ));
-                    goto OnErrorExit;
-                };
-            }
+    sd_event_source *evtSource;
+    int err;
 
-            if (!json_object_object_get_ex (commandJ, "volume", &volJ)) {
-                afb_req_fail_f (request, "vol-missing","command=%s vol not present", json_object_get_string (commandJ));
-                goto OnErrorExit;
-            }
+    /* Read and parse XML file */
+    ucsConfig = ParseFile (request);
+    if (NULL == ucsConfig) goto OnErrorExit;
 
-            if (!sscanf (json_object_get_string (volJ), "%d", &vol)) {
-                afb_req_fail_f (request, "vol-invalid","command=%s vol:%s is not an integer", json_object_get_string (commandJ), json_object_get_string (volJ));
-                goto OnErrorExit;
-            }
+    /* When ucsContextS is set, do not initalize UNICENS, CDEVs or system hooks, just load new XML */
+    if (!ucsContextS)
+    {
+        if (!ucsContextS && !InitializeCdevs(&ucsContext))  {
+            afb_req_fail_f (request, "devnit-error", "Fail to initialise device [rx=%s tx=%s]", CONTROL_CDEV_RX, CONTROL_CDEV_TX);
+            goto OnErrorExit;
+        }
 
-            break;
+        /* Initialise UNICENS Config Data Structure */
+        UCSI_Init(&ucsContext.ucsiData, &ucsContext);
 
-        default:
-            afb_req_fail_f (request, "setvol-invalid","command=%s not valid JSON Volume Command", json_object_get_string(commandJ));
+        /* register aplayHandle file fd into binder mainloop */
+        err = sd_event_add_io(afb_daemon_get_event_loop(), &evtSource, ucsContext.rx.fileHandle, EPOLLIN, onReadCB, &ucsContext);
+        if (err < 0) {
+            afb_req_fail_f (request, "register-mainloop", "Cannot hook events to mainloop");
             goto OnErrorExit;
-    }
-
+        }
 
-    /* Fulup what's append when channel or vol are invalid ??? */
-    err = UCSI_Vol_Set  (&ucsContext->ucsiData, numid, (uint8_t) vol);
-    if (err) {
-        /* Fulup this might only be a warning (not sure about it) */
-        afb_req_fail_f (request, "vol-refused","command=%s vol was refused by UNICENS", json_object_get_string (volJ));
+        /* save this in a statical variable until ucs2vol move to C */
+        ucsContextS = &ucsContext;
+    }
+    /* Initialise UNICENS with parsed config */
+    if (!UCSI_NewConfig(&ucsContext.ucsiData, ucsConfig))   {
+        afb_req_fail_f (request, "UNICENS-init", "Fail to initialize UNICENS");
         goto OnErrorExit;
     }
 
-    return 0;
+    afb_req_success(request,NULL,"UNICENS-active");
 
-  OnErrorExit:
-    return 1;
+ OnErrorExit:
+    return;
 }
 
 
-PUBLIC void ucs2SetVol (struct afb_req request) {
-    struct json_object *queryJ;
-    int err;
-
-    /* check UNICENS is initialised */
-    if (!ucsContextS) {
-        afb_req_fail_f (request, "UNICENS-init","Should Load Config before using setvol");
-        goto OnErrorExit;
-    }
+// List Avaliable Configuration Files
+PUBLIC void ucs2_listconfig (struct afb_req request) {
+    struct json_object *queryJ, *tmpJ, *responseJ;
+    DIR  *dirHandle;
+    char *dirPath, *dirList;
+    int error=0;
 
     queryJ = afb_req_json(request);
-    if (!queryJ) {
-        afb_req_fail_f (request, "query-notjson","query=%s not a valid json entry", afb_req_value(request,""));
-        goto OnErrorExit;
-    };
+    if (queryJ && json_object_object_get_ex (queryJ, "cfgpath" , &tmpJ)) {
+        dirList = strdup (json_object_get_string(tmpJ));
+    } else {    
+        dirList = strdup (UCS2_CFG_PATH); 
+        AFB_NOTICE ("fgpath:missing uses UCS2_CFG_PATH=%s", UCS2_CFG_PATH);
+    }
 
-    enum json_type jtype= json_object_get_type(queryJ);
-    switch (jtype) {
-        case json_type_array:
-            for (int idx=0; idx < json_object_array_length (queryJ); idx ++) {
-               err= volSndCmd (request, json_object_array_get_idx (queryJ, idx), ucsContextS);
-               if (err) goto OnErrorExit;
+    responseJ = json_object_new_array();
+    for (dirPath= strtok(dirList, ":"); dirPath && *dirPath; dirPath=strtok(NULL,":")) {
+         struct dirent *dirEnt;
+         
+        dirHandle = opendir (dirPath);
+        if (!dirHandle) {
+            AFB_NOTICE ("ucs2_listconfig dir=%s not readable", dirPath);
+            error++;
+            continue;
+        } 
+        
+        AFB_NOTICE ("ucs2_listconfig scanning: %s", dirPath);
+        while ((dirEnt = readdir(dirHandle)) != NULL) {
+            // Unknown type is accepted to support dump filesystems
+            if (dirEnt->d_type == DT_REG || dirEnt->d_type == DT_UNKNOWN) {
+                struct json_object *pathJ = json_object_new_object();
+                json_object_object_add(pathJ, "dirpath", json_object_new_string(dirPath));
+                json_object_object_add(pathJ, "basename", json_object_new_string(dirEnt->d_name));
+                json_object_array_add(responseJ, pathJ);
             }
-            break;
-
-        case json_type_object:
-            err = volSndCmd (request, queryJ, ucsContextS);
-            if (err) goto OnErrorExit;
-            break;
-
-        default:
-            afb_req_fail_f (request, "query-notarray","query=%s not valid JSON Volume Command Array", afb_req_value(request,""));
-            goto OnErrorExit;
+        }
     }
-
-
-    afb_req_success(request,NULL,NULL);
-
- OnErrorExit:
+    
+    free (dirList);
+   
+    if (!error)  afb_req_success(request,responseJ,NULL);
+    else {
+        char info[40];
+        snprintf (info, sizeof(info), "[%d] where not scanned", error); 
+         afb_req_success(request,responseJ, info);
+    } 
+    
     return;
 }
 
+PUBLIC void ucs2_subscribe (struct afb_req request) {
+    
+    if (!eventData) {
+        
+        eventData = malloc(sizeof(EventData_t));
+        if (eventData) {
+            eventData->node_event = afb_daemon_make_event ("node-availibility");
+        }
+        
+        if (!eventData || !afb_event_is_valid(eventData->node_event)) {
+            afb_req_fail_f (request, "create-event", "Cannot create or register event");
+            goto OnExitError;
+        }
+    }
+    
+    if (afb_req_subscribe(request, eventData->node_event) != 0) {
+        
+        afb_req_fail_f (request, "subscribe-event", "Cannot subscribe to event");
+        goto OnExitError;
+    }
+    
+    afb_req_success(request,NULL,"event subscription successful"); 
+    
+OnExitError:
+    return;
+}
 
-PUBLIC void ucs2Init (struct afb_req request) {
-    static UcsXmlVal_t *ucsConfig;
-    static ucsContextT ucsContext;
-
-    sd_event_source *evtSource;
-    int err;
-
-    /* Read and parse XML file */
-    ucsConfig = ParseFile (request);
-    if (NULL == ucsConfig) goto OnErrorExit;
+STATIC void ucs2_writei2c_CB (void *result_ptr, void *request_ptr) {
+    
+    if (request_ptr){
+        afb_req *req = (afb_req *)request_ptr;
+        Ucs_I2c_ResultCode_t *res = (Ucs_I2c_ResultCode_t *)result_ptr;
+        
+        if (!res) {
+            afb_req_fail(*req, "processing","busy or lost initialization");
+        }
+        else if (*res != UCS_I2C_RES_SUCCESS){
+            afb_req_fail_f(*req, "error-result", "result code: %d", *res);
+        }
+        else {
+            afb_req_success(*req, NULL, "success");
+        }
+        
+        afb_req_unref(*req);
+        free(request_ptr);
+    } 
+    else {
+        AFB_NOTICE("write_i2c: ambiguous response data");
+    }
+}
 
-    // Fulup->Thorsten BUG InitializeCdevs should fail when control does not exit
-    if (!InitializeCdevs(&ucsContext))  {
-        afb_req_fail_f (request, "devnit-error", "Fail to initialise device [rx=%s tx=%s]", CONTROL_CDEV_RX, CONTROL_CDEV_TX);
+/* write a single i2c command */
+STATIC void ucs2_writei2c_cmd(struct afb_req request, json_object *j_obj) {
+    
+    static uint8_t i2c_data[I2C_MAX_DATA_SZ];
+    uint8_t i2c_data_sz = 0;
+    uint16_t node_addr = 0;
+    struct afb_req *async_req_ptr = NULL;
+    
+    node_addr = (uint16_t)json_object_get_int(json_object_object_get(j_obj, "node"));
+    AFB_NOTICE("node_address: 0x%02X", node_addr);
+    
+    if (node_addr == 0) {
+        afb_req_fail_f(request, "query-params","params wrong or missing");
         goto OnErrorExit;
     }
-
-    // Initialise Unicens Config Data Structure
-    UCSI_Init(&ucsContext.ucsiData, &ucsContext);
-
-    // Initialise Unicens with parsed config
-    if (!UCSI_NewConfig(&ucsContext.ucsiData, ucsConfig))   {
-        afb_req_fail_f (request, "UNICENS-init", "Fail to initialize Unicens");
+       
+    if (json_object_get_type(json_object_object_get(j_obj, "data"))==json_type_array) {
+        int size = json_object_array_length(json_object_object_get(j_obj, "data"));
+        if ((size > 0) && (size <= I2C_MAX_DATA_SZ)) {
+            
+            int32_t i;
+            int32_t val;
+            struct json_object *j_elem;
+            struct json_object *j_arr = json_object_object_get(j_obj, "data");
+
+            for (i = 0; i < size; i++) {
+                
+                
+                j_elem = json_object_array_get_idx(j_arr, i);
+                val = json_object_get_int(j_elem);
+                if ((val < 0) && (val > 0xFF)){
+                    i = 0;
+                    break;
+                }
+                i2c_data[i] = (uint8_t)json_object_get_int(j_elem);
+            }
+            
+            i2c_data_sz = (uint8_t)i;
+        }
+    }
+    
+    if (i2c_data_sz == 0) {
+        AFB_NOTICE("data: invalid or not found");
+        afb_req_fail_f(request, "query-params","params wrong or missing");
         goto OnErrorExit;
     }
-
-    // register aplayHandle file fd into binder mainloop
-    err = sd_event_add_io(afb_daemon_get_event_loop(afbIface->daemon), &evtSource, ucsContext.rx.fileHandle, EPOLLIN, onReadCB, &ucsContext);
-    if (err < 0) {
-        afb_req_fail_f (request, "register-mainloop", "Cannot hook events to mainloop");
+   
+    async_req_ptr = malloc(sizeof(afb_req));
+    *async_req_ptr = request;
+    
+    if (UCSI_I2CWrite(  &ucsContextS->ucsiData,   /* UCSI_Data_t *pPriv*/
+                        node_addr,                /* uint16_t targetAddress*/
+                        false,                    /* bool isBurst*/
+                        0u,                       /* block count */
+                        0x2Au,                    /* i2c slave address */
+                        0x03E8u,                  /* timeout 1000 milliseconds */
+                        i2c_data_sz,              /* uint8_t dataLen */
+                        &i2c_data[0],             /* uint8_t *pData */
+                        &ucs2_writei2c_CB,        /* callback*/
+                        (void*)async_req_ptr      /* callback argument */
+                  )) {
+        /* asynchronous command is running */
+        afb_req_addref(request);
+    }
+    else {
+        AFB_NOTICE("i2c write: scheduling command failed");
+        afb_req_fail_f(request, "query-command-queue","command queue overload");
+        free(async_req_ptr);
+        async_req_ptr = NULL;
         goto OnErrorExit;
     }
+    
+OnErrorExit:
+    return;
+}
 
-    // init Unicens Volume Library
-    ucsContext.channels = UCSI_Vol_Init (&ucsContext.ucsiData, volumeCB);
-    if (!ucsContext.channels) {
-        afb_req_fail_f (request, "register-volume", "Could not enqueue new Unicens config");
+/* parse array or single command */
+PUBLIC void ucs2_writei2c (struct afb_req request) {
+    
+    struct json_object *j_obj;
+    
+    /* check UNICENS is initialised */
+    if (!ucsContextS) {
+        afb_req_fail_f(request, "unicens-init","Should Load Config before using setvol");
         goto OnErrorExit;
     }
-    // save this in a statical variable until ucs2vol move to C
-    ucsContextS = &ucsContext;
-
-    afb_req_success(request,NULL,"UNICENS-active");
 
+    j_obj = afb_req_json(request);
+    if (!j_obj) {
+        afb_req_fail_f(request, "query-notjson","query=%s not a valid json entry", afb_req_value(request,""));
+        goto OnErrorExit;
+    };
+    
+    AFB_DEBUG("request: %s", json_object_to_json_string(j_obj));
+    
+    if (json_object_get_type(j_obj)==json_type_array) {
+        
+        int cnt;
+        int len = json_object_array_length(j_obj);
+        
+        if (len != 1) {
+            afb_req_fail_f(request, "query-array","query of multiple commands is not supported");
+            goto OnErrorExit;
+        }
+        
+        for (cnt = 0; cnt < len; cnt++) {
+            
+            json_object *j_cmd = json_object_array_get_idx(j_obj, cnt);
+            ucs2_writei2c_cmd(request, j_cmd);
+        }
+    }
+    else {
+        ucs2_writei2c_cmd(request, j_obj);
+    }
+    
  OnErrorExit:
     return;
 }