Posts with «open hardware» label

Driving a Sony Car Radio LCD Display with Arduino

Driving the LCD display of a Sony car radio with Arduino is possible. Jose Luis Monteiro proves it on the detachable front panel of a Sony CDX-A250, talking directly to the LC75826W driver. The project gathers reverse engineering notes, the reference sketch and a guide to reproducing the experiment. The starting point is the driver datasheet alone, because the segment mapping is not documented.

The Sony CDX-A250 panel contains the LC75826W LCD driver, listed as IC901 in Sony’s service documentation. The driver exposes a serial interface on connector CN901. The wiring used in the project is direct: DATA-LCD to DI of the LC75826 on pin 11 of CN901 and pin D8 of the Arduino sketch, CE-LCD to CE on pin 12 of CN901 and pin D10, CLOCK-LCD to CL on pin 13 of CN901 and pin D9. The panel’s +B supply comes in on pin 14 of CN901 from an external bench power supply, while the panel ground stays common with the Arduino.

The CCB protocol of the LC75826W driver

The LC75826 uses SANYO’s CCB serial format. Every transfer starts with device address 41H and then sends one of four 72-bit groups, identified by the two DD bits. The groups cover the ranges D1-D52, D53-D104, D105-D152 and D153-D208. The first group also carries the control fields that configure the driver: P0-P3 for segment output or general-purpose selection, DR for LCD bias selection, DN for 200 or 208 segment selection, FC0-FC2 for frame frequency control, OC for internal or external oscillator mode, SC for display on/off and BU for normal or power-saving mode.

The reference code sends every byte starting from the least significant bit. The segment mapping, that is which visible symbol corresponds to which position in the matrix, has to be discovered experimentally because the datasheet does not provide it. The searchOfSegments() routine advances one test state at a time. A button on D2 advances the test, while the serial monitor prints the information needed to identify the current state. The sketch’s serial monitor is used at 115200 baud for debugging and for the segment identification output.

What you need to repeat the experiment

Only a few parts are needed to reproduce the project. In particular, the list includes:

  • a detachable front panel from a Sony CDX-A250
  • an Arduino-compatible board with Uno-style pin numbering
  • a bench power supply to power the panel
  • a button for the segment identification routine
  • the CN901 connector to access the panel signals

Jose Luis Monteiro’s repository collects the reference Arduino sketch and documentation files on the connections, the protocol, the segment mapping, troubleshooting and references. The Sony CDX-A250/CDX-A250EE service manual is version 1.1, dated 2006-01, publication 9-879-865-02. The project is meant to be reusable on other displays based on the same LC75826, so the reverse engineering notes apply beyond this single car radio model.

Anyone who wants to start from an Arduino board for the test bench will find several options in the catalogue. The code and the documentation remain the heart of the project anyway, because the segment mapping has to be redone by hand on your own panel.

Source: https://github.com/emsyscode/lc75826-sony-cdx-a250

The post Driving a Sony Car Radio LCD Display with Arduino appeared first on Open Electronics.

Nuvi: an Arduino UNO Q Desktop Companion

Nuvi is a small, expressive desktop companion, less than 30 cm tall. It wakes up when someone comes close, answers when it is called by name and holds a conversation with the user. It also searches the web, controls smart home devices by voice or with a hand gesture, and reads the room’s temperature and humidity. It was designed by Luca Di Lorenzo, and the board that brings it to life is the Arduino UNO Q.

What stands out is not the conversation itself, but where it runs. The Linux side of the UNO Q runs the artificial intelligence pipeline, the voice engine and the application logic, all on the board itself rather than on a connected PC. So Nuvi is self-contained: you switch it on and it is there.

Two souls on one board: microcontroller and Linux

Arduino UNO Q splits the work in two. The real-time microcontroller side handles the physical control: four servos for the arms and ears, two serial servos for the neck, the display, the sensors and the touch inputs. The Linux side, on the other hand, takes care of the heavy part, that is the artificial intelligence and the voice.

