capacitor-motioncal 0.0.1

package/CapacitorMotionCal.podspec

@@ -0,0 +1,23 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorMotionCal'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c}', 'common/**/*.{h,c}'
+  s.public_header_files = 'common/*.h'
+  s.ios.deployment_target = '13.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+  
+  s.pod_target_xcconfig = {
+    'HEADER_SEARCH_PATHS' => '"${PODS_TARGET_SRCROOT}/common"',
+    'SWIFT_OBJC_BRIDGING_HEADER' => '${PODS_TARGET_SRCROOT}/ios/Sources/MotionCalibrationPlugin/MotionCalibration-Bridging-Header.h'
+  }
+end

package/README.md

@@ -0,0 +1,126 @@
+# Capacitor MotionCal Plugin
+
+A Capacitor plugin for motion/magnetometer calibration using native C libraries.
+
+## Installation
+
+Install directly from GitHub:
+
+```bash
+npm install github:denizak/motioncal-capacitor
+npx cap sync
+```
+
+Or clone and install locally:
+
+```bash
+git clone https://github.com/denizak/motioncal-capacitor.git capacitor-motioncal
+npm install ./capacitor-motioncal
+npx cap sync
+```
+
+## API
+
+### updateBValue(options)
+
+Update the B (magnetic field magnitude) value.
+
+```typescript
+import { MotionCalibration } from 'capacitor-motioncal';
+
+await MotionCalibration.updateBValue({ value: 45.0 });
+```
+
+### getBValue()
+
+Get the current B value.
+
+```typescript
+const result = await MotionCalibration.getBValue();
+console.log('B value:', result.value);
+```
+
+### readDataFromFile(options)
+
+Read calibration data from a file.
+
+```typescript
+const result = await MotionCalibration.readDataFromFile({ filename: 'magdata.bin' });
+console.log('Read result:', result.result);
+```
+
+### sendCalibration()
+
+Send/process the calibration data.
+
+```typescript
+const result = await MotionCalibration.sendCalibration();
+console.log('Calibration result:', result.result);
+```
+
+### Quality Metrics
+
+```typescript
+const gapError = await MotionCalibration.getQualitySurfaceGapError();
+const varianceError = await MotionCalibration.getQualityMagnitudeVarianceError();
+const wobbleError = await MotionCalibration.getQualityWobbleError();
+const fitError = await MotionCalibration.getQualitySphericalFitError();
+```
+
+### Calibration Results
+
+```typescript
+// Get hard iron offset [x, y, z]
+const offset = await MotionCalibration.getHardIronOffset();
+console.log('Hard iron offset:', offset.offset);
+
+// Get soft iron matrix (3x3)
+const matrix = await MotionCalibration.getSoftIronMatrix();
+console.log('Soft iron matrix:', matrix.matrix);
+
+// Get geomagnetic field magnitude
+const magnitude = await MotionCalibration.getGeomagneticFieldMagnitude();
+console.log('Field magnitude:', magnitude.magnitude);
+```
+
+### Visualization
+
+```typescript
+// Get points for 3D visualization
+const points = await MotionCalibration.getDrawPoints();
+console.log('Draw points:', points.points);
+
+// Clear points
+await MotionCalibration.clearDrawPoints();
+```
+
+### Reset
+
+```typescript
+await MotionCalibration.resetRawData();
+```
+
+## Full API Reference
+
+| Method | Parameters | Returns |
+|--------|------------|---------|
+| `updateBValue` | `{ value: number }` | `Promise<void>` |
+| `getBValue` | - | `Promise<{ value: number }>` |
+| `isSendCalAvailable` | - | `Promise<{ available: number }>` |
+| `readDataFromFile` | `{ filename: string }` | `Promise<{ result: number }>` |
+| `setResultFilename` | `{ filename: string }` | `Promise<void>` |
+| `sendCalibration` | - | `Promise<{ result: number }>` |
+| `getQualitySurfaceGapError` | - | `Promise<{ error: number }>` |
+| `getQualityMagnitudeVarianceError` | - | `Promise<{ error: number }>` |
+| `getQualityWobbleError` | - | `Promise<{ error: number }>` |
+| `getQualitySphericalFitError` | - | `Promise<{ error: number }>` |
+| `displayCallback` | - | `Promise<void>` |
+| `getCalibrationData` | - | `Promise<{ data: string }>` |
+| `getDrawPoints` | - | `Promise<{ points: number[][] }>` |
+| `resetRawData` | - | `Promise<void>` |
+| `getHardIronOffset` | - | `Promise<{ offset: number[] }>` |
+| `getSoftIronMatrix` | - | `Promise<{ matrix: number[][] }>` |
+| `getGeomagneticFieldMagnitude` | - | `Promise<{ magnitude: number }>` |
+| `clearDrawPoints` | - | `Promise<void>` |
+
+

