CodeCell can also detect whether the device is on a table, stationary, or in motion, using its Motion State sensing feature.

Understanding Motion State Detection

The CodeCell's BNO085 sensor provides a built-in algorithm called Motion State, which classifies the device’s movement into simple, easy-to-use states.

Enable Motion State with:

myCodeCell.Init(MOTION_STATE);    // Enable motion state sensing

Read the current state using:

int state = myCodeCell.Motion_StateRead();

Motion State Reference

Tip:
The difference between Stationary and Stable:

• Stable = recently stopped but still settling
• Stationary = fully still for a moment

Example – Serial Motion State Monitor

This example prints the current Motion State every 100 ms.

/*
  Example: Motion State Monitor Demo
  Boards: CodeCell C3 / CodeCell C3 Light / CodeCell C6 / CodeCell C6 Drive

  Overview:
  - Demonstrates the CodeCell's Motion State sensing.
  - Continuously reports whether the device is On-Table, In Motion, Stabilizing, or Stationary.  
*/

#include <CodeCell.h>

CodeCell myCodeCell;

void setup() {
  Serial.begin(115200);           // Start USB serial at 115200 baud
  myCodeCell.Init(MOTION_STATE);  // Enable Motion State sensing
}

void loop() {
  if (myCodeCell.Run(10)) {  // Run at 10 Hz
    Serial.print("State: ");
    switch (myCodeCell.Motion_StateRead()) {
      case MOTION_STATE_STABLE:
        Serial.println("Motion Stopped - Stabilizing");
        break;
      case MOTION_STATE_ONTABLE:
        Serial.println("On Table");
        break;
      case MOTION_STATE_STATIONARY:
        Serial.println("Stationary");
        break;
      case MOTION_STATE_MOTION:
        Serial.println("In Motion");
        break;
      default:
        Serial.println("Unknown");
        break;
    }
  }
}

When to Use Motion State

• Notify devices when picked up: Detect when a project moves.
• Trigger actions on motion stop: Start logging or measuring once movement stabilizes.
• Sleep mode optimization: Enter deep sleep when stationary for better battery life.

Notes

• Motion State may take a few seconds to stabilize after powering on.
• Mounting orientation affects sensitivity - fixed, rigid mounting gives the best results.

CodeCell is designed to stay compact, which means it doesn’t include physical RST or BOOT buttons like larger ESP32 development boards. Instead, the board automatically enters boot mode whenever you upload new code through the Arduino IDE.

Why There’s No BOOT Button

In most ESP32 boards, the BOOT button is used to place the microcontroller into programming mode. On CodeCell, this process is handled automatically through the USB interface, saving valuable board space and keeping the design as small as possible.

When You Might Need Manual Boot Mode

If the CodeCell gets stuck in a reset loop or fails to connect during firmware upload, you can manually enter boot mode to recover and re-flash the board.

How to Manually Enter Boot Mode

1. Connect a wire between the SCL pin and GND pin.
2. Unplug the USB-C cable and turn off the battery (if connected).
3. Reconnect the USB-C cable to your computer.
4. Re-upload your firmware from the Arduino IDE.
5. Once the upload is complete, remove the wire between SCL and GND and restore power.

After Recovery

• The CodeCell should restart normally and run your new sketch.
• If it still doesn’t respond, check your USB cable and Tools > Port settings.
• Re-enable USB_CDC_On_Boot in Tools if Serial Monitor isn’t working.

Once reflashed successfully, CodeCell will continue to enter boot mode automatically during uploads, no manual steps needed.

CodeCell C6 Drive is a tiny all-in-one robotics board that combines an ESP32-C6 microcontroller, onboard sensors and two H-bridge motor drivers. Each of the two built-in drivers (Drive 1 & Drive 2) can deliver PWM-controlled current to directly power:

• DC Motors & Gearmotors – for small robots, rovers, or fans.
• Actuators & Coil-Based Devices – such as CoilPad or FlatFlap.
• High-Power LEDs – drive lighting or status indicators with smooth PWM dimming.
• Buzzers & Haptic Actuators – create tones or vibration effects directly from the driver.

Drive Functions

Each driver channel includes several functions for different behaviors:

// 1️⃣ Initialize driver pins and timers
myCodeCell.Drive1.Init();      

// 2️⃣ Drive(direction, power_percent)
// Run the motor or load in a direction (true = forward, false = reverse)
// with PWM power level (0–100% duty cycle)
myCodeCell.Drive1.Drive(true, 80);

// 3️⃣ Tone()
// Generate a sweeping tone using PWM – ideal for audio or feedback vibration
myCodeCell.Drive1.Tone();

// 4️⃣ Pulse(direction, ms_duration)
// Apply a short directional pulse (in milliseconds) – great for flip actuators
myCodeCell.Drive1.Pulse(true, 150);

// 5️⃣ Buzz(us_buzz)
// Toggle output rapidly to create a buzzing sound
myCodeCell.Drive1.Buzz(800);

// 6️⃣ Toggle(power_percent)
// Alternate polarity at a set duty level – creates vibration patterns
myCodeCell.Drive1.Toggle(60);

// 7️⃣ Run(smooth, power_percent, flip_speed_ms)
// Periodically flip polarity for actuators (CoilPad, FlatFlap, etc.)
myCodeCell.Drive1.Run(false, 80, 200);   // Square wave (fast)
myCodeCell.Drive2.Run(true, 60, 400);    // Smooth wave (gentle flap)

Example – Proximity-Controlled Motors

This example links the onboard VCNL4040 proximity sensor with both drive outputs. As your hand moves closer, the output motors or LEDs, spin or brighten faster.

#include <CodeCell.h>

CodeCell myCodeCell;

#define PROXIMITY_RANGE 1000U
#define MOTOR_DEADZONE 30U
#define MOTOR_MAXSPEED 90U

void setup() {
  Serial.begin(115200);
  myCodeCell.Init(LIGHT);        // Enable proximity sensing

  myCodeCell.Drive1.Init();      // Initialize both drivers
  myCodeCell.Drive2.Init();

  myCodeCell.Drive1.Tone();      // Short feedback buzz
  myCodeCell.Drive2.Tone();
}

void loop() {
  if (myCodeCell.Run(10)) {      // Run at 10 Hz
    uint16_t proximity = myCodeCell.Light_ProximityRead();
    proximity = min(proximity, PROXIMITY_RANGE);

    uint8_t speed = map(proximity, 0, PROXIMITY_RANGE,
                        MOTOR_DEADZONE, MOTOR_MAXSPEED);

    myCodeCell.Drive1.Drive(true, speed);
    myCodeCell.Drive2.Drive(true, speed);

    Serial.printf("Proximity: %u | Speed: %u%%\n", proximity, speed);
  }
}

Customization Tips

• Change Direction: Use false in Drive() to reverse rotation.
• Tune Deadzone & Speed: Adjust MOTOR_DEADZONE and MOTOR_MAXSPEED for your motors.
• Alternate Effects: Replace Drive() with Pulse() or Run() for rhythmic motion for flapping actuators.
• Combine Sensors: Use motion, or gesture sensors to control drive behavior.

Follow these steps to get your CodeCell C3 or CodeCell C6 ready for programming in just a few minutes.

Step 1 – Install the Arduino IDE

Download and install the latest version from the official Arduino website.

Step 2 – Add ESP32 Board Support

1. Open File > Preferences.
2. In the Additional Board Manager URLs field, paste:
   

   https://dl.espressif.com/dl/package_esp32_index.json

3. Click OK and restart the IDE.
4. Go to Tools > Board > Boards Manager, search for ESP32, and click Install.

Step 3 – Install the CodeCell Library

1. Go to Sketch > Include Library > Manage Libraries.
2. Search for CodeCell and install the latest version.

Step 4 – Select Your Board

For CodeCell C3

• Go to Tools > Board → select ESP32C3 Dev Module.
• Set CPU Frequency → 160 MHz.
• Set Partition Scheme → Default 4MB with SPIFFS.
• Set Flash Size → 4MB 
• Enable USB_CDC_On_Boot under Tools.

For CodeCell C6

• Go to Tools > Board → select ESP32C6 Dev Module.
• Set CPU Frequency → 160 MHz.
• Set Partition Scheme → 8M with SPIFFS (3MB APP / 1.5MB SPIFFS).
• Set Flash Size → 8MB 
• Enable USB_CDC_On_Boot under Tools.

Step 5 – Select the Port & Upload

1. Go to Tools > Port and select the port that appears when you plug in CodeCell.
2. Open File > Examples > CodeCell > GettingStarted.
3. Click Upload and wait for “Done Uploading.”

Step 6 – Open the Serial Monitor

Go to Tools > Serial Monitor and set the baud rate to 115200 to see messages from your CodeCell.

Quick Tips

• Use a USB-C cable that supports data transfer, not just power charging
• Always keep the ESP32 core and CodeCell library updated 

Your CodeCell is now ready to program in Arduino. Try the examples, explore the library, and start building your own projects!

CodeCell C3 is a fully featured, sensor-packed board built around the ESP32-C3. Compact yet powerful, it combines wireless connectivity, battery charging, motion sensing and light sensing, in just 1.85 cm of width.

Key Features

• Microcontroller: ESP32-C3-MINI-1-N4
• Connectivity: Wi-Fi 4 + Bluetooth 5 (BLE)
• Flash / SRAM: 4 MB Flash / 400 KB SRAM
• Power: USB-C + LiPo charging (BQ24232)
• Sensors:
  • VCNL4040 – Light + Proximity Sensor
  • BNO085 – 9-Axis IMU (accelerometer, gyro, magnetometer)

Typical Use

Ideal for wearables, motion-tracking projects, and compact robots with wireless connectivity.

Highlights

• Tiny 1.85 cm form factor
• USB-C power + data with auto boot mode
• On-board charging + battery protection
• Full Arduino IDE and CodeCell Library support
• Connects with the MicroLink smartphone App

View schematics and 3D models: CodeCell Hardware Files

CodeCell C3 Light keeps the same compact design as the C3 but removes the IMU sensor for projects focused on basic light or proximity detection. It’s a simple, low-cost entry into the CodeCell ecosystem.

Key Features

• Microcontroller: ESP32-C3-MINI-1-N4
• Connectivity: Wi-Fi 4 + Bluetooth 5 (BLE)
• Flash: 4 MB SPI Flash
• Power: USB-C + LiPo charging (BQ24232)
• Sensor: VCNL4040 Light + Proximity

Typical Use

Best suited for tiny robots, IoT devices, ambient light loggers, touch-free switches, and other simple diy projects.

Highlights

• Light and proximity sensing on-board
• Same pin layout as CodeCell C3 for easy upgrade
• Compact 1.85 cm width and auto boot mode
• Arduino ready with CodeCell Library examples
• Connects with the MicroLink smartphone App

View schematics and 3D models: CodeCell Hardware Files

CodeCell C6 upgrades the CodeCell C3 with the new ESP32-C6 microcontroller — offering Wi-Fi 6, BLE 5, and Zigbee support in the same compact footprint. It’s built for advanced IoT and wearable applications that require low-power operation and extended wireless standards.

Key Features

• Microcontroller: ESP32-C6-MINI-1-H8
• Connectivity: Wi-Fi 6 + BLE 5 + Zigbee
• Flash: 8 MB SPI Flash
• Power: USB-C + LiPo charging (BQ24232)
• Sensors:
  • VCNL4040 – Light + Proximity
  • BNO085 – 9-Axis IMU Sensor

Typical Use

Ideal for wearables, tiny robots and connected IoT devices that need multi-protocol wireless connectivity.

Highlights

• ESP32-C6 with Wi-Fi 6 and Zigbee support
• 8 MB flash for larger firmware and OTA updates
• More efficient low-power modes 
• Fully compatible with CodeCell Library for Arduino
• Connects with the MicroLink smartphone App

View schematics and 3D models: CodeCell Hardware Files

CodeCell C6 Drive is the all-in-one controller built for robotics. It combines the wireless ESP32-C6 with dual H-bridge motor drivers and on-board sensors, everything you need to power small robots or smart motion systems.

Key Features

• Microcontroller: ESP32-C6-MINI-1-H8
• Connectivity: Wi-Fi 6 + BLE 5 + Zigbee
• Flash: 8 MB SPI Flash
• Motor Drivers: Dual H-Bridge Drivers for 2 DC-motors/Actuators
• Power: USB-C + LiPo charging (BQ24232)
• Sensors: VCNL4040 + BNO085 9-Axis IMU

Typical Use

Designed for mobile robots and sensor systems that require built-in motion control and wireless connectivity.

Highlights

• Built-in dual motor drivers, no external boards needed
• Tiny Form-factor 2.25x1.85cm (0.89 × 0.73 in)
• USB-C power and charging built-in
• Full support in CodeCell Arduino Library examples
• Connects with the MicroLink smartphone App

View schematics and 3D models: CodeCell Hardware Files

The MicroLink app simplifies wireless control for your CodeCell – whether you're building tiny robots, setting up DIY sensors, or experimenting with interactive projects. With buttons, sliders, a joystick, and real-time data streaming, you can control, monitor, and debug your projects directly from your phone – no wires, no hassle.

What is MicroLink?

MicroLink is a Bluetooth mobile app designed to interact with our devices – including the CodeCell. When paired with the MicroLink Arduino library, your CodeCell can:

• Read input from 4 buttons, 3 sliders, and a joystick
• Send live sensor data like battery level, proximity, and heading
• Print messages to the app for debugging or display
• React in real time to control input

This makes MicroLink ideal for remote control, live feedback, and building interactive electronics.

Installing the Library

Install the CodeCell MicroLink library from the Arduino Library Manager. It includes 6 example sketches covering basic sensor feedback, remote control, and motor interaction. 

How It Works

Here’s a quick overview of how your CodeCell communicates with the app:

Initialization

myMicroLink.Init();

This sets up buttons, sliders, joystick, and Bluetooth notifications for battery, proximity, heading, and messages.

Sending Sensor Data

myMicroLink.ShowSensors(battery, proximity, heading);

Only sends when values change, reducing BLE traffic.

Sending Messages

myMicroLink.Print("Hello from CodeCell");

Use this to send debug or status messages. Print() supports strings up to 20 characters. Combine text and variables like this:

sprintf(message, "%u RPM", MotorRPM);
myMicroLink.Print(message);

Reading Controls

Use these functions to read inputs from the app:

myMicroLink.ReadButtonA();   // true if pressed
myMicroLink.ReadButtonB();
myMicroLink.ReadButtonC();
myMicroLink.ReadButtonD();
myMicroLink.ReadSlider1();   // 0–100
myMicroLink.ReadSlider2();
myMicroLink.ReadSlider3();
myMicroLink.ReadJoystickX(); // joystick X axis
myMicroLink.ReadJoystickY(); // joystick Y axis

Once any of these are used in your code, they automatically appear in the MicroLink app.

Example 1 – Motor Control with Sliders

In this example, two DriveCell modules control motors. Two sliders in the app adjust motor speeds. A button flips polarity:

uint8_t slider1 = myMicroLink.ReadSlider1();
uint8_t slider2 = myMicroLink.ReadSlider2();
DriveCell1.Drive(polarity, slider1);
DriveCell2.Drive(polarity, slider2);

Flip polarity with a button press:

if (myMicroLink.ReadButtonA()) {
    polarity = !polarity;
    myMicroLink.Print("Reversing Polarity");
}

Try It Yourself

Once installed, open the Arduino IDE and go to:

File → Examples → CodeCell MicroLink

You’ll find 6 example sketches ready to explore and customize — no advanced setup needed. Start with the examples, explore the controls, and build something fun!

Download

The MicroLink Connect App is available on both on the Google Play Store and Apple iOS. It’s completely free and features a clean, ad-free interface.

If you require further assistance feel free to reach out - Happy Building!

CodeCell is designed to be simple to use, but like any microcontroller, issues can happen. This quick guide covers the most common problems you might face when using CodeCell C3 or CodeCell C6 - and how to fix them fast.

Before You Start

• Make sure your CodeCell Library is up to date in the Arduino IDE.
• Check that the ESP32 board package (by Espressif Systems) is updated.
• Always use a USB-C cable that supports data transfer, not just charging.

1. CodeCell Not Showing Up in Arduino IDE

• Unplug and reconnect CodeCell, wait a few seconds.
• Go to Tools > Port and check if a new port appears.
• If not, try another USB-C cable or USB port.
• Ensure USB_CDC_On_Boot is enabled in Tools.
• On Windows, open Device Manager → under “Ports (COM & LPT)” check if CodeCell is listed.

2. Code Upload Fails

• Check that you selected the correct board:
  • CodeCell C3 → ESP32C3 Dev Module
  • CodeCell C6 → ESP32C6 Dev Module
• Go to Tools > Port and pick the right COM port.
• Enable USB_CDC_On_Boot.
• If CodeCell is stuck or not responding:
  • Short SCL (GPIO9) to GND.
  • Unplug the battery and unplug the USB, wait a few seconds, and reconnect the USB.
  • Re-upload your sketch, then remove the short once done.

3. Serial Monitor Not Showing Data

• Ensure the Serial Monitor baud rate is set to 115200.
• Confirm USB_CDC_On_Boot is enabled.
• Close and reopen the Serial Monitor after uploading a sketch.
• Try unplugging and replugging the board.

4. LED Behavior Reference

• 🔵 Static Blue → Charging
• 🟢 Breathing Green → Running on battery
• 🔵 Breathing Blue → Fully charged
• 🔴 Flashing Red → Low battery (<3.3 V)

5. Battery or Power Issues

• If the LED doesn’t light up, check your USB cable or adapter.
• If using a battery, make sure it’s properly connected and charged.
• If still off, remove all power for 10 seconds, then reconnect.

6. Sensors Not Responding

• Make sure the correct sensor is initialized using:
  

  myCodeCell.Init(SENSOR_MACRO);

• Check the Serial Monitor for “sensor not found” messages.
• If using external sensors, avoid I²C addresses:
  • 0x60 → VCNL4040 (light sensor)
  • 0x4A → BNO085 (IMU)

7. Still Having Trouble?

• Restart the Arduino IDE and reconnect your CodeCell.
• Update the CodeCell Library to the latest version.

Final Tip

If the issue persists, check the CodeCell GitHub Issues page, you’ll often find quick solutions from other makers and our team.

Still stuck? Reach out - We’re always happy to help you get your CodeCell back up and running!

Bluetooth Low Energy (BLE) is a popular way to communicate wirelessly between electronic devices. It is an energy-efficient version of Bluetooth that allows devices to exchange small amounts of data with low power consumption. Here are it's key concepts:

• BLE Server → CodeCell acts as a server, advertising itself to other devices.
• BLE Client → A phone, tablet, or another microcontroller that connects to CodeCell.
• BLE Service → A collection of characteristics that define the data being sent.
• BLE Characteristic → A specific data point (e.g., button presses, sensor readings).

Viewing BLE Data on a Smartphone

Before we start testing, your need to download an app to send BLE data on your  smartphone. So start by downloading a BLE scanner app:

• Android → nRF Connect or "BLE Scanner"
• iOS → nRF Connect

Setting Up BLE on CodeCell

To make CodeCell advertise itself as a BLE device, we need to initialize BLE, create a service and characteristic, and start advertising.

This code creates a BLE server, advertises a service, and sets up a characteristic that can be read and written by a connected device. The CodeCell will receive the button characteristic and control its onboard RGB LED:

• If the button value is 1, the LED turns red.
• If the button value is 0, the LED turns green.

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <BLE2902.h>

#include <CodeCell.h>
CodeCell myCodeCell;

BLECharacteristic *pButtonCharacteristic = NULL;
#define BUTTON_UUID "abcd1234-abcd-1234-abcd-123456789012"

class MyServerCallbacks : public BLEServerCallbacks {
  void onConnect(BLEServer *pServer) override {
    Serial.println("BLE Connected");
    delay(1000);
  }

  void onDisconnect(BLEServer *pServer) override {
    Serial.println("BLE Disconnected");
    delay(500);
    BLEDevice::startAdvertising(); // Restart advertising
  }
};

// Callback class for handling button writes
class ButtonCallback : public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic *pCharacteristic) override {
   String value = pCharacteristic->getValue();
    
    if (value.length() > 0) {
      int buttonState = value[0]; 

      Serial.print("Button State: ");
      Serial.println(buttonState);

      if (buttonState == 1) {
        myCodeCell.LED(255, 0, 0); // Red LED when button is 1
      } else {
        myCodeCell.LED(0, 255, 0); // Green LED when button is not 1
      }
    }
  }
};

void setup() {
    Serial.begin(115200);
    myCodeCell.Init(LIGHT); // Initializes the light sensor

    BLEDevice::init("CodeCell_BLE"); // Set BLE device name
    BLEServer *bleServer = BLEDevice::createServer();
    bleServer->setCallbacks(new MyServerCallbacks());

    BLEService *bleService = bleServer->createService(BLEUUID("12345678-1234-5678-1234-56789abcdef0"));

    // Create BLE characteristic for button state
    pButtonCharacteristic = bleService->createCharacteristic(
        BUTTON_UUID,
        BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_WRITE
    );
    pButtonCharacteristic->addDescriptor(new BLE2902());
    pButtonCharacteristic->setCallbacks(new ButtonCallback());

    bleService->start();

    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
    pAdvertising->addServiceUUID("12345678-1234-5678-1234-56789abcdef0");
    BLEDevice::startAdvertising();
}

void loop() {
    // No need to continuously check, LED updates only on BLE write
}

How This Code Works

• BLE Initialization → CodeCell advertises itself as a BLE device called "CodeCell_BLE".
• BLE Service & Characteristic → A service with a button characteristic is created.
• BLE Callbacks → The server prints "BLE Connected" when a client connects and "BLE Disconnected" when it disconnects.
• Advertising Restart → When disconnected, BLE automatically starts advertising again so new devices can connect.

Testing the LED Control  

• Connect to "CodeCell_BLE" in the BLE Scanner app.
• Select the service you created - typically displayed as Unknown Service
• Find the button characteristic (BUTTON_UUID) and send the value:
  • Write 1 → LED turns red 🔴
  • Write 0 → LED turns green 🟢

Sending Sensor Data

Next we'll define a new BLE characteristic that allows CodeCell to send sensor values to a connected device.

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <BLE2902.h>

#include <CodeCell.h>
CodeCell myCodeCell;

BLECharacteristic *pSensorCharacteristic = NULL;
#define SENSOR_UUID "abcd5678-abcd-5678-abcd-56789abcdef0"

class MyServerCallbacks : public BLEServerCallbacks {
  void onConnect(BLEServer *pServer) override {
    Serial.println("BLE Connected");
    delay(1000);
  }

  void onDisconnect(BLEServer *pServer) override {
    Serial.println("BLE Disconnected");
    delay(500);
    BLEDevice::startAdvertising(); // Restart advertising
  }
};

void setup() {
    Serial.begin(115200);
    myCodeCell.Init(LIGHT); // Initialize light and proximity sensor

    BLEDevice::init("CodeCell_BLE"); // Name the BLE device
    BLEServer *bleServer = BLEDevice::createServer();
    bleServer->setCallbacks(new MyServerCallbacks());

    BLEService *bleService = bleServer->createService(BLEUUID("12345678-1234-5678-1234-56789abcdef0"));

    // Create BLE characteristic for sensor data
    pSensorCharacteristic = bleService->createCharacteristic(
        SENSOR_UUID,
        BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY
    );
    pSensorCharacteristic->addDescriptor(new BLE2902());

    bleService->start();

    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
    pAdvertising->addServiceUUID("12345678-1234-5678-1234-56789abcdef0");
    BLEDevice::startAdvertising();
}

void loop() {
    if (myCodeCell.Run(10)) { // Read every 100ms (10Hz)
        uint16_t proximity = myCodeCell.Light_ProximityRead();
        Serial.print("Proximity: ");
        Serial.println(proximity);

        // Convert proximity value to string and send over BLE
        String proximityStr = String(proximity);
        pSensorCharacteristic->setValue(proximityStr.c_str());
        pSensorCharacteristic->notify(); // Notify connected device
    }
}

How it works?

• This code sets up a new characteristic (SENSOR_UUID) that clients can read and get real-time updates:
  • PROPERTY_READ → Allows the client to read the value manually.
  • PROPERTY_NOTIFY → Automatically sends updates when new data is available.
• The Light_ProximityRead() function gets a value from the onboard light sensor that detects nearby objects. We convert the number to a string and send it to the BLE client.

Try it out

Now that CodeCell is sending proximity sensor data over BLE, you can view it on a phone.

• Open a BLE app like nRF Connect (Android/iOS)
• Scan for "CodeCell_BLE" and connect
• Find the sensor characteristic (SENSOR_UUID)
• Enable notifications and watch the proximity data update in real-time!
• Your Serial Monitor data should match the data sent to your phone

Move an object near the sensor and see how values change!

The CodeCell module, powered by the ESP32, has built-in Wi-Fi capabilities that allow it to connect to the internet, communicate with other devices, or even host a small web server. This means you can:

• Control your CodeCell remotely from a smartphone or computer
• Send and receive data over the internet
• Host a small web page that other devices can access

