Acceleration Magnitude

Lab 2: คำนวณ Acceleration Magnitude

วัตถุประสงค์

• Motion Detection: ขนาดของ acceleration บอกระดับการเคลื่อนไหว

• Gravity Reference: วางนิ่ง = 1g (9.81 m/s²)

• Impact Detection: ตกกระแทก = magnitude spike

จะได้เรียนรู้อะไร

1. Vector Magnitude: √(x² + y² + z²)

2. Math Functions: sqrtf()

3. Physical Meaning: ความหมายของ magnitude

2.1 Concept: Vector Magnitude

$$\text{magnitude} = \sqrt{x^2 + y^2 + z^2}$$

เมื่อวางราบ:

• x ≈ 0, y ≈ 0, z ≈ 9.81

• Magnitude ≈ 9.81 m/s² (1g)

เมื่อเคลื่อนไหว:

• Magnitude > 9.81 หรือ < 9.81

• สามารถใช้ตรวจจับการเคลื่อนไหว!

เมื่อตกอิสระ:

• Magnitude ≈ 0 (weightlessness)

โหลด Project Code จาก AIC Github Repo เพื่อเปิดบน VSCode IDE

GitHub - Advance-Innovation-Centre-AIC/aic-psoc-edge-epc2-imu-magnitudeGitHub

2.2 เปิดโปรเจกต์ aic-psoc-edge-epc2-imu-magnitude-master

เปิดไฟล์ proj_cm33_ns/sensor_hub_daq_task.c และศึกษาโครงสร้าง:

aic-psoc-edge-epc2-imu-magnitude-master/
├── proj_cm33_s/              # Secure Project
├── proj_cm33_ns/             
│   ├── main.c
│   ├── sensor_hub_daq_task.c 
│   └── sensor_hub_daq_task.h
└── proj_cm55/                # CM55 Project

เพิ่ม Include

#include <math.h>  /* sqrtf */

Important Macros and Variables

/*******************************************************************************
* Macros
*******************************************************************************/
#define GRAVITY_EARTH                       (9.80665f)
#define DEG_TO_RAD                          (0.01745f)
#define GYR_RANGE_DPS                       (2000.0f)
#define ACC_RANGE_2G                        (2.0f)

/* Custom app module ID to avoid collisions */
#define APP_RSLT_MODULE_ID                  (1U)

/* App error for task creation failure */
#define APP_RSLT_ACQ_TASK_CREATE_FAILED     CY_RSLT_CREATE(CY_RSLT_TYPE_ERROR,\
                                                        APP_RSLT_MODULE_ID,\
                                                        1U)

/*******************************************************************************
* Global Variables
*******************************************************************************/
static mtb_hal_i2c_t CYBSP_I2C_CONTROLLER_hal_obj;
static cy_stc_scb_i2c_context_t CYBSP_I2C_CONTROLLER_context;

static mtb_bmi270_data_t bmi270_data;
static mtb_bmi270_t bmi270;

static cy_en_scb_i2c_status_t initStatus;
static cy_rslt_t result;

สร้างฟังก์ชัน Raw accelerometer Conversion ชื่อ lsb_to_mp2()

/*******************************************************************************
 * Function Name: lsb_to_mps2
 *******************************************************************************
 * Summary:
 *   Converts raw accelerometer value to m/s²
 *
 * Parameters:
 *   val       - raw value from sensor (-32768 to +32767)
 *   g_range   - accelerometer range in g (2 = ±2g)
 *   bit_width - data width in bits (16)
 *
 * Return:
 *   float - acceleration in m/s²
 ******************************************************************************/
static float lsb_to_mps2(int16_t val, int8_t g_range, uint8_t bit_width)
{
    float half_scale = (float)(1u << (bit_width - 1u));
    return ((GRAVITY_EARTH) * val * g_range) / half_scale;
}

สร้างฟังก์ชัน Magnitude Calcuation ชื่อ calculate_magnitude()

