Open Electronics

OVODYO is a desk clock that shows the time by rolling and flipping two 3D-printed spheres shaped like icosahedra. The hours sphere has 12 faces carrying the 12 hours, while the minutes sphere has 12 faces at 5-minute intervals. Six RGB LEDs in the centre indicate the intermediate minutes. The project is by ekaggrat singh kalsi, who describes the build on the project page on Hackaday.io.

The two icosahedral spheres are raised above the clock base by a brass support shaft. An internal drive shaft runs through the centre of the support shaft and drives a set of bevel gears. The gears rotate the outer shells around two axes, periodically cycling through all twelve faces. Only one set of numbers appears upright at a time.

How the bevel gear transmission works

The central shaft drives the central bevel gear. This in turn rotates the 90-degree bevel gear on the lower bevel gear with a 1:1 ratio. The rotation of the 90-degree bevel gear makes the inclined bevel gear rotate on the main bevel gear, with a ratio that flips the sphere.

The two movements follow different cadences. The hours sphere stops every one and a quarter turns, equal to 450 degrees. The minutes sphere stops every 90 degrees, equal to a quarter turn. So the hour advances with a long movement, while the minutes change much more often.

• Hours sphere: 12 faces, stops every 450 degrees
• Minutes sphere: 12 faces, stops every 90 degrees
• Outer diameter of the spheres: about 78 mm
• Overall dimensions: 383 x 78 x 163 mm
• Motors: 15 mm stepper motors with 1:99 gearbox
• Intermediate minute indication: 6 RGB LEDs in the centre

Electronics, Arduino firmware and Hall sensors

The electronic heart is an ATmega8, which drives the motors through a DRV8833. The code is written in the Arduino environment. The base has 3 parts: left and right house the motors and the drive shaft, the centre holds the electronics.

The motors find their starting position using a magnet and a 3144 Hall effect sensor. This way the firmware knows where to restart after every rotation. Since the minutes sphere turns every 5 minutes, to show the intermediate minutes there are 6 RGB LEDs in the centre that light up in sequence and blink. When the last LED finishes blinking the sphere turns and the LEDs reset.

Anyone wanting to rebuild OVODYO has to allow for two stepper motors with gearbox, a dual H-bridge driver and the position sensors. A compact stepper motor with gearbox is the kind of actuator needed to move the spheres without excessive bulk, while for the lighting part you could consider effect RGB LED modules to adapt to the minute indication.

The mechanical assembly remains the most delicate part. The bevel gears must be aligned precisely, because any play adds up along the chain and shifts the numbers relative to the expected position. In addition, the drive shaft must stay centred inside the brass support shaft, otherwise the sphere wobbles as it rotates.

3D printing, dimensions and calibration of the spheres

The two icosahedral spheres and the outer shells come from 3D printing. The outer diameter of the spheres is about 78 mm, so each face must stay readable from across a desk. Calibration of the starting position relies on the magnet and the Hall effect sensor, which give a fixed reference on every cycle.

The overall dimensions of the clock are 383 x 78 x 163 mm. The base is divided into three parts: on the left and right are the motors and the drive shaft, in the centre the electronics. This division simplifies both assembly and maintenance, because the drivers can be reached without dismantling the spheres.

Anyone wanting to follow the project will find the build story signed by ekaggrat singh kalsi on the project page on Hackaday.io. The starting point, however, remains the mechanics: without accurate alignment of the bevel gears, no firmware keeps the numbers upright.

Source: https://hackaday.io/project/206586-ovodyo

Related products

• NEMA 11 stepper motor – 1 A
• LED DJ Flower Effect 4 x 3 W RGBA

The post OVODYO: the desk clock that rolls two icosahedra appeared first on Open Electronics.

Built around Arduino and a special breakout board, it drives a relay when it detects and recognises a previously paired RFID tag; it is also suitable for reading contactless NFC cards.

RFID and NFC: a technology that is now widespread

Recognition and access control performed by turnstiles, gates and motorised doors driven by RFID electronic systems is now an established reality in many fields, involving both companies and apartment buildings; by now many of us carry in our pocket a passive wireless tag (transponder) that lets us enter the workplace, buy a drink from a food vending machine, get into the gym, but also open the front door of the house and clock in at work. The same technology, known as RFID, is the basis of the most recent and now widespread contactless electronic identification and payment systems, also known as NFC, built into debit cards or into mobile devices such as smartphones and tablets.

We devote the project you find in these pages to RFID/NFC technology; it is both a complete application for access control and a development and prototyping platform for very short range identification systems based on passive or active transponders (tags).

How a passive RFID tag works

Before getting into the heart of the project, let us make a preamble that helps in understanding how RFID works: systems of this kind behave as true transponders and are typically passive, meaning that the portable identification device (called a tag) only acts when it is excited by the fixed exciter system and has no autonomous power source of its own. Here is how it works: the detection system has an exciter circuit that generates an electromagnetic field, typically at low frequency (normally around 125 kHz, but systems operating at higher frequencies exist) and radiates it through a coil over a short distance; this ranges from a few cm for contactless payment systems and NFC (where transmission must be kept as narrow as possible to avoid fraudulent interception by hackers and malicious people) to a few tens of cm for pedestrian and vehicle access points.

Induction and identification of the tag

When a tag enters the electromagnetic field, an alternating voltage is induced in the coil inside it; this is rectified by a diode and charges a capacitor, between whose plates enough energy remains to run the tag’s logic. That logic is based on an encoder which, once powered, generates an identification code (usually unique) that drives the base of a transistor; at every logic high level the transistor conducts and electrically “loads” the coil, causing an induced reaction in the coil of the exciter circuit, as a result of which each conduction increases the current draw.

Through a sense resistor the exciter circuit detects the pulses and reconstructs the code produced by the encoder, thus managing to identify the tag. During the periods when the transistor loads the coil, the diode prevents the capacitor from discharging, so that the energy stored in it keeps the encoder running for the time needed to complete identification.

The project

That said, let us look at what the RFID identification system consists of; essentially it is a programmable transponder electronic lock with a user interface for easy use.

The project is based on an Arduino Uno fitted with an LCD Shield, a 5 volt relay module and a module specifically for reading RFID tags and NFC in general. The module in question ( Fig. 1 ) is the PN532, a NFC/RFID tag reader/writer (writing applies to active tags) with a coil integrated in the PCB, I²C, SPI and HSU (High Speed UART) communication interfaces, plus an indicator LED. The board, measuring 43x41x4 mm, can work as an RFID card reader/writer, as an NFC reader for Android smartphones (it only works with some types) and in wireless peer-to-peer mode between two similar devices.

The PN532 module: interfaces and supported tags

The circuit works with a voltage from 3.3 to 5 V and the communication interface, available on a row of pads on one side of the board, is selected via dip-switches as shown in Table 1 . In reality the board, as you can see in Fig.1 , carries two rows of contacts: one with four pads and one with 8; together they form both the data interfaces and the service connections, that is, power supply and control signals.

The row of four pads carries the I²C bus, namely SCL, SDA, common ground and power supply; the 8-pad row carries the complete SPI bus, so SCK, MISO, MOSI and SS, plus Vcc, GND, reset (RST0) and IRQ, which are pins to be used for direct control from a microcontroller: in particular IRQ provides a signal every time a tag detection is made, to request the microcontroller’s attention.

Supported tags and reading distance

Among the tags supported by the module are Mifare 1k, 4k (Mifare is a standard created by NXP Semiconductors and widely used in RFID and NFC cards), Ultralight and DesFire cards, as well as ISO/IEC 14443-4 cards such as CD97BX, CD light, Desfire, P5CN072 (SMX), Innovision Jewel cards such as IRT5001 and also FeliCa cards such as RCS_860 and RCS_854. The ISO/IEC 14443 standard provides for operation with an excitation electromagnetic field at a frequency of 13.56 MHz.

The maximum tag capture and communication distance for our PN532 module is typically between 30 and 70 mm. The module can be used with Arduino to build access control devices, etc., thanks to the library provided for managing it.

The library for managing it is supplied by Adafruit and can be downloaded both from the manufacturer’s site and from the page www.futurashop.it/NFC-RFID?search=RFiD (the library is called adafruit pn532).

Practical build

Good, let us now move on to assembling the system components; to sum up, the hardware as a whole consists of:

• Arduino UNO;
• LCD Keypad Shield (1686-SHIELD-LCD);
• RFID module (2846-PN532);
• 5V-10A relay module (2846-RELAY1CH).

The whole set is available from Futura Elettronica (online shop www.futurashop.it) and the product codes are those shown in brackets. Once the hardware has been obtained, it must be connected with Arduino jumpers following the connections given in the wiring diagram you find in these pages.

As for the RFID module, the connections to Arduino, or rather to the LCD Shield, are:

• the SCK contact goes to pin 13 of the shield;
• the MISO contact goes to pin 12 of the shield;
• the MOSI contact goes to pin 3 of the shield;
• the SS contact goes to pin 2 of the shield;
• the VCC contact goes to the 5V pin of the shield;
• ground (GND) goes to the GND pin of the shield.

Relay connections and user interface

The relay module, on the other hand, connects with its 5V to the 5V of the Arduino (together with the power supply of the RFID module) and GND to a free GND pin of the Arduino (or of the LCD Shield); the relay’s control input must be connected to pin D5 of the Arduino (of the Shield).

To manage the LCD shield, which forms the user interface of the system, the sketch includes the appropriate library (also downloadable from www.futurashop.it), which allows the alphanumeric display to be controlled and the buttons to be read.

Speaking of buttons, in the project they have the following functions:

• UP and DOWN let you move between menu items;
• SELECT is used to choose a menu item;
• DOWN starts interrogation of the transponder;
• LEFT, from the display’s initial screen, lets you test the output relay;
• RST; returns you to the initial screen.

To use the system we recommend enclosing all the electronics in a plastic case machined so that the buttons protrude and the LCD display remains visible; the RFID board can be glued with silicone sealant just below the front panel of the case, which, being plastic, does not interfere in any way with the electromagnetic field generated by the coil or with detection of the induced reaction.

That said, we can look at the system’s features.

Start-up and main menu

So let us take a look at how the whole thing works, starting by saying that it must be powered through the DC jack of the Arduino Uno with a mains power supply able to deliver at least 500 milliamperes and a voltage of 9 to 10 volts.

As soon as the device is powered up, the LCD display shows the words “Access Card Reader” ( Fig. 2 ).

The message “Lettura: Lettura in corso” (Reading: reading in progress) is then shown. The system will then read any tag present within range (the electromagnetic field) of the module, replying with a message granting or denying authorisation. Of course, all this only makes sense if the system has previously stored one or more tags, otherwise authorisation will always be denied; when authorisation is granted, the relay is activated.

From the main screen, pressing the “DOWN” button takes you to the menu, which offers the following options:

• Read Mode (Fig. 3), corresponding to the initial tag reading procedure;
• Edit Mode (Fig. 4), corresponding to the procedure for learning a tag and writing it to the Arduino memory;
• Delete Mode (Fig. 5), which lets you delete all the tags already learned whose code is in the Arduino memory.

Use the “UP” and “DOWN” buttons to scroll through the options, and press “SELECT” to select one. Press “RST” to return to the initial procedure at any time. While the “Main menu” screen is displayed you can press the “LEFT” button to test that the relay works correctly.

Edit mode: registering a new tag

Let’s briefly look at the modes, starting with Edit Mode: once selected, it lets the user register a new tag.

The procedure, which starts when the display shows the screen in Fig. 4, requires you to pass the tag to be learned over the module at a maximum distance of 7 cm, at which point the system automatically acquires its code and saves it among the authorised ones. If the tag is not detected (you will notice because the display content does not change), try passing it at a shorter distance until it is detected.

Bear in mind that the module can recognise certain types of tag, which are also the most common ones, so the tags you want it to learn must be among those summarised a few paragraphs back.

In any case, if the storage operation succeeds, the display will show the message “TESSERA SALVATA” (Fig. 6).

At this point, if you stay in Edit Mode and pass the same tag you have just learned again, its code is removed from memory; this deletion state is confirmed by the message “TESSERA RIMOSSA” (Fig. 7).

Delete mode and read mode

Let’s move on to Delete Mode, which starts when the display shows the screen already seen in Fig. 5; from there, to remove all the previously learned tags from memory you have to press the SELECT button; once you do, the display shows the screen visible in Fig. 8.

When the operation is complete you have to press the “RST” button to return to the main menu. Once the memory has been cleared, the display shows the screen visible in Fig. 9.

We finish with Read Mode: when you enter it from the main menu (with the screen of Fig. 3 on the display) and pass a tag in front of the module, what is shown in Fig. 8 appears.

In practice, when the module detects a tag within its field of action it interrogates it, and during this phase the display shows the message of the aforementioned figure. When the read is complete, two conditions shown in Fig. 9 can occur: if the tag is one of those already learned in Edit Mode, it is recognised and the display shows the message Acc. Consentito, together with the relay switching on. If instead the tag is not recognised as one of those already learned, Acc. Negato is shown and nothing happens to the relay.

Customising the firmware

These are all the functions provided, but of course by “tinkering” with the firmware you can implement others; for example, you can add various kinds of local signalling to the relay output, such as a buzzer that sounds when a tag is recognised or an LED that lights up when the aforementioned condition occurs.

If you want, without “tampering” with the Arduino sketch you can add an LED or a buzzer by connecting them in parallel (the LED requires a limiting resistor, typically 270 ohm…) to the relay coil, that is in series with the collector of an NPN transistor connected in common emitter with its base driven by the Arduino Uno output that controls the relay board.

The firmware

Having looked at the hardware and described how it works, let’s spend a few lines on the firmware that manages the electronic lock.

The sketch to load into the Arduino Uno board is quite bulky, so in Listing 1 we only reproduce the most significant portion, the one dealing with normal operation. You can download the whole sketch (.ino file) together with the files for this issue of the magazine.

Listing 1

if (success) { // Display some basic information about the card if(debug) { Serial.println(“Found an ISO14443A card”); Serial.print(“ UID Length: “);Serial.print(uidLength, DEC);Serial.println(“ bytes”); Serial.print(“ UID Value: “);nfc.PrintHex(uid, uidLength); } cardid = getCardIdAsInt(uid,uidLength); //is MASTER if (cardid == uid_master) { master_mode = 1; master_mode_counter = 0; if(debug) Serial.println(“MASTER detected, going into MASTER MODE “); } // is not MASTER else { int32_t findUid = findRfidInEeprom( uidLength, uid); // is MASTER MODE, include or exclude RFID from storage if(master_mode == 1) { // card rfid already exists so exlude it from storage if( findUid != -1) { if(debug) { Serial.println(“removing card from eeprom”); Serial.println(“ “); lcd.setCursor(0,1); lcd.print(“Tessera Rimossa “); delay(2000); lcd.setCursor(0,1); lcd.print(“Modifica… “); } deleteRfidfromEeprom(findUid, uidLength); } // card rfid not found in storage so include it else if (findUid == -1) { // check if space to store rfid available int32_t storageAddress = getEepromStorageAddress(uidLength); // storage available if(storageAddress >= 0) { if(debug) { Serial.print(“storing card in position = “);Serial.print(storageAddress);Serial.println(“ “); } // storing card writeRfidToEeprom( storageAddress, uidLength, uid); lcd.setCursor(0,1); lcd.print(“Tessera Salvata “); delay(2000); lcd.setCursor(0,1); lcd.print(“Modifica… “); } else { // no storage space available or error if(debug) Serial.println(“memory full or error”); } } master_mode = 0; } // no MASTER MODE, authorise or deny door access else { // card authorised if( findUid != -1) { // open door // write routine for door access, example set an output to high if(debug) Serial.println(“Card authorised”); lcd.clear(); lcd.setCursor(0,0); lcd.print(“Lettura:”); lcd.setCursor(0,1); lcd.print(“Acc. Consentito”); digitalWrite(11,HIGH); delay(2000); digitalWrite(11, LOW); lcd.setCursor(0,1); lcd.print(“Lettura in corso”); } else { // deny access if(debug) Serial.println(“Card not authorised”); lcd.clear(); lcd.setCursor(0,0); lcd.print(“Lettura:”); lcd.setCursor(0,1); lcd.print(“Acc. Negato”); delay(2000); lcd.setCursor(0,1); lcd.print(“Lettura in corso”); } } } delay(500); }

As usual the firmware starts with the definition of the I/Os and the inclusion of the libraries, of which there are two in this project: the one for the RFID reader and the one for the LCD Shield.

The setup follows and then we come to the portion shown in the aforementioned Listing 1, where, depending on the mode we have set using the shield’s buttons, the card (the RFID tag) will be stored, deleted or, in the case of “normal” operation, simply read to compare its identification code with the data in memory; in this case, if the code read is already present in the Arduino Flash memory, the relay on the board is activated.

The relay is activated in pulse mode, that is monostable, and the time it stays in the “energised” state (and therefore with the relay contact closed) is 2 seconds, as defined by this portion of code:

digitalWrite(11,HIGH); delay(2000); digitalWrite(11, LOW);

where digitalWrite (11, HIGH) is the instruction that activates digital line 11 (which controls the relay board), delay(2000) sets the time it stays at high level through the delay with which output D11 returns to low level and, finally, digitalWrite (11, LOW) brings the aforementioned Arduino line back to logic low.

If you want, you can change the relay activation time by changing, in the sketch, the value in brackets after delay, remembering that it is in milliseconds.

Conclusions

So we have reached the end of the description of this project, which, although it was born as an electronic lock with a transponder key, can be used for a variety of applications and, with a few tweaks to the firmware, can find use in identification via NFC thanks to the full support provided by the sensor board and its pairing with a Personal Computer.

Related products

• RFID NFC 13.56 MHz Read-Write Module
• LCD keypad shield for Arduino
• NFC RFID reader with two transponders

The post NFC/RFID Lock with LCD appeared first on Open Electronics.

The JetKVM Mini delivers KVM over IP for 39 dollars. The board captures a computer’s video, encodes it in H.264 and sends it to the host over WebRTC. It also drives keyboard and mouse as if they were physically connected. Compared with the original JetKVM, which relied on Linux running on a Rockchip RV1106G3 SoC, the Mini uses an ESP32-P4X for video capture, H.264 encoding, USB and the rest of its functions. The project therefore moves to RISC-V and to a FreeRTOS firmware based on ESP-IDF.

The Mini variant has a 100 Mbps RJ45 Ethernet port. The Mini W adds dual-band WiFi 6, Bluetooth and 802.15.4 for Zigbee and Thread thanks to an ESP32-C5 module. Pricing is 39 dollars for a single unit and 33 dollars per unit in a three-pack bundle. The Mini W costs 42 dollars, or 36 dollars per unit in the three-pack bundle.

ESP32-P4X: dual-core 400 MHz RISC-V CPU and 32 MB of PSRAM

The heart of the Mini is Espressif Systems’ ESP32-P4X. Inside there is a 32-bit dual-core RISC-V HP CPU running at up to 400 MHz, with an AI instruction extension and single-precision FPU, plus a RISC-V LP MCU core at up to 40 MHz. Memory includes 768 KB of HP L2MEM, 32 KB of LP SRAM, 8 KB of TCM, 32 MB of PSRAM, 128 KB of HP ROM and 16 KB of LP ROM. For storage there is 16 MB of flash and a microSD card slot, used for virtual media.

The VPU supports the H.264 and JPEG codecs, with a Pixel Processing Accelerator and a 2D DMA controller. The GPU is a 2D Pixel Processing Accelerator. The display is a 240 x 240 pixel non-touch IPS panel. The HDMI input goes up to 720p60 or 1080p30, with 4K supported through JetKVM OS Services. The H.264-encoded stream is sent to the host over WebRTC.

USB ports, 5V/500mA power and 42 x 42 x 23 mm dimensions

On the connectivity side, the Mini offers two USB 2.0 Type-C ports. The main one runs at 480 Mbps, the second at 12 Mbps. Power is 5V/500mA through a USB Type-C port. Dimensions are 42 x 42 x 23 mm, so the device fits in a fist. Those who want to rework the firmware development side will find in the catalogue the development board with Wi-Fi, Bluetooth and USB Type-C connector, useful for getting familiar with the ESP32 ecosystem before getting hands-on with the KVM.

• 32-bit dual-core RISC-V HP CPU up to 400 MHz with AI extension and FPU
• RISC-V LP MCU core up to 40 MHz
• 768 KB of HP L2MEM, 32 KB of LP SRAM, 8 KB of TCM
• 32 MB of PSRAM, 128 KB of HP ROM, 16 KB of LP ROM
• 16 MB of flash and microSD slot for virtual media
• 240 x 240 pixel non-touch IPS display
• 100 Mbps Ethernet over RJ45 in the Mini variant
• Dual-band WiFi 6, Bluetooth and 802.15.4 in the Mini W via ESP32-C5

The software runs on FreeRTOS with the ESP-IDF framework. Capture and encoding go through JetKVM OS services, while transport to the browser relies on WebRTC. Those who want to follow development and read the code will find the project’s code repository, where the firmware is published and updated. Open source firmware was planned from the start, so the Mini also suits anyone who wants to modify the capture logic or add features.

What a KVM over IP like the JetKVM Mini is for

A KVM over IP is useful when the computer to be controlled is far away or has no operating system running. The Mini gets into the BIOS, the boot screen or the bootloader, because it works at the level of the video signal and keyboard and mouse emulation. That is why it is used for rack servers, for mini PCs without a monitor and for test machines in the lab. The 100 Mbps Ethernet port is enough for a 1080p30 stream, while the W variant frees you from the network cable.

The 240 x 240 pixel IPS display shows status information directly on the device, without opening the browser. The microSD slot also lets you mount ISO images as virtual media, so an operating system can be installed remotely. Finally, the second USB 2.0 Type-C port at 12 Mbps handles the emulation peripherals. Those who want a starting point for their own IoT experiments will find in the catalogue the development kit for IoT projects with WiFi 6 and integrated peripherals, a way to get practice with the radios in the Espressif family.

Source: https://github.com/jetkvm

Related products

• ESP32 – Development board with Wi-Fi, Bluetooth and USB Type-C connector
• ESP32-C6-Zero Wi-Fi 6 IoT Development Kit

The post JetKVM Mini: $39 KVM over IP Built on ESP32-P4X appeared first on Open Electronics.

VolAnti is an open source acoustic drone detector: it listens to the sound of the propellers instead of the radio signal. That is why it also works against fibre-optic FPV drones, which emit nothing and stay invisible to any receiver. The project is by Agam Rossen and it only detects and alerts, with no jamming, interception or countermeasures.

The heart is an ESP32-S3. Four ICS-43434 MEMS microphones are arranged in a cross, 79 mm from corner to corner, and synchronised from a single source. The four streams are summed: at these frequencies 79 mm is a tenth of a wavelength, so sound from any direction adds up in phase while each capsule’s own noise does not. The gain is about 6 dB of signal-to-noise ratio for free, with a nearly omnidirectional response.

The spectrum is computed with a 2048-point FFT every 512 samples at 16 kHz, that is one window every 32 ms. The detector keeps a running picture of what the site normally sounds like at every frequency and subtracts it. Quiet things are learned in about 6 s, loud broadband bursts in less than a second.

The harmonic comb of the propellers and the six consecutive windows

A propeller with B blades at R revolutions per second generates a harmonic comb with evenly spaced peaks and silent valleys. For every candidate speed from 70 to 2000 Hz the firmware sums the energy on the teeth of the comb, subtracts that in the valleys, normalises and keeps the best score. On top of that the same speed has to win six consecutive windows within 2%: a single high-scoring frame means nothing, noise does not behave like that, a rotor does.

Four independent detectors work on the same spectrum and the alarm is whichever one is sure first. The measured latencies vary a lot from one to another:

• detector 1, fast comb: 0.23 s latency
• detector 2, slow comb: 1.4 to 4 s latency
• detector 3, envelope wash: 1 to 3 s latency
• detector 4, no-floor comb: 5 to 15 s latency

On 6 September 2026 tier 4 triggered the alarm at 104.2 m, 114 yards on the map. On 21 August, on open ground with variable wind, detection was at 14 m with loaded propellers and no false alarm all day. On 28 August, with the first production board, the detector output was identical to the reference on the golden vectors, with a worst frame of 29.4 ms against the 32 ms budget over 1,938 frames and no overrun.

Power, e-paper screen and an 18-byte LoRa packet

Power starts from a 1S 2500 mAh LiPo, charged by the BQ24074 and regulated to 3.3 V by the TPS63020 buck-boost. The claimed runtime is 18-22 h on a single charge. The case measures 91 mm and also houses an e-paper screen. The radio is a Ra-01H module: the LoRa alarm packet is 18 bytes, so a few dozen bytes are enough to let a second VolAnti know there is something in the air.

The frequency has to be set for the country of use: 868 MHz in the UK and the EU, 915 MHz in the United States. In still air and at a quiet site you can expect 100 to 200 m. At a windy or noisy site you can expect 15 to 50 m, and above 8 m/s detection is assumed to be degraded. So far there have been no false alarms in the field sessions.

Rebuilding it takes very little. The breadboard build costs about £35-45 and an evening, while the complete unit costs about £50-80 and a weekend. In Agam Rossen’s repository you will find the firmware, the live simulator, the breadboard guide, the complete unit guide, the flashing instructions, running multiple units, the audio test and the website source.

Assembly needs no exotic tools: soldering, a bit of patience and the willingness to tune the detector to your own site. A school or a farm can build and repair it themselves, without depending on a supplier. For anyone who wants to start from a development board, the ESP32-C6-Zero IoT kit is an option for practising with Wi-Fi 6 and built-in peripherals, while a round ESP32-S3 HMI display with a touch knob and LVGL graphics can serve as the control interface in a more ambitious version.

Source: https://github.com/agamrossen/VolAnti

The post VolAnti: the open source acoustic drone detector that listens to propellers appeared first on Open Electronics.

The TP4056 module with protection charges single-cell 3.7 V Li-Ion and Li-Po batteries. It also protects them from overcharge, deep discharge and short circuit. Compared with the basic version it adds the DW01A chip. AdriRobot describes its schematic, the charge current and a few practical hookups. We already covered the version without protection in Li-Ion Charger with the TP4056 Module.

The variants of the TP4056 module

Several boards are built around the TP4056. The one without protection only handles charging. The one with protection, the subject of this article, adds the DW01A and a dual MOSFET. That way it shields the battery from overcharge, deep discharge and short circuit.

There are also versions with an MT3608 step-up converter, adjustable from 4 to 28 V. The J5019, also called HW-357, does not protect the battery. The LX-LCBST, on the other hand, also has an HM5434 protection chip.

How the TP4056 module works

The TP4056 uses the CC/CV algorithm, constant current and constant voltage, typical of lithium-ion batteries. Charging happens in three phases. First, below about 2.9 V, it applies a reduced current (trickle charge) to bring the cell back to a safe level. Then it delivers the set current, up to 1 A. Finally, when the battery reaches 4.2 V, it holds the voltage and gradually reduces the current until charging ends.

The module is preset to 1 A, suitable for cells such as the 18650. The input is Micro USB or USB Type-C at 5 V. Two LEDs also show the status: red while charging, blue or green when charging is complete. The dimensions are 22 × 17.3 × 3.6 mm, the weight 2 g.

• input: 4.5 to 5.5 V;
• charge current: up to 1000 mA, adjustable with a resistor;
• end-of-charge voltage: 4.2 V with 1% tolerance;
• protections: overcharge at 4.3 V, deep discharge at 2.4 V, overcurrent at 150 mV;
• operating temperature: -10 to +85 °C.

The schematic: TP4056, DW01A and FS8205A

In the charging section the TP4056 is a linear controller for single cells. Resistor R3, 1.2 kΩ, sets the current to about 1 A. Two LEDs with 1 kΩ resistors indicate charging and end of charge, while a 0.1 µF capacitor stabilises the chip. Protection is handled by the DW01A, which monitors the cell, and by the FS8205A, a dual MOSFET. When the DW01A detects an abnormal condition, it turns off the MOSFETs and isolates the load.

There are three pairs of terminals. IN+ and IN- take the 5 V, as an alternative to the USB connector. B+ and B- go to the battery, while OUT+ and OUT- power the load. The load must be connected to OUT+ and OUT-, not directly to the battery, otherwise the protections will not kick in.

Setting the charge current

The current depends on resistor Rprog on pin 2 of the TP4056. The formula is I = Vprog / Rprog × 1200, with Vprog equal to 1 V. With 1.2 kΩ you get 1 A. With 2 kΩ it drops to about 580 mA and with 3 kΩ to 400 mA. With 5 kΩ the current is 250 mA, with 10 kΩ it is 130 mA. For a small battery, for example 500 mAh, it is better to raise Rprog: the current falls and damage is avoided.

Practical hookups and use with Arduino

In the basic hookup the battery goes to B+ and B-. The 5 V comes in from USB or from IN+ and IN-. Also, only one battery is charged at a time, respecting the polarity. At 1 A the chip can get hot, so it is better to mount it in a ventilated spot. While charging, powering a heavy load such as a motor is not recommended. The module might in fact fail to recognise the end of charge.

For a 3.3 V microcontroller, the OUT+ and OUT- output feeds a CN3903 DC/DC converter. The converter keeps the voltage stable even when the battery drops from 4.2 to 3.0 V. The solution is intended for ESP8266, ESP32-C3, STM32 and IoT sensors. For higher voltages the same output can feed an MT3608 step-up, adjustable from 5 to 28 V. It is useful for custom power banks and portable instruments. In both cases the converter must be connected to OUT+ and OUT-.

With an Arduino UNO you read the charge status from pins CHRG (7) and STDBY (6) of the TP4056. A low level indicates charging in progress and charge complete respectively. With a network-connected board such as an ESP32-C3, the battery can also be monitored remotely.

If the battery does not charge, check the voltage on VCC, which must be between 4.0 and 8.0 V. Then check the value of Rprog and the connection to the BAT and GND pins. If instead the chip gets hot, reduce the current or improve the heat dissipation.

There is the 1A charging module for lithium battery, Type-C, with protection and USB Type-C input.

Source: the original article by AdriRobot also includes the sketch for Arduino UNO and the TP4056 pin table.

Related products

• 1A charging module for lithium battery – TYPE-C

The post TP4056 Module with Protection: Li-Ion and Li-Po Charger appeared first on Open Electronics.

A language model with 14.3 million parameters runs entirely on an ESP32-S3 microcontroller and makes every high-level decision for a small virtual fish tank: eat, hide, explore, socialize, rest or flee. The brain is a 7.56 MB file read directly from flash, with no network and no cloud. The tank lives on a 1.8-inch AMOLED display you can hold in one hand. So no server, no API, no connection is needed: the fish decides on its own, on the spot.

The project shows that a model distilled from roughly 26 billion parameters can run on a microcontroller costing a few dollars. The student, called pocket-tank, has 14.3 million parameters with dimension 384, 8 layers and 8 heads: about 1,818 times fewer than the teacher. In fp32 it would weigh 57 MB, in 4 bit it drops to 7.56 MB. The vocabulary is 58 tokens, a closed-schema lexicon, against the teacher’s roughly 262K tokens.

Three separate layers compiled identically in the simulator and the firmware

The architecture is split into three layers, all in common/ and compiled identically in the simulator and the firmware: the reflexes layer (tank.c), the LLM advisor (llm/) and the progression layer (progression.c). The reflexes layer handles physics, steering, schooling, touch gestures, feeding, hunger economy, vegetation and algae. It runs every frame and never blocks on the model. The LLM advisor, on the other hand, is a 4-bit inference engine in the style of llama2.c, with a word-level tokenizer and a shared state encoder.

The model runs on the ESP32-S3’s second core with SIMD dot products and quantized activations in internal SRAM. The weights are memory-mapped from flash and are never copied. That’s why the tank stays smooth while the model thinks. The fish are re-queried only when their situation changes significantly: that way four or six fish share a single brain.

Each fish periodically describes its situation to the model as a single line of text: hunger, energy, fear, who is nearby, its personality.

The model completes the line with a goal and an urgency.

The reflexes layer turns that goal into movement.

The model samples its own distribution instead of always taking the most likely answer.

When the top two choices are close, the fish visibly hesitates before committing.

There are no fallback heuristics that override the decision.

The training numbers tell the story of the distillation quality. The model was trained on 51,162 situations labeled by the teacher. The student picks the teacher’s goal in 75% of cases, while the teacher agrees with itself in 82% of cases. A hungry fish chooses seek_food at least 89% of the time, across all personalities. So the 4-bit quantization did not destroy the learned behavior.

The board, the 8 MB partition and the bench-measured timings

The firmware is based on ESP-IDF v5.4 with 8 MB octal PSRAM. The target board has 16 MB of flash and 8 MB of PSRAM. The model lives in a dedicated 8 MB raw partition and only needs to be flashed once, at address 0x290000. On the hardware side the project uses a Waveshare ESP32-S3-Touch-AMOLED-1.8 with ESP32-S3R8, a 368×448 AMOLED display, capacitive touch, IMU, PMIC and RTC. The board with screen and battery actually costs around 35 dollars.

On the real board a decision takes about 3.6 s at 12 tokens per second, with the tank rendered at 25-30 fps in parallel on the other core. In QEMU emulation a decision takes about 2.3 s. The tank starts with two fry and grows to as many as five fish. A meal lasts five or six minutes while awake. Holding a finger on the glass for three seconds calls over the fish that trust you. The reset prompt disappears after twenty seconds of silence.

For anyone who wants to rebuild the project, the software chain includes ESP-IDF v5.4, a 4-bit inference engine in the style of llama2.c, LVGL v9.2.2, SDL2, ESP Web Tools, the scripts tools/make_installer.py and tools/director.py, and QEMU in the Espressif version. Those who want to look at a board with an integrated display and LVGL graphics can also consider other options, but the heart of the project remains the 8 MB raw partition and the 4-bit engine. The code, the scripts and the flash procedure are collected in the project code repository.

Anyone who wants to replicate the sensor part can consider a 9-axis IMU module to add orientation and movement to the tank, or an RTC circuit on an I2C bus to keep track of time even when the board is off. Both components already appear on the target board, so the wiring stays consistent with the existing firmware.

Source: https://github.com/mediacutlet/pocket-tank

Related products

• Blebrick 9-Axis IMU
• I2C Real-Time Clock IC

The post A 14.3-million-parameter language model runs on an ESP32-S3 and decides the life of a virtual aquarium appeared first on Open Electronics.

A 16-bit relay computer that computes Pi, the square root of 60000 and Dijkstra’s shortest paths. It sounds like an exercise in style, but it is a real machine, built by Peter with self-holding relays running at 24 V. The CPU is an accumulator-register design: all math and load/store operations go through the ACCU. The instruction set has 19 commands, enough to run algorithms that are usually seen on far more generous machines.

Computing Pi to 2 decimal places took a little over 8 minutes and 1,377 instructions. The integer square root of 60000 came out as 244, that is 1111 0100 in binary. These numbers say two things: the machine is slow, but the project is complete. In fact it is not a partial prototype, but a system with memory, peripherals and a 32×32 LED matrix display connected at the output.

The program counter, the SR register and the three addressing modes

The program counter has a dedicated adder capable only of adding 1. That is why the PC_HR register exists: the modified PC cannot be written directly to its own value plus 1, so an intermediate holding place is needed. The SR register stores the return address, so the CALL and RET instructions handle a single level of subroutine. No stack is implemented, and with 19 instructions none is needed.

The CPU supports 3 addressing modes. With LD X the ACCU is loaded with the word at the address following the opcode. With LD M(X) it loads the data at the address contained after the opcode. With LD M(M(X)) we reach indirect addressing. So the programmer already has the tools for pointers and tables, not just for adding two numbers.

• 16-bit CPU with ACCU accumulator register
• 19 instructions in the CPU instruction set
• 3 addressing modes, including indirect M(M(X))
• SR register for one subroutine level with CALL and RET
• Clock made up of 4 different pulses
• Relay supply at 24 V
• Memory implemented with an Arduino
• Clock generator built with a second Arduino
• 32×32 LED matrix display
• 16-bit I/O register and 16-port input register

Why the clock has 4 pulses and the memory sits on an Arduino

All registers made with self-holding relays must be cleared before any write. Consequently the clock is not a normal digital clock, but is made up of 4 different pulses. This is the part that surprises anyone trying to rebuild the project: the clear and load sequence has to be designed together with the logic, not afterwards.

The memory is not relay-based. It is implemented by an Arduino, and a second, separate Arduino builds the clock generator. That way the project stays within reach of anyone with a normal workbench: the relays do the electromechanical part, the microcontrollers do the rest. In addition, the I/O register is 16 bits and the input register is 16 ports.

Before soldering, Peter verified everything in simulation. The full-system simulation runs in the game Logic World, used to design the system and try out variants. Then there are the Excel macros, which execute the code step by step and show registers and memory up to a breakpoint. Finally the VHDL code on FPGA emulates the relay system design. Anyone who wants to follow the same path will find the full story on the page for Peter’s project on Hackaday.io, with the tests carried out and the variants discarded.

For anyone who wants to replicate the display part, the catalogue offers an FPGA-based development board to drive LED matrices, while a small 2.42-inch OLED module with 128×64 resolution and SPI or I²C interface can serve as a status panel for registers and memory. They are two different routes: the first stays consistent with programmable logic, the second costs little and connects with just a few wires.

Rebuilding this relay computer means starting from the 4-pulse clock and the accumulator register. Without those two pieces nothing runs, not even with 19 perfect instructions. The rest is patience: 24 V on the relays, flyback diodes, one Arduino for the memory and one for the clock.

Source: https://hackaday.io/project/189725-homebrew-16-bit-relay-computer

The post A 16-bit Relay Computer Runs Pi and Dijkstra appeared first on Open Electronics.

ROHM Semiconductor announces that its innovative power semiconductor solutions are being used in the electric vehicle platforms of a world-leading premium car manufacturer. In BMW’s “Neue Klasse”, ROHM’s SiC (silicon carbide) chips support the efficiency, performance and reliability of the vehicle’s electric powertrain systems.

Integrating SiC MOSFETs into the BMW Neue Klasse

The high-performance components integrated into the vehicle support key power electronics functions and are designed to ensure high energy efficiency as well as reliable operation under the harsh operating conditions typical of the automotive sector. In this way, they make an important contribution to optimising the range, charging performance and overall energy efficiency of electric vehicles.

Statements

“The integration of our SiC MOSFETs into the Gen 6 of BMW’s electric vehicles, better known as the Neue Klasse, highlights ROHM’s technological expertise in power electronics for the automotive sector,” says Wolfram Harnack, President of ROHM Semiconductor GmbH: “We are proud to contribute, together with the BMW Group, to the progress of next-generation electric mobility through our SiC technology. This underlines our long-term commitment to supporting our automotive customers with high-quality products and extremely high reliability.”

ROHM’s experience in the automotive sector

ROHM has extensive experience in the development and production of power semiconductors for automotive applications and works closely with vehicle manufacturers and Tier 1 suppliers worldwide to actively promote the electrification and decarbonisation of mobility.

For further information, visit the ROHM website.

The post ROHM Supplies SiC Chips for BMW Neue Klasse Electric Powertrain appeared first on Open Electronics.

Capturing 3D images without lenses is possible. The okooptics project proves it, starting from a Raspberry Pi camera whose lens is removed and over whose sensor a thin layer of Scotch tape is applied. The tape is not a market-stall trick: it acts as an optical diffuser and imprints a known point spread function on the scene. With the right deconvolution maths, the initially blurry capture turns into a real image.

The interesting part comes next. By weighting the point spread function across three dimensions and adding a directional bias to the process, an effect similar to a shift in the camera position is created. That way the scene reveals itself from a slightly different angle, without physically moving anything.

How deconvolution works on a blurry capture

The workflow starts with a Raspberry Pi camera without the normal lens element installed. In place of the lens, a thin layer of Scotch tape is applied over the sensor. That veil diffuses light in a controlled way, so every point in the scene leaves a blob of predictable shape on the sensor. The shape of the blob is the point spread function.

• You start with a Raspberry Pi camera without the lens element.
• In place of the lens, a thin layer of Scotch tape is applied over the sensor.
• The tape acts as a diffuser and defines the point spread function.
• Deconvolution recovers a real image from the initially blurry capture.
• Weighting the point spread function across three dimensions extends the concept to 3D.
• Adding a directional bias simulates a shift of the camera.

Once the point spread function is known, deconvolution is a linear algebra problem. The software takes the blurry capture and the diffuser function, then estimates the original image. It is the same idea behind many computational imaging techniques, but here the diffuser is a piece of tape costing a few cents instead of an optical element designed in a lab.

The directional bias that shifts the viewpoint

The jump to 3D lies in the weight given to the point spread function. Instead of treating it as a flat function, the project weights it across three dimensions. What is more, by adding a directional bias to the process, an effect similar to a shift in the camera position is created. The result is a view from a slightly different angle of the objects in front of the camera.

Rebuilding the project takes only a few parts. The Raspberry Pi camera is the heart of the system, and the Scotch tape is the diffuser. Anyone who wants to start from scratch can use a 5 megapixel camera module for Raspberry Pi, which carries the Omnivision 5647 sensor. The rest is software: the deconvolution runs on a computer or on the board itself, depending on how much power you have available.

If you want to do the computation directly on board, you need a board with a bit of muscle. The Raspberry Pi 5 with 2 GB of memory carries the Broadcom BCM2712 quad-core processor at 2.4 GHz with Arm Cortex-A76 architecture, so it handles deconvolution operations on reasonably sized images well.

The author does not hide the practical limits of the technique. The quality of the reconstruction depends on how precisely the point spread function is estimated, and tape is not an optical component that stays stable over time. What is more, deconvolution amplifies noise, so it is best to work with well-lit scenes and sensors with low background noise. Anyone who wants to dig deeper into the science behind the project will find the full story and references to the research papers on the project page on Hackaday.io.

Source: https://hackaday.io/contests

Related products

• 5 Mpx Camera for Raspberry Pi
• Raspberry Pi 5 – 2 GB memory version

The post Lensless 3D imaging with Scotch tape and deconvolution appeared first on Open Electronics.

GlitchCaster is an evaluation device for electromagnetic fault injection, or EMFI. It generates an electromagnetic pulse of about 250 V through coil probes and mounts directly on the head of an old 3D printer or a CNC machine. That makes security testing repeatable, because the probe moves along the X, Y and Z axes with the precision the machine’s mechanics already guarantee. The project comes from Diffused Tactics.

The coil is brought close to the target device and the pulses fire with precise timing. The disturbance is temporary and aims to make the target fail at the exact moment it performs a check. The mount also follows the same topology as 40 mm fans, so the bracket fits many heads already found in a workshop. The module has no built-in controller: it exposes 2.54 mm headers and screw terminals, and you choose the GPIO and PWM controller.

The 250 V flyback and the 630 V 470 nF capacitor

The high-voltage section uses a DC/DC flyback circuit built around the LDA111 and the ATB3225. The storage capacitor is rated 630 V 470 nF, so its working voltage sits comfortably above the 250 V of the pulse. The included probe coil is 4.7 uH, with a 4 x 15 mm ferrite core and a 17.5-turn winding. An adapter board lets you swap between coils with a through-hole lead and coils with an SMA connector.

The measurements of the three PCBs help you judge the footprint. The main board measures 71 mm x 32 mm x 1.65 mm. The SMA adapter board measures 11.6 mm x 10.1 mm x 1.65 mm, which becomes 29.3 mm once the connectors are included. Finally, the controller board measures 71 mm x 30 mm x 1.65 mm. The supplied jumper wires are 24 inches long, enough to carry the signals from the machine head to the controller without straining the cables.

PicoEMP firmware and interchangeable SMA connectors

The firmware stays compatible with that of PicoEMP-based projects, so anyone who has already worked on that design will find the same logic. On top of that, the firmware can be customised by advanced users, who can adapt the pulse timing to their own test bench. Mounting on the printer or CNC rail does the rest: the Raspberry Pi Pico kit with sensors and actuators covers the prototyping side around the controller, if you need something to connect to the GPIOs.

Anyone who wants to rebuild the test bench will find a description of the device and its parts in the Diffused Tactics campaign on Crowd Supply. For the rest, the list of parts that matter is short and worth reading through again in order.

• LDA111 and ATB3225 for the DC/DC flyback of the high-voltage section
• 630 V 470 nF storage capacitor
• 4.7 uH probe coil with a 4 x 15 mm ferrite core and 17.5 turns
• 2.54 mm connectors, 2.54 mm screw terminals and SMA connectors
• controller board based on the Raspberry Pi Pico
• 24-inch jumper wires and adapter PCB for the probes

The strong point is the recycled mechanics. A 3D printer sitting idle in a corner becomes a three-axis positioner for the probe, and every pulse starts from the same point with the same delay. As a result, tests can be repeated and compared, instead of depending on the hand holding the coil. The GlitchCaster makes EMFI security testing accessible and repeatable by exploiting a machine that is already in the workshop.

Source: https://www.crowdsupply.com/diffused-tactics/glitchcaster

Related products

• Raspberry Pi Pico Primer Kit – Plug&Play Sensors and Actuators

The post GlitchCaster: EM Fault Injection Rides on a 3D Printer Head appeared first on Open Electronics.

Melexis has introduced the MLX91224 and MLX91225, expanding its portfolio of isolated current sensors for high-voltage applications in the automotive and industrial sectors. Offering plug-and-play measurements up to 100 A RMS, ASIL B compliance and a fast analog response in three package options, these new devices simplify the design of electric vehicle powertrains, DC-DC converters, chargers and solar systems.

The challenge of current measurement in electrification

As electrification continues to advance across many applications (renewable energy, industrial, automotive, energy storage systems…), current measurement becomes increasingly complex. Designers need accurate, isolated measurements for system control and safety. For measuring small currents, a common solution is the shunt-based approach. However, these solutions generally involve increased ohmic losses, the need for isolated amplifiers, greater assembly complexity and a significant commitment to end-of-line calibration.

The MLX91224 and MLX91225 overcome these challenges by integrating the current conductor, the sensing element, signal conditioning and isolation into a compact SOIC package. Current flows directly through the package’s low-impedance leadframe, while two sets of Hall plates differentially detect the magnetic flux generated by the current. This architecture minimizes interference from external magnetic fields and delivers a linear, high-speed analog output proportional to the measured current, with isolation values that depend on the package and support working voltages up to 1640 V RMS.

Built-in safety and fast current measurement

For automotive applications, Melexis brings to market an integrated current sensor platform with ASIL B certification unprecedented in the industry for high-voltage current measurement, in the form of the MLX91224 and MLX91225. Developed as Safety Elements out of Context (SEooC) according to ISO 26262, the devices give designers a more solid starting point for measuring safety-related current in high-voltage automotive systems. This platform ensures a fast response for current measurement in motor control, electric drives, DC-DC converters, AC and DC chargers, solar installations, power supplies and many other applications.

The devices are available in DE, DG and DH package options to meet different current, isolation and impulse overvoltage requirements. The compact DE package offers a continuous operating current capability up to 50 A (RMS value) and overcurrent detection (OCD) in a cost-effective SOIC6FL format. In the SOIC16W format, the DG variant supports a similar continuous operating current range and working voltage, guaranteed by greater isolation and creepage distance. For higher-current designs, the DH package extends the platform to a continuous operating current capability of 100 A RMS in the SOIC12W FL package, with excellent impulse overvoltage values up to ±29 kA.

A versatile solution for automotive and industrial power

All devices support AC and DC current measurement, bipolar or unipolar detection and ratiometric or fixed output configurations. The MLX91224 is designed for 5 V systems, while the MLX91225 supports 3.3 V systems, allowing designers to select the device best suited to the available supply voltage and microcontroller architecture. The OCD function is provided through a dedicated pin, with thresholds defined internally or externally via the OCD-TH pin, to support protection and monitoring functions. With an operating temperature range from -40 °C to 150 °C, the platform is designed for use in particularly demanding industrial and automotive applications.

«Many customers design solutions across a wide range of power levels, from low-power motors to higher-current infrastructure», said Bruno Boury, Product Line Director at Melexis. «The MLX91224 and MLX91225 offer a current sensor platform that can grow with their power requirements, while helping to simplify isolation, overcurrent detection and functional safety integration.»

The MLX91224 and MLX91225 extend Melexis’ integrated current sensor portfolio toward higher-current applications, supporting the company’s strategy focused on electric vehicle powertrains, electrification and sustainable energy infrastructure. The devices are designed for use in the automotive sector and beyond, covering applications such as AC and DC chargers, electric drives, DC-DC converters, solar systems, data center power distribution units, power supplies and load and demand control.

The MLX91224 and MLX91225 are available in three package options. For more information, visit www.melexis.com/MLX91224-MLX91225.

The post Melexis MLX91224 and MLX91225: Integrated Current Sensors up to 100 ARMS appeared first on Open Electronics.

The TinyGo Starter Kit with Seeed Studio XIAO brings the Go language to embedded hardware. At its centre is the pre-soldered Seeed Studio XIAO ESP32-C3 board, with 2.4GHz WiFi and BLE 5.0, which plugs into the Grove Base for XIAO. The kit includes 11 plug-and-play Grove modules and a set of official tutorials for learning by building real projects. The price is 53.54 dollars.

Go was released to the public in 2009 and today is a widely used language on the server side. TinyGo brings a version designed for microcontrollers, with support for more than 150 development boards and WebAssembly as a target. Anyone who already programs in Go therefore finds a direct path into the embedded world, without changing language.

XIAO ESP32-C3, Grove Base and 11 modules with no soldering

Assembly requires no soldering. The XIAO ESP32-C3 board slots onto the Grove Base for XIAO, which acts as an expansion board for the modules. From there each module connects with the Grove connector, so you go straight to the code. For anyone who wants to start with a cheap and versatile board, an ESP12 board with mikroBus and Grove slots remains a different but equally easy-to-program option.

• Inputs: button, touch, rotary, light, sound, temperature, vibration and acceleration
• Outputs: RGB LED, OLED display and buzzer
• Sensors included: Grove Light Sensor v1.2 with LS06-S phototransistor, Piezo Vibration Sensor, Temperature Sensor, Rotary Angle Sensor
• Other modules: Piezo Buzzer/Active Buzzer and Sound Sensor based on the LM358 amplifier
• 0.66-inch Grove OLED display (SSD1306), IIC, 3.3V/5V
• Grove RGB LED Stick with 10 WS2813 Mini 3535 LEDs

Every hardware module is backed by programming tutorials written by Patricio Whittingslow of TinyGo. The path therefore does not stop at the board: you move from the light sensor to the buzzer, from the OLED display to the RGB LED, building projects that really work. For anyone looking for a compact board for embedded and IoT prototyping, a mini development board based on the RP2040 is an interesting alternative, but here the point is something else: the Go language.

TinyGo v0.41 and native wireless support on XIAO

TinyGo v0.41 brought native wireless support to the XIAO ESP32-C3 and XIAO ESP32-S3. As a result, you write Wi-Fi applications in Go and flash them directly onto the boards, without going through other languages. The WebAssembly target also remains available, so the same environment covers both the microcontroller and the browser.

The kit sells for 53.54 dollars and includes 11 plug-and-play Grove modules. The XIAO ESP32-C3 board has 2.4GHz WiFi and BLE 5.0, so it covers both network connectivity and connectivity to nearby devices. For anyone who wants to understand how to write a Wi-Fi application in Go on this board, the maker’s site with the TinyGo tutorials is the place to start.

The kit is designed for those who already know Go and want to bring it to hardware, but also for those who want to learn a language different from the usual ones. The combination of a pre-soldered board, plug-and-play modules and official tutorials reduces the barrier to entry to a minimum. The code does the rest.

Source: https://www.seeedstudio.com/tinygo-xiao-starter-kit.html

Related products

• GANIMEDE.E12 ESP12 Board with USB, Wi-Fi, mikroBus and Grove Sockets
• RP2040 Mini Development Board

The post TinyGo Starter Kit with XIAO ESP32-C3: Go Comes to Hardware appeared first on Open Electronics.

An E-ink e-reader can become a printer. Nishant Joshi has modified the CrossPoint firmware to run the IPP protocol on a reader based on the ESP32-C3. This way the device announces itself to the operating system as a printing peripheral and receives documents without any dedicated software. You just select the printer from your computer and hit print.

The reader presents itself as a monochrome, single-sided printer at 300 DPI on A5 paper. It accepts Apple raster and PWG raster formats, so system drivers need no special translation. The fork also works on the Xteink X4 and Xteink X3, two models built around the ESP32-C3 microcontroller. The project page on Hackaday.io collects Nishant Joshi’s work.

Pixel by pixel, row by row, to avoid saturating RAM

The raster images of an A5 page at 300 DPI are too large for the microcontroller’s memory. So the firmware does not hold them all in RAM. It receives the pixels one row at a time and writes them immediately, both directly to the screen and to the SD card. As a result, the document remains available even after printing.

The fork of the CrossPoint firmware implements the IPP protocol on the ESP32-C3.

The reader announces itself as a monochrome, single-sided printer at 300 DPI on A5 paper.

It accepts Apple raster and PWG raster formats.

The pixels are received and written row by row, because the whole image does not fit in RAM.

Each row ends up both on the screen and on the SD card.

A folder on the SD card acts as the printer’s output tray.

Anyone who wants to rebuild the project starts from an ESP32-C3 module, the same microcontroller that powers the reader. For those looking for a compact board with integrated wireless connectivity there is the SuperMini form factor development module, suitable for IoT and embedded projects. Alternatively, for those who prefer to start from a more complete kit, the catalogue offers a kit based on the ESP32-C6-Zero with Wi-Fi 6 and integrated peripherals.

The folder on the SD card as an output tray

Every printed document ends up in a folder on the SD card. That folder works as an output tray: anyone who wants to re-read a page finds it there, without having to print it again. Moreover, writing to the SD card happens in parallel with writing to the screen, so the reader is not left blocked waiting for the save to finish.

The flow is linear. The operating system sees the printer, sends the job in raster format, the firmware breaks it down into rows and deposits them. Finally the document appears on the E-ink screen and stays archived on the card. No application is needed on the computer, because the IPP protocol is the standard one for network printers.

For those who want to follow the work closely, Nishant Joshi’s project page on Hackaday.io is the starting point. There you will find the fork of the CrossPoint firmware with the IPP implementation and the references to the two supported hardware versions.

Source: https://hackaday.io/contests

Related products

• Mini ESP32-C3 module
• ESP32-C6-Zero Wi-Fi 6 IoT Development Kit

The post Printing from an E-ink e-reader: the IPP firmware on ESP32-C3 appeared first on Open Electronics.

It lets you understand and be warned acoustically and visually when the concentration of ethyl alcohol in your breath is over the tolerable threshold, optionally activating a relay.

When you say “breathalyzer”, your thoughts immediately run to the roadside checks carried out by the police to identify and fine those driving under the influence; on those occasions a device is used that has an interchangeable mouthpiece (for obvious hygiene reasons) where the person under test blows and the breath is directed against the sensitive surface of an ethyl alcohol sensor. We want to offer you something like that in these pages, but not so that you go and swell the ranks of roadside checks or play at being “rookie cops” – rather because it can always be useful to check, after getting up from the table and before taking the car, that you are not risking being in violation.

In fact, just like the alcohol testers available commercially for that purpose, it lets you measure the blood alcohol level (that is, the specific amount of alcohol in the blood) of the puff of breath directed against the surface of the sensor used. The latter is a device labelled MQ-3, able to detect not only alcohol vapours but also various types of gas and hydrocarbons, although the aerosol compound it is most sensitive to is certainly alcohol, followed by petrol; we will use it in the circuit described below, analysing its electrical schematic. First, though, let’s take stock of the sensor, explaining how it works.

The MQ-3 sensor

This device is made by Hanwei Electronics (www.hwsensor.com) and is based on the well-established metal oxide film structure, long used successfully to detect gases: the sensitive element is an oxide layer that is heated by a filament powered through two dedicated pins (labelled H for heater) so that it reaches the optimal temperature for its operation; the filament has a cold resistance (at room temperature) of about 33 ohm, is made of a nickel-chromium alloy and has no polarity, but should preferably be powered with direct current, at least for our purposes.

The metal film is applied to a tubular ceramic support made of alumina (Al2O3), which is an electrically insulating material; it is made of tin dioxide (SnO2) and its characteristic is that, when heated, it becomes permeable to the atoms of the gases it is sensitive to. Contact with ethyl alcohol and the resulting oxidation-reduction reaction alter the conductivity of the tin dioxide film, which under normal conditions is very low: in fact the resistance measurable at rest is in the order of kohm. To be precise, we are in the order of a few hundred ohm, up to 20 kohm for ethyl alcohol concentrations varying between 10 and 0.05 mg/L, corresponding to the range measurable by the sensor (the higher the concentration, the lower the resistance and vice versa); the reference resistance given by the manufacturer for an ethyl alcohol concentration of 0.4 mg/L is defined as Ro. The oxidation-reduction reaction triggered by the alcohol (taking into account the oxygen content of the surrounding air) causes the release of electrons that increase the conductivity of the sensitive element and therefore lower the resistance.

To detect the variation in resistance of the film, the latter is placed in a resistive divider powered at 5V and having a load resistance (the one terminating to the ground of the measurement circuit) typically of 20 kohm as shown in Fig. 1 ,

even though in our case we are around 1.2 kohm because the circuit requires it; as the concentration of alcohol in the air pushed past the protective grid of the MQ-3 increases, the resistance of the filament decreases and consequently the voltage detectable across the load resistance grows. To give you an idea of the behaviour of the sensor, that is of its thin tin dioxide film, in Fig. 2 we show the logarithmic-scale graph of its response to various types of gas and clearly to ethyl alcohol.

The curves refer to 20 °C ambient temperature and 65% relative humidity, with an oxygen concentration in the order of 21%. In the graph, Ro is the resistance of the sensor at an ethyl alcohol concentration of 0.4 mg/L in clean, dry air; Rs, on the other hand, is the resistance assumed by the sensor element at a given concentration of the compound in the air, which in this specific case is air. You can see that at 0.4 mg/L concentration Rs equals Ro and therefore the ratio is 1; at 10 mg/L Rs becomes practically 1/10 of Ro. The Rs/Ro ratio determines the sensitivity of the MQ-3. From the graph it is clear that the sensitive element of the MQ-3 sensor also responds to the presence of other aerosols and gases, because the tin dioxide film behaves that way, although in the case of the sensor we use the behaviour towards ethyl alcohol is the relevant one (the ratio varies by about 20 times over the measurement range).

Electrical schematic

Well, having established what the sensor is and how it works, we can see how the MQ-3 has been used in the circuit of the alcohol tester proposed in these pages: looking at the electrical schematic you can see that we adopt the configuration mentioned above, where the resistance of the sensitive element is placed in series with a resistance with which it forms a divider; to help you follow the schematic, in Fig. 3 we show the pinout and the internal connections of the MQ-3.

The sensor divider and the 555 timer

Since the sensor is analogue, between the series of resistors R3 and R5 we will get a voltage that varies according to the graph in Fig. 2 as a function of the ethyl alcohol concentration; since R5 is a trimmer, it is possible to vary the amplitude of the voltage obtained, that is the ratio between the potential difference presented at pin 2 of the integrated circuit U1 and ground and the supply voltage of the filament, which is 5 volts DC. In accordance with the manufacturer’s prescriptions, in series with the heater filament we have placed a resistor that limits its current and with it the dissipated power, staying within safe values that guarantee both the correct response to alcohol and long-term durability.

We use the signal provided by the sensitive element, and therefore the voltage across the series R3-R5, in a fairly unusual way: no reading by the DAC of a microcontroller or anything like that, but much more simply we send it to the trigger input of an ordinary 555 timer, whose internal flip-flops we exploit. To understand what role the 555 plays we need to look at what is inside it, with the help of the block diagram shown in Fig. 4 :

The internal comparators and flip-flop

Inside the 555 we find two comparators sharing a ladder voltage divider of resistors that biases the inverting input of the upper op-amp and the non-inverting input of the lower one; of the comparators, the non-inverting input of the upper one is made accessible from outside (the terms upper and lower refer to the reference potential they receive from the multiple divider, so the upper comparator receives the higher voltage), corresponding to pin 6 (THR, that is Threshold), and the inverting input of the upper one, corresponding to pin 2 (TRI, that is Trigger).

The node between the first and second resistor (starting from the positive supply, that is from pin 8) of the multiple reference divider of the two comparators is brought outside through pin 5 (CV, Control Voltage) and this allows the reference voltages of the comparators to be altered, so as to control with an external voltage the operating frequency in the astable configuration (performing the frequency shift as is done in VCOs, that is voltage-controlled oscillators) or the pulse duration in the timer (monostable) one. But this feature does not interest us for the circuit we are describing.

What interests us is what comes next: the outputs of the comparators drive one the RESET (that of the upper comparator) and the other the SET input (lower comparator) of an RS-type flip-flop, which is a logic circuit whose direct output (Q) goes to a high level (corresponding to about the potential of pin 8) when SET is at a high level, that is it takes the logic zero if SET is brought to about zero volts; the output behaves in exactly the opposite way when the RESET input is activated, which, when it is placed at a logic high level, resets the flip-flop, bringing the logic state of the direct output Q to zero.

The flip-flop has a complementary output (/Q), whose logic state is always the inverse of Q; in the 555 it drives the base of an NPN transistor wired in open-collector configuration, whose emitter is connected to ground and whose collector goes to the DIS (Discharge, 7) pin, which we do not use in this application. The direct output, Q, is connected to the OUT (3) pin of the IC through an internal push-pull buffer, capable of sourcing a maximum of 200 mA. The negative supply, that is the 555’s reference ground, corresponds to pin 1, while pin 4 is the flip-flop’s active-low reset: this pin lets you force a reset of the circuit from outside by applying a logic low, but we have tied it permanently high because we don’t need it.

Configuring the alarm

In our application we connected pin 6 to the positive supply, so the upper comparator can never switch and its output stays permanently at a logic high, and with it the flip-flop reset. So we only use the lower comparator, which is tied to the trigger pin; every time pin 2 is pulled to a logic low, the 555’s output (pin 3) goes to a logic high. Therefore, as long as the alcohol concentration is low and the voltage across the resistor chain is below 1/3 of the 555’s supply voltage, the output of the latter stays high; but if the concentration rises enough to bring the voltage between pin 2 and ground above 1/3 of the supply voltage, the lower comparator drives its output low and the flip-flop’s set returns to a low level. In this condition the reset state prevails and the flip-flop’s direct output goes low; this condition powers the piezo buzzer and the positive-test LED labelled LD2, biased through the current-limiting resistor R2.

The relay for use as a gas alarm

But that’s not all: pin 3 of the 555 also powers the coil of relay RL1, which we deliberately included in the circuit so that anyone who wants to can also use it together with an alarm control panel, to detect the presence of gases such as LPG and other gases the sensor can detect, as well as petrol and alcohol aerosols. To protect the 555’s output transistor from the reverse overvoltages that occur across the relay coil when it is de-energised, we included diode D1, connected in antiparallel with it. The relay is very useful if you intend to use the circuit as a gas detector and alarm, but you have to bear in mind that you need a hermetically sealed relay, since even the small spark produced by switching the load could trigger an explosion. Of RL1 we make the changeover available only on contacts C and NO, so it can be used as a switch.

Powering the circuit

We finish the description of the schematic with the power supply, which must be a stabilised DC voltage of 5V maximum and is applied to the power plug observing the polarity shown; to switch the circuit on and off we included a changeover switch used as a power switch and labelled SW1, from whose wiper the supply is taken for the MQ-3 sensor, the 555 and the rest of the circuit, including the relay coil (5V). Between the positive line and ground, at the output of the switch, is LED LD1, powered through resistor R1, which acts as a power-on indicator for the circuit.

Building and using it

Well, now that we have described how the circuit works, we can look at how to build it, starting from the printed circuit board we designed to hold all the required components, sensor included; the PCB is double-sided and, so that you can make it by photoetching, we publish the two copper-side traces to print on tracing paper or acetate to produce the necessary films.

Assembling the printed circuit board

Once the printed circuit board is etched and drilled, you can fit the components starting with the lowest-profile ones such as the resistors and the silicon diode (to be oriented as shown in the assembly drawing visible in these pages), then moving on to the socket for the 555, the horizontal trimmer and the slide switch with right-angle pins. Then come the DC power jack, the MQ-3 sensor, the 5V miniature relay, the buzzer and the two LEDs. Pay attention to the polarity of the two LEDs, whose cathodes (corresponding to the flat on the body) must face the piezo buzzer BZ1; the latter also has a polarity to respect, so when inserting it into its holes on the board keep the + facing the side of the board along which it is positioned. The photos of the prototype and the assembly drawing you find in these pages are helpful during the various assembly stages anyway.

Power supply and calibration

As for use, you need a mains power supply with a stabilised 5 Vdc output, capable of delivering 250 milliamps of current; battery power is also possible using a battery pack with a 5V regulator or, better still, a power bank able to provide a 5V voltage and enough current for good autonomy, considering the circuit’s draw, which even at rest sits at around 170 mA because of the current drawn by the heater filament of the MQ-3 sensor.

To use the product, first turn the switch to ON; after that the buzzer will probably sound, because you will most likely need to adjust the trimmer to set the alarm threshold, that is the sensitivity of our alcohol tester. At this point, if there is no alcohol in the air, turn the trimmer anticlockwise and then release it the moment the buzzer stops sounding. For correct calibration it would be a good idea to leave the device powered for a few minutes (at least 5 minutes) with the trimmer at minimum and only then proceed with calibration, because by that point the sensor, or rather its sensing film, will have reached its operating temperature and its behaviour will be stable. Once calibration is done you can use the device.

Using the device

If alcohol is present, the red LED will light up, the buzzer will sound and the relay will energise, closing the contact on connector CN1. It should be pointed out that this is not a breathalyser, because our circuit does not take measurements: it is an alcohol tester, that is something that warns you if the alcohol concentration is above the set threshold; to align it with the devices used before driving, you should compare it with one of those and adjust the trimmer after breathing into it, checking when it signals excess alcohol.

Alternatively you can refer to the response graph given in Fig. 2 and set the trimmer so that LED LD2 lights up at the desired ethyl alcohol concentration; for example, you can calibrate it by putting a little denatured ethyl alcohol on a table top and holding the sensor a few centimetres away from it with the circuit powered: adjust the trimmer until the buzzer starts sounding and LED LD2 lights up, checking that once the alcohol has evaporated everything returns to rest. When putting the alcohol down, be careful not to spray it onto hot bodies or high-voltage circuits, because it would catch fire.

Related products

• Breathalyzer with LED and Buzzer Alarm – Kit

The post Breathalyzer with audible and visual alarm appeared first on Open Electronics.

A self-built robot arm is usually controlled by programming its movements or by holding a controller. Kelton Serra took a different route: puppet-style control. A scaled-down input device replicates the real arm and physically mirrors its structure. Move a joint on the device and the robot moves in exactly the same way. The project is a redesigned version that is cheaper, easier to build and better performing than the original.

The advantage of puppet control is how intuitive it is. There is no need to write a sequence of angles or to learn the kinematics of the manipulator. You pick up the input device and move it, and the arm follows. That makes a project which would otherwise demand complex programming accessible even to beginners. On top of that, the design is meant to be 3D printed and assembled easily.

Potentiometers instead of motors in the input device

The input device is a scaled-down replica of the arm. Instead of servo motors it carries potentiometers, one per joint. The analog voltage output by each potentiometer corresponds to the angle of that joint. So every movement of your hand on the device translates into a voltage value read by the brain of the system.

The brain of the robot arm is an Arduino Nano ESP32 board, which reads the potentiometers as inputs. The Arduino then commands the arm’s servo motors through a servo driver board, making them match the position. The cycle is continuous: read, compute, command. As a result the real arm chases the input device without any programming required.

• Arduino Nano ESP32 as the control unit
• Servo driver board to drive the motors
• Servo motors for the arm joints
• Potentiometers mounted on the scaled input device
• Belt on the wrist and rack-and-pinion on the gripper

The mechanics have been updated compared with the original. The wrist joint now uses a belt drive, while the gripper adopts a rack-and-pinion system. These two choices improve the arm’s performance and simplify construction. The structure is also designed for 3D printing, so anyone who wants to rebuild it can start from the files and assemble it piece by piece.

Anyone wanting to take on the project will find the starting point on the page with the printable files. There you’ll find the files for 3D printing, so you can begin with the mechanics and then move on to the electronics. The components do the rest: the Arduino Nano ESP32 board, the servo driver board, the servo motors and the potentiometers. For controlling traditional three-pin RC servos there is also a shield solution, handy if you would rather not wire everything by hand.

If you are looking for the control board, the compact board with integrated Wi-Fi and Bluetooth is the one the project adopts as its brain. To drive the servos, on the other hand, the shield that controls up to six traditional RC servos is an option worth keeping in mind during assembly.

The beauty of puppet control is that it requires no complicated software. There are no trajectories to plan, no torque sensors to read. You move the input device and the arm copies it. The project therefore stays within reach of anyone with a bit of manual skill and a 3D printer, without having to master advanced robotics.

For anyone who wants to rebuild it, Kelton Serra’s page with the printable files is the place to start. There you’ll find the files for 3D printing, so the mechanics of both the arm and the input device. From there you move on to the electronics and assembly, following the same logic as the original project.

Source: https://www.printables.com/model/1834841-arduino-robot-arm-and-controller-v2-rad

Related products

• Arduino NANO ESP32 with Wi-Fi and Bluetooth
• Arduino shield for RC servo control

The post DIY Robot Arm with Puppet-Style Control appeared first on Open Electronics.

Livegrid Aura is a wall-mounted digital aquarium that turns air quality into a visual spectacle. A 64×192 pixel HUB75 RGB LED matrix displays virtual creatures that are not merely decorative: their health depends on the environmental values measured by a Sensirion SCD40 sensor. The panel is also interactive, thanks to a time-of-flight depth sensor that detects who is standing in front of it without using a camera.

The project is by Dhruv Kumar and is the natural evolution of Livegrid, the previous version with a 78×78 pixel matrix. The new frame is about three times wider than the original, and the result is an object that combines digital art, environmental sensors and interaction with people. Dhruv Kumar’s crowdfunding campaign gathers the details on costs and shipping for anyone who wants to support the project.

How the virtual aquarium works

The heart of the system is an ESP32-S3 that drives the LED matrix and collects data from the sensors. The SCD40 environmental sensor measures temperature, humidity and carbon dioxide. The virtual fish thrive when these values are within the normal range, while their health worsens if the air becomes stale. This way the panel becomes a visual indicator of environmental quality, far more immediate than a numeric display.

The time-of-flight depth sensor detects the distance and shape of whoever is in front of the panel. The fish follow the movements of a hand or gather around a person standing still. Moreover, the device does not use cameras: the sensor reads only shape and distance, guaranteeing the privacy of those interacting with it. All computation happens locally, without sending data to external services.

• 64×192 pixel HUB75 RGB LED matrix for the display
• Sensirion SCD40 sensor for CO2, temperature and humidity
• Time-of-flight sensor to detect presence and movement
• ESP32-S3 for local processing and control

Connectivity and home automation integration

The ESP32-S3’s built-in Wi-Fi is disabled by default. This reduces power consumption and keeps the device isolated from the network. Those who want to can enable it to unlock advanced features: a REST API, ArtNet and sACN streaming at 30 fps, and MQTT connectivity. The latter makes it possible to integrate the aquarium with home automation systems, for example to change scene when a window is opened.

The redesigned Livegrid is now three times wider, or taller if rotated, and has a built-in depth sensor. This geometry expands the space for animations and makes interaction more natural. The 64×192 pixel matrix offers higher resolution than the 78×78 of the previous version, with a panoramic format that suits a wall well.

Cost and availability

The hardware price starts at £299, about $405, plus shipping, for the first backers of the base model’s Kickstarter campaign. Anyone who wants to build a similar system can start from standard components. For the proximity sensing part, a TOF module with a VL53L0X sensor can be used, offering a solid basis for camera-free interaction experiments.

For those who prefer a more traditional development platform, an Arduino Uno R4 Wi-Fi board with a dual microcontroller can be a starting point for prototyping similar logic, even though the original project uses an ESP32-S3. The choice depends on the need to directly drive the HUB75 LED matrix and streaming protocols such as ArtNet.

Livegrid Aura shows how a decorative object can become an interactive environmental sensor. The combination of LED matrix, air quality sensors and depth detection creates an experience that changes with the environment and with the people around it. A project that looks to the future of digital art at home.

Source: https://www.kickstarter.com/projects/livegrid/livegrid-aquatic-environment-monitor/description

Related products

• TOF (Time Of Flight) Module with VL53L0X Sensor
• Arduino Uno R4 Wi-Fi with Renesas RA4M1 and Espressif ESP32-S3

The post Livegrid Aura: the digital aquarium that lives with air quality appeared first on Open Electronics.

Tiny Engineer is an open-source, 3D-printable desktop robot that gives a physical body to an AI coding agent. Krzysztof Jamroz’s project turns monitoring the agent from a passive on-screen activity into a tangible experience. Instead of watching the IDE to figure out what the AI is doing, you see it nod, gesture and type on an imaginary keyboard. The robot translates the agent’s activities, such as reading, thinking, writing code and finishing the job, into physical movements and gestures. When the task is done, it rings a bell.

Operation is simple and relies on an integration that turns the AI agent’s activities into events. These events are sent to the robot’s REST API over the LAN. Krzysztof Jamroz’s repository contains the code and files needed to rebuild the project. The Waveshare ESP32-C3-Zero board receives the commands and handles the robot’s logic and animations. The ESP32-C3 drives 5 servos through the PCA9685 PWM controller for the head, neck, hands and body movements.

Robot components and circuit

The component list is essential and well defined. The robot uses 5 PowerHD HD-1370A servos for the movements. A 0.91-inch, 128×32-pixel SSD1306 OLED display shows the status, the face and information. Audio is handled by a MAX98357A amplifier with an 8 Ω, 1 W speaker. Everything is powered at 5 V with at least 2 A of current.

The firmware is compiled with PlatformIO and the serial port runs at 115200 baud. The configured Wi-Fi network must be 2.4 GHz. The robot runs specific animations such as ‘typing’, ‘reading’, ‘thinking’ or ‘ring’ based on the commands received. For connectivity, the project uses an ESP32-C3-Zero board, but those who want to experiment can consider an ESP32 development board with Wi-Fi and Bluetooth to get closer to the project.

3D printing and customisation

An overview of the project shows how carefully designed it is. The structure is 3D-printable and the project is meant to be modified. You can change the CAD, modify the animations or connect a different agent. The repository contains everything you need to get started.

The robot is designed to be a desktop object, so its dimensions are compact. The 5 PowerHD HD-1370A servos are distributed between the head, neck, hands and body. The 0.91-inch SSD1306 OLED display is small but readable. The 8 Ω, 1 W speaker is enough for the notification sounds.

Customisation is one of the strengths. Beyond 3D printing, you can work on the firmware to change the animations. The source code is available and well organised. Communication with the AI agent happens through the REST API over the LAN, so you can adapt it to different systems.

Power and network requirements

The required power supply is 5 V and at least 2 A. This ensures the 5 servos can move without current problems. The configured Wi-Fi network must be 2.4 GHz, a common choice for IoT devices. The 115200-baud serial port makes debugging easier during development.

For those who want to dig deeper, Krzysztof Jamroz’s repository is the ideal starting point. You will find the code, the STL files and the instructions. The project shows how the work of an AI agent can be made tangible, turning monitoring into a physical experience.

Source: https://github.com/jamro/tiny-engineer

Related products

• OLED Display I2C 0.96” – VCC/GND/SCL/SDA
• ESP32 – Development board with Wi-Fi, Bluetooth and USB Type-C connector

The post Tiny Engineer: a desktop robot that gives your AI agent a body appeared first on Open Electronics.

Kelton has redesigned his robot arm, applying three years of experience to improve its mechanical design and accessibility. The new arm keeps the scale-model control scheme, but is easier to print and assemble. All the parts are designed to be 3D printed without supports, which simplifies assembly. The total cost of the required components and hardware is under 100 dollars.

The project is accessible: it costs less than 100 dollars, prints in a couple of days and requires no programming to be used. The video of the original project, published three years ago, has reached 654,000 views on YouTube. This new design grew out of the experience gained with that first version.

How scale-model control works

The robot arm is controlled by a custom input device, which is a scale model of the arm itself. When you move a joint on the model, the corresponding joint on the robot arm moves in the same way. The control is based on an Arduino Nano ESP32 board and a driver board for the servos.

The new wrist joint uses a belt drive. The new gripper uses a rack-and-pinion mechanism. These design choices improve the precision and reliability of the movement. On top of that, printing without supports makes assembly much faster.

• Arduino Nano ESP32
• servo driver board
• servomotors
• drive belt
• rack-and-pinion gear

3D printing and required components

Printing all the parts takes a couple of days. The parts are designed to be printed without supports, so no extra work is needed. This cuts down the time and materials required, making the project suitable even for people with little 3D printing experience.

For the electronics you need an Arduino Nano ESP32 board, which handles the control. Alongside it, a driver board for the servomotors. The servomotors move the joints of the arm. Everything connects to the scale model, which acts as the controller.

Anyone who wants to rebuild the project can find all the files to print on the project page. The page with the files to print collects Kelton’s work and lets you download the necessary parts. The project is meant to be replicated without difficulty, even by someone who has never assembled a robot arm before.

The overall cost stays under 100 dollars, a remarkable figure for a robot arm with these characteristics. The choice of common, easy-to-source components helps keep the price low. What’s more, the modular design allows individual parts to be replaced if they wear out.

A project built to last

The new design comes from three years of experience with the previous version. Kelton listened to feedback from the community and improved the weak points. The result is a sturdier arm that is easier to print and simpler to assemble.

Control through a scale model is intuitive and requires no programming skills. This makes it suitable even for those approaching robotics for the first time. The project shows that excellent results can be achieved with inexpensive components and a lot of care in the design.

Source: https://www.printables.com/model/1834841-arduino-robot-arm-and-controller-v2-rad

The post 3D-Printable Robot Arm Controlled by a Scale Model appeared first on Open Electronics.

The UNO Media Carrier is a carrier board that brings two MIPI-CSI camera inputs, one MIPI-DSI display output and three 3.5 mm audio jacks to compatible host boards. The connection runs through the high-speed JMEDIA and JMISC connectors, so the board stays in the UNO form factor. That way the multimedia capabilities of the UNO Q and VENTUNO Q are extended without touching the host board’s headers directly.

The strong point lies in the standard connectors. Two 22-pin MIPI-CSI ports accept IMX219 cameras, for example the Camera Module 2, and open the way to computer vision applications with dual cameras. A 22-pin MIPI-DSI port, meanwhile, supports Waveshare displays, so you add an interactive visual output without any special soldering.

On the audio side the carrier offers three separate 3.5 mm jacks: a combined microphone input and headphone output, a line out for amplifiers or powered speakers, and an ear out for connecting earphones directly. In addition, the JMEDIA and JMISC connectors have a passthrough design, so all the host board signals remain accessible for stacking additional modules or carriers.

The exposed signals: I2C, PSSI and two-voltage GPIO

Besides the multimedia connectors, the board exposes several interfaces useful to anyone who wants to integrate sensors and peripherals. There is I2C (CCI and MCU I2C4), an 8-bit PSSI parallel camera interface, the SoC GPIOs at 1.8 V and the MCU GPIOs at 3.3 V. This dual voltage reflects the architecture of the UNO Q, which pairs an STM32U585 microcontroller with an application processor.

For those who want to get started right away, the 8-megapixel camera module with a Sony IMX219 sensor is the right component to pair with the two MIPI-CSI inputs. The module with the IMX219 sensor for Raspberry Pi 5 covers exactly that kind of application, from surveillance to embedded computer vision.

Power, dimensions and operating temperature

The VIN (DC_IN) supply accepts 7 to 24 V DC through the 4-pin J13 header. The VCOIN input, on the other hand, is 3.0 V DC for the host board’s RTC, with a maximum of 3.6 V, and goes through the 4-pin J10 header. The dimensions are 68.58 x 53.34 mm, so the form factor stays UNO, and the temperature range goes from -10 to 60 degrees. The board also has room for 4 RGB LEDs.

• Two 22-pin MIPI-CSI connectors for IMX219 cameras
• One 22-pin MIPI-DSI connector for Waveshare displays
• Three 3.5 mm audio jacks: mic/headphones, line out, ear out
• JMEDIA and JMISC connectors, 60-pin female, in passthrough
• I2C (CCI and MCU I2C4) and 8-bit PSSI
• SoC GPIOs at 1.8 V and MCU GPIOs at 3.3 V

The list price is 19.25 dollars, or 19.89 euros including VAT, on the Arduino store. For those who want to start from scratch with the host board, the complete kit with accessories for the UNO Q 4GB covers the starting point. The complete kit with accessories for the UNO Q 4GB combines the STM32U585 microcontroller with the application processor, that is, the same combination that the Media Carrier sets out to extend.

On the software side Arduino provides a User Manual and a Kiosk Mode tutorial, which explains how to connect and configure the UNO Q and Media Carrier with a Waveshare touch display. Those who want to dig deeper will find everything on the Arduino maker site, where the manual and tutorial are collected.

Source: https://docs.arduino.cc/hardware/uno-media-carrier/

Related products

• 8MP Camera Module with Sony IMX219 for Raspberry Pi 5
• Arduino UNO Q 4GB – Complete kit with accessories

The post UNO Media Carrier: cameras, displays and audio for the UNO Q appeared first on Open Electronics.

A TrueTime XL-AK GPS time server from 1995 is back at work, but with a new heart. The project replaces the original electronics with a Raspberry Pi 5 and a GNSS HAT, and the result is a stratum 1 NTP server for the local network. The enclosure, the 16×2 LCD display and the bicolour LED are still the ones from thirty years ago.

The board was purchased in June and received on 22 June. Sixteen days later, a similar GPS time server caused a 12-hour cellular service outage in Australia. An episode that shows how widespread these instruments were, and how much they still matter, even when they stop working.

The Raspberry Pi 5 and the GNSS module

The Raspberry Pi 5 runs Pi OS Lite and communicates with the u-blox NEO-M9N GNSS module through the GNSS HAT. The HAT software creates a bridge to transfer the NMEA sentences, which carry date and time, to gpsd and chrony. It also provides a PPS signal for precise timing.

You can also use a Raspberry Pi 5 with 1GB of RAM, at a cost of 44 dollars. The version used in the project has 4GB, but the difference is not in the memory: it is in clock stability and thermal management, which here matter more than anything else.

Configuring chrony and PPS

Chrony is configured to use the PPS refclock as the preferred source and the SHM refclock, which comes from gpsd, as a reference. The configuration includes an offset of 0.0 and a delay of 0.05 for the SHM. The PPS refclock is set with poll 3 and filter 16.

For maximum precision, the system was pushed on the clock parameters. Here are the main values of the chrony configuration:

• maxclockerror set to 0.5
• maxupdateskew 100.0 and makestep 1000 3
• maxchange 0.1 1 -1 to limit sudden corrections

Thermal stability is another key point. The Raspberry Pi is configured with force_turbo, which draws about 1W more continuously, and with a fan running at a constant duty cycle. The fan is set to 50% duty cycle to reduce noise, while 75% offers slightly better performance. Thermal insulation was also added.

The original LCD display and bicolour LED are driven by the Raspberry Pi to show the server status. The LED, for example, indicates the GPS status. The NTP server then provides time synchronisation services to clients on the local network through chrony.

The project was built with VCF Midwest in mind, an event dedicated to retrocomputing. The video documenting the restoration shows the whole process, from the original board to the working NTP server. Anyone who wants to redo the work will also find the GNSS HAT software and the fan control utility, included in the Time Pi repository.

Source: https://www.youtube.com/watch?v=1T9xQy-dsQo

The post A 1995 GPS Time Server Gets a Raspberry Pi 5 Heart Transplant appeared first on Open Electronics.