CodeCell

CodeCell C6 is powered by the ESP32-C6, supporting Zigbee, Thread, Wi-Fi 6, and Bluetooth LE. In this guide we’ll focus on Zigbee and how you can use it with CodeCell C6 in the Arduino IDE.

What Is Zigbee?

Zigbee is a wireless communication protocol built for low power and reliability. Unlike Wi-Fi, Zigbee is not meant for large data transfers. Instead, it focuses on small messages between devices such as sensors, lights, switches, and smart plugs.

Key characteristics of Zigbee:

• Low power: Great for battery-powered devices.
• Mesh network: Each device can relay messages, extending range across a home or building.
• Reliable: Works well even in environments with lots of Wi-Fi traffic.
• Smart-home friendly: Used in systems like Philips Hue, Aqara, IKEA TRÅDFRI and many hubs that support Zigbee or Matter bridges.

Zigbee vs Wi-Fi vs Bluetooth LE

• Wi-Fi: High speed, high power. Best for internet access, web servers, and cloud-connected devices.
• Bluetooth LE: Short-range, low power. Best for phone peripherals and direct connections.
• Zigbee: Best for sensors, automation, and smart-home devices. Because Zigbee forms a mesh, you can place small devices around a room or house, and they help extend each other’s range.

If You’re New to Zigbee + Home Assistant

If you’re just starting with Zigbee, one of the easiest ways to experiment is with Home Assistant:

• Grab a Zigbee USB coordinator like the SONOFF Zigbee USB Dongle (or similar).
• Plug it into a Raspberry Pi running Home Assistant.
• In Home Assistant, add the Zigbee integration (e.g. ZHA) and pair your CodeCell C6 as a new device.

This setup makes the USB dongle your Zigbee coordinator, and your CodeCell boards become nodes on that network. 

Arduino IDE Setup for Zigbee on CodeCell C6

Before uploading the example, make sure the Arduino Tools menu is configured for Zigbee on the ESP32-C6. In the Arduino IDE, go to Tools and check:

• Board: ESP32C6 Dev Module
• Flash Size: 8MB (64Mb)
  This matches the C6 module’s flash size so the Zigbee stack and your sketch fit correctly.
• Partition Scheme: Zigbee 8MB with spiffs
  This layout reserves space for the Zigbee stack and NVS while still leaving room for SPIFFS and your application.
• Zigbee Mode: Zigbee ED (end device)
  This makes the CodeCell behave as a Zigbee end device (sensor, switch, etc.) that joins a coordinator like your Home Assistant dongle.

Once these are set, you can compile and flash the sketch below directly to your CodeCell C6 or C6 Drive.

Example 1 – Zigbee On/Off Light (CodeCell as a Simple Light)

In this example, the CodeCell controls a real lamp using Home Assistant automations:

• Shake the CodeCell to toggle the lamp ON/OFF
• Hold your finger near the proximity sensor to enable “brightness mode”
• Tilt up/down to increase/decrease brightness (while proximity is active)

The CodeCell exposes two Zigbee endpoints:

• Endpoint 1 (ZigbeeAnalog): a brightness value (0–254) derived from Pitch angle (only when proximity is active)
• Endpoint 4 (ZigbeeBinary): a binary toggle that flips state on each shake

Important: Home Assistant will receive these as entities, but you still need to create automations that map them to your actual lamp. In our setup we created 3 automations:

• If shake detected → toggle lamp ON/OFF
• If tilt up → increase brightness
• If tilt down → decrease brightness

/*
  Example: CodeCell Zigbee Lamp Control - Tilt-Brightness + Shake Switch
  Boards: CodeCell C6 / CodeCell C6 Drive

  Overview:
  - Endpoint 1 (ZigbeeAnalog): When proximity sensor is pressed, the CodeCell's Pitch angle is mapped to brightness
      Use this value in Home Assistant to set a lamp's brightness.
  - Endpoint 2 (ZigbeeBinary): toggled by a shake gesture, toggles the binary state ON/OFF
      Use this in Home Assistant to turn the lamp on/off.

  Behavior:
  - Press proximity sensor with fingure → proximity detected → "brightness control" is active.
  - Tilt the CodeCell to change Pitch → this updates the brightness value.
  - Remove your fingure → brightness control stops (lamp can stay at last value).
  - Shake the CodeCell → endpoint toggles (can be mapped to toggle lamp automations)

  Required Arduino Tools Settings:
  - Board: ESP32C6 Dev Module
  - Flash Size: 8MB (64Mb)
  - Partition Scheme: Zigbee 8MB with spiffs
  - Zigbee Mode: Zigbee ED (end device)
*/

