Merge remote-tracking branch 'origin/master'

.gitmodules

@@ -50,3 +50,6 @@
 [submodule "linux_kernel_modules/bmi088/BMI08x-Sensor-API"]
 	path = linux_kernel_modules/bmi088/BMI08x-Sensor-API
 	url = https://github.com/BoschSensortec/BMI08x-Sensor-API.git
+[submodule "components/libiioComponent/libiio"]
+	path = components/libiioComponent/libiio
+	url = https://github.com/mangOH/libiio.git

components/libiioComponent/Component.cdef

+externalBuild:
+{
+    "cmake -DWITH_IIOD=OFF -DWITH_USB_BACKEND=OFF -DWITH_SERIAL_BACKEND=OFF -DWITH_NETWORK_BACKEND=OFF -DWITH_TESTS=OFF ${CURDIR}/libiio"
+    "cmake --build ."
+    "mkdir -p ${MANGOH_ROOT}/build/${MANGOH_BOARD}_${LEGATO_TARGET}/libs"
+    /*
+     * This is a bit gross. We need to bundle the files from a known location, but there's currently
+     * no way to know the name of the directory that we just created the .so files in.
+     */
+    "cp -a libiio.so* ${MANGOH_ROOT}/build/${MANGOH_BOARD}_${LEGATO_TARGET}/libs/"
+}
+
+bundles:
+{
+    file:
+    {
+        [rx] ${MANGOH_ROOT}/build/${MANGOH_BOARD}_${LEGATO_TARGET}/libs/libiio.so      /usr/lib/
+        [rx] ${MANGOH_ROOT}/build/${MANGOH_BOARD}_${LEGATO_TARGET}/libs/libiio.so.0    /usr/lib/
+        [rx] ${MANGOH_ROOT}/build/${MANGOH_BOARD}_${LEGATO_TARGET}/libs/libiio.so.0.15 /usr/lib/
+    }
+}

components/libiioComponent/README.md