/*******************************************************************************
 * Function Name: calculate_magnitude
 *******************************************************************************
 * Summary:
 *   Calculates the magnitude of acceleration vector: |acc| = sqrt(x² + y² + z²)
 *   Used for motion detection and impact sensing.
 *
 * Parameters:
 *   acc_x, acc_y, acc_z - acceleration components in m/s²
 *
 * Return:
 *   float - magnitude in m/s² (stationary ≈ 9.81 m/s² = 1g)
 *
 * Note:
 *   - Stationary: magnitude ≈ 9.81 m/s² (1g from gravity)
 *   - Moving: magnitude deviates from 9.81
 *   - Free fall: magnitude ≈ 0 (weightlessness)
 ******************************************************************************/
static float calculate_magnitude(float acc_x, float acc_y, float acc_z)
{
    return sqrtf(acc_x * acc_x + acc_y * acc_y + acc_z * acc_z);
}

2.3 เขียน Main Task Loop

/*******************************************************************************
 * Function Name: sensor_hub_daq_task
 *******************************************************************************
 * Summary:
 *   FreeRTOS task that reads BMI270 sensor and displays magnitude
 ******************************************************************************/
static void sensor_hub_daq_task(void *pvParameters)
{
    TickType_t xLastWakeTime = 0;
    const TickType_t xDelay = 100 / portTICK_PERIOD_MS;

    float acc_x = 0.0f;
    float acc_y = 0.0f;
    float acc_z = 0.0f;
    float magnitude = 0.0f;

    (void)pvParameters;

    /* Initialize I2C */
    initStatus = Cy_SCB_I2C_Init(CYBSP_I2C_CONTROLLER_HW,
                                &CYBSP_I2C_CONTROLLER_config,
                                &CYBSP_I2C_CONTROLLER_context);

    if (CY_SCB_I2C_SUCCESS != initStatus)
    {
        handle_app_error();
    }

    Cy_SCB_I2C_Enable(CYBSP_I2C_CONTROLLER_HW);

    result = mtb_hal_i2c_setup(&CYBSP_I2C_CONTROLLER_hal_obj,
                                &CYBSP_I2C_CONTROLLER_hal_config,
                                &CYBSP_I2C_CONTROLLER_context,
                                NULL);

    if (CY_RSLT_SUCCESS != result)
    {
        handle_app_error();
    }

    /* Initialize BMI270 */
    result = mtb_bmi270_init_i2c(&bmi270,
                                &CYBSP_I2C_CONTROLLER_hal_obj,
                                MTB_BMI270_ADDRESS_DEFAULT);

    if (CY_RSLT_SUCCESS != result)
    {
        handle_app_error();
    }

    result = mtb_bmi270_config_default(&bmi270);

    if (CY_RSLT_SUCCESS != result)
    {
        handle_app_error();
    }

    /* Clear screen */
    printf("\x1b[2J\x1b[;H");

    printf("************************************************************\r\n");
    printf("     Lab 2-2: Acceleration Magnitude                        \r\n");
    printf("************************************************************\r\n\r\n");
    printf("Magnitude = sqrt(x^2 + y^2 + z^2)\r\n");
    printf("Stationary: ~9.81 m/s^2 (1g)\r\n\r\n");

    xLastWakeTime = xTaskGetTickCount();

    for (;;)
    {
        /* Read sensor */
        result = mtb_bmi270_read(&bmi270, &bmi270_data);

        if (CY_RSLT_SUCCESS != result)
        {
            handle_app_error();
        }

        /* Convert to m/s² */
        acc_x = lsb_to_mps2(bmi270_data.sensor_data.acc.x,
                            ACC_RANGE_2G,
                            bmi270.sensor.resolution);
        acc_y = lsb_to_mps2(bmi270_data.sensor_data.acc.y,
                            ACC_RANGE_2G,
                            bmi270.sensor.resolution);
        acc_z = lsb_to_mps2(bmi270_data.sensor_data.acc.z,
                            ACC_RANGE_2G,
                            bmi270.sensor.resolution);

        /* Calculate magnitude */
        magnitude = calculate_magnitude(acc_x, acc_y, acc_z);

        /* Display results */
        printf("Accelerometer:\r\n");
        printf("  x: %9.6f m/s^2\r\n", (double)acc_x);
        printf("  y: %9.6f m/s^2\r\n", (double)acc_y);
        printf("  z: %9.6f m/s^2\r\n", (double)acc_z);
        printf("\r\n");
        printf("Magnitude: %9.6f m/s^2 (%.2f g)\r\n",
               (double)magnitude,
               (double)(magnitude / GRAVITY_EARTH));

        /* Move cursor back for clean display */
        printf("\x1b[6A");

        /* Toggle LED to show activity */
        Cy_GPIO_Inv(CYBSP_USER_LED1_PORT, CYBSP_USER_LED1_PIN);

        /* Wait for UART */
        while(!(Cy_SCB_UART_IsTxComplete(CYBSP_DEBUG_UART_HW))) {};

        vTaskDelayUntil(&xLastWakeTime, xDelay);
    }
}

