# Advertise device Bluetooth Name
import bluetooth
import time

# 1. Initialize BLE
ble = bluetooth.BLE()
ble.active(True)

# 2. Define the name
DEVICE_NAME = "FBL_R"

def advertise():
    # BLE Advertisement format: [Length, Type, Data]
    # Type 0x09 is the 'Complete Local Name'
    name_bytes = DEVICE_NAME.encode('utf-8')
    # Payload = [Len of name + 1, Type 0x09, The Name]
    payload = bytearray([len(name_bytes) + 1, 0x09]) + name_bytes
    
    # gap_advertise(interval_us, payload)
    # 100000 us = 100ms interval
    ble.gap_advertise(100000, payload)
    print("FBL_R is now advertising...")

# 3. Start advertising
advertise()

# 4. Keep the program running
while True:
    time.sleep(1)
					

# LED light blinking 

from machine import Pin
import time

# Replace 'X' with the GPIO number from your PCB design
led = Pin(X, Pin.OUT)

while True:
    led.value(0)  # Logic 0 = LED ON (Common Anode)
    print("LED is ON")
    time.sleep(0.5)
    
    led.value(1)  # Logic 1 = LED OFF
    print("LED is OFF")
    time.sleep(0.5)
					

# Vibrator change strength 
from machine import Pin

# D6 corresponds to GPIO 21 on the ESP32-C3
motor = Pin(21, Pin.OUT)

# Set it to 0 (Stopped)
motor.value(0)
print("Motor on D6 (GPIO 21) is now set to 0")
					

# MPU sensor and reading
import machine
import time
import struct

# Initialize I2C
i2c = machine.I2C(0, sda=machine.Pin(6), scl=machine.Pin(7))
addr = 0x68

# IMPORTANT: Wake up the MPU-6050 inside this script
try:
    i2c.writeto_mem(addr, 0x6B, b'\x00')
    print("MPU-6050 Woken Up Successfully")
except:
    print("Could not find sensor. Check wires!")

def read_accel():
    try:
        # Read 6 bytes starting from 0x3B
        data = i2c.readfrom_mem(addr, 0x3B, 6)
        # Unpack high and low bytes into 3 signed integers (x, y, z)
        return struct.unpack('>hhh', data)
    except:
        return None

while True:
    vals = read_accel()
    if vals:
        ax, ay, az = vals
        print("X: {:6d} | Y: {:6d} | Z: {:6d}".format(ax, ay, az))
    else:
        print("Sensor disconnected!")
        break # Exit the loop if the sensor is lost
        
    time.sleep(0.2)
					

Prompt to Gemini: OK, today we'll start coding the complete code for the microcontroller, then I'll start linking it to the app. Let's start with the microcontroller first: advertise the name so it can be discovered on Bluetooth, set X/Y/Z for the calibration, and define the function for when the angle changes by 10% for a duration of 3 minutes. Keep in mind the angle and duration should be variables defined by the user through the app. If the movement is beyond the defined angles, the vibration motor should start working and the LED should start blinking. Once it's back in the predefined calibrated position, the vibrator should stop and the LED becomes stable. (Verbatim prompt — kept as sent.)

import machine
import bluetooth
import time
import struct
from machine import Pin, PWM, ADC

# ==============================================================================
# 0. TWIN-NODE SIDE SELECTION (CHANGE THIS PER NODE BEFORE FLASHING!)
# ==============================================================================
CLIP_SIDE = "FBL_R"  # Set to "FBL_L" for left clip, "FBL_R" for right clip

# ==============================================================================
# 1. HARDWARE CONFIGURATION
# ==============================================================================
i2c = machine.I2C(0, sda=machine.Pin(6), scl=machine.Pin(7), freq=400000)
MPU_ADDR = 0x68

# Indicators (Common Anode LEDs: 1=OFF, 0=ON)
led_red = machine.Pin(10, machine.Pin.OUT)   # D10
led_green = machine.Pin(9, machine.Pin.OUT)  # D9
led_blue = machine.Pin(8, machine.Pin.OUT)   # D8

# Actuator: Initialize Motor Pin (GPIO 21) as PWM at 1000Hz
motor_pwm = PWM(Pin(21))
motor_pwm.freq(1000)

# Battery Telemetry: Initialize ADC on Pin A0 (GPIO 2)
battery_adc = ADC(Pin(2))
battery_adc.atten(ADC.ATTN_11DB) 