+# libiio Legato Component
+
+[libiio](https://wiki.analog.com/resources/tools-software/linux-software/libiio) is a library for
+interacting with iio devices. This repository provides a Legato component which builds and bundles
+libiio. A [mangOH fork](https://github.com/mangOH/libiio) of the [libiio git repository](
+https://github.com/analogdevicesinc/libiio) is included as a git submodule.
+
+To use this component, the Component.cdef of the component wishing to use libiio should be modified
+as follows:
+```
+requires:
+{
+    component:
+    {
+        ${MANGOH_ROOT}/components/libiioComponent
+    }
+    lib:
+    {
+        libiio.so
+        libiio.so.0
+        libiio.so.0.15
+    }
+}
+cflags:
+{
+    -I${MANGOH_ROOT}/components/libiioComponent/libiio
+}
+```

libiio @ 58136469

+Subproject commit 58136469a7aef5634a1c249e1bb983d086a8adef

mangOH.sdef

@@ -91,6 +91,7 @@ componentSearch:
     ${CURDIR}/apps/RedSensorToCloud
     ${CURDIR}/apps/LocationTriangulation
     ${CURDIR}/apps/MqttClient
+    ${CURDIR}/components
 }
 
 kernelModules:

samples/BoschSensorsMonitor/boschSensorsComponent/Component.cdef

-ldflags:
-{
-    -liio
-}
-
-sources:
-{
-    boschSensorsClient.c
-}

samples/BoschSensorsMonitor/boschSensorsMonitor.adef → samples/IioDeviceList/iioDeviceList.adef

 sandboxed: false
-version: 1.0.0
+version: 0.1
 start: manual
 
 executables:
 {
-    boschSensorsClient = ( boschSensorsComponent )
+    iioDeviceList = ( iioDeviceListComponent )
 }
 
 processes:
 {
-    envVars:
+    run:
     {
-        LE_LOG_LEVEL = INFO
+        ( iioDeviceList )
     }
-    run:
+    envVars:
     {
-        ( boschSensorsClient )
+        // This is required so that the bundled libraries are visible to the non-sandboxed app
+        LD_LIBRARY_PATH = /legato/systems/current/apps/iioDeviceList/read-only/usr/lib
     }
-}
-
-bindings:
-{
-    
+    faultAction: stopApp
 }

samples/IioDeviceList/iioDeviceListComponent/Component.cdef

+sources:
+{
+    main.c
+}
+
+requires:
+{
+    component:
+    {
+        ${MANGOH_ROOT}/components/libiioComponent
+    }
+    lib:
+    {
+        libiio.so
+        libiio.so.0
+        libiio.so.0.15
+    }
+}
+
+cflags:
+{
+    -I${MANGOH_ROOT}/components/libiioComponent/libiio
+    -std=c99
+}

samples/IioDeviceList/iioDeviceListComponent/main.c

+#include "legato.h"
+#include "interfaces.h"
+
+#include "iio.h"
+
+static void PerformScan(struct iio_context *localCtx)
+{
+    unsigned int i;
+    struct iio_device *device;
+    for (i = 0, device = iio_context_get_device(localCtx, i);
+         device != NULL;
+         ++i, device = iio_context_get_device(localCtx, i))
+    {
+        LE_INFO("-> IIO Device: '%s'", iio_device_get_name(device));
+        unsigned int j;
+        const char *attr;
+        char attrVal[128];
+
+        LE_INFO("--> IIO Device is trigger: %d", iio_device_is_trigger(device));
+        for (j = 0, attr = iio_device_get_attr(device, j);
+             attr != NULL;
+             ++j, attr = iio_device_get_attr(device, j))
+        {
+            const ssize_t readLen = iio_device_attr_read(device, attr, attrVal, sizeof(attrVal));
+            LE_INFO(
+                "--> IIO Device Attribute: '%s=%s'",
+                attr,
+                readLen < 0 ? "read error!" : attrVal);
+        }
+        for (j = 0, attr = iio_device_get_buffer_attr(device, j);
+             attr != NULL;
+             ++j, attr = iio_device_get_buffer_attr(device, j))
+        {
+            const ssize_t readLen =
+                iio_device_buffer_attr_read(device, attr, attrVal, sizeof(attrVal));
+            LE_INFO(
+                "--> IIO Device Buffer Attribute: '%s=%s'",
+                attr,
+                readLen < 0 ? "read error!" : attrVal);
+        }
+        for (j = 0, attr = iio_device_get_debug_attr(device, j);
+             attr != NULL;
+             ++j, attr = iio_device_get_debug_attr(device, j))
+        {
+            const ssize_t readLen =
+                iio_device_debug_attr_read(device, attr, attrVal, sizeof(attrVal));
+            LE_INFO(
+                "--> IIO Device Debug Attribute: '%s=%s'",
+                attr,
+                readLen < 0 ? "read error!" : attrVal);
+        }
+
+        struct iio_channel *chan;
+        for (j = 0, chan = iio_device_get_channel(device, j);
+             chan != NULL;
+             ++j, chan = iio_device_get_channel(device, j))
+        {
+            unsigned int k;
+            LE_INFO("--> IIO Channel: %s,%s", iio_channel_get_id(chan), iio_channel_get_name(chan));
+            LE_INFO("---> Direction: %s", iio_channel_is_output(chan) ? "output" : "input");
+            LE_INFO("---> Channel Type: %d", iio_channel_get_type(chan));
+            LE_INFO("---> Enabled: %s", iio_channel_is_enabled(chan) ? "yes" : "no");
+            for (k = 0, attr = iio_channel_get_attr(chan, k);
+                 attr != NULL;
+                 ++k, attr = iio_channel_get_attr(chan, k))
+            {
+                const ssize_t readLen = iio_channel_attr_read(chan, attr, attrVal, sizeof(attrVal));
+                LE_INFO(
+                    "---> IIO Channel Attribute: %s=%s",
+                    attr,
+                    readLen < 0 ? "read error!" : attrVal);
+            }
+        }
+    }
+}
+
+COMPONENT_INIT
+{
+    struct iio_context *localCtx = iio_create_local_context();
+    LE_ASSERT(localCtx != NULL);
+
+    LE_FATAL_IF(
+        iio_context_set_timeout(localCtx, 5000) != 0, "Failed to set timeout for local context");
+
+    PerformScan(localCtx);
+
+    iio_context_destroy(localCtx);
+}