Create Sensor Hub DAQ Task Function

/*******************************************************************************
 * Function Name: create_sensor_hub_daq_task
 ******************************************************************************/
cy_rslt_t create_sensor_hub_daq_task(void)
{
    BaseType_t status;

    status = xTaskCreate(sensor_hub_daq_task, "IMU Magnitude",
                            TASK_SENSOR_HUB_DAQ_STACK_SIZE, NULL,
                            TASK_SENSOR_HUB_DAQ_PRIORITY, NULL);

    return (pdPASS == status) ?
        CY_RSLT_SUCCESS : APP_RSLT_ACQ_TASK_CREATE_FAILED;
}

2.4 Build และ Flash

make build -j8
make program

2.5 Output ที่คาดหวัง

Accelerometer:
x: 0.012345, y: -0.023456, z: 9.806650 m/s²
Magnitude: 9.806789 m/s² (1.00 g)

[เมื่อเขย่า]
Magnitude: 12.345678 m/s² (1.26 g)

[เมื่อตกกระแทก]
Magnitude: 24.516625 m/s² (2.50 g)

Gyroscope:
x: 0.001234, y: 0.002345, z: -0.003456

Orientation = ORIENTATION_UP

Physical Meaning

สถานะ	Magnitude	ความหมาย
วางนิ่ง	≈ 9.81 m/s²	1g จากแรงโน้มถ่วง
เคลื่อนไหวเบา	9.5-10.5 m/s²	±0.1g deviation
เคลื่อนไหวปานกลาง	8-12 m/s²	±0.3g deviation
ตกกระแทก	> 20 m/s²	> 2g (impact)
ตกอิสระ	≈ 0 m/s²	Weightlessness

Flowchart

---

✍️ Exercise

1. G-Force Display : แสดงค่า magnitude ในหน่วย g พร้อม visual indicator

|====------| 0.8g (Low)
|=========-| 1.2g (High)

Hint

void print_g_force_bar(float magnitude)
{
    float g_force = magnitude / GRAVITY_EARTH;
    int bars = (int)(g_force * 10);  /* 0.1g per bar */

   ...

    printf("|");
    for (int i = 0; i < 20; i++)
    {
        ...
    }
    ...
}

1. Max/Min Tracking : เก็บค่า max และ min magnitude ที่เคยวัดได้

Hint

static float max_magnitude = 0.0f;
static float min_magnitude = 100.0f;

void track_magnitude(float magnitude)
{
    if (magnitude > max_magnitude)
    {
        ...
    }
    if (magnitude < min_magnitude)
    {
        ...
    }

    printf("Current: %.3f | Min: %.3f | Max: %.3f m/s²\r\n",
           (double)magnitude,
           (double)min_magnitude,
           (double)max_magnitude);
}

---

จบ Session 2 | ต่อไป: Session 3: LVGL Display