# Safe initial hardware baselines
motor_pwm.duty(0) 
led_red.value(1)
led_green.value(1)
led_blue.value(1)

# ==============================================================================
# 2. VARIABLE REGISTRY (Dynamic Targets via BLE App)
# ==============================================================================
ALLOWED_DRIFT = 0.25             # Default 25% structural drift allowance
ALERT_DURATION_THRESHOLD = 5     # Default 5-second test window delay
MOTOR_STRENGTH = 75              # Default 75% vibration strength
BATTERY_PERC = 100               # Calculated live battery scale

# Calibration Targets
cali_x, cali_y, cali_z = 0.0, 0.0, 0.0
is_calibrated = False
trigger_calibration = False      # Volatile flag managed by incoming App requests

# Time Registries
slump_start_time = None          
last_blink_time = time.ticks_ms()
last_battery_check = 0           
led_toggle_state = False

# ==============================================================================
# 3. BLE STACK & UUID REGISTRATION (Fixed Initialization Order)
# ==============================================================================
_BLE_IRQ_CENTRAL_WRITE = 3

# 1. Instantiate the physical hardware BLE object FIRST
ble = bluetooth.BLE()
ble.active(True)

# 2. Define the universally unique profiles
SERVICE_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
CONFIG_CHAR_UUID = bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E") 
BATTERY_CHAR_UUID = bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E") 

# 3. Register local services database 
SERVICES_REGISTRY = (
    SERVICE_UUID,
    (
        (CONFIG_CHAR_UUID, bluetooth.FLAG_WRITE),
        (BATTERY_CHAR_UUID, bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY),
    ),
)
((config_handle, battery_handle),) = ble.gatts_register_services((SERVICES_REGISTRY,))

# 4. Define the interrupt packet listener
def ble_interrupt_handler(event, data):
    global ALLOWED_DRIFT, ALERT_DURATION_THRESHOLD, MOTOR_STRENGTH, trigger_calibration
    
    if event == _BLE_IRQ_CENTRAL_WRITE:
        conn_handle, value_handle = data
        if value_handle == config_handle:
            raw_packet = ble.gatts_read(config_handle).decode('utf-8').strip()
            print("Received BLE Payload:", raw_packet)
            
            try:
                if raw_packet == "CAL":
                    trigger_calibration = True 
                elif raw_packet.startswith("STR:"):
                    MOTOR_STRENGTH = int(raw_packet.split(":")[1])
                elif raw_packet.startswith("DEL:"):
                    ALERT_DURATION_THRESHOLD = int(raw_packet.split(":")[1])
                elif raw_packet.startswith("ANG:"):
                    ALLOWED_DRIFT = float(raw_packet.split(":")[1])
            except Exception as parse_error:
                print("Failed to map incoming packet structure:", parse_error)

ble.irq(ble_interrupt_handler)

# 5. Define the advertising function LAST (Now it safely knows what 'ble' is!)
def start_ble_advertising():
    name_bytes = CLIP_SIDE.encode('utf-8')
    payload = bytearray()
    payload += bytearray([0x02, 0x01, 0x06])  # Phone Flags
    payload += bytearray([len(name_bytes) + 1, 0x09]) + name_bytes  # Local Name Header
    
    ble.gap_advertise(100000, payload)  
    print("BLE Stack Online. Broadcasting Identity payload for '{}'.".format(CLIP_SIDE))
	
# ==============================================================================
# 4. SYSTEM PROCESSING UTILITIES
# ==============================================================================
def init_mpu():
    try:
        i2c.writeto_mem(MPU_ADDR, 0x6B, b'\x00')
        time.sleep(0.1)
        return True
    except:
        return False

def read_accel_g():
    try:
        data = i2c.readfrom_mem(MPU_ADDR, 0x3B, 6)
        raw_x, raw_y, raw_z = struct.unpack('>hhh', data)
        return raw_x / 16384.0, raw_y / 16384.0, raw_z / 16384.0
    except:
        return None

def update_battery_percentage():
    global BATTERY_PERC
    try:
        raw_value = battery_adc.read()
        pin_voltage = (raw_value / 4095.0) * 3.3
        actual_battery_voltage = pin_voltage * 2
        
        if actual_battery_voltage >= 4.2: BATTERY_PERC = 100
        elif actual_battery_voltage <= 3.4: BATTERY_PERC = 0
        else:
            BATTERY_PERC = int(((actual_battery_voltage - 3.4) / (4.2 - 3.4)) * 100)
            
        # Update our internal Bluetooth register memory with the new level
        ble.gatts_write(battery_handle, struct.pack(' last_second_print:
            print("Node locked. Recording vectors... {}s remaining.".format(10 - current_second))
            last_second_print = current_second
            led_blue.value(0 if led_blue.value() == 1 else 1)
        
        vals = read_accel_g()
        if vals:
            sum_x += vals[0]
            sum_y += vals[1]
            sum_z += vals[2]
            samples_taken += 1
        time.sleep(0.02) 

    if samples_taken > 0:
        cali_x = sum_x / samples_taken
        cali_y = sum_y / samples_taken
        cali_z = sum_z / samples_taken
        is_calibrated = True
        trigger_calibration = False # Reset flag
        
        led_blue.value(1)  
        led_green.value(0) 
        print("=== BASELINE DATA SAVED TO CORES ===")
        print("Baseline Locked: X:{:.2f}g Y:{:.2f}g Z:{:.2f}g\n".format(cali_x, cali_y, cali_z))
    else:
        print("Error: Calibration sample collection failed.")

# ==============================================================================
# 5. INITIALIZATION RUNTIME
# ==============================================================================
start_ble_advertising()
mpu_status = init_mpu()
update_battery_percentage()

if mpu_status:
    # Initial quick baseline lock so the hardware functions out-of-the-box
    print("Caching boot position baseline coordinates...")
    run_calibration()

# ==============================================================================
# 6. RUNTIME DATA EVALUATION LOOP
# ==============================================================================
while True:
    if not mpu_status:
        led_red.value(0)
        time.sleep(0.5)
        continue

    # Execute over-the-air calibration interrupt immediately if app button was tapped
    if trigger_calibration:
        run_calibration()

    # Track battery decay profiles every 5 seconds
    if time.ticks_diff(time.ticks_ms(), last_battery_check) > 5000:
        update_battery_percentage()
        last_battery_check = time.ticks_ms()

    current_vals = read_accel_g()
    if current_vals:
        cx, cy, cz = current_vals  
        
        diff_x = abs(cx - cali_x)
        diff_y = abs(cy - cali_y)
        diff_z = abs(cz - cali_z)
        
        has_slumped = (diff_x > ALLOWED_DRIFT) or (diff_y > ALLOWED_DRIFT) or (diff_z > ALLOWED_DRIFT)
        
        if has_slumped:
            if slump_start_time is None:
                slump_start_time = time.ticks_ms()
            
            elapsed_seconds = time.ticks_diff(time.ticks_ms(), slump_start_time) / 1000
            
            if elapsed_seconds >= ALERT_DURATION_THRESHOLD:
                # Trigger haptics using dynamically updated strength limits
                if MOTOR_STRENGTH > 0:
                    calculated_duty = int((MOTOR_STRENGTH / 100) * 1023)
                    motor_pwm.duty(calculated_duty)
                
                # Rapid async flash alerting via blue light
                if time.ticks_diff(time.ticks_ms(), last_blink_time) > 250:
                    led_toggle_state = not led_toggle_state
                    led_blue.value(0 if led_toggle_state else 1) 
                    led_red.value(1)   
                    led_green.value(1) 
                    last_blink_time = time.ticks_ms()
            else:
                motor_pwm.duty(0)
                led_red.value(1)
                led_blue.value(1)
                led_green.value(0) 
                
        else:
            if slump_start_time is not None:
                slump_start_time = None 
            
            motor_pwm.duty(0)       
            led_red.value(1)     
            led_blue.value(1) 
            led_green.value(0)   

    time.ticks_ms() # Small execution keepalive
    time.sleep(0.1)

My prompt to Gemini: …before that, let's make sure the main logic is correct. OK, let's define the exact functionality between App Inventor and the microcontroller. We will have 1 app and 2 identical microcontroller clips — one left, one right. The app will first detect the clips, connect to them, (2) show the battery level, (3) initialize calibration when a button is clicked, (4) using the sliders on the app, the user can define 3 things on the slider: vibration strength, delay before the vibration and LED blinking start, and the angle for the "accepted threshold". The microcontroller should be on and working. (Verbatim prompt — kept as sent.)