Integrar CB2S con Arduino Nano vía UART para datos meteorológicos en formato JSON

aiereza wrote:

quisiera utilizar un CB2S para una estación meteorológica con un Arduino Nano, pero necesito que el firmware tenga comunicación con el Nano por UART y que pueda descargar la info meteo de una web y co...

The core issue is that the CB2S is not an ESP32-C3. The online sample that claims that is incorrect. In practice, CB2S is a Tuya Wi‑Fi module based on Beken BK7231N/BK7231T family, and firmware

1.18.278

is typically Tuya factory firmware. That firmware is intended for Tuya cloud / TuyaMCU use, not for arbitrary HTTP requests to OpenWeatherMap and custom JSON processing.

So the direct answer is:

Direct answer

With the original Tuya firmware on a CB2S, what you want is not realistic.
If you want the CB2S to:

- connect to your Wi‑Fi,
- call

api.openweathermap.org

,
- parse the returned JSON,
- build your own JSON,
- send it by UART to an Arduino Nano,

then you need custom firmware on the CB2S, or you should replace the CB2S with a module that is easier to program, such as ESP8266 / ESP32.

For this project, the most practical options are:

1. Best practical option: replace CB2S with an ESP8266/ESP32 module.
2. If you must keep CB2S: flash OpenBeken / custom BK7231 firmware, but this is significantly more advanced.
3. Alternative architecture: let another device on the LAN fetch weather data and use CB2S only as a UART/network bridge.

---

Important correction to the sample answers

One of the online answers says CB2S is based on ESP32-C3. That is wrong for the usual Tuya CB2S module.
For Elektroda users this distinction matters a lot, because:

- ESP32-C3 can be programmed with standard Espressif toolchains.
- CB2S/BK7231 requires a different workflow.
- Code written for ESP8266/ESP32 will not compile directly for BK7231.

So do not start from an ESP32-C3 tutorial if your module is truly CB2S.

---

Recommended system architecture

For your weather station, the clean architecture is:



This is correct because the Nano has very little RAM, so it should not download and parse the full OpenWeatherMap response. The Wi‑Fi module should do that work and send only a compact payload to the Nano.

---

What data to request from OpenWeatherMap

You said you need:

- temperature
- relative humidity
- wind speed
- wind direction
- feels like
- weather description
- for your location

That maps well to the current weather endpoint. Typical fields are:

-

main.temp

-

main.humidity

-

main.feels_like

-

wind.speed

-

wind.deg

-

weather[0].description

If you want your exact location, the best method is usually:

- fixed latitude/longitude, or
- city + country code

For reliability, latitude/longitude is better than a city string.

---

Practical recommendation: do not send full JSON to the Nano unless necessary

Although you asked to convert to JSON and send it to the Arduino, from an embedded design perspective I recommend one of these two formats:

Option A — compact JSON
Good if you really want structured data:



Advantages:
- easy to inspect
- easy to extend

Disadvantages:
- larger than necessary
- on Nano, JSON parsing still costs RAM

Option B — compact delimited text
Better for Arduino Nano:



Advantages:
- much smaller memory footprint
- trivial parsing on ATmega328P

Disadvantages:
- less elegant than JSON

If the Nano only needs to display or log data, Option B is usually better.

---

If you insist on using the CB2S

What you will need

Because Tuya stock firmware will not do this job, you would need to:

1. flash alternative firmware to the CB2S,
2. make the module connect to Wi‑Fi,
3. implement HTTP/HTTPS client code,
4. parse OpenWeatherMap JSON,
5. serialize only the fields you need,
6. send them by UART to the Nano.

Why this is difficult on CB2S

On a BK7231-based Tuya module, this is harder than on ESP8266/ESP32 because:

- fewer beginner-friendly examples,
- less mature mainstream Arduino-style ecosystem,
- more effort to flash and debug,
- custom networking + JSON + UART workflow is more involved.

If you are comfortable with embedded C and flashing Tuya/Beken modules, it is possible. If not, it will consume far more time than the rest of the project.

---

Recommended alternative: use ESP8266 or ESP32 instead of CB2S

For this use case, an ESP8266 or ESP32 is much more suitable.

Why:

- simple development in Arduino IDE or PlatformIO,
- many examples for OpenWeatherMap,
- mature Wi‑Fi and HTTP libraries,
- easy UART communication with Nano,
- easier debugging over serial monitor.

If your main objective is the weather station and not the challenge of reverse-engineering Tuya hardware, this is the engineering choice I would recommend.

---

Example firmware logic for the Wi‑Fi module

Regardless of module type, the firmware should work like this:

1. boot
2. connect to Wi‑Fi
3. every 5–15 minutes:
- call OpenWeatherMap
- parse response
- extract required fields
- create short output string / JSON
- send to Nano over UART
4. if error:
- send error frame to Nano
- retry later

Example transmitted JSON:



Example error frame:



---

UART electrical considerations

This is very important.