Now, let's go step by step to connect CodeCell to Wi-Fi.

Connecting CodeCell to a Wi-Fi Network

To connect your CodeCell to a Wi-Fi network, you need to provide the network name (SSID) and password. Let's use the Arduino IDE to write a simple program that connects CodeCell to Wi-Fi.

#include <WiFi.h>
#include <CodeCell.h>

CodeCell myCodeCell;
const char* ssid = "your_SSID"; // Replace with your Wi-Fi name
const char* password = "your_PASSWORD"; // Replace with your Wi-Fi password

void setup() {
    Serial.begin(115200); // Start the Serial Monitor
    myCodeCell.Init(LIGHT); // Set up CodeCell's light sensor
    WiFi.begin(ssid, password); // Connect to Wi-Fi

    Serial.print("Connecting to Wi-Fi");
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print("."); // Print dots while connecting
    }
    
    Serial.println("\nConnected!");
    Serial.print("IP Address: ");
    Serial.println(WiFi.localIP()); // Print the assigned IP address
}

void loop() {
    // Run every 10Hz
    if (myCodeCell.Run(10)) {
        // Your main loop code here
    }
}

How It Works:

• This code starts the Serial Monitor to track the Wi-Fi connection progress.
• It connects to Wi-Fi using WiFi.begin(ssid, password);.
• Once connected, it prints the assigned IP address.

Troubleshooting:

• If it doesn’t connect, double-check your SSID and password.
• Make sure your router is on and not blocking unknown devices.

Hosting a Simple Web Page on CodeCell

Once CodeCell is connected to Wi-Fi, we can make it act like a tiny web server! This means we can control it or display information using a web page.

#include <WiFi.h>
#include <WebServer.h>
#include <CodeCell.h>

CodeCell myCodeCell;
const char* ssid = "your_SSID";
const char* password = "your_PASSWORD";

WebServer server(80);

void handleRoot() {
    int proximityValue = myCodeCell.Light_ProximityRead(); // Read proximity sensor
    String response = "

Welcome to CodeCell Wi-Fi Server!

";
    response += "

Proximity Value: " + String(proximityValue) + "

";
    server.send(200, "text/html", response);  
}

void setup() {
    Serial.begin(115200);
    myCodeCell.Init(LIGHT); // Set up CodeCell's light sensor
    WiFi.begin(ssid, password);
    
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("\nConnected to Wi-Fi");
    Serial.print("IP Address: ");
    Serial.println(WiFi.localIP());
    
    server.on("/", handleRoot);
    server.begin();
    Serial.println("HTTP server started");
}

void loop() {
  if(myCodeCell.Run(10)){
    server.handleClient();
  }
}

How It Works:

• This code sets up a simple web server that displays a message.
• When you type the IP address (printed in Serial Monitor) into a browser, it will show a webpage saying "Welcome to CodeCell Wi-Fi Server!" and shows the current proximity value read by the CodeCell.

Try It Out!

1. Upload the code to CodeCell.
2. Open the Serial Monitor to find the IP Address.
3. Type the IP address into a browser – you should see the message!
4. Refresh the page to see the proximity value update

Sending Data to a Server (Basic IoT Example)

CodeCell can also send data to a web server, such as a cloud service that collects sensor readings.

#include <WiFi.h>
#include <HTTPClient.h>
#include <CodeCell.h>

CodeCell myCodeCell;
const char* ssid = "your_SSID";
const char* password = "your_PASSWORD";
const char* serverName = "http://example.com/data"; // Replace with your server URL

void setup() {
    Serial.begin(115200);
    myCodeCell.Init(LIGHT); // Set up CodeCell's light sensor
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("Connected to Wi-Fi");
}

void loop() {
    if (myCodeCell.Run(10)) { // Run every 10hz
        HTTPClient http;
        http.begin(serverName);
        int httpResponseCode = http.GET();
        Serial.print("HTTP Response code: ");
        Serial.println(httpResponseCode);
        http.end();
    }
}

How It Works:

• The CodeCell connects to Wi-Fi and sends a request to http://example.com/data.
• The response is printed in the Serial Monitor.
• You can use this method to send sensor data to a web service!

Conclusion

Wi-Fi makes CodeCell powerful for IoT projects! Start experimenting, and soon you’ll be building amazing projects!