package/android/build.gradle

@@ -0,0 +1,67 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.2.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.denizak.motioncalibration"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 34
+        versionCode 1
+        versionName "0.0.1"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        
+        ndk {
+            abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    
+    sourceSets {
+        main {
+            jniLibs.srcDirs = ['src/main/jniLibs']
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/denizak/motioncalibration/MotionCalibrationPlugin.java

@@ -0,0 +1,248 @@
+package com.denizak.motioncalibration;
+
+import android.util.Base64;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+@CapacitorPlugin(name = "MotionCalibration")
+public class MotionCalibrationPlugin extends Plugin {
+
+    // Load the native library
+    static {
+        System.loadLibrary("motioncalibration");
+    }
+
+    // Native method declarations
+    private native void updateBValueNative(float bValue);
+    private native float getBValueNative();
+    private native short isSendCalAvailableNative();
+    private native int readDataFromFileNative(String filename);
+    private native void setResultFilenameNative(String filename);
+    private native int sendCalibrationNative();
+    private native float getQualitySurfaceGapErrorNative();
+    private native float getQualityMagnitudeVarianceErrorNative();
+    private native float getQualityWobbleErrorNative();
+    private native float getQualitySphericalFitErrorNative();
+    private native void displayCallbackNative();
+    private native byte[] getCalibrationDataNative();
+    private native float[][] convertDrawPoints();
+    private native void resetRawDataNative();
+    private native float[] getHardIronOffsetNative();
+    private native float[][] getSoftIronMatrixNative();
+    private native float getGeomagneticFieldMagnitudeNative();
+    private native void clearDrawPointsNative();
+
+    @PluginMethod
+    public void updateBValue(PluginCall call) {
+        Float value = call.getFloat("value");
+        if (value == null) {
+            call.reject("Value is required");
+            return;
+        }
+        updateBValueNative(value);
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void getBValue(PluginCall call) {
+        float result = getBValueNative();
+        JSObject ret = new JSObject();
+        ret.put("value", result);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void isSendCalAvailable(PluginCall call) {
+        short isAvailable = isSendCalAvailableNative();
+        JSObject ret = new JSObject();
+        ret.put("available", (int) isAvailable);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void readDataFromFile(PluginCall call) {
+        String filename = call.getString("filename");
+        if (filename == null) {
+            call.reject("Filename is required");
+            return;
+        }
+        String fullPath = getContext().getFilesDir().getAbsolutePath() + "/" + filename;
+        int result = readDataFromFileNative(fullPath);
+        JSObject ret = new JSObject();
+        ret.put("result", result);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void setResultFilename(PluginCall call) {
+        String filename = call.getString("filename");
+        if (filename == null) {
+            call.reject("Filename is required");
+            return;
+        }
+        String fullPath = getContext().getFilesDir().getAbsolutePath() + "/" + filename;
+        setResultFilenameNative(fullPath);
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void sendCalibration(PluginCall call) {
+        getActivity().runOnUiThread(() -> {
+            new Thread(() -> {
+                int result = sendCalibrationNative();
+                JSObject ret = new JSObject();
+                ret.put("result", result);
+                call.resolve(ret);
+            }).start();
+        });
+    }
+
+    @PluginMethod
+    public void getQualitySurfaceGapError(PluginCall call) {
+        float error = getQualitySurfaceGapErrorNative();
+        if (Float.isNaN(error)) {
+            error = 100.0f;
+        }
+        JSObject ret = new JSObject();
+        ret.put("error", error);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getQualityMagnitudeVarianceError(PluginCall call) {
+        float error = getQualityMagnitudeVarianceErrorNative();
+        if (Float.isNaN(error)) {
+            error = 100.0f;
+        }
+        JSObject ret = new JSObject();
+        ret.put("error", error);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getQualityWobbleError(PluginCall call) {
+        float error = getQualityWobbleErrorNative();
+        if (Float.isNaN(error)) {
+            error = 100.0f;
+        }
+        JSObject ret = new JSObject();
+        ret.put("error", error);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void getQualitySphericalFitError(PluginCall call) {
+        float error = getQualitySphericalFitErrorNative();
+        if (Float.isNaN(error)) {
+            error = 100.0f;
+        }
+        JSObject ret = new JSObject();
+        ret.put("error", error);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void displayCallback(PluginCall call) {
+        displayCallbackNative();
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void getCalibrationData(PluginCall call) {
+        byte[] calibrationData = getCalibrationDataNative();
+        if (calibrationData != null) {
+            String base64Data = Base64.encodeToString(calibrationData, Base64.DEFAULT);
+            JSObject ret = new JSObject();
+            ret.put("data", base64Data);
+            call.resolve(ret);
+        } else {
+            call.reject("No calibration data available");
+        }
+    }
+
+    @PluginMethod
+    public void getDrawPoints(PluginCall call) {
+        new Thread(() -> {
+            try {
+                float[][] points = convertDrawPoints();
+                JSArray jsonPoints = new JSArray();
+                for (float[] point : points) {
+                    JSArray jsonPoint = new JSArray();
+                    for (float coord : point) {
+                        jsonPoint.put(coord);
+                    }
+                    jsonPoints.put(jsonPoint);
+                }
+                JSObject ret = new JSObject();
+                ret.put("points", jsonPoints);
+                call.resolve(ret);
+            } catch (Exception e) {
+                call.reject("Failed to get draw points: " + e.getMessage());
+            }
+        }).start();
+    }
+
+    @PluginMethod
+    public void resetRawData(PluginCall call) {
+        resetRawDataNative();
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void getHardIronOffset(PluginCall call) {
+        try {
+            float[] offset = getHardIronOffsetNative();
+            JSArray jsonOffset = new JSArray();
+            for (float val : offset) {
+                jsonOffset.put(val);
+            }
+            JSObject ret = new JSObject();
+            ret.put("offset", jsonOffset);
+            call.resolve(ret);
+        } catch (Exception e) {
+            call.reject("Failed to get hard iron offset: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getSoftIronMatrix(PluginCall call) {
+        try {
+            float[][] matrix = getSoftIronMatrixNative();
+            JSArray jsonMatrix = new JSArray();
+            for (float[] row : matrix) {
+                JSArray jsonRow = new JSArray();
+                for (float val : row) {
+                    jsonRow.put(val);
+                }
+                jsonMatrix.put(jsonRow);
+            }
+            JSObject ret = new JSObject();
+            ret.put("matrix", jsonMatrix);
+            call.resolve(ret);
+        } catch (Exception e) {
+            call.reject("Failed to get soft iron matrix: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getGeomagneticFieldMagnitude(PluginCall call) {
+        float magnitude = getGeomagneticFieldMagnitudeNative();
+        JSObject ret = new JSObject();
+        ret.put("magnitude", magnitude);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void clearDrawPoints(PluginCall call) {
+        clearDrawPointsNative();
+        call.resolve();
+    }
+}

package/common/imuread.h

@@ -0,0 +1,156 @@
+#ifndef IMUread_h_
+#define IMUread_h_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <unistd.h>
+
+#define TIMEOUT_MSEC 14
+
+#define MAGBUFFSIZE 650 // Freescale's lib needs at least 392
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+typedef struct {
+	float x;
+	float y;
+	float z;
+	//int valid;
+} Point_t;
+
+typedef struct {
+	float q0; // w
+	float q1; // x
+	float q2; // y
+	float q3; // z
+} Quaternion_t;
+extern Quaternion_t current_orientation;
+
+extern int port_is_open(void);
+extern int open_port(const char *name);
+extern int read_serial_data(void);
+extern int write_serial_data(const void *ptr, int len);
+extern void close_port(void);
+void raw_data_reset(void);
+void cal1_data(const float *data);
+void cal2_data(const float *data);
+void calibration_confirmed(void);
+void raw_data(const int16_t *data);
+extern int send_calibration(void);
+void visualize_init(void);
+void apply_calibration(int16_t rawx, int16_t rawy, int16_t rawz, Point_t *out);
+extern void display_callback(void);
+void resize_callback(int width, int height);
+int MagCal_Run(void);
+void quality_reset(void);
+void quality_update(const Point_t *point);
+extern float quality_surface_gap_error(void);
+extern float quality_magnitude_variance_error(void);
+extern float quality_wobble_error(void);
+extern float quality_spherical_fit_error(void);
+extern short is_send_cal_available(void);
+extern void set_result_filename(const char *filename);
+
+// PhiEs start ==
+extern void clear_file(const char *filename);
+extern int read_ipc_file_data(const char *filename);
+extern int write_ipc_file_data(const void *ptr, int len);
+extern const uint8_t* get_calibration_data(void);
+extern float* get_draw_points(void);
+extern int get_draw_points_count(void);
+extern void clear_draw_points(void); // <-- Added function declaration here
+// PhiEs end ======
+
+// Expose MagCalibration_t properties
+extern void get_hard_iron_offset(float V[3]);
+extern void get_soft_iron_matrix(float invW[3][3]);
+extern float get_geomagnetic_field_magnitude(void);
+
+// magnetic calibration & buffer structure
+typedef struct {
+    float V[3];                  // current hard iron offset x, y, z, (uT)
+    float invW[3][3];            // current inverse soft iron matrix
+    float B;                     // current geomagnetic field magnitude (uT)
+    float FourBsq;               // current 4*B*B (uT^2)
+    float FitError;              // current fit error %
+    float FitErrorAge;           // current fit error % (grows automatically with age)
+    float trV[3];                // trial value of hard iron offset z, y, z (uT)
+    float trinvW[3][3];          // trial inverse soft iron matrix size
+    float trB;                   // trial value of geomagnetic field magnitude in uT
+    float trFitErrorpc;          // trial value of fit error %
+    float A[3][3];               // ellipsoid matrix A
+    float invA[3][3];            // inverse of ellipsoid matrix A
+    float matA[10][10];          // scratch 10x10 matrix used by calibration algorithms
+    float matB[10][10];          // scratch 10x10 matrix used by calibration algorithms
+    float vecA[10];              // scratch 10x1 vector used by calibration algorithms
+    float vecB[4];               // scratch 4x1 vector used by calibration algorithms
+    int8_t ValidMagCal;          // integer value 0, 4, 7, 10 denoting both valid calibration and solver used
+    int16_t BpFast[3][MAGBUFFSIZE];   // uncalibrated magnetometer readings
+    int8_t  valid[MAGBUFFSIZE];        // 1=has data, 0=empty slot
+    int16_t MagBufferCount;           // number of magnetometer readings
+} MagCalibration_t;
+
+extern MagCalibration_t magcal;
+
+void f3x3matrixAeqI(float A[][3]);
+void fmatrixAeqI(float *A[], int16_t rc);
+void f3x3matrixAeqScalar(float A[][3], float Scalar);
+void f3x3matrixAeqInvSymB(float A[][3], float B[][3]);
+void f3x3matrixAeqAxScalar(float A[][3], float Scalar);
+void f3x3matrixAeqMinusA(float A[][3]);
+float f3x3matrixDetA(float A[][3]);
+void eigencompute(float A[][10], float eigval[], float eigvec[][10], int8_t n);
+void fmatrixAeqInvA(float *A[], int8_t iColInd[], int8_t iRowInd[], int8_t iPivot[], int8_t isize);
+void fmatrixAeqRenormRotA(float A[][3]);
+
+#define SENSORFS 100
+#define OVERSAMPLE_RATIO 4
+
+// accelerometer sensor structure definition
+#define G_PER_COUNT 0.0001220703125F  // = 1/8192
+typedef struct
+{
+	float Gp[3];           // slow (typically 25Hz) averaged readings (g)
+	float GpFast[3];       // fast (typically 200Hz) readings (g)
+} AccelSensor_t;
+
+// magnetometer sensor structure definition
+#define UT_PER_COUNT 0.1F
+typedef struct
+{
+	float Bc[3];           // slow (typically 25Hz) averaged calibrated readings (uT)
+	float BcFast[3];       // fast (typically 200Hz) calibrated readings (uT)
+} MagSensor_t;
+
+// gyro sensor structure definition
+#define DEG_PER_SEC_PER_COUNT 0.0625F  // = 1/16
+typedef struct
+{
+	float Yp[3];                           // raw gyro sensor output (deg/s)
+	float YpFast[OVERSAMPLE_RATIO][3];     // fast (typically 200Hz) readings
+} GyroSensor_t;
+
+#define USE_MAHONY_FUSION
+
+void fusion_init(void);
+void fusion_update(const AccelSensor_t *Accel, const MagSensor_t *Mag, const GyroSensor_t *Gyro,
+    const MagCalibration_t *MagCal);
+void fusion_read(Quaternion_t *q);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif