Week16. Wildcard Week

                 
         /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
               
             

               
                 brew install node
             
           

             
               brew install node
           
         

                 
                   mkdir ~/.npm-global
                   npm config set prefix '~/.npm-global'
                   echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.profile 
               
             

             
               mkdir ~/.npm-global
               npm config set prefix '~/.npm-global'
               echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.zprofile
           
         

           
             npm install -g edge-impulse-cli
         
       

    
    
      // XIAO BLE Sense LSM6DS3 Data  Forwarder

      #include "LSM6DS3.h"
      #include "Wire.h"

     //Create a instance of class LSM6DS3
     LSM6DS3 myIMU(I2C_MODE, 0x6A);  //I2C device address 0x6A

     #define CONVERT_G_TO_MS2 9.80665f
     #define FREQUENCY_HZ 50
     #define INTERVAL_MS (1000 / (FREQUENCY_HZ + 1))

     static unsigned long last_interval_ms = 0; 
     void setup(){
        Serial.begin(115200);
        while (!Serial){

         if (myIMU.begin() != 0) {
            Serial.println("Device error");
         } else {
            Serial.println("Device OK!");
         }
      }
     }
     void loop() {
        if (millis() > last_interval_ms + INTERVAL_MS) {
          last_interval_ms = millis();
          Serial.print(myIMU.readFloatAccelX() * CONVERT_G_TO_MS2, 4);
          Serial.print('\t');
        Serial.print(myIMU.readFloatAccelY() * CONVERT_G_TO_MS2, 4);
        Serial.print('\t');
        Serial.println(myIMU.readFloatAccelZ() * CONVERT_G_TO_MS2, 4);
     }
   }
  

    
    /* Includes ---------------------------------------------------------------- */
    // Include the necessary libraries for activity monitoring and IMU functionality
    #include <ActivityMonitor_Xiao_Sense_inferencing.h>  //replace the library name with yours
    #include "LSM6DS3.h"

    /* Constant defines -------------------------------------------------------- */
    // Conversion factor from acceleration in g to m/s²
    #define CONVERT_G_TO_MS2    9.80665f
    // Maximum accepted acceleration range
    #define MAX_ACCEPTED_RANGE  2.0f        // starting 03/2022, models are generated setting range to +-2, but this example use Arudino library which set range to +-4g. If you are using an older model, ignore this value and use 4.0f instead
    // Interval calculation based on the specified frequency
    #define INTERVAL_MS (1000 / (FREQUENCY_HZ + 1))
    // Variable to store the last interval timestamp
    static unsigned long last_interval_ms = 0;

    // Initialize the LSM6DS3 IMU with I2C mode and device address 0x6A
    LSM6DS3 myIMU(I2C_MODE, 0x6A);  

    // Flag for enabling debug mode for neural network
    static bool debug_nn = false; // Set this to true to see e.g. features generated from the raw signal

    /**
    * @brief      Arduino setup function
    */
    void setup()
    {
        // put your setup code here, to run once:
        // Initialize serial communication at 115200 baud rate
        Serial.begin(115200);
        // Wait for serial connection (needed for some cases)
        // comment out the below line to cancel the wait for USB connection (needed for native USB)
        while (!Serial);
        Serial.println("Edge Impulse Inferencing Demo");

        // Initialize the IMU
        if (!myIMU.begin()) {
            ei_printf("Failed to initialize IMU!\r\n");
        }
        else {
            ei_printf("IMU initialized\r\n");
        }

        // Check if the number of raw samples per frame matches the expected value
        if (EI_CLASSIFIER_RAW_SAMPLES_PER_FRAME!= 3) {
            ei_printf("ERR: EI_CLASSIFIER_RAW_SAMPLES_PER_FRAME should be equal to 3 (the 3 sensor axes)\n");
            return;
        }
    }

    /**
     * @brief Return the sign of the number
     *
     * @param number
     * @return int 1 if positive (or 0) -1 if negative
     */
    float ei_get_sign(float number) {
        // Function to determine the sign of a number
        return (number >= 0.0)? 1.0 : -1.0;
    }

    /**
    * @brief      Get data and run inferencing
    *
    * @param[in]  debug  Get debug info if true
    */
    void loop()
    {
        //ei_printf("\nStarting inferencing in 2 seconds...\n");

        // Delay for 2 seconds before starting inferencing
        delay(2000);

        //ei_printf("Sampling...\n");

        // Allocate a buffer for the IMU data
        float buffer[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE] = { 0 };

        // Read IMU data and perform range checks and conversions
        for (size_t ix = 0; ix < EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE; ix += 3) {
            // Determine the next sampling time
            uint64_t next_tick = micros() + (EI_CLASSIFIER_INTERVAL_MS * 1000);

            // Read acceleration data from the IMU
            buffer[ix+0] = myIMU.readFloatAccelX();
            buffer[ix+1] = myIMU.readFloatAccelY();
            buffer[ix+2] = myIMU.readFloatAccelZ();

            // Clip the data if it exceeds the maximum accepted range
            for (int i = 0; i < 3; i++) {
                if (fabs(buffer[ix + i]) > MAX_ACCEPTED_RANGE) {
                    buffer[ix + i] = ei_get_sign(buffer[ix + i]) * MAX_ACCEPTED_RANGE;
                }
            }

            // Convert acceleration from g to m/s²
            buffer[ix + 0] *= CONVERT_G_TO_MS2;
            buffer[ix + 1] *= CONVERT_G_TO_MS2;
            buffer[ix + 2] *= CONVERT_G_TO_MS2;

            // Delay to match the sampling interval
            delayMicroseconds(next_tick - micros());
        }

        // Prepare the data for classification
        signal_t signal;
        int err = numpy::signal_from_buffer(buffer, EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, &signal);
        if (err!= 0) {
            ei_printf("Failed to create signal from buffer (%d)\n", err);
            return;
        }

        // Run the classifier
        ei_impulse_result_t result = { 0 };

        err = run_classifier(&signal, &result, debug_nn);
        if (err!= EI_IMPULSE_OK) {
            ei_printf("ERR: Failed to run classifier (%d)\n", err);
            return;
        }

        // Print the classification results
        //ei_printf("Predictions ");
        //ei_printf("(DSP: %d ms., Classification: %d ms., Anomaly: %d ms.)",
        // result.timing.dsp, result.timing.classification, result.timing.anomaly);
        //ei_printf("\n");
        for (size_t ix = 0; ix < EI_CLASSIFIER_LABEL_COUNT; ix++) {
        //ei_printf("    %s: %.5f\n", result.classification[ix].label, result.classification[ix].value);
            if (result.classification[ix].value >.5) {
                ei_printf("%s \n", result.classification[ix]);
            }
        }

        //  if (result.classification[ix].value >.5) {
        //     ei_printf("    %s: %.5f\n", result.classification[ix].label, result.classification[ix].value);
        // }
        // }


#if EI_CLASSIFIER_HAS_ANOMALY == 1
        ei_printf("anomaly score: %.3f\n", result.anomaly);
#endif
    }

#if!defined(EI_CLASSIFIER_SENSOR) || EI_CLASSIFIER_SENSOR!= EI_CLASSIFIER_SENSOR_ACCELEROMETER
#error "Invalid model for current sensor"
#endif