#ifndef ZIGBEE_MODE_ED
#error "Zigbee end device mode is not selected in Tools->Zigbee mode"
#endif

#include <CodeCell.h>
#include "Zigbee.h"
#include <math.h> 

// Zigbee endpoints
#define ZIGBEE_BRIGHTNESS_ENDPOINT  1   // Numeric brightness value (0–254)
#define ZIGBEE_SHAKE_ENDPOINT       4   // Binary toggle (shake switch)

// Proximity threshold for "brightness control active"
#define PROX_ACTIVE_THRESHOLD       200U   // Adjust to taste

// Pitch → brightness mapping
#define PITCH_MIN_DEG              -45.0f  // Fully down
#define PITCH_MAX_DEG               45.0f  // Fully up

// Shake detection
const float SHAKE_THRESHOLD           = 15.0f;   // Adjust for sensitivity
const unsigned long SHAKE_DEBOUNCE_MS = 800UL;   // Minimum time between shakes

CodeCell myCodeCell;

// Zigbee endpoints
ZigbeeAnalog zbBrightness(ZIGBEE_BRIGHTNESS_ENDPOINT);
ZigbeeBinary zbShake(ZIGBEE_SHAKE_ENDPOINT);

// Motion variables
float Roll  = 0.0f;
float Pitch = 0.0f;
float Yaw   = 0.0f;

float ax = 0.0f, ay = 0.0f, az = 0.0f;

uint8_t lastBrightness           = 0;
unsigned long lastBrightReportMs = 0;
const uint8_t BRIGHT_DELTA_MIN   = 3;      // Minimum change to report
const unsigned long BRIGHT_REPORT_INTERVAL_MS = 300UL;

bool shakeState          = false;      // Toggles ON/OFF on each shake
unsigned long lastShakeMs = 0;

void handleBrightness(uint16_t proximity);
void handleShake();

void setup() {
  Serial.begin(115200);

  // Enable Light + Rotation (pitch) + Accelerometer
  myCodeCell.Init(LIGHT + MOTION_ROTATION + MOTION_ACCELEROMETER);

  myCodeCell.LED(0, 0, 0);//Turn off on-board LED

  // Brightness endpoint (analog-like input) 
  zbBrightness.setManufacturerAndModel("Microbots", "CodeCellC6-PitchBrightness");
  zbBrightness.addAnalogInput();

  // Use Espressif's "percentage" application type so ZHA treats it as a generic level
  zbBrightness.setAnalogInputApplication(ESP_ZB_ZCL_AI_PERCENTAGE_OTHER);
  zbBrightness.setAnalogInputDescription("Brightness level (0–254) from Pitch angle");
  zbBrightness.setAnalogInputResolution(1.0f);
  zbBrightness.setAnalogInputMinMax(0.0f, 254.0f);

  // Shake endpoint 
  zbShake.setManufacturerAndModel("Microbots", "CodeCellC6-ShakeSwitch");
  zbShake.addBinaryInput();
  zbShake.setBinaryInputApplication(BINARY_INPUT_APPLICATION_TYPE_SECURITY_MOTION_DETECTION);
  zbShake.setBinaryInputDescription("Shake to toggle");

  // Register endpoints with Zigbee core 
  Serial.println("Adding Zigbee endpoints (brightness + shake)");
  Zigbee.addEndpoint(&zbBrightness);
  Zigbee.addEndpoint(&zbShake);

  // Start Zigbee
  Serial.println("Starting Zigbee...");
  if (!Zigbee.begin()) {
    Serial.println("Zigbee failed to start, rebooting...");
    ESP.restart();//If not connected - reset esp32
  }

  Serial.println("Connecting to Zigbee network...");
  while (!Zigbee.connected()) {
    Serial.print(".");
    delay(100);
  }
  Serial.println("\nZigbee connected!");
}

