I have been thinking about writing a guide to teach people how to use the LLM vision step on our platform.

I've also been shipping a lot of SEO agents recently, so thought this would be a fun opportunity to leverage those to create a data-driven blog post plan based on keyword and competitor research.

I'm doing this outside of work just for fun.

## Step 1: Invent an agent.

On our platform, we have the ability to invent new agents.

This was the starter prompt I gave it:

```txt
An agent to develop a full end-to-end content plan for teaching someone else about an informational topic, based on full keyword strategy, search intent and gap analysis etc. Just a single topic.

Using Moz v3 api for keyword research etc. You also have google search and web scraping capabilities.

This was the agent it invented (with placeholder tools)

Any topic, blog post

[list of tools I want it to use, like google search, fetch keywords etc].
```

That produced my starter agent, which looks like this:

![CleanShot 2025-06-11 at 17.32.51@2x.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/f0ae5888-e722-4cc7-a4bd-77d231e9bc54.png)

I changed the model to Claude Sonnet 4, just because I love it for any kind of writing task. It's expensive as all heck, but can optimise later once it all works.

## Update the prompt and tools

Next, I pulled in the tools and parts of other agent prompts to map out the workflow I was looking for. 

This took me about 20 minutes. Here is what the agent prompt looks like now:

![CleanShot 2025-06-11 at 17.54.21@2x.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/663b8805-b532-499a-94fe-fa0041479ef1.png)

## Try out a task

Next, I chucked in the following task to see what the agent would do. Task prompt:

```txt
Topic: LLM Vision
Goal: Teach beginners how to use LLM vision step to do AI image analysis tasks at scale
````

### Prompt corrections

- I had to structure my task to make the topic and goal clearer, because the agent did a bunch of steps then asked me to provide the topic and goal.
- I had to tell the agent to get the ranking keywords for the first informational search result only, because it kept trying to find them for youtube and forums instead of a blog post.
- ⭐️ Make sure keywords are retrieved at a URL level, not a domain level, so we get keywords relevant to the topic not the platform.

## Output thoughts

This task cost 1000 credits to run, and I'm very very happy with the results.

Here's the full output:

![CleanShot 2025-06-11 at 18.09.12@2x.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/6756ceb0-2bde-4fba-8f7e-f51fae9c23f2.png)

I'll comment on the output section by section:

### Keyword research suggestions

The keyword research strategy is perfect. I'm happy with the primary, secondary and related keyword suggestions.

What's interesting, is that none of the keywords have an especially high search volume. So this is a long-tail niche topic that will be fairly easy to rank for (low to medium ranking difficulty is the majority).

### Competitor gap analysis suggestions

Every piece of ranking competitor content for this topic approaches it from a different angle.

There isn't a single piece that covers LLM vision from a beginner perspective.

Most are highly technical and focused on coding examples, while our platform (Relevance AI) is a no-code tool. 

The content gap analysis is missing information about our platform, so it suggests providing code snippets for customers to run, rather than demonstrating no-code examples. Updating the prompt to include more information about Relevance and the purpose of our help guides would improve this.

### Content plan suggestions

I love, love, LOVE the heading based roadmap, which lists what to write for the H1, H2s and H3s. That is so pleasant.

However, as with the content gap analysis, it's way too technical. Our customers don't need to setup a developer environment or APIs.

So the fix for the content gap analysis should help here too.

It's also too long and in-depth for what we want.

### Scrap the SEO recommendations

I want to delete the SEO recommendations section as it's not adding any value (e.g. what does use 0.5%-1% secondary keyword density even mean).

Here is the new section I added to the prompt which includes company details and content aims:

![CleanShot 2025-06-11 at 18.23.37@2x.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/ca763bd0-688c-454e-bdd1-d964449b7a3b.png)

## Final agent prompt

![CleanShot 2025-06-11 at 19.02.37@2x.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/435ee65c-69f5-4ce4-9641-95221ef16dbb.png)

## Final SEO content plan produced by this agent

![CleanShot 2025-06-11 at 19.04.19@2x.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/e338346f-0cc7-495f-997f-e2afdbeddc8c.png)

I can see myself using 100% of the keyword suggestions and 80% of the actual content plan for writing a guide on LLM vision.

That's an amazing starting point.

Planning content with help of SEO AI Agent

In the previous post, we learned how to flash our first hello-world program to our [Beetle-C3: To blink the onboard LED](/blog/esp32-c3-beetle-dev-env). Next, we're going to do the exact same thing with an external LED.

## You Will Need:

- 1 x <a href="/components/esp32-beetle" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/7f467510-8b35-4c1e-8835-8c195ae04e7e.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />ESP32-C3 Beetle Development Board</a>
- 1 x <a href="/components/led" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/787af4b7-81c7-42ea-93dd-cb89394d35b7.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />LED (Light-Emitting Diode)</a>
- 1 x <a href="/components/breadboard" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/de8745c7-4bb3-4d0f-be8e-e329bbd3113f.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />Breadboard</a>
- 2 x <a href="/components/jumper-wires" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/b87b8e02-e09f-4f64-b477-8f4eb94fb03c.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />Jumper Wires</a>
- 1 x <a href="/components/resistor" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/ba848294-4e84-4a34-b3c2-01b2463ad593.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />Resistor</a> (typically 220Ω to 330Ω).

We'll be using the exact same code we wrote when [blinking the onboard LED on our Beetle](/blog/esp32-c3-beetle-dev-env). The only thing we'll change is the pin number.

## 1. Attach Beetle to Breadboard

Your Beetle will have come with two strips of male header pins. In my case, there were two more pins in the strip than there were holes along the side of the Beetle (10 pins, 8 holes).

Use a pair of pliers to snap two of the pins off.

![beetle_pins.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/b022a766-e0fa-4070-8cc8-07309df1a73e.png)

To attach your Beetle to the breadboard, you can push the strip of pins through the holes on either side of your beetle.

Then plug your Beetle into the breadboard so that it straddles the gap running vertically down the middle of your <a href="/components/breadboard" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/de8745c7-4bb3-4d0f-be8e-e329bbd3113f.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />Breadboard</a>.

![beetle_to_breadboard.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/eee025eb-25a2-4b9f-860b-a34722219e39.png)

Your Beetle needs to straddle the middle gap of your breadboard, so that the pins on either side each have their own row (rails that are not electrically connected to each other).

## 2. Connect your LED

Next, add your <a href="/components/led" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/787af4b7-81c7-42ea-93dd-cb89394d35b7.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />LED (Light-Emitting Diode)</a> to the board. You want the long leg of the LED (anode) to be in one row, while the shorter leg (cathode) is in another row. The two will be parallel to the middle gap.

## 3. Connect your resistor

Connect one end of the <a href="/components/resistor" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/ba848294-4e84-4a34-b3c2-01b2463ad593.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />Resistor</a> to the cathode (short leg) of your LED.

Then connect the other end of the resistor to a **GND** pin on the Beetle using a <a href="/components/jumper-wires" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/b87b8e02-e09f-4f64-b477-8f4eb94fb03c.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />Jumper Wires</a>.

[ohms-law-calculator]

## 4. Connect a GPIO pin to your LED

Next, choose a digital output pin (e.g. GPI20) on your Beetle.

Use a <a href="/components/jumper-wires" class="inline-component-card" style="display:inline-flex;align-items:center;background:#fff;border:1px solid #e5e7eb;border-radius:4px;padding:0 6px 0 2px;font-size:0.95em;margin:0 2px;text-decoration:none;color:#111;"><img src="https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/component-images/b87b8e02-e09f-4f64-b477-8f4eb94fb03c.png" alt="icon" style="width:1em;height:1em;vertical-align:-0.15em;margin-right:0.3em;border-radius:2px;border:1px solid #e5e7eb;" />Jumper Wires</a> to connect the **GPI20** to the anode (long leg) of the LED.

## 5. Build & Compile your code

Next, write the code to blink your external LED on and off.

You can use the exact same code for [blinking the onboard Beetle LED](/blog/esp32-c3-beetle-dev-env). All you need to change is the pin number, to LED in this case. That post will also show you how to setup your dev environment if you haven't done that already.

This is what the code will look like to blink your LED on and off every half second:

```cpp
#include <Arduino.h>

int led = 20;

void setup() {
 pinMode(led, OUTPUT);
}

void loop() {
 digitalWrite(led, HIGH);
 delay(500);
 digitalWrite(led, LOW);
 delay(500);
}
```

## 6. Plug your Beetle in

Finally, plug your Beetle into your computer using the USB-C wire. Build your code and upload it to your board.

Here is what this looks like when done!

!VIDEO[https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-videos/5270a865-bd88-416d-9487-b99484178b7e-1747736186797.mov]

Woo hoo congrats! You learned how to build your first electronics project!!!

🥳

ESP32-C3 Beetle - Blinking an External LED

Let's setup our developer environment so we can start flashing code to our [ESP32-C3 beetle development board](/blog/esp32-c3-beetle-pins).

🥳

There are a few different ways you can setup a development environment for your ESP32-C3 Beetle.

## Arduino IDE (nope)

You could install the [Arduino IDE](https://www.arduino.cc/en/software), which you can use to write, compile and upload code to Arduino boards and other microcontrollers like this ESP32.

It's great for beginners, but you can't create folders. You can create individual `.ino` files (main file used for writing Arduino programs), but they all get merged at compile time. So you can't separate projects.

## PlatformIO (yep)

I chose to go with [PlatformIO](https://platformio.org/install/ide?install=vscode), which is an extension for [VS Code](https://code.visualstudio.com/) that also lets you write, build, and upload code to microcontrollers.

My preferred IDE is [Cursor](https://www.cursor.com/) (VS Code under the hood with AI features built-in). Anything that works with VS Code works with Cursor.

PlatformIO is better than Arduino IDE for more complex projects (or in general imo), because you can organise your files and projects with folders.

You also get all the benefits of autocomplete, syntax checking etc.

You can also install different libraries for each of your individual projects. Whereas in Arduino IDE, you install them all globally which can create conflicts when you start working on a different project. You'd need to uninstall the libraries for your previous project first, and you can't switch between them.

### Install PlatformIO in VS Code (or Cursor)

1. Open VS Code or Cursor.
2. Go to the extensions panel (left sidebar, or "View" > "Extensions" in the toolbar).
3. In the search bar, type: "PlatformIO IDE". You'll see the official PlatformIO extension by PlatformIO Labs.
4. Click the "Install" button. It'll take a minute for it to setup all the compilers and tools in the background.

### Create your first PlatformIO project

After you have installed PlatformIO, click the new "PlatformIO icon" (ant head logo) in your sidebar. From there, you'll be able to create new projects, and manage boards & libraries etc.

You'll see a page like this, where you can click "Create new Project":

![create_platformio_project.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/1a93261b-560d-4e11-b725-797d96b8f55d.png)

Next, give your project a name and choose your development board, which is the DRRobot Beetle ESP32-C3 in this case.

I called the project "beetle_c3_blink", because I'll be making the onboard LED light blink for my first beetle project.

The framework will automatically be chosen depending on the board you pick, in this case it's set to Arduino.

You can leave the "Use default location" checked if you want the project to be stored in your docs folder under PlatformIO. I chose to store mine in a personal development project folder elsewhere.

### Standard PlatformIO project structure

When you create a PlatformIO project, it'll automatically create this folder tree for you:

![platformio_new_project_structure.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/29041517-4180-405f-b318-fc5349b6e31a.png)

It'll also download and setup compilers, tools and frameworks in the background.

## Write your first ESP32 Program - blinky LED

For this first program, all we're going to make the onboard LED on the Beetle blink.

Let's start with the code.

### 1. Write blinking LED code

PlatformIO will have created a `main.cpp` file in the `/src` folder. It will have added basic `setup()` and `loop()` functions which you'll use as the starting point for your blink code.

Replace the code in that file with this:

```cpp
#include <Arduino.h>

#define LED_PIN 10 // Onboard LED is GPIO 10 on Beetle ESP32-C3

void setup() {
 pinMode(LED_PIN, OUTPUT);
}

void loop() {
 digitalWrite(LED_PIN, HIGH);
 delay(500);
 digitalWrite(LED_PIN, LOW);
 delay(500);
}
```

The `setup()` function runs one when the board powers up. We've used it to set GPIO 10 as the output (GPIO 10 is the pin that the onboard LED is connected to).

The `loop()` function repeats forever while the board is running. In this case, we turn the LED on, and off every 500ms (half a second).

### 2. Connect your beetle

Plug your ESP32-C3 beetle into your computer with a USB-C cable.

### 3. Build your project

In VS Code's bottom bar, click the **checkmark** icon. This will compile (build) your code.

Wait until you see "SUCCESS" in the terminal output before you continue.

![esp32-c3-build-upload.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/0d3fdefc-8976-42c3-a502-7a05945f5585.png)

### 4. Flash (upload) the code

Next to the checkmark icon, there will be a **Right Arrow** icon. Click that to upload the code to your Beetle.

Once you've done that, you'll see the onboard LED on your Beetle start to blink every half a second.



!VIDEO[https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-videos/53c56a89-07f5-449b-9770-e958f70b8da3-1747471785838.MOV]

🌯 That's a wrap for writing a hello-world LED blinking program for your Beetle-C3!

ESP32-C3 Beetle - Dev Environment Setup

Helloo all, in today's post, we're going to explore what all the pins are on your ESP32-C3 Beetle.

The **[ESP32-C3 Beetle](https://www.dfrobot.com/product-2566.html?srsltid=AfmBOoropVxfIlHhMZTrbkGcHVfihTJn-Sr-1AcZo_XeJu6bWyW8QdML)** is a coin-sized development board that you can use as a bridge between the digital world (Wi-Fi/Bluetooth) and the physical world (motors, lights, buttons).


![esp32-c3-beetle-pin-functions.png](https://zqlevjinwifjmnhpkcsf.supabase.co/storage/v1/object/public/blog-images/d04fac63-2a18-4cc8-a51a-b0014f5ff0cb.png)

## What are pins?

Pins are the physical metal rods (connection points) on your microcontroller that let you talk to other components/devices.

On tiny boards like this Beetle c3, you'll see small gold-coloured holes instead, which are called "pads" or "through-holes".

These holes are connected to the microcontroller's internal pins and functions. They are where you connect wires, sensors or other components. Each one is labelled to show what it does.

The holes become pins when you solder metal connectors into them, or by pushing male header pins into the boards holes and plugging them into a breadboard.

For the purpose of this post, we'll just call the holes pins (to reference the pins inside the board that the holes connect to).

## 13 x Input / Output (I/O) pins

The board itself has 13 Digital I/O pins, which means you can connect it to 13 different Input or Output devices.

### Input examples

- Push Buttons for detecting presses.
- Switches (toggle or slide) for detecting on/off states.- Temperature, Humidity, Light, Motion, Proximity sensors.
- Microphones for retrieving audio input.

### Output examples

- LEDs (lights).
- Buzzers or speakers for sound output.
- Motors for movement or rotation ect.
- Displays like little screens.

Digital I/O pins can only send two possible signals:

- **High**: On.
- **Low**: Off.

If you are using an I/O pin to control an LED output, then the light will either be the brightest possible (fully on), or completely off.

## 13 pins on the Beetle-C3

### 6 x Pulse Width Modulation (PWM) channels

PWM channels allow you to control how much power you send to a device, like an LED or motor, by quickly switching the power on and off.

If the power is off 50% of the time, then the device will only receive half of the power it would have if it was on all of the time.

This is an alternative way than regulating the amount of voltage that is sent to the device, and allows you to achieve the same effect just by sending rapid on/off signals without needing any extra voltage regulation hardware.

The amount of time that the power is ON vs OFF is known as the Duty Cycle.

#### Duty Cycle

- **100% duty cycle** = Always on → Full brightness.
- **50% duty cycle** On half the time → Half brightness.
- **10% duty cycle** Mostly off → Very dim.

You can use PWM channels to control the brightness of your LED lights, how fast motors move, or how loud or quiet the sound coming through a speaker is.

### 2 x Universal Asynchronous Receiver/Transmitter ports

UART is a method of sending and receiving data between two electronic devices.

On the Beetle, the first UART port is connected to the USB-C interface. It's used for uploading code to the beetle, and for communicating with your computer (data exchange).

The second UART port is available for you to use on two pins, one for transmitting data (TX) and one for receiving data (RX). Two wires are needed to send and receive data.

You can use this to connect exchange data with other devices that communicate using serial messages (data sent one bit at a time, in order):

- **GPS module** → sending location data.
- **C02 sensors** → gas concentration data.
- **RFID readers** → sending tag IDs.
- **Other boards** → communicating with other microcontrollers or boards.

### 1 x I²C (Inter-Integrated Circuit) Interface

I²C allows the Beetle to talk to many devices using only two wires (one to many connection):

- **SDA (Serial Data Line)**: Carries the information being sent between the Beetle and other devices.
- **SCL (Serial Clock Line)**: Tells all the connected devices *when* to read or write data, so they don't talk over each other (now it's your turn to talk, now it's my turn to listen, now it's your time to wait for someone else to talk).

Each connected device has its own address, so the Beetle can communicate with each one individually, even though they all share the same two wires.

Physically, you can use a single wire to connect multiple devices via a breadboard where they all share the same line, "Y-split" connections with jumper wires, daisy-chain cables or other parallel connection methods.

### 1 x Serial Peripheral Interface (SPI)

SPI is another way for the Beetle to communicate with many other devices, but is designed for faster data transfer than I²C. It also requires 4 wires, 2 more than I²C.

#### SPI wires

- **Master Out, Slave In (MOSI)** → Data from Beetle to device.
- **Master In, Slave Out (MISO)** → Data from device to Beetle.
- **Serial Clock (SCLK)** → Clock signal from Beetle to keep timing.
- **Chip Select (CS)** → Tells which device the Beetle wants to talk to.

The Beetle acts as the "master" while the devices (sensors, displays, SD cards etc) are the "slaves" (ew who named them!?).

It is faster than I²C for a few reasons:

- You don't need to send address data to select a device. You can just send out a low signal from the CS pin to make sure only the selected device will respond.
- SPI can send and receive data at the same time.
- SPI has higher clock speeds.

### 1 x Inter-IC Sound (I²S) Interface

I²S is a communication method designed specifically for sending and receiving sound (digital audio data). There is one I²S controller hardware block inside the ESP32-C3 chip.

While there is only one I²S controller, you can choose which GPIO pins are used for the I²S bus. The term "bus" refers to the set of physical wires that carry the signals between the Beetle's GPIO pins to the audio device.

For a basic I²S connection, you typically have:

- **Clock wire (SCK)**: keeps timing for sending or receiving audio bits.
- **Word select wire (WS or LRCLK)**: tells when the audio data switches from left to right channels (left or right speaker, or which channel the audio data belongs to).
- **Data wire (SD)**: carries the audio bits.

Because there is only one I²S controller, you can only use one audio device at a time. You can connect both a mic and a speaker, but you can't listen for sound or play sound at the same time, only one at a time.

### 2 x Analougue-to-Digital Converters (up to 6 channels)

ADC allows the Beetle to read signals from devices that output analogue voltages, which are signals that can change smoothly between 0V and 3.3V instead of just ON and OFF.

The ESP32-c3 chip has 2 x ADC units inside, and together they can read from 6 different input pins (channels), where each channel is for one analogue signal. 

This means you can connect up to 6 different analogue devices, and each device will get it's own channel. This is great for sensors including light, temperature, gas, moisture etc.

🌯 That's a wrap for all 13 pins that are part of your Beetle.

Blog