This separation makes practical sense. Movements have to respond immediately, without waiting, and that is why they live on the microcontroller. The conversation can take a few moments longer, so it lives on the processor running Linux. As a result, the arms, ears and head move smoothly while the brain works out the sentence.

  • Four servos for the arms and ears
  • Two serial servos for neck rotation and tilt
  • Display for the animated eyes
  • Temperature and humidity sensors
  • Touch inputs on the head and belly

Gemini to understand, Piper to speak without the cloud

The conversation is based on Gemini, which handles both speech understanding and response generation in a single pass. There is therefore no separate speech-to-text stage: the model does everything at once, and the pipeline stays leaner.

For the outgoing voice, on the other hand, Nuvi uses Piper, a voice engine that runs entirely on the board. So the synthesis does not go through the cloud: the sentence is spoken locally. In particular, it is this choice that makes the robot usable even when the network is poor, at least for the sound side of things.

The animated eyes express different moods. The ears and arms move, the head rotates and tilts, and touching the head and belly triggers a reaction. Finally, purely for fun, there is also a little dance.

What you need to rebuild it: 3D files, electronics and code

Anyone who wants to build a Nuvi starts from the Arduino UNO Q, the heart of the project. The complete kit with accessories includes the board and what you need to start working with it. To drive traditional three-pin RC servos, with power, ground and PWM signal, you then need a dedicated driver stage.

On the sensor side, Nuvi reads the room’s temperature and humidity. Nuvi uses a Modulino Thermo module for the room’s temperature and humidity, while two Modulino Distance modules take care of noticing who is approaching.

The rest is assembly: 3D printing for the body, wiring the servos, connecting the display and the touch inputs. Luca Di Lorenzo’s video shows the project in action, and from it you can see how much work lies behind every single gesture Nuvi makes.

The most interesting part remains the amount of personality you can put into a project based on the UNO Q. 3D files, electronics, code and a step-by-step tutorial are available for anyone who wants to build one. And the result, under 30 cm tall, sits comfortably on a desk.

Source: https://projecthub.arduino.cc/lucadilo/nuvi-ai-desk-companion-bdd30c

The post Nuvi: an Arduino UNO Q Desktop Companion appeared first on Open Electronics.

Smart Mirror: local visual AI turns a mirror into a style consultant

The Smart Mirror turns a mirror into a style consultant. With a tap on Scan your look, a USB camera frames the garment being worn and the system recognises its colour and type, then suggests how to complete the outfit. The example runs on the Arduino VENTUNO Q board and shows how local visual AI can become part of a context-aware retail experience. Here the inference happens on the board, not on a remote server: images never leave the device, so privacy and latency stay under control.

The flow is linear and reads well from start to finish. A USB camera provides a live video stream, and the most recent frame is saved into a shared buffer. When Scan your look is tapped, the last frame is analysed locally on the VENTUNO Q board by the Qwen3-VL model, accessible through the Arduino VLM Brick. The model identifies the main garment and its colour and returns two short sentences: a description of the outfit and a style suggestion.

Two App Lab Bricks and an MJPEG stream to the browser

The result is sent to the browser and shown over the live camera view. The browser displays the live feed through an MJPEG stream exposed by the backend. The application therefore uses two App Lab Bricks: the Vision Language Model Brick and the Web Interface Brick. The first handles frame analysis, the second the page and the stream. The prompt behaviour can also be customised through a single configuration file, prompt.py.

Arduino VENTUNO Q as the compute board

  • USB camera for the live video stream
  • Arduino VLM Brick to access the model
  • Vision Language Model Brick for frame analysis
  • Web Interface Brick for the page and MJPEG stream
  • prompt.py to customise the prompt

Anyone who wants to rebuild the project will find the parts list here is fairly short overall. The VENTUNO Q board is the heart of the system, while the USB camera is the only sensor required. The Qwen3-VL model does not need training: it is used as it is, through the Arduino VLM Brick.

The physical assembly is not described in the example: the system relies on a USB camera connected to the VENTUNO Q board and on a backend that exposes the MJPEG stream. The rest, from the framing to the physical mirror, depends on how you want to build the mount. The software side, on the other hand, is all inside the two Bricks and the prompt.py file.

What changes with visual AI inference running locally

The interesting point is not the individual style suggestion, but where it is computed. The Qwen3-VL model runs on the VENTUNO Q board, so no image of the garment being worn is sent to a cloud service. As a result, latency stays low and privacy is simpler to guarantee: what the camera sees does not leave the mirror. The system also works without an internet connection, because inference is local.

The complete flow can be summed up like this: the camera produces the frames, the shared buffer holds the most recent one, the model analyses it on request and the browser shows the result over the live video. Every step stays on the board or on the local network, and the tap on Scan your look is the only trigger for the analysis. If you want to see how the project is built and which files it uses, the post on the Arduino blog is the place to start.

For those working in retail or in the maker world, this Smart Mirror is a concrete example of how local visual AI can power a complete, real-time user experience. No cloud is needed, no fast connection is needed, no images travelling outside the home are needed. A USB camera, a VENTUNO Q board and two well-chosen Bricks are enough.

Source: https://blog.arduino.cc/2026/09/23/making-retail-smarter-build-context-aware-experiences-with-the-arduino-ventuno-q-board/

The post Smart Mirror: local visual AI turns a mirror into a style consultant appeared first on Open Electronics.

Arduino examples for the 6-colour e-paper display on the reTerminal E1002

Driving a 6-colour e-paper display is not like driving a monochrome panel. Seeed Studio’s reTerminal E1002 carries a 7.3-inch ACeP with 800×480 resolution, and a XIAO ESP32-S3 runs underneath it. Mariusz Jurgielewicz has put together a set of Arduino examples tested on exactly this combination, so newcomers don’t have to reinvent pinout, polarity and refresh sequences.

The practical value of the collection lies in the details the official drivers don’t tell you. The GDEP073E01 panel uses the ED2208 controller and is wired to the carrier through an internal FPC. So the pins are not the ones you’d expect from a breakout module: SCK is on GPIO 7, MOSI on GPIO 9, CS on GPIO 10, DC on GPIO 11, RST on GPIO 12 and BUSY on GPIO 13. Logging is also duplicated across two serials, Serial1 on GPIO 43 and GPIO 44 through the USB-UART bridge, plus the XIAO ESP32-S3’s native USB CDC Serial.

BUSY active-low and SPI clock at 2 MHz

Trap number one is the BUSY polarity. On the ED2208 the signal is active-low: 0 means refresh in progress, 1 means ready. Inverting it locks up the driver or corrupts subsequent writes, and the symptom isn’t a clear error but a panel that stays half-drawn.

The second trap is the clock. The SPI bus runs reliably at 2 MHz, and this also applies to the upload speed set in the Arduino IDE, fixed at 115200. The log serial runs at 115200 baud. Higher frequencies on the internal flex risk clock distortion, with pixel dropouts or corrupted command bytes. Finally there’s the watchdog: during a cold refresh the 40-second timeout can fire, so the sequence has to be handled accordingly.

  • SCK on GPIO 7, MOSI on GPIO 9, CS on GPIO 10
  • DC on GPIO 11, RST on GPIO 12, BUSY on GPIO 13
  • BUSY active-low: 0 refresh in progress, 1 ready
  • Reliable SPI clock at 2 MHz
  • Serial1 on GPIO 43 (TX) and GPIO 44 (RX), plus native USB CDC
  • 192,000 bytes of frame buffer in OPI PSRAM

A full frame buffer of 800×480 pixels at 4 bits per pixel, two pixels per byte, requires 192,000 bytes. It doesn’t fit in the ESP32-S3’s internal RAM, so it has to be buffered in OPI PSRAM. The panel exposes 6 native solid colour fields: black, white, red, green, blue and yellow. So each pixel is not a grey value but a colour index, and dithering has to be planned accordingly.

On the software side the collection covers three driver stacks. The first is Jean-Marc Zingg’s GxEPD2, the upstream one you get from the Library Manager. The second is the Good Display vendor driver. The third is Waveshare’s GUI_Paint graphics framework, sitting on top of Adafruit_GFX. Watch out for one detail: the Seeed_GxEPD2 fork should not be installed, because it conflicts with the upstream GxEPD2.

Besides the display, the examples cover the carrier board’s onboard peripherals. There’s the PCF8563 real time clock and the SHT4x environmental sensor, so a complete project can show the time plus temperature and humidity data without adding external modules. Anyone who wants to rebuild everything from scratch will find Mariusz Jurgielewicz’s repository with the sketches ready to upload.

To work on it you need the Arduino IDE with XIAO ESP32-S3 support, the GxEPD2 library from the Library Manager, and the panel connected to the carrier.

Source: https://github.com/melastmohican/reTerminal-E1002-arduino-examples

The post Arduino examples for the 6-colour e-paper display on the reTerminal E1002 appeared first on Open Electronics.

A DIY laptop built on the ATmega2560: real multitasking on 8 KB of RAM

An ATmega2560 with 8 KB of RAM can support a multitasking desktop environment, complete with games, file management and video playback. That is what Vladimir demonstrated by building a DIY laptop around an Arduino-compatible board with an ATmega2560, the Mega 2560 Pro Mini. The device measures 12x11x3.4 cm and packs a QWERTY keyboard, a 128×64 monochrome display, audio, microSD, an RTC and an 18650 battery into a 3D-printed enclosure. The firmware runs on FreeRTOS and offers real multitasking, with task switching via Alt-Tab. So a video that has been started keeps playing its audio while you play Sokoban.

The architecture of independent tasks is the core of the project. Applications receive events and draw through the UI engine, while the shell handles registration, stacks, switching and events. As a result, adding a new application does not require touching the others. A new task is a class with setup and loop plus a couple of methods for its menu entry and icon.

The UI engine and the applications on FreeRTOS

The interface engine handles forms, buttons, checkboxes, lists, input fields and dialogs. It takes care of key presses, tabbing, redrawing and the events sent to the owning task. On top of it run the ready-made applications:

  • file manager
  • video player
  • music player
  • clock
  • calculator
  • Sokoban
  • Snake
  • Game of Life
  • text editor

The ST7920 display is driven in parallel mode with a custom-written driver and a 1 KB video buffer in SRAM. The graphics functions range from a single pixel to text and XBM images. The AVR microcontroller runs at 16 MHz and everything runs on 8 KB of RAM, half of which is already taken up by global variables. That is why every byte of the buffer counts.

8×8 keyboard, debouncing and a 4-to-16 decoder

The keyboard has 64 keys in total, arranged in an 8×8 matrix that requires two 8-bit ports of the microcontroller. The keys were laid out in an 11×6 rectangle. Scanning happens column by column at hundreds of hertz, with software debouncing. In one revision a diode was added for each key and column selection moved to a 4-to-16 decoder. This way four pins are enough to select a column and the keyboard can expand to 16 columns.

The matrix rows are currently 6, but by reading a whole port of the microcontroller they can be brought to 8. The key labels were printed with a 0.25 mm nozzle. For the audio and memory side, the project relies on components that have a direct counterpart in the catalogue: an audio decoding shield for compressed formats, a microSD card reader with an SPI interface for the files, and a board that combines an ATmega2560 with Wi-Fi connectivity for anyone who would rather start from a different base.

24 fps video and XBM format plus MP3 in a single file

The video player uses a custom format with an XBM stream and MP3 in a single file. This way the player comfortably handles 24 fps video with audio, without keeping more in RAM than needed. The rest of the board is taken up by the RTC and the 18650 battery, which make the device self-contained. The enclosure was machined with a CNC3018 and 3D printed, while the schematics were drawn in EasyEDA.

Anyone who wants to rebuild the project will find the story of the work and the information to recreate it on the project page on Hackaday.io signed by Vladimir. Alternatively, an enclosure for an Arduino Mega can serve as a dimensional reference for the electronics, even though this laptop’s case is printed to measure.

Source: https://hackaday.io/project/206744-avr-laptop

Related products

The post A DIY laptop built on the ATmega2560: real multitasking on 8 KB of RAM appeared first on Open Electronics.

0.96-inch 128×64 OLED Display: SSD1306 and I2C

The 0.96-inch 128×64 OLED display is a compact module widely used in electronics projects. It uses the SSD1306 driver and communicates over I2C, so it connects to Arduino, ESP8266 and ESP32 with just a few wires. It shows text, sensor data, symbols and graphics. AdriRobot tested it with an Arduino UNO and with an ESP32-C3 SuperMini.

128×64 OLED display: technology and colours

OLED stands for Organic Light Emitting Diode. Each pixel emits its own light, so contrast is high and no backlight is needed. Power consumption is lower than that of a backlit LCD, and readability stays good both in the dark and in bright light. The module comes with white, blue or yellow pixels, or in a two-colour version with a yellow top strip and the rest in blue.

  • 0.96-inch size, 128 × 64 pixel resolution, SSD1306 driver;
  • supply from 3.3 to 5 V, 0.06 W consumption in normal display mode;
  • viewing angle greater than 160°;
  • operating temperature from -30 to +70 °C;
  • glass screen, lifetime of at least 16,000 hours;
  • module dimensions: 29.28 × 27.1 mm.

Pins, I2C address and power supply

The connector has four pins: VCC (3.3-5 V), GND, SCL and SDA. The reset circuit is on board, so no extra pin is needed. On the Arduino UNO the I2C pins are A5 for SCL and A4 for SDA, on the Mega they are 21 and 20.

Watch out for the two power pins, because on some modules their order is reversed. Displays marked JMDO.96C.1 let you choose: two pads on the PCB, shorted with 0 Ω SMD resistors or with a blob of solder, swap the two pins. Before connecting, it is therefore worth checking the silkscreen.

On some modules VCC and GND are swapped: read the silkscreen (photo: AdriRobot)

The I2C address is 0x3C, the same as other SSD1306 displays, and it cannot be changed. If other peripherals with that address are on the bus, another solution is needed.

Test with Arduino UNO

For the test, the display is mounted on a small breadboard and connected to an Arduino UNO. First you read the address with the i2c_scanner sketch (File, Examples, Wire): if nothing shows up, try swapping the SDA and SCL wires. Then install the Adafruit SSD1306 library from the Library Manager, accepting the Adafruit GFX dependency as well with Install all.

The test sketch then fills the screen, draws a pixel in each corner and writes a few lines of text. On the two-colour model, in fact, the first line comes out yellow because it sits in the top strip.

The test sketch running on the 128×64 OLED display (photo: AdriRobot)

Test with ESP32-C3 SuperMini

Connecting the display to the ESP32-C3 SuperMini (diagram: AdriRobot)

With the ESP32-C3 SuperMini the display uses 3.3 V, GND, GPIO9 as SCL and GPIO8 as SDA. In the IDE you select ESP32C3 Dev Module and enable USB CDC On Boot and Erase All Flash Before Sketch Upload, as in the other tests. Finally the sketch initialises I2C on pins 8 and 9, starts the display at address 0x3C and writes a few lines of text.

AdriRobot also used it on a board with an ESP8266 12F, to show temperature and humidity from a DHT11, and on a shield with a DFPlayer Mini, to print messages. The white-pixel model is available as a 0.96-inch I2C OLED display.

Source: AdriRobot’s original article includes the circuit diagram, the downloadable sketches and the test video.

Related products

The post 0.96-inch 128×64 OLED Display: SSD1306 and I2C appeared first on Open Electronics.

Boxing Band Counts Punches and Analyses Them in Real Time

A boxing band that counts your punches and analyses them as you throw them. Manivannan’s project brings together an Arduino Nesso N1, a Pulse Sensor and a machine learning model trained in Edge Impulse. The built-in 1.14-inch touch display shows the count and changes colour according to heart rate. That way the athlete immediately knows whether they are working in the rest zone or at peak intensity, without looking at an external app.

The Nesso N1 is the board that carries the whole system. The ESP32-C6 microcontroller mounts two 32-bit RISC-V processors, with an HP core up to 160 MHz and an LP core at 20 MHz. Memory amounts to 16 MB of NOR flash and 512 KB of SRAM, figures that leave room for the model and the firmware. On board there is also an SX1262 LoRa module in the 850-960 MHz band, useful if you later want to send data to a second device. The dimensions are 18 mm x 45 mm, so the band stays compact. Power comes from an integrated lithium-polymer battery, with a nominal 5 V input.

From the Nesso_IMU.ino firmware to the four punch classes

The Nesso_IMU.ino firmware initialises the Nesso N1’s IMU, configures the sampling pipeline and sends the readings from the 3-axis accelerometer over the serial port. The serialised motion frames are then acquired by Edge Impulse through the data forwarder. Here the work moves to Edge Impulse Studio, where the frames are segmented and labelled into four classes: Idle, Hook, Jab-Cross and UppeCut.

The preprocessing block is Spectral analysis, the learning block is Classification. The analysis window is 1200 ms and the stride is 750 ms, so the system looks at a little over one second of movement at a time and advances by three quarters of a second. The neural network is trained with 100 training cycles and a learning rate of 0.05. The stated result is 100% accuracy in both the training and the testing phase.

The trained model is exported as an Arduino library and imported into the IDE. From that point on, inference runs locally on the device, with no cloud dependency. The results update the punch count variables, while the Pulse Sensor continuously reads heart rate. Anyone who wants to retrace the path will find the full account of the workflow, from data collection to library export, on Manivannan’s project page on Hackster.io.

The Pulse Sensor on pin GPIO5 and the backlight colours

The pulse sensor must be connected to pin GPIO5, not to the default pin. The PulseSensor Playground library therefore has to be modified: inside PulseSensor.cpp the InputPin variable goes from 7 to 5. The sensor sits on the tip of the index finger and is secured with a hook-and-loop strap, so it stays in contact during the punches.

Heart rate sets the colour of the LED backlight, which becomes an intensity indicator you can read out of the corner of your eye:

  • Below 100 bpm the backlight turns green, rest zone or low intensity.
  • Between 100 and 140 bpm it turns blue, moderate activity.
  • Between 140 and 160 bpm it turns yellow, high intensity.
  • Above 160 bpm it turns red, peak intensity.

Rebuilding the band takes only a few parts: the Nesso N1, a Pulse Sensor, hook-and-loop tape and a 5 cm jumper wire kit. Assembly requires no special soldering, because the connections go through the jumpers. What is more, the hook-and-loop strap holds sensor and band together without 3D printing. Anyone looking for a board from the same family for other IoT experiments will find the board with Matter and Bluetooth LE in the catalogue, intended for home automation rather than for sports wearables.

The delicate point is calibrating the heart-rate thresholds. The four ranges on the board hold true for this project, but every athlete has different maximums. So it is worth recording a few rounds and comparing the colours with the real values before trusting the feedback. Sensor position matters too: if it shifts even slightly, the reading wobbles and the colour changes for no good reason.

Punch counting relies on the model’s four classes. Idle increments nothing, while Hook, Jab-Cross and UppeCut push the counter up. Consequently the number on screen is not a simple accelerometer peak, but the result of a classification. The limitation is that the model was trained on one person’s movements: with a different boxer, or with the opposite hand, performance can drop.

Source: https://www.hackster.io/manivannan/smart-ai-boxing-band-bddc39

Related products

The post Boxing Band Counts Punches and Analyses Them in Real Time appeared first on Open Electronics.

Active and passive buzzer modules: KY-006 and KY-012 with Arduino

A buzzer module emits a sound to signal a danger or the end of a set time. It also serves to confirm a command. There are two types: passive, such as the KY-006 and Ks0019, and active, such as the KY-012 and Ks0018. AdriRobot tested them with an Arduino UNO, with a Multi Test Shield and with the micro:bit board.

Active and passive buzzer module: the difference

Loose buzzers and buzzer modules used in the tests (photo: AdriRobot)

The buzzer is an audio signalling device. It can be mechanical, electromechanical or piezoelectric. In the active module there is an internal oscillator: you just power it and the sound starts. The passive module has none, so the control circuit must supply it with a square wave between 2 and 5 kHz.

The piezoelectric buzzer is based on a ceramic disc with a metallic layer. It is robust and cheap. That is why it is used for narrow-band alarm signals, for example in household appliances and in medical technology. Electromagnetic buzzers, on the other hand, have a metal diaphragm set vibrating by an electromagnetic circuit, with the electronics already integrated.

The four modules compared

The KY-006 and KY-012 have the same circuit, made up of a connector and the buzzer. Only the type of buzzer changes, passive in the first and active in the second. Of the connector only GND and signal are used, so the current comes from the Arduino pin. Each module also measures 15 × 19 × 9 mm and weighs 2.4 g.

The Keyestudio Ks0018 (active) and Ks0019 (passive) modules are more elaborate. An NPN S8050 transistor acts as a switch between the control pin and the buzzer. There are two resistors: one on the base and one in series with the power supply. This way the control pin only supplies the current for the transistor. The connector therefore has three connections: GND, signal and 3.3 or 5 V power. Finally, these modules measure 30 × 20 × 10 mm and weigh 3 g.

The NPN S8050 transistor acts as a switch on the Keyestudio module (schematic: AdriRobot)

Testing with Arduino: square wave and tone()

The KY-006 module connected to an Arduino UNO for the basic test (schematic: AdriRobot)

To test a passive module you need an Arduino UNO, some Dupont jumpers and the KY-006 or the Ks0019. In the first sketch digital pin 3 goes from high to low with short pauses. This way the square wave is built by hand. Alternatively you use tone(pin, frequency, duration), which generates a square wave with a 50% duty cycle.

The command also produces only one tone at a time. If another pin is already playing, the call has no effect, while on the same pin it changes the frequency. To stop the sound you use noTone(pin). In AdriRobot’s example the buzzer sounds at 500 Hz and at 1000 Hz for one second each. Then it stays silent for five seconds.

The active module is simpler. With the KY-012 or Ks0018 a signal pin at high level makes the buzzer sound. At low level it stops it.

Multi Test Shield and micro:bit

The Multi Test Shield is a shield built by AdriRobot, compatible with the Arduino UNO R3. It is used to test the sensors of the 37-in-1 kit. The KY-012 is inserted on the JP2 connector. This way the sketch alternates sound and silence and shows the various phases on a small OLED display.

The Ks0018 and Ks0019 modules can also be connected to a micro:bit board. You need the Keyestudio Micro:bit Sensor V2 shield and three female-female Dupont cables. The program is also written with the MakeCode block editor and saved directly onto the board.

Where to find the modules

The individual modules are in the catalogue: the passive buzzer module KY-006 and the active buzzer module KY-012. Both are also part of the box of 37 sensors for Arduino, Raspberry Pi and robotics.

Source: the original article by AdriRobot includes the complete sketches, the MakeCode programs and other examples of buzzer use in projects.

Related products

The post Active and passive buzzer modules: KY-006 and KY-012 with Arduino appeared first on Open Electronics.

3D-Printed Tactile Zoo: Young Makers Show Off Their Mistakes

A group of children aged 7 to 13 is building a tactile zoo with 3D-printed robotic animals. The creatures, more than 20 in total, are equipped with LEDs, motors, buttons, and gears. At Maker Faire Bay Area, the group will also display their printing errors and failed prototypes. The goal is to show the iteration process that leads from an idea to a working object.

The project turns 3D printing into an educational and interactive activity. Mistakes are not hidden but become an integral part of the exhibition. Visitors can thus understand that making errors is a normal step in the work, not a failure. The maker’s website details how the children faced technical difficulties and what solutions they found.

From choosing the animal to the first print

Each young maker chooses an animal, real, mythological, or completely invented. Then they decide what behavior the creature should have. Some design the animals from scratch, others start from existing 3D models and modify them, cutting or redesigning sections to make room for the electronics. Once the body is ready, they add a function such as an LED, a servo, a motor, a button, or a set of gears.

The group includes eight creatures, among them Em. To make Plate the Armadillo roll into a ball, 11 prints were needed. Each failed attempt taught something new: a joint too tight, a motor off-axis, a wall too thin. The children learned to observe the error and correct it in the next print.

An exhibition you can touch and open