void loop() {
  if (myCodeCell.Run(10)) { // Run sensors at 10 Hz
    
    uint16_t proximity = myCodeCell.Light_ProximityRead(); // Read proximity first (to know if brightness control is active)

    // Read rotation (roll, pitch, yaw)
    myCodeCell.Motion_RotationRead(Roll, Pitch, Yaw);

    // Handle brightness control using Pitch when proximity is active
    handleBrightness(proximity);

    // Handle shake-based toggle
    handleShake();
  }
}

/**
 * Handle brightness control:
 * - If proximity is above threshold, use Pitch to map to brightness 0–254.
 * - Sends brightness to Zigbee as analog input.
 * - LED shows brightness using green channel.
 */
void handleBrightness(uint16_t proximity) {
  unsigned long now = millis();

  if (proximity < PROX_ACTIVE_THRESHOLD) {
    // No hand close → brightness control not active
    myCodeCell.LED(0, 0, 0);  // LED off
    return;
  }

  // Clamp pitch and map to 0–254
  float pitchClamped = Pitch;
  if (pitchClamped < PITCH_MIN_DEG) {
    pitchClamped = PITCH_MIN_DEG;
  }
  else if (pitchClamped > PITCH_MAX_DEG) {
    pitchClamped = PITCH_MAX_DEG;
  }
  else{
    //skip
  }

  // Normalize Angle
  float normalized = (pitchClamped - PITCH_MIN_DEG) / (PITCH_MAX_DEG - PITCH_MIN_DEG);
  if (normalized < 0.0f) {
    normalized = 0.0f;
  } else if (normalized > 1.0f) {
    normalized = 1.0f;
  }
  else{
    //skip
  }

  uint8_t brightness = (uint8_t)(normalized * 254.0f);

  // Only report if changed enough or enough time passed
  if ( (abs((int32_t)brightness - (int32_t)lastBrightness) >= (int32_t)BRIGHT_DELTA_MIN) ||
       (now - lastBrightReportMs >= BRIGHT_REPORT_INTERVAL_MS) ) {

    lastBrightReportMs = now;
    lastBrightness = brightness;

    zbBrightness.setAnalogInput((float)brightness);
    zbBrightness.reportAnalogInput();

    Serial.print("Pitch: ");
    Serial.print(Pitch);
    Serial.print(" deg -> Brightness: ");
    Serial.println(brightness);
  }

  // Visual feedback: LED green = brightness level
  myCodeCell.LED(0, brightness, 0);
}

/**
 * Handle shake detection:
 * - Read accelerometer.
 * - If total acceleration crosses threshold (and debounce passes),
 *   toggle a Zigbee binary endpoint.
 */
void handleShake() {
  unsigned long now = millis();

  myCodeCell.Motion_AccelerometerRead(ax, ay, az);
  float totalAcceleration = sqrt(ax * ax + ay * ay + az * az);

  if (totalAcceleration > SHAKE_THRESHOLD && (now - lastShakeMs) > SHAKE_DEBOUNCE_MS) {
    lastShakeMs = now;

    // Toggle internal state
    shakeState = !shakeState;

    Serial.print("Shake detected! New switch state: ");
    Serial.println(shakeState ? "ON" : "OFF");

    // Update and report binary input (shake switch) to Zigbee
    zbShake.setBinaryInput(shakeState);
    zbShake.reportBinaryInput();
  }
}

How It Works

• Brightness control: When your finger is close to the proximity sensor (value above PROX_ACTIVE_THRESHOLD), the CodeCell maps Pitch to a brightness value (0–254) and reports it via ZigbeeAnalog.
• Shake toggle: A shake gesture toggles a boolean state and reports it via ZigbeeBinary. Home Assistant can use that change as a trigger.
• Home Assistant automations: Use the CodeCell entities as triggers/inputs, then control any lamp entity you want (smart bulb, smart plug, etc.).

Other Basic Zigbee Examples You Can Try

• Zigbee Light Switch
• Zigbee Color Light (Control Color & Brightness)
• Zigbee Proximity Presence Sensor
• Zigbee Motion Sensor (BNO085 Motion State)

Try modifying thresholds, report intervals, or combining multiple endpoints in one sketch, and you’ll quickly have your own custom Zigbee devices running on CodeCell C6.

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/C6-Drive

• 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.

Note: For CodeCell C6 Drive make sure to also install the 'DriveCell' library

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

Die MicroLink-App vereinfacht die drahtlose Steuerung Ihrer CodeCell – egal, ob Sie kleine Roboter bauen, DIY-Sensoren einrichten oder mit interaktiven Projekten experimentieren. Mit Tasten, Schiebereglern, Joystick und Echtzeit-Datenstreaming können Sie Ihre Projekte direkt von Ihrem Smartphone aus steuern, überwachen und debuggen – ganz ohne Kabel und Aufwand.

Was ist MicroLink?

MicroLink ist eine mobile Bluetooth-App für die Interaktion mit unseren Geräten – einschließlich der CodeCell . In Verbindung mit der MicroLink Arduino-Bibliothek kann Ihre CodeCell:

• Lesen Sie die Eingabe von 4 Tasten, 3 Schiebereglern und einem Joystick
• Senden Sie Live-Sensordaten wie Batteriestand, Nähe und Richtung
• Drucken Sie Nachrichten zur Fehlerbehebung oder Anzeige an die App
• Reagieren Sie in Echtzeit auf Steuereingaben

Dadurch eignet sich MicroLink ideal für die Fernsteuerung, Live-Feedback und den Aufbau interaktiver Elektronik.

Installieren der Bibliothek

Installieren Sie die CodeCell MicroLink- Bibliothek aus dem Arduino Library Manager. Sie enthält sechs Beispielskizzen zu grundlegendem Sensorfeedback, Fernsteuerung und Motorinteraktion.

Wie es funktioniert

Hier ist ein kurzer Überblick darüber, wie Ihre CodeCell mit der App kommuniziert:

Initialisierung

myMicroLink.Init();

Dadurch werden Schaltflächen, Schieberegler, Joystick und Bluetooth-Benachrichtigungen für Akku, Nähe, Richtung und Nachrichten eingerichtet.

Senden von Sensordaten

 myMicroLink.ShowSensors(battery, proximity, heading);

Sendet nur, wenn sich Werte ändern, wodurch der BLE-Verkehr reduziert wird.

Senden von Nachrichten

 myMicroLink.Print("Hello from CodeCell");

Verwenden Sie diese Funktion, um Debug- oder Statusmeldungen zu senden. Print() unterstützt Zeichenfolgen mit bis zu 20 Zeichen. Kombinieren Sie Text und Variablen wie folgt:

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

Lesesteuerung

Verwenden Sie diese Funktionen, um Eingaben aus der App zu lesen:

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

Sobald eines davon in Ihrem Code verwendet wird, wird es automatisch in der MicroLink-App angezeigt.

Beispiel 1 – Motorsteuerung mit Schiebereglern

In diesem Beispiel steuern zwei DriveCell -Module Motoren. Zwei Schieberegler in der App regeln die Motordrehzahl. Ein Knopf dient zum Umschalten der Polarität:

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

Polarität per Knopfdruck umkehren:

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

Probieren Sie es selbst aus

Öffnen Sie nach der Installation die Arduino IDE und gehen Sie zu:

Datei → Beispiele → CodeCell MicroLink

Sie finden sechs Beispielskizzen, die Sie erkunden und anpassen können – keine erweiterte Einrichtung erforderlich. Beginnen Sie mit den Beispielen, erkunden Sie die Bedienelemente und erstellen Sie etwas Lustiges!

Herunterladen

Die MicroLink Connect App ist sowohl im Google Play Store als auch für Apple iOS erhältlich. Sie ist völlig kostenlos und verfügt über eine übersichtliche, werbefreie Oberfläche.

Wenn Sie weitere Hilfe benötigen, können Sie sich jederzeit an uns wenden – viel Spaß beim Bauen!

CodeCell ist einfach einzurichten und zu verwenden, aber wie bei jedem Mikrocontroller können Probleme auftreten. Diese Anleitung hilft Ihnen bei der effektiven Fehlerbehebung und Fehlerbehebung bei CodeCell.

Stellen Sie sicher, dass Sie über die neuesten Bibliotheksversionen verfügen

Stellen Sie vor der Fehlerbehebung sicher, dass Sie die neuesten Versionen von:

• CodeCell-Bibliothek → Aktualisieren Sie immer auf die neueste Version, um Fehlerbehebungen und Verbesserungen zu erhalten.
• ESP32C3-Board-Supportpaket → Stellen Sie sicher, dass Sie die neuesten ESP32-C3-Board-Definitionen in der Arduino IDE installiert haben.

So aktualisieren Sie:

1. Öffnen Sie die Arduino IDE und navigieren Sie zu Sketch > Include Library > Manage Libraries .
2. Suchen Sie nach CodeCell und installieren Sie die neueste Version.
3. Navigieren Sie zu Tools > Board > Board Manager , suchen Sie nach ESP32 und aktualisieren Sie auf die neueste Version.

Einrichten und Verwenden von CodeCell

Um die Programmierung zu vereinfachen, bietet die CodeCell-Bibliothek verschiedene Funktionen zum Initialisieren, Lesen und Verwalten von Sensoren und Stromversorgung. Hier finden Sie alles, was Sie zur Einrichtung Ihres Geräts und seiner Bibliothek wissen müssen.

Auspacken Ihrer CodeCell

In der Box finden Sie:

• CodeCell : Eine winzige, aber leistungsstarke Platine auf ESP32-C3-Basis mit programmierbaren GPIOs und Sensoren.
• Schrauben : Vier M1,2 x 6 mm Schrauben zur Befestigung.
• Header : Drei Sätze Buchsenleisten (gelötet oder ungelötet, je nach Ihrer Auswahl).
• Akku/Kabel : Falls gekauft, ein 170mAh 20C LiPo-Akku mit vorgelötetem Kabel oder einem Akkuanschlusskabel.

CodeCell zum ersten Mal einschalten

Schließen Sie ein USB-C-Kabel an, und CodeCell führt Folgendes aus:

• Initialisieren Sie die internen Peripheriegeräte und Sensoren. Der Status wird auf dem seriellen Monitor angezeigt und informiert Sie über erkannte Probleme.
• Überprüfen Sie den Stromstatus :
  • Wenn keine Batterie angeschlossen ist, erfolgt eine atmende LED-Animation .
  • Bei Stromversorgung über USB blinkt die LED blau .
  • Im Batteriebetrieb blinkt die LED grün .
  • Während des Ladevorgangs bleibt die LED statisch blau, bis der Akku vollständig aufgeladen ist.

Häufige Probleme mit der Stromversorgung und deren Behebung:

• Seriennummer funktioniert nicht?
  • Überprüfen Sie, ob Ihr USB-C-Kabel sowohl Strom als auch Daten unterstützt.
  • Stellen Sie sicher, dass Tools/USB_CDC_On_Boot aktiviert ist
  • Versuchen Sie es mit einem anderen USB-Anschluss oder Netzteil.
• Batterie nicht erkannt?
  • Stellen Sie sicher, dass die Batterie richtig angeschlossen und geladen ist.

Verbinden von CodeCell mit der Arduino IDE

Schritt 1: Arduino IDE installieren

Laden Sie die neueste Version von der offiziellen Arduino-Website herunter.

Schritt 2: ESP32-Board-Unterstützung hinzufügen

1. Öffnen Sie die Arduino IDE und gehen Sie zu Datei > Einstellungen .
2. Geben Sie im Feld „Zusätzliche Board Manager-URLs“ Folgendes ein:

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

3. Klicken Sie auf „OK“ und starten Sie Arduino IDE neu.

Schritt 3: Wählen Sie die richtige Karte und den richtigen Port

1. Navigieren Sie zu Tools > Board > ESP32C3 Dev Module .
2. Wählen Sie unter Tools > Port den richtigen COM-Port aus.
3. Aktivieren Sie USB_CDC_On_Boot unter Tools > USB_CDC_On_Boot .
4. Stellen Sie die CPU-Taktfrequenz auf 160 MHz ein.

Schritt 4: Installieren Sie die CodeCell-Bibliothek

1. Navigieren Sie zu Skizze > Bibliothek einschließen > Bibliotheken verwalten .
2. Suchen Sie nach CodeCell und installieren Sie die neueste Version.
3. Öffnen Sie Datei > Beispiele > CodeCell und probieren Sie das Beispiel „GettingStarted“ aus.

Schritt 5: Laden Sie Ihre erste Skizze hoch und führen Sie sie aus

1. Klicken Sie auf die Schaltfläche „Hochladen“ .
2. Öffnen Sie Tools > Serial Monitor, um die Ausgabe Ihrer CodeCell anzuzeigen.

CodeCell-Bibliothek und -Funktionen

CodeCell initialisieren

Der erste Schritt besteht darin, die CodeCell mit folgendem Befehl zu initialisieren:

 myCodeCell.Init(SENSOR_MACRO);

Verfügbare Makros:

• LICHT → Aktiviert die Lichterkennung.
• MOTION_ACCELEROMETER → Aktiviert die Beschleunigungssensorik.
• MOTION_GYRO → Aktiviert die Gyroskoperkennung.
• MOTION_MAGNETOMETER → Aktiviert die Magnetometererkennung.
• MOTION_STEP_COUNTER → Aktiviert die Schrittzählung.
• MOTION_ACTIVITY → Erkennt Gehen, Laufen oder Fahren.

Sie können mehrere Makros mit dem Operator + kombinieren:

 myCodeCell.Init(LIGHT + MOTION_ACCELEROMETER + MOTION_GYRO);

Detaillierteres Debuggen

• CodeCell wird in der Arduino IDE nicht erkannt
  • Stellen Sie sicher, dass das USB-C-Kabel nicht nur die Stromversorgung, sondern auch die Datenübertragung unterstützt .
  • Starten Sie Arduino IDE neu und versuchen Sie, den richtigen COM-Port auszuwählen .
  • Überprüfen Sie im Geräte-Manager (Windows) bzw. Systembericht (Mac), ob CodeCell als USB-Gerät angezeigt wird .
• 
  Code-Upload schlägt fehl
  • Stellen Sie sicher, dass USB_CDC_On_Boot aktiviert ist.
  • Wenn CodeCell in einer Reset-Schleife feststeckt:
    • SCL (GPIO9) mit GND kurzschließen.
    • Ziehen Sie den USB-Stecker ab und schalten Sie die Batterie aus.
    • Schließen Sie das USB-Gerät wieder an und laden Sie die Skizze erneut hoch.
    • Entfernen Sie den Kurzschluss, sobald Sie neu programmiert haben.
• Serieller Monitor zeigt keine Daten an
  • Stellen Sie sicher, dass die Baudrate auf 115200 eingestellt ist .
  • Gehen Sie zu Tools > USB_CDC_On_Boot und aktivieren Sie es.
  • Stellen Sie sicher, dass das USB-C-Kabel nicht nur die Stromversorgung, sondern auch die Datenübertragung unterstützt .
  • Versuchen Sie, den seriellen Monitor neu zu starten.
• Unerwartetes LED-Verhalten
  • 🔴 Rot blinkend → Schwacher Batteriestand (<3,3 V), Wechsel in den Ruhemodus.
  • 🔵 Statisch Blau → Batterie wird geladen.
  • 🟢 Grünes Licht → Batteriebetrieben.
  • 🔵 Blau atmen → Vollständig aufgeladen.
• Sensoren reagieren nicht
  • Stellen Sie sicher, dass Sie den richtigen Sensor mit myCodeCell.Init(SENSOR_MACRO);
  • Überprüfen Sie den seriellen Monitor. Dies sollte Ihnen helfen, herauszufinden, warum der Sensor nicht reagiert
  • Vermeiden Sie bei der Verwendung externer Sensoren die Verwendung der I2C-Adressen 0x60 (VCNL4040) und 0x4A (BNO085), da es zu Konflikten kommen kann.

Abschließende Gedanken

Wir hoffen, dies hat Ihnen geholfen, die Ursache zu identifizieren. Sollte das Problem weiterhin bestehen, zögern Sie nicht, uns zu kontaktieren – wir helfen Ihnen gerne weiter!

Bluetooth Low Energy (BLE) ist eine leistungsstarke Möglichkeit zur drahtlosen Kommunikation zwischen Ihrer CodeCell und anderen Geräten wie Smartphones, Tablets und sogar anderen Mikrocontrollern. In dieser Anleitung richten wir BLE auf CodeCell ein, ermöglichen den Empfang von Befehlen von einem BLE-Client und steuern die RGB-LED basierend auf den empfangenen Daten.

Was ist BLE?

BLE ist eine energieeffiziente Version von Bluetooth, die es Geräten ermöglicht, kleine Datenmengen bei geringem Stromverbrauch auszutauschen. Hier sind die wichtigsten Konzepte:

• BLE-Server → CodeCell fungiert als Server und macht sich bei anderen Geräten bekannt.
• BLE-Client → Ein Telefon, Tablet oder ein anderer Mikrocontroller, der eine Verbindung zu CodeCell herstellt.
• BLE-Dienst → Eine Sammlung von Merkmalen , die die gesendeten Daten definieren.
• BLE-Eigenschaft → Ein bestimmter Datenpunkt (z. B. Tastendrücke, Sensorwerte).

Anzeigen von BLE-Daten auf einem Smartphone

Bevor wir mit dem Testen beginnen, müssen Sie eine App herunterladen, um BLE-Daten auf Ihr Smartphone zu senden. Beginnen Sie mit dem Herunterladen eine BLE-Scanner-App:

• Android → nRF Connect oder „BLE Scanner“
• iOS → nRF Connect

Einrichten von BLE auf CodeCell

Damit CodeCell sich selbst als BLE-Gerät ankündigt , müssen wir BLE initialisieren, einen Dienst und eine Eigenschaft erstellen und mit der Werbung beginnen .

Dieser Code erstellt einen BLE-Server , kündigt einen Dienst an und richtet eine Eigenschaft ein , die von einem angeschlossenen Gerät gelesen und geschrieben werden kann. Die CodeCell empfängt die Tasteneigenschaft und steuert ihre integrierte RGB-LED:

• Wenn der Tastenwert 1 ist , leuchtet die LED rot .
• Wenn der Tastenwert 0 ist , leuchtet die LED grün .

 #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);

 wenn (ButtonState == 1) {
 myCodeCell.LED(255, 0, 0); // Rote LED, wenn die Taste 1 ist
 } anders {
 myCodeCell.LED(0, 255, 0); // Grüne LED, wenn die Schaltfläche nicht 1 ist
 }
 }
 }
 };

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(LIGHT); // Initialisiert den Lichtsensor

 BLEDevice::init("CodeCell_BLE"); // BLE-Gerätenamen festlegen
 BLEServer *bleServer = BLEDevice::createServer();
 bleServer->setCallbacks(neu MyServerCallbacks());

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

 // BLE-Merkmal für den Schaltflächenzustand erstellen
 pButtonCharacteristic = bleService->createCharacteristic(
 BUTTON_UUID,
 BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_WRITE
 );
 pButtonCharacteristic->addDescriptor(neues BLE2902());
 pButtonCharacteristic->setCallbacks(neuer ButtonCallback());

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

 void-Schleife() {
 // Keine ständige Überprüfung erforderlich, LED-Updates nur beim BLE-Schreiben
 }

Wie dieser Code funktioniert

• BLE-Initialisierung → CodeCell bewirbt sich selbst als BLE-Gerät mit dem Namen "CodeCell_BLE" .
• BLE-Dienst und -Eigenschaft → Es wird ein Dienst mit einer Schaltflächeneigenschaft erstellt.
• BLE-Rückrufe → Der Server druckt „BLE Connected“ , wenn ein Client eine Verbindung herstellt, und „BLE Disconnected“, wenn die Verbindung getrennt wird.
• Neustart der Werbung → Wenn die Verbindung getrennt wird, startet BLE automatisch erneut mit der Werbung, damit neue Geräte eine Verbindung herstellen können.

Testen der LED-Steuerung

• Stellen Sie in der BLE Scanner-App eine Verbindung zu "CodeCell_BLE" her.
• Wählen Sie den von Ihnen erstellten Dienst aus (normalerweise wird er als „Unbekannter Dienst“ angezeigt).
• Suchen Sie die Schaltflächeneigenschaft ( BUTTON_UUID ) und senden Sie den Wert:
  • Schreibe 1 → LED leuchtet rot 🔴
  • Schreibe 0 → LED leuchtet grün 🟢

Senden von Sensordaten

Als Nächstes definieren wir eine neue BLE-Eigenschaft , die es CodeCell ermöglicht, Sensorwerte an ein verbundenes Gerät zu senden .

 #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 getrennt");
 Verzögerung (500);
 BLEDevice::startAdvertising(); // Werbung neu starten
 }
 };

 void setup() {
 Serial.begin(115200);
 myCodeCell.Init(LIGHT); // Licht- und Näherungssensor initialisieren

 BLEDevice::init("CodeCell_BLE"); // Benennen Sie das BLE-Gerät
 BLEServer *bleServer = BLEDevice::createServer();
 bleServer->setCallbacks(neu MyServerCallbacks());

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

 // BLE-Kennlinie für Sensordaten erstellen
 pSensorCharacteristic = bleService->createCharacteristic(
 SENSOR_UUID,
 BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY
 );
 pSensorCharacteristic->addDescriptor(neues BLE2902());

 bleService->start();

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

 void-Schleife() { 
if (myCodeCell.Run(10)) { // Alle 100 ms (10 Hz) lesen
 uint16_t Nähe = myCodeCell.Light_ProximityRead();
 Serial.print("Nähe: ");
 Serial.println(Nähe);

 // Näherungswert in Zeichenfolge umwandeln und über BLE senden
 String proximityStr = String(Nähe);
 pSensorCharacteristic->setValue(proximityStr.c_str());
 pSensorCharacteristic->notify(); // Verbundenes Gerät benachrichtigen
 }
 }

Wie funktioniert es?

• Dieser Code richtet eine neue Eigenschaft ( SENSOR_UUID ) ein , die Clients lesen und von der sie Echtzeit-Updates erhalten können:
  • PROPERTY_READ → Ermöglicht dem Client, den Wert manuell zu lesen.
  • PROPERTY_NOTIFY → Sendet automatisch Updates, wenn neue Daten verfügbar sind.
• Die Funktion Light_ProximityRead() ruft einen Wert vom integrierten Lichtsensor ab , der nahe gelegene Objekte erkennt. Wir konvertieren die Zahl in eine Zeichenfolge und senden sie an den BLE-Client.

Probieren Sie es aus

Da CodeCell jetzt Näherungssensordaten über BLE sendet , können Sie diese auf einem Telefon anzeigen .

• Öffnen Sie eine BLE-App wie nRF Connect (Android/iOS)
• Nach "CodeCell_BLE" suchen und verbinden
• Suchen Sie die Sensorcharakteristik ( SENSOR_UUID )
• Aktivieren Sie Benachrichtigungen und beobachten Sie, wie sich die Näherungsdaten in Echtzeit aktualisieren!
• Ihre Serial Monitor-Daten sollten mit den an Ihr Telefon gesendeten Daten übereinstimmen

Bewegen Sie ein Objekt in die Nähe des Sensors und sehen Sie, wie sich die Werte ändern!

Wie geht es weiter?

Nachdem Sie CodeCell nun über BLE steuern können, versuchen Sie:

• Hinzufügen weiterer Befehle (z. B. blaue LED, Blinken, Sensorauslöser)
• Empfangen mehrerer Werte (z. B. Senden von Beschleunigungs- oder Näherungssensordaten)
• Erstellen Sie ein vollständig BLE-gesteuertes IoT-Gerät oder verbinden Sie es sogar mit einer anderen App