Voltage levels
- CB2S/BK7231: typically 3.3 V logic
- Arduino Nano: usually 5 V logic

So:

- CB2S TX → Nano RX is often acceptable if Nano recognizes 3.3 V as HIGH.
- Nano TX → CB2S RX is the dangerous direction because 5 V can damage a 3.3 V input.

Use:
- a level shifter, or
- at least a resistor divider on Nano TX → CB2S RX.

Common ground
You must connect:
- GND of CB2S
- GND of Nano

without that, UART will be unreliable.

Baud rate
Use something conservative like:
-

9600

or

19200

Especially if the Nano also has to do other tasks.

---

Power supply considerations

Also critical.

The CB2S is a Wi‑Fi module, so it needs a stable 3.3 V supply with enough peak current.
Do not power it from a weak 3.3 V pin that cannot handle Wi‑Fi transmit bursts.

Use a proper 3.3 V regulator with enough margin. If power is marginal, symptoms include:

- random resets,
- failed Wi‑Fi association,
- corrupted UART output,
- HTTP failures.

Add local decoupling near the module, for example:

- 100 nF ceramic
- 10 µF to 470 µF bulk capacitance, depending on layout and supply quality

---

OpenWeatherMap side: practical notes

For OpenWeatherMap, typical request style is:



Notes:

- use

units=metric

- use

lang=es

if you want Spanish descriptions
- prefer

lat

/

lon

over city name
- do not poll too frequently; every 10 minutes is usually enough for a home weather display

---

Recommended payload to send to Nano

For an ATmega328P, I would send this exact style:



or even better:



If you later want wind direction text, convert degrees either on the Wi‑Fi module or on the Nano:

- 0° / 360° = N
- 45° = NE
- 90° = E
- 135° = SE
- 180° = S
- 225° = SW
- 270° = W
- 315° = NW

---

If you use an ESP8266/ESP32 instead: example approach

If you decide to replace the CB2S, the software stack is straightforward:

-

WiFi

/

ESP8266WiFi

-

HTTPClient

-

WiFiClientSecure

if using HTTPS
-

ArduinoJson

Then the module:

- connects to Wi‑Fi,
- performs the GET request,
- parses the JSON,
- sends a reduced frame to Nano via UART.

This is the path with the highest probability of success.

---

If you still want to keep the CB2S: realistic project plan

If your goal is specifically to learn CB2S/BK7231, then proceed in stages:

Stage 1
Flash alternative firmware and verify:
- boot messages
- UART TX/RX
- Wi‑Fi connection

Stage 2
Implement a minimal network test:
- DNS resolution
- HTTP GET to a simple page

Stage 3
Query OpenWeatherMap and print raw response over debug UART.

Stage 4
Parse only 2 fields first:
- temperature
- humidity

Stage 5
Add:
- wind speed
- wind direction
- feels like
- description

Stage 6
Format final UART protocol for Nano.

This staged approach reduces debugging complexity.

---

What I would recommend on Elektroda, practically

For a working build, I would recommend:

Variant 1 — best overall
- Replace CB2S with ESP8266
- Keep Arduino Nano
- ESP handles API and JSON
- Nano handles display/logic

Variant 2 — simpler hardware
- Eliminate Nano entirely
- Use only ESP32/ESP8266
- drive display directly from the Wi‑Fi MCU

Variant 3 — keep CB2S only if mandatory
- Flash alternative BK7231 firmware
- treat it as an advanced custom embedded project

If you do not have a hard reason to keep the CB2S, Variant 1 or 2 is much better.

---

Example protocol between Wi‑Fi module and Nano

To make the UART link robust, I suggest framed lines ending with newline:



Where:
- field 1 = temperature
- field 2 = humidity
- field 3 = wind speed
- field 4 = wind direction
- field 5 = feels like
- field 6 = description

That is more Nano-friendly than JSON.

If you want JSON anyway, terminate each JSON object with

\n

so the Nano knows where a packet ends.

---

Final conclusion

Short version
- Stock CB2S Tuya firmware 1.18.278 is not suitable for your requirement.
- CB2S is not ESP32-C3; do not follow that wrong assumption.
- Your project is technically valid, but with CB2S it requires custom firmware and is relatively advanced.
- The most practical solution is to use an ESP8266 or ESP32 instead, fetch OpenWeatherMap there, and send a short frame by UART to the Arduino Nano.

My engineering recommendation
If your objective is to finish a reliable weather station quickly, do not use CB2S for this task unless you specifically want a BK7231 firmware development project.

---

What I can provide next

If you want, in the next message I can give you one of these three things:

1. A complete ESP8266/ESP32 sketch that downloads OpenWeatherMap data and sends it to the Nano by UART.
2. A wiring diagram for Nano ↔ Wi‑Fi module, including level shifting and power.
3. A CB2S/OpenBeken path, with realistic flashing steps and what is and is not feasible on BK7231.

If you want the fastest path, ask me for:
“Give me the complete ESP8266 + Nano code and wiring.”