The zoo is not a simple showcase. Visitors can press buttons, flip switches, and open the animals to see the wires, gears, and electronics inside. This choice makes the electronics transparent and understandable even to those who have never opened a device. Next to the finished animals, broken prints, melted parts, and earlier versions are displayed, so visitors can ask what went wrong and how it was fixed.

For those who want to recreate the project, the electronic part can be built with simple, modular components. For example, a servo motor with metal gears can move an animal’s legs, while a shield for controlling RC servos allows managing multiple movements with an Arduino board. For light effects, a WS2812 LED matrix offers endless color possibilities. Finally, a compact board like the Arduino Nano Matter can handle logic and connectivity in a small space.

Mistakes on display: the educational value of failure

The choice to display printing errors is the heart of the project. In a world that shows only perfect results, these children reveal the behind-the-scenes. The broken prints tell the real difficulties of 3D printing: material shrinkage, parts detaching from the bed, motors that don’t find space. Visitors to Maker Faire will be able to talk with the young makers and discover how each problem was tackled.

This approach also changes the way the children work. They learn that a failed prototype is not wasted time, but a step forward. Each error provides valuable information for the next version. The iteration process thus becomes a mental habit, useful not only in 3D printing but in every design activity.

Source: https://view.protectedpdf.com/portal/AMR/LogIn

Related products

The post 3D-Printed Tactile Zoo: Young Makers Show Off Their Mistakes appeared first on Open Electronics.

SO-101 Robot Arm Meets Arduino VENTUNO Q: Local-AI Pick-and-Place

An SO-101 robot arm, originally a desktop toy, now picks and places rubber ducks by reasoning with a vision-language-action model. Dmitry Maslov’s project swaps the original brain for an Arduino VENTUNO Q board, which runs Hugging Face’s SmolVLA model locally. The result shows that robotics tasks combining vision and language, once confined to costly labs, now fit on a 299-dollar board.

Hardware: two processors on one board

The Arduino VENTUNO Q board has a dual nature. On one side sits an SBC system with a Qualcomm Dragonwing IQ8 processor, equipped with an Adreno 623 GPU and a Hexagon Tensor NPU, built for AI processing. On the other side is an STM32H5F5 microcontroller with an Arm Cortex-M33 core running at 250 MHz, which handles real-time servo control. The board offers 16 GB of LPDDR5 RAM and 64 GB of integrated eMMC storage.

The original SO-101 arm carries gearmotors on every joint and two cameras: one fixed overhead and one on the gripper. The images and joint position data go to the Dragonwing IQ8 processor, where the SmolVLA model interprets them. The model was trained with 50 demonstrations of the task of grabbing and moving the rubber ducks.

The SmolVLA model and the system’s numbers

SmolVLA is an open source vision-language-action model from Hugging Face. It processes the camera images and joint data, then produces the commands for the servo motors. All the processing happens locally on the VENTUNO Q board, with no connection to external services. The board costs 299 dollars, against 399 dollars for the Jetson Orin Nano Super Developer Kit, cited as a competitor.

Dmitry Maslov’s system points the way to accessible robotics. What’s more, the fact that the model runs on a commercial board costing less than 300 dollars opens up new scenarios for makers. For anyone who wants to see the project in action, Dmitry Maslov’s video shows the arm grabbing and moving the rubber ducks.

  • Arduino VENTUNO Q board with Qualcomm Dragonwing IQ8 processor and STM32H5F5
  • Hugging Face SmolVLA model running locally
  • 50 demonstrations to train the pick-and-place task
  • Two cameras: one overhead and one on the gripper
  • 16 GB of LPDDR5 RAM and 64 GB of eMMC storage

For anyone wanting to rebuild the project, the trickiest part is the integration between the SBC side and the microcontroller side of the board. The Dragonwing IQ8 processor runs the model, while the STM32H5F5 controls the servos. Communication between the two sides is essential to synchronise vision with movement.

Source: https://youtu.be/T0frBNASr3M?si=Wf1VPI8SoJ6tr18p

The post SO-101 Robot Arm Meets Arduino VENTUNO Q: Local-AI Pick-and-Place appeared first on Open Electronics.