Українською
  In English
Open Electronics
An ESP32 Becomes a Matter Light with Just a Few Lines of Code
An ESP32 becomes a Matter device of the On/Off Light type and drives a GPIO pin. The result can be commissioned in Apple Home, Google Home, Amazon Alexa, Home Assistant or any other Matter controller. The firmware fits in a few lines, because the Matter library has been included in the ESP32 Arduino Core since version 3.1.0. Rui Santos and Sara Santos published the project on their site, with the complete code and the pairing procedure.
The device does not depend on any manufacturer’s cloud. Local control via a button works even without a hub, the light state survives a reboot and a long press returns the board to factory conditions. Three behaviours that usually require separate firmware live together here in the same sketch.
The Matter.h and Preferences.h libraries in the sketchThe code includes three libraries. Matter.h handles the protocol stack, Preferences.h saves the on/off state in non-volatile memory, Arduino.h does the rest. The MatterOnOffLight endpoint implements the standard On/Off Light cluster and is initialised with the last state read from Preferences. So the light comes back on the way you left it, even after a power cycle.
The setLightOnOff() callback switches the physical LED on or off according to the state requested by Matter and writes the state to non-volatile memory. The default GPIO pin for the LED is 2, if the board does not define LED_BUILTIN. In the loop, matterRestartIfNoFabric() is called and the button is read with button.poll(), which tells a single click apart from a long press.
- Matter.h for the protocol stack and the On/Off Light endpoint
- Preferences.h to save the on/off state in non-volatile memory
- Arduino.h for the sketch structure
- matterRestartIfNoFabric() in the loop to handle the absence of a fabric
- button.poll() to read clicks and long presses of the BOOT button
Wi-Fi credentials are only needed in one case. With CHIPoBLE the hub provides the SSID and password during commissioning, so they are not written into the code. On ESP32 or ESP32-S2 with prebuilt Arduino the board cannot commission over BLE and the credentials must be entered by hand. The manual Matter pairing code is made up of 11 digits.
The BOOT button between local toggle and decommissioningThe BOOT button, usually GPIO 0, does two different things depending on how long you hold it. A click commands the local toggle of the light, without going through any controller. A long press starts decommissioning and the board leaves the fabric it was associated with. So the same button covers everyday use and the factory reset.
To rebuild the project you need Arduino IDE 2 and the ESP32 Arduino Core from version 3.1.0 upwards. In Tools you select the Huge APP partition scheme (3MB No OTA/1MB SPIFFS) and the serial monitor must be set to 115200 baud. The Preferences library is already available in the core. The project runs on ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C5, ESP32-C6 and ESP32-H2, so the choice of board depends on what you have in your drawer.
For those who want to start from a recent board, a development kit with an ESP32-C6 module covers both Wi-Fi 6 and the Bluetooth LE used in commissioning. If instead you need a smaller module, a mini ESP32-C3 module supports the same Matter firmware. In both cases the sketch stays the same.
Anyone who wants to rebuild the project will find the complete sketch, the step-by-step commissioning procedure and the notes on the differences between boards on the maker’s site. The code is not long, but the details that matter are all there: the LED pin, the handling of non-volatile memory and the behaviour of the BOOT button.
Source: https://randomnerdtutorials.com/esp32-matter-on-off-light/
Related productsThe post An ESP32 Becomes a Matter Light with Just a Few Lines of Code appeared first on Open Electronics.
A credit-card-sized portable bench power supply
A USB-C charger becomes a portable bench power supply, adjustable and as thin as a business card. That is what Anas Malas has built: a PCB-format board that negotiates the USB PD 3.1 protocol with the source, then brings the selected voltage to its output. The voltage ranges from 5 to 48 V in 0.1 V steps, and the board can deliver up to 5 A. Along the edge, an LED bar and a display show what the source can do and what is happening at the output.
The format is not a gimmick. The PCB is a 4-layer, 0.8 mm board with ENIG plating, and the total thickness with components mounted comes to 2 mm. So it fits in a wallet and comes along without a second thought. On top of that, the cost is 8 dollars per board delivered, for a quantity of 100 pieces.
The LED bar reads the source’s capabilitiesAs soon as a USB PD charger is connected to the POWER port, the SOURCE CAPABILITY bar lights up for every voltage the source can supply, from 5 to 48 V. The mode indicators, meanwhile, show which PD modes the supply supports: PDO, PPS, SAVS and EAVS. That way you immediately know whether the charger in your pocket is enough for the job at hand.
An EPR charger lights up the whole bar, from 5 to 48 V. (photo: Anas Malas)
The voltage is selected with the V/A, FINE +/- and COARSE +/- buttons. The new value blinks until APPLY is pressed, or you hold APPLY to enable AUTO APPLY. The MODE button selects between AUTO, PDO, PPS, SAVS and EAVS, and holding it enables or disables EPR, the mode where 28 V and above live. Finally, the LOAD ON/OFF button enables the output to the load: the LOAD EN indicator lights up when the output is active and blinks if the output cannot turn on yet.
Holding V/A locks the buttons, to avoid accidental voltage changes while you work. Even with the buttons locked, though, LOAD ON/OFF keeps working.
About 200 0402 LEDs and a load below 90 uFThere are about 200 LEDs on the board. They are 0402 LEDs that produce 10 mcd while drawing less than 0.2 mA each, and they cost 0.004 dollars apiece. The TPD4S480 chip, which handles protection, costs 1.1 dollars at 1000 pieces. The rest of the bill of materials includes an LDO and some depletion-mode N-channel MOSFETs.
- Output voltage from 5 to 48 V, in 0.1 V steps
- Maximum deliverable current: 5 A
- Board thickness: 2 mm, PCB and components included
- 4-layer 0.8 mm PCB with ENIG plating
- About 200 0402 LEDs on the board
- Cost: 8 dollars per board delivered, for 100 pieces
- Load capacitance to keep below 90 uF
The load connects via a wire wedge, banana plug, crocodile clip or 0.1″ header. The load capacitance must be kept below 90 uF: it is a limit to respect, because the output does not like large capacitances in parallel. A PD power supply needs a charger or power bank of at least 20 W. For 28 V and above, on the other hand, you need an EPR charger, usually 140 W or more, and a 240 W cable.
0.1 header, banana plug and wire wedge with a crocodile clip and a wire. (photo: Anas Malas)
On the software side there is a web console that works in Chrome or Edge and in Chrome on Android. Firmware updates happen directly in the browser, on a Mac or an Android phone. The author also plans to make the library for the PD protocol open source. Bug reporting is enabled by default and can be turned off: it sends logs and black box data. Anyone who wants to follow the project or try the console will find everything on the maker’s site, where Anas Malas collects the web console and the firmware update page.
Source: https://anasmalas.com/bcv2/
The post A credit-card-sized portable bench power supply appeared first on Open Electronics.
TDK-Lambda CCG60: a 60W isolated DC-DC converter in a 1×1 inch footprint
TDK Corporation has introduced the TDK-Lambda CCG60, a 60 W isolated DC-DC converter in a compact 1 × 1 inch footprint. Part of the existing CCG series, the CCG60 delivers up to twice the power of the CCG30 in the same footprint, helping equipment designers add power without increasing the converter’s mounting area.
Key featuresModern electronic systems contain multiple discrete loads, while designers continue to face strict limits on board space, efficiency and thermal performance. The CCG60 addresses these requirements by delivering up to 60 W from a 25.4 × 25.4 mm footprint with an overall height of 13.0 mm and a weight of 30 g. TDK-Lambda comparisons show that the converter requires less than half the mounting area of selected competing products.
Two 4:1 input range options support commonly used system voltages. CCG60-24 models operate from 9 to 36 Vdc for 12 V and 24 V systems, while CCG60-48 models accept 18 to 76 Vdc. Both input ranges are available with nominal outputs of 3.3 V, 5 V, 12 V, 15 V or 24 V.
Efficiency reaches up to 93%, reducing power losses and easing thermal management. The CCG60 operates from -40 °C to +85 °C and delivers up to 60 W at an ambient temperature of 60 °C, with 30 W available at 85 °C under the stated operating conditions. Both convection and forced-air cooling are supported.
The CCG60 includes remote on/off control, output voltage adjustment and overcurrent protection. Input-to-output isolation voltage is 1500 Vdc for one minute, with an isolation voltage of 1000 Vdc from input or output to case, providing functional isolation.
Six-sided metal shielding reduces radiated and conducted EMI, helping to simplify system EMC compliance and cutting the time and cost associated with passing regulatory tests. The CCG60 is covered by a five-year warranty, giving customers confidence in long-term reliability and product performance.
Certification to IEC, EN, UL and CSA 62368-1 supports equipment compliance and covers operation at altitudes up to 5000 m. The converter is intended for industrial, test and measurement, communication and broadcast equipment.
You are invited to visit www.emea.lambda.tdk.com/en/ccg.
Main applicationsIndustrial, test and measurement, communication and broadcast equipment.
Key features and benefits- 60 W output in a compact 1 × 1 inch footprint, delivering up to twice the power of the CCG30 in the same board mounting area.
- Two 4:1 input ranges (9–36 Vdc and 18–76 Vdc) with 3.3 V, 5 V, 12 V, 15 V and 24 V output options, supporting a wide range of system voltages.
- Efficiency up to 93% and operation from -40 °C to +85 °C, helping to reduce power losses and support thermal performance in space-constrained designs.
- Six-sided metal shielding, which helps reduce radiated and conducted EMI.
- Built-in control and protection functions, including remote on/off, output voltage adjustment and overcurrent protection.
- IEC, EN, UL and CSA 62368-1 certification, with operation supported at altitudes up to 5000 m.
- Type: CCG60
- Isolated DC-DC converter
- Maximum output power: 60 W; 39.6 W (for 3.3 V models)
- Input voltage ranges: 9–36 Vdc or 18–76 Vdc
- Nominal output voltages: 3.3 V, 5 V, 12 V, 15 V or 24 V
- Maximum efficiency: 93%
- Operating temperature: -40 °C to +85 °C
- Weight: 30 g (typical)
- Dimensions (L x W x H): 25.4 × 25.4 × 13.0 mm
- Safety certifications: IEC, EN, UL and CSA 62368-1
For further information, visit www.emea.lambda.tdk.com.
The post TDK-Lambda CCG60: a 60W isolated DC-DC converter in a 1×1 inch footprint appeared first on Open Electronics.
MSI enters electric mobility with a dedicated EVSE division
MSI, a global leader in AI computing solutions and high-performance hardware, has announced its strategic entry into the Italian EVSE (Electric Vehicle Supply Equipment) market. The move is part of a wider expansion and diversification plan for the Group, which is already active worldwide in renewable energy and sustainable mobility. To drive business development in the country, MSI has set up a new dedicated business division, staffed by a local team, with the goal of positioning the company as a reference technology partner for businesses, infrastructure operators and private customers.
An engineering approach to charging infrastructure“An electric vehicle charging station is not simply a hardware terminal, but a genuine critical node for energy conversion and grid quality management,” said Elsa Yeh, Assistant Vice President of MSI’s EVSE division. “MSI approaches this sector by leveraging decades of leadership in precision electronics engineering and complex IT systems to offer a highly reliable and scalable technology platform, designed to guarantee maximum performance and operational continuity for every driver.”
MSI’s entry into the charging infrastructure sector responds to growing demand for reliable, efficient solutions capable of optimising the running costs of electric and hybrid vehicles, both for corporate fleets and for residential users.
The European and Italian charging market“The European charging infrastructure market, among the most advanced in the world for technology and innovation, is characterised by the presence of multiple global players and by regulation geared towards decarbonisation and smart energy management, supported by the growth of renewables and the digitalisation of energy systems. The charging point is increasingly part of an interoperable, interconnected ecosystem,” added Luca Griggio, Regional Business Development Manager, MSI EVSE. “This evolution is particularly evident in Italy, where the spread of distributed photovoltaics and of residential, corporate and public charging makes the integration of mobility and energy increasingly central. This is exactly the ground where MSI can make a difference: we bring our consolidated experience in electronics, computing and AIoT to electric charging. With one of the largest combustion-engine vehicle fleets on the continent, in full transition towards electric, Italy is a key market for MSI. That is why we have decided to invest directly in the country with a new local division, to respond promptly, extensively and with tailored solutions to the needs of Italian operators, installers and drivers.”
MSI’s offering for the EVSE marketThe offering that MSI will progressively introduce to the Italian EVSE (Electric Vehicle Supply Equipment) market includes a natively integrated ecosystem of hardware solutions and software management platforms, for both private users and business environments. In particular, the EZwall wallbox, the Hyper 80 Dual fast station and the EZgo mobile charger will arrive in the country in the coming months, alongside the aConnect and eConnect software platforms for remote control, management and monitoring.
An electric vehicle charging station: solutions like this make up MSI’s offering for the EVSE market.
The EZwall device reaches up to 22 kW in three-phase and is ready for integration with photovoltaic systems and energy management systems, while the Hyper 80 Dual goes up to 80 kW in direct current, can serve two vehicles at the same time and supports Plug & Charge via ISO 15118. The EZgo portable device, finally, is a transportable solution of up to 11 kW designed expressly for the European market.
With this model, MSI addresses both individual drivers and those operating in segments such as Real Estate, Retail & Large-Scale Distribution, Hospitality and Corporate Fleets, offering them a complete technology architecture from infrastructure production to operational management. For more information: https://evse.msi.com/it-it/.
The post MSI enters electric mobility with a dedicated EVSE division appeared first on Open Electronics.
A TV console inside an antenna connector: DOOM runs on the ESP32-S3
A complete TV console, battery included, inside an antenna connector. RayTriangle took a little box designed for something else entirely and stuffed into it everything needed to run DOOM on a PAL television. The video signal is generated by the ESP32-S3, then modulated onto a carrier wave and sent to the TV’s VHF tuner. So no HDMI, no SCART cables: just a screw-terminal connector bolted to the television.
The enclosure is the most curious part. The antenna connector with screw terminals is meant to match a 300 ohm balanced line to a 75 ohm coaxial cable. RayTriangle used it as a project box, exploiting the internal space for two boards and the battery. What’s more, the connector’s very format suggests the trick: the RF signal comes out of it and goes straight into the tuner.
The resistor-ladder DAC and the chrominance tableThe good-quality composite signal comes from a resistor-ladder DAC. To get the right colours, the firmware uses a lookup table with the phase-shifted chrominance waveforms for each colour. That way the video signal is not a simple pulse train, but a real composite, with the luminance and chrominance information in the right place.
Then comes the most old-school part of the whole project. The composite signal is modulated onto a carrier provided by the ESP’s clock generator. So the ESP32-S3 doesn’t just do the maths: its clock also becomes the reference for the RF modulation. As a result the signal comes out already ready for the VHF tuner, with no intermediate stages.
- ESP32-S3 as the console’s brain
- Resistor-ladder DAC for the composite signal
- Lookup table for the phase-shifted chrominance waveforms of each colour
- Modulation onto a carrier generated by the ESP clock
- Antenna connector with screw terminals as the enclosure
- Two boards either side of the battery, joined by a flexible PCB
The space inside the connector is tiny, so the hardware is split across two boards. They sit on either side of the battery and are joined by a flexible PCB. This way the battery takes up the centre and the two boards adapt to the shape of the enclosure. The flexible PCB also serves as both the electrical connection and the mechanical hinge.
The ESP32-S3 talks to a controller over Bluetooth. So the player has no wires to the console: the pad stays in your hands and the console stays screwed to the television. The video result, it must be said, is a bit noisy. Don’t expect the cleanliness of a digital signal: here you’re working with a resistor-ladder DAC and RF modulation, and a bit of noise is part of the package.
Anyone who wants to rebuild the project will find RayTriangle’s write-up on the project page on Hackaday.io. There you’ll find the choices made, the enclosure used and the tricks for fitting everything inside the connector. For anyone who wants to understand how to generate a composite signal with a microcontroller, it’s the right starting point.
Source: https://hackaday.io/contests
The post A TV console inside an antenna connector: DOOM runs on the ESP32-S3 appeared first on Open Electronics.
DIY ESP32 walkie-talkie: two-way voice and text messaging over radio
A self-built ESP32 walkie-talkie that brings two-way voice and text messaging into a single handheld device. Two identical units talk directly to each other over radio, with no mobile network and no internet. Inside each unit there is an ESP32, an INMP441 digital microphone, a MAX98357A amplifier with a 3 W speaker, a 0.96-inch OLED display, a 4×4 keypad and an nRF24L01 module with an RF antenna. The PCB is designed to measure so it sits comfortably in the hand. The project is by Md Mizanur Rahman, known as ElectroSurgeon, and is rated Advanced: it takes about 3 days of work.
The radio side is handled by the nRF24L01 module, so communication stays direct between the two units and does not go through any infrastructure. The firmware is also programmed with the Arduino IDE, so anyone who has already worked with the ESP32 finds a familiar environment. The code and project files are in Md Mizanur Rahman’s code repository, which is the starting point for rebuilding the two units.
I2S voice and T9 messages on the 4×4 keypadIn voice mode you select Walkie Talkie / Voice Mode from the menu and press the PTT button. Voice is captured by the INMP441 digital microphone over I2S. The ESP32 processes the digital audio and transmits it over radio through the nRF24L01 module to the other unit. The receiving ESP32 reconstructs the audio and sends it to the MAX98357A I2S amplifier, which drives the 3 W speaker. The result is two-way voice communication between the two handhelds.
In message mode you open Messages from the menu and type the text with the 4×4 keypad, using a T9/multi-tap scheme. Then you confirm and the ESP32 sends the data over radio. The receiving device shows the message on the 0.96-inch OLED display. The keypad is also used to navigate the menus, select characters, open the communication modes, confirm commands and control the device. So a single input block handles everything.
What you need to build the two unitsThe basic bill of materials is made up of a few parts, but each one has a precise role in the audio chain and in the radio chain. Here is the list of main components:
- ESP32, the microcontroller that processes audio and messages
- INMP441, digital microphone read over I2S
- MAX98357A, I2S amplifier for the speaker
- 3 W speaker
- 0.96-inch OLED display
- 4×4 keypad
- nRF24L01 module with RF antenna
- 0805 SMD LEDs for the PCB
Assembly revolves around the custom-designed PCB, which holds the board, radio, display and keypad together in a portable battery-powered format. Soldering the 0805 SMD LEDs is the finest part of the job, because the components are small and demand a steady hand. For the audio chain an INMP441 I2S MEMS microphone breakout is enough, while for the link between the two units the catalogue has a 2.4 GHz transceiver module with nRF24L01. For testing the display you can use a 0.96-inch I2C OLED display, handy for trying out menus and messages before moving to the final PCB.
The firmware is written and uploaded with the Arduino IDE. So the work sequence is this: prepare the PCB, solder the components, connect the microphone, amplifier, display, keypad and radio, then upload the firmware to both units. Finally you test short-range communication and check that voice and messages arrive correctly. The project is rated Advanced and takes about 3 days of work, between assembly and hardware debugging.
Related products- I2S MEMS Microphone Breakout – INMP441
- 2.4 GHz Transceiver Module with nRF24L01
- OLED Display I2C 0.96” – VCC/GND/SCL/SDA
The post DIY ESP32 walkie-talkie: two-way voice and text messaging over radio appeared first on Open Electronics.
eInfochips demonstrates end-to-end turnkey ASIC capability
eInfochips, an Arrow Electronics company and a provider of semiconductor and product engineering services, has announced that it has successfully demonstrated its end-to-end turnkey ASIC design capability for the development, fabrication, packaging and realisation of a test chip.
Architecture and features of the test chipThe architecture includes an integrated microcontroller for current and voltage monitoring, intelligent programmable control, diagnostics and software configurability. By combining these functions in a single device, the overall framework reduces component count and board complexity while improving system-level monitoring, protection and control.
Some of the electronic chips developed with the end-to-end turnkey design flow described in the article.
“Customers developing custom silicon often have to coordinate across design, foundry, packaging and the manufacturing ecosystem. This result demonstrates our ability to take greater responsibility along that path, helping customers reduce handoffs, improve accountability and move more efficiently from concept to working silicon.” – Sumit Sethi, Vice President and General Manager, Engineering Services, eInfochips
Expertise and programme supporteInfochips has supported automotive, industrial and semiconductor programmes for more than two decades, with capabilities spanning architecture, IP development, analog and mixed-signal design, verification, DFT, physical design, signoff, post-silicon engineering and manufacturing ecosystem coordination.
This demonstration reinforces eInfochips’ role as an engineering services provider able to support customers across the entire custom silicon development cycle, while adapting the underlying technical expertise to the customer’s specific requirements.
To learn more about eInfochips’ turnkey chip design services, visit: https://www.einfochips.com/services/silicon-engineering/turnkey-chip-design/
The post eInfochips demonstrates end-to-end turnkey ASIC capability appeared first on Open Electronics.
Home automation with the ESP32: managing loads through a web server
We manage loads through relays, remotely, using a smartphone, tablet or PC connected to the network on which a web server is installed.
Home automation is usually described as a set of automated electromechanical systems that, in the home environment, improve the quality of life of the occupants by eliminating human intervention as far as possible; but there is actually something more to it, because home automation includes selected forms of intelligence, a home network and/or a centralised distributed network, logic or a specific control unit. The simplest home automation system is based on an approach in which the functionality is hard-wired and integrated into the system and cannot be changed automatically without the intervention of an expert technician. Modern sensor technology, with the evolution of wireless solutions, expands the possibilities of sensing by connecting communication networks and the physical world, and enables wide-ranging home automation applications.
To introduce you to the potential of control systems in home automation, in this article we propose a simple practical project for controlling relays remotely through a web server.
The projectThe goal of our project is to demonstrate how relatively simple it is to control one or more relay modules remotely using a smartphone, tablet or PC connected to the network on which a web server is installed. The relays can be used to switch electrical loads such as lamps, power sockets, actuators in general, and so on, on and off from a distance. The circuit uses the ESP32 NodeMCU development board (Fig. 1) and a set of 5 relays controlled by the ESP32 through the digital outputs GPIO02, GPIO26, GPIO27, GPIO25 and GPIO33, connected respectively to the relay inputs IN1, IN2, IN3, IN4 and IN5.
Fig. 1 ESP32 NodeMCU development board.
In Fig. 2 you can see the basic block diagram of the relay controller we will implement, while in Fig. 3 we propose the corresponding wiring diagram, that is, the one for the complete system, complete with an 8-channel relay board.
Fig. 2 Basic block diagram of the relay controller.
Fig. 3 Electrical schematic of the relay control system, in this case paired with an 8-relay board.
The ESP32 NodeMCU development board is an IoT platform based on the Espressif Systems ESP-WROOM-32 module; in Fig. 4 you can see its pinout. The ESP-WROOM-32 is a powerful WiFi and Bluetooth BLE 4.2 microcontroller that can be used in a wide range of applications, from low-power sensor networks to more demanding uses such as voice coding, audio streaming and MP3 decoding. The module integrates the ESP32-D0WD chip, which belongs to the ESP32 chip series. The embedded chip is designed to be scalable and adaptive.
There are two CPU cores that can be controlled individually; the CPU clock frequency is adjustable from 80 MHz to 240 MHz. It is also possible to turn off the CPU and use the low-power coprocessor to constantly monitor the peripherals in order to detect any changes. The ESP32 integrates a rich set of peripherals, including capacitive touch sensors, Hall effect sensors, SD-Card, board interface, Ethernet, high-speed SPI, UART, I²S and I²C.
Fig. 4 Pinout of the ESP32 NodeMCU development board.
The integration of Bluetooth, Bluetooth LE and WiFi guarantees a wide range of applications. Using WiFi allows long range and a direct connection to the Internet through a WiFi router, while using Bluetooth lets the user connect conveniently to a phone or transmit at low energy so that other Bluetooth devices can detect it. The sleep current of the ESP32 chip is less than 5 µA, which makes it suitable for battery-powered electronic applications and wearable devices.
The module supports a data transmission rate of up to 150 Mbps and has an antenna output power of 20 dBm, guaranteeing a wide range for the RF signal. The module proves highly suitable for IoT applications, offering advanced specifications and the best performance in terms of electronic integration, range, power consumption and connectivity. The operating system chosen for the ESP32 is freeRTOS with integrated hardware acceleration. It also supports secure (encrypted) OTA (Over The Air) updates, so that users can update their products even after installation, with minimal cost and expenditure of time and effort.
Technical specifications and programming of the boardFig. 5 shows the block diagram of the ESP32 module. The ESP32 NodeMCU development board, being equipped with a micro USB connector, is programmable through a cable connected to the PC (USB-A/micro USB-B), which is also the path used for programming. As for connectivity, it is compatible with the WLAN 802.11 b / g / n and Bluetooth 4.2 / BLE protocols.
The CPU is a 32-bit dual-core Tensilica L108 running at 160 MHz, with 512 kB SRAM and 16 MB of Flash memory. It has 32 digital I/O pins (3.3 V logic levels), 6 analog-to-digital pins and various communication interfaces: 3 UARTs, 2 SPI ports, 2 I²C interfaces and a USB-to-UART interface through the CP2102 chip integrated on the board. The ESP32 NodeMCU development board can be programmed using Arduino code, Lua or MicroPython. Table 1 lists the technical specifications of the ESP32 NodeMCU board.
Fig. 5 Internal block diagram of the ESP32.
Table 1 Technical specifications of the ESP32 NodeMCU development board.
This project uses 5 relays; for convenience these relays can be split across relay boards that can be activated with TTL logic levels, like the ones for Arduino, so several two-relay boards such as the one shown in Fig. 6, one 4-relay board plus one 2-relay board, or an 8-relay board.
These boards typically have a common 5 Vdc supply line, and the control inputs each go to the base (with a limiting resistor in between) of an NPN transistor connected in common-emitter configuration, with the collector driving the coil of a relay.
Fig. 6 Two-relay module.
As a result of this configuration, when an input is taken to a high logic level the corresponding transistor saturates and effectively brings the relay coil to ground; since the other end of the coil is connected to the supply, the relay itself is energised, moving its moving armature and connecting together the Normally Open contact (NA or NO) and the common (C).
On the side near the relays there are three-terminal blocks (high-voltage section up to 250 VAC) for each relay, for connecting electrical loads: Common (COM), Normally Closed (NC), Normally Open (NO); on the opposite side there are pins for powering the relays and for the activation and deactivation command of each relay (inputs). Usually one of the two conductors of the power source of the load to be controlled (for example, one of the two mains voltage conductors) is connected to the COM terminal (common, otherwise indicated as C), breaking it; the piece of cable going to the load is instead connected to the NC or NO (NA) terminal, depending on the application.
NC and NO configurationsThe NC (Normally Closed) terminal is used when you want the relay to be closed at rest. In this mode, NC and COM are connected, that is, the conductor of the power source is common with NC. Conversely, NO (Normally Open) is not connected to COM, so the conductor of the power source connected to COM is not common with NO. Each module has a status LED for each channel (powered in parallel with the coil of the corresponding relay), whose lighting indicates that each relay is activated. Relay boards often have opto-isolated inputs, that is, coupled to the transistor bases through an optocoupler; in this case, with a LOW level applied to input IN1, the optocoupler LED will conduct, the status LED of the corresponding channel will light up, and the transistor inside the optocoupler will conduct, saturating the transistor that will activate the relay.
Having the full changeover contact for each relay, the following scenarios are possible:
- Normally closed configuration (NC): with an input signal at a high logic level, current flows between COM and NC of the relay, while when the input is at a low level the current is interrupted;
- Normally open configuration (NO): with an input signal at a high level the relay is at rest and the current is interrupted, while with a logic zero input the current flows between COM and NO.
There are also relay boards that provide two supply lines: one for the control logic and the other for the relay coils; for this purpose they have a jumper to choose what the coil supply is connected to, that is, whether to the 5V of the logic or to the dedicated contact. The latter configuration is used to electrically isolate the relay from the control circuit (the ESP32, in our case).
Programming the ESP32Having finished describing the hardware of the project, let’s move on to the software side: to program the ESP32 board you first need to install the driver that allows the board to communicate with the PC over USB; for this purpose, the ESP32 microcontroller uses the CP2102 chip for the USB serial interface to the PC.
Connect the ESP32 board to the computer with a USB-to-micro USB cable. If the computer’s operating system does not automatically recognise the CP2102 chip, you need to download the driver from http://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers and unzip it. On Windows, it is enough to install it by running “CP210xVCPInstaller_x86.exe” or “CP210xVCPInstaller_x64.exe”, depending on whether the operating system is 32- or 64-bit; on Mac, you install the DMG file in the uploaded archive. For Windows XP and Vista operating systems you need to install the driver from https://www.silabs.com/community/interface/knowledge-base.entry.html/2017/01/10/legacy_os_softwarea-bgvU .
After disconnecting and reconnecting the ESP32 board, in the list of communication peripherals in Windows a COM port should appear, identifiable as “Silicon Labs CP210x USB to UART Bridge”.
Installing the ESP32 board in the Arduino IDEThe next step is installing the Arduino software from the official site www.arduino.cc (in this article we refer to Arduino software version 1.8.9). When the program starts, from the Arduino IDE you need to install the ESP32 board. From File > Preferences, under “Additional Boards Manager URLs” enter the link https://dl.espressif.com/dl/package_esp32_index.json.
Then, with Tools > Board > Boards Manager, type “esp32” in the search bar; select and install the management firmware for the ESP32 board “ESP 32 by Espressif Sistems”. An image like the one shown in Fig. 7 will appear. Once the installation of the ESP32 board is complete, from Tools > Board, select the “ESP32 Dev Module” board or equivalent, then the upload speed of 115200, and finally select the COM port (on Windows) or ttyUSB (on Mac) corresponding to the CP210x USB to UART Bridge VCP driver. In order to verify that the ESP32 board works, we will test it with an example sketch.
Fig. 7 installation of the ESP32 board.
From the Arduino IDE, with File -> Examples -> WiFi -> WiFiscan, a new sketch called WiFiscan will open. Upload the code to the ESP32NodeMCU board by clicking the “->” (Upload) button. When the compilation and upload of the code are finished, open the Arduino serial monitor and set it to a baud rate of 115200 on the corresponding COM port: on the screen you will see something similar to what is shown in Fig. 8.
Having successfully verified the execution of the WiFiscan example program, we are certain that the ESP32 board works correctly, so we can proceed with the software for the relay controller. In this project a web server is implemented that allows you to control 5 relays via a smartphone, tablet or Personal Computer. By modifying a few lines of the web server code you can define the number of relays you want to control and the assignment of their control pins.
Fig. 8 Result of the WiFiScan sketch on the serial monitor.
To implement the web server we use the ESPAsyncWebServer library, which we will install following these steps: first of all, download the ESPAsyncWebServer.zip library from https://github.com/me-no-dev/ESPAsyncWebServer and copy it into a folder. In the Arduino IDE, with Sketch -> #include library -> Add library from .ZIP file, select the ESPAsyncWebServer.zip library that you downloaded and copied into a folder.
Installing the Async TCP library for ESP32The ESPAsyncWebServer library requires the AsyncTCP library, which we will install following these steps: download the AsyncTCP.zip library from https://github.com/me-no-dev/AsyncTCP and copy it into a folder. In the Arduino IDE, with Sketch -> #include library -> Add library from .ZIP file, select the AsyncTCP.zip library that you downloaded and copied into a folder.
Listing 1 shows the code of the relay controller.
Listing 1
/********* Rui Santos Complete The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. *********/
// Import required libraries #include “WiFi.h” #include “ESPAsyncWebServer.h”
// Set to true to define Relay as Normally Open (NO) #define RELAY_NO true
// Set number of relays #define NUM_RELAYS 5
// Assign each GPIO to a relay int relayGPIOs[NUM_RELAYS] = {2, 26, 27, 25, 33};
// Replace with your network credentials const char* ssid = “REPLACE_WITH_YOUR_SSID”; const char* password = “REPLACE_WITH_YOUR_PASSWORD”;
const char* PARAM_INPUT_1 = “relay”; const char* PARAM_INPUT_2 = “state”;
// Create AsyncWebServer object on port 80 AsyncWebServer server(80);
const char index_html[] PROGMEM = R”rawliteral( <!DOCTYPE HTML><html> <head> <meta name=”viewport” content=”width=device-width, initial-scale=1″> <style> html {font-family: Arial; display: inline-block; text-align: center;} h2 {font-size: 3.0rem;} p {font-size: 3.0rem;} body {max-width: 600px; margin:0px auto; padding-bottom: 25px;} .switch {position: relative; display: inline-block; width: 120px; height: 68px} .switch input {display: none} slider {position: absolute; top: 0; left: 0; right: 0; bottom: 0; background-color: #ccc; border-radius: 34px} .slider:before {position: absolute; content: “”; height: 52px; width: 52px; left: 8px; bottom: 8px; background-color: #fff; -webkit-transition: .4s; transition: .4s; border-radius: 68px} input:checked+.slider {background-color: #2196F3} input:checked+.slider:before {-webkit-transform: translateX(52px); -ms-transform: translateX(52px); transform: translateX(52px)} </style> </head> <body> <h2>ESP Web Server</h2> %BUTTONPLACEHOLDER% <script>function toggleCheckbox(element) { var xhr = new XMLHttpRequest(); if(element.checked){ xhr.open(“GET”, “/update?relay=”+element.id+”&state=1”, true); } else { xhr.open(“GET”, “/update?relay=”+element.id+”&state=0″, true); } xhr.send(); }</script> </body> </html> )rawliteral”;
// Replaces placeholder with button section in your web page String processor(const String& var){ //Serial.println(var); if(var == “BUTTONPLACEHOLDER”){ String buttons =””; for(int i=1; i<=NUM_RELAYS; i++){ String relayStateValue = relayState(i); buttons+= “<h4>Relay #” + String(i) + ” – GPIO ” + relayGPIOs[i-1] + “</h4><label class=\”switch\”><input type=\”checkbox\” onchange=\”toggleCheckbox(this)\” id=\”” + String(i) + “\” “+ relayStateValue +”><span class=\”slider\”></span></label>”; } return buttons; } return String(); }
String relayState(int numRelay){ if(RELAY_NO){ if(digitalRead(relayGPIOs[numRelay-1])){ return “”; } else { return “checked”; } } else { if(digitalRead(relayGPIOs[numRelay-1])){ return “checked”; } else { return “”; } } return “”; }
void setup(){ // Serial port for debugging purposes Serial.begin(115200);
// Set all relays to off when the program starts – if set to Normally Open (NO), the relay is off when you set the relay to HIGH for(int i=1; i<=NUM_RELAYS; i++){ pinMode(relayGPIOs[i-1], OUTPUT); if(RELAY_NO){ digitalWrite(relayGPIOs[i-1], HIGH); } else{ digitalWrite(relayGPIOs[i-1], LOW); } }
// Connect to Wi-Fi WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.println(“Connecting to WiFi..”); }
// Print ESP32 Local IP Address Serial.println(WiFi.localIP());
// Route for root / web page server.on(“/”, HTTP_GET, [](AsyncWebServerRequest *request){ request->send_P(200, “text/html”, index_html, processor); });
// Send a GET request to <ESP_IP>/update?relay=<inputMessage>&state=<inputMessage2>
server.on(“/update”, HTTP_GET, [] (AsyncWebServerRequest *request) {
String inputMessage;
String inputParam;
String inputMessage2;
String inputParam2;
// GET input1 value on <ESP_IP>/update?relay=<inputMessage>
if (request->hasParam(PARAM_INPUT_1) & request->hasParam(PARAM_INPUT_2)) {
inputMessage = request->getParam(PARAM_INPUT_1)->value();
inputParam = PARAM_INPUT_1;
inputMessage2 = request->getParam(PARAM_INPUT_2)->value();
inputParam2 = PARAM_INPUT_2;
if(RELAY_NO){
Serial.print(“NO “);
digitalWrite(relayGPIOs[inputMessage.toInt()-1], !inputMessage2.toInt());
}
else{
Serial.print(“NC “);
digitalWrite(relayGPIOs[inputMessage.toInt()-1], inputMessage2.toInt());
}
}
else {
inputMessage = “No message sent”;
inputParam = “none”;
}
Serial.println(inputMessage + inputMessage2);
request->send(200, “text/plain”, “OK”);
});
// Start server
server.begin();
}
void loop() {
}
Customising the softwareYou can set the relay configuration to normally open (NO) or normally closed (NC) by changing the variable “#define RELAY_NO true”: true for NO, false for NC. By changing the variable “#define NUM_RELAYS 5”, you can define the number of relays you want to include in the project.
Of course, the number of relays set by the NUM_RELAYS variable must match the number of GPIOs assigned in the relayGPIOs array; in fact, with the array variable “int relayGPIOs [NUM_RELAYS] = {2, 26, 27, 25, 33};”, you can define the ESP32 GPIO relay control digital ports. Finally, you need to enter the WiFi network credentials in the following variables:
const char * ssid = “REPLACE_WITH_YOUR_SSID”;
const char * password = “REPLACE_WITH_YOUR_PASSWORD”;
After installing the required libraries and making the desired software changes in the code, copy the code into a new sketch and upload it to the ESP32 board.
Practical buildAt this point, with all the necessary software installed, you can go ahead and assemble the components of the relay controller prototype, that is, the ESP32 board, five relays, some jumpers and an experimental breadboard, following the connections of the wiring diagram shown in Fig. 3.
For the power supply of the circuit it is advisable not to use the PC’s USB ports, so the prototype can be powered by connecting an external 5V power supply to the micro USB connector of the board, or by connecting an external power supply with a voltage from 7 to 12 V to the 5V (Vin) and GND pins of the board; in both cases, the external power supply must be able to deliver a current of at least 150 mA.
Be careful that the ESP32 board must be powered by only one of the above voltages. Using more than one power supply at the same time could irreparably damage the board and the corresponding power supplies.
Testing the systemOpen the serial monitor set to a baud rate of 115200 and press the RESET button. On the monitor you will be able to read the IP address of the ESP32 board, which you should note down.
Now, open a browser on a device connected to the local WiFi network and type the IP address of the ESP32 you noted down earlier to access the web server.
If everything has been done correctly, on the display of the mobile device or on the PC monitor you should see buttons in a number corresponding to the number of relays defined in the code (Fig. 9). Well, with this we are done.
Fig. 9 Web server on a smartphone (Source: Random)
The post Home automation with the ESP32: managing loads through a web server appeared first on Open Electronics.
DNS blocking on ESP32-C3: ad-free browsing without PSRAM
An open source Pi-hole-style DNS blocker runs on a 2-dollar ESP32-C3 Super Mini module and filters ads and trackers for every device on a home or small office network. The firmware answers 0.0.0.0 to queries for domains on the blocklist and forwards the rest to an external DNS server. What sets it apart from the usual network adblockers is the method: the domain strings are not kept in RAM, but in flash as sorted 40-bit FNV-1a hashes. That way more than 140,000 domains take up about 0.7 MB of flash and only about 50 KB of RAM, with no need for PSRAM. The project is by Zed (M-Abozaid) and the code lives in a public repository.
The heart of the system is the ESP32-C3FH4 module: single-core 32-bit RISC-V CPU up to 160 MHz, 400 KB SRAM, 4 MB of flash, 2.4 GHz WiFi 4 and a USB Type-C port for programming. Power comes in at 5V over USB and needs a stable source to avoid radio brownouts. In the minimal version, all you need is a compact ESP32-C3 module with USB Type-C plugged directly into a router’s USB port, as shown in the photo below.
DNS blocker on an ESP32-C3 SuperMini connected directly to a router’s USB port
When a UDP DNS query arrives, the C++ firmware extracts the domain, computes its hash including the parent suffixes and does a binary search in the hash table in flash. If the domain is on the blocklist it answers 0.0.0.0; otherwise it forwards the query upstream and returns the response to the client. A DNS lookup takes about 10 ms, including roughly 18 flash reads and the Wi-Fi round-trip. The blocklist check alone costs 50 microseconds.
The capacity figures depend on the partition chosen. With 40-bit hashes you get about 141,000 domains with almost no collisions, about 250,000 domains with dual-app partitions for firmware OTA, or up to about 537,000 domains with a single-app partition and about 1 collision. On a 4 MB ESP32-C3 board, OTA firmware updates require two application slots, leaving about 1.3 MB of flash for the blocklist. With 32-bit hashes you save flash space, but you would get about seven collisions at 250,000 domains.
- ESP32-C3 Super Mini with 4 MB of flash: over 140,000 domains in about 0.7 MB, 50 KB of RAM, 50 microseconds per check
- ESP32-S3 with 8 MB PSRAM: holds the current blocklist, checks in 50 microseconds, about twice as fast as the ESP32
- ESP32 with 4 MB PSRAM: truncates the current blocklist, checks in 100 microseconds
- ESP32-S3 with 16 MB: about 2.7 million domains with 40-bit hashes, versus about 466,000 domains as strings in 8 MB of PSRAM
The web dashboard is reachable at c3adblock.local and shows blocked and allowed DNS requests per client, lets you block specific devices and add custom domains to the blocklist. Initial Wi-Fi configuration happens through a captive portal, so there is no need to put the credentials in the code. Firmware and blocklist OTA updates are also supported, with scheduled automatic updates that download precompiled blocklist files from a specified URL.
The software is built with an Arduino sketch (ESP32_AdBlocker), esp32 arduino core minimum v3.1.1 and PlatformIO. For automatic blocklist updates the firmware uses a WebDAV client with HTTP Basic Auth. Anyone who wants to rebuild the project will find the code to compile and the files to upload in Zed’s (M-Abozaid) repository.
The minimal build needs no soldering: you plug the module into the router’s USB port, configure the captive portal and point the router’s DHCP to the board’s address. For a wired variant, the project also provides for a W5500 Ethernet controller and a WS2812 RGB LED for status: the catalogue includes the mini Ethernet board with W5500 chip and the WS2812B addressable RGB LED.
Source: https://github.com/s60sc/ESP32_AdBlocker
Related products- Mini ESP32-C3 module
- Mini Ethernet Board with W5500 chip
- Addressable SMD5050 RGB LED with WS2812B chip – NEOPIXEL
The post DNS blocking on ESP32-C3: ad-free browsing without PSRAM appeared first on Open Electronics.
A 38-Year-Old NEC ProSpeed 286 Lives Again Thanks to a Raspberry Pi
A 38-year-old NEC ProSpeed 286 is running again, but the original hardware is no longer inside. Cory Whitesell replaced the failed components with a Raspberry Pi and a modern LCD display, keeping the original case, keyboard and power supply. The machine thus emulates DOS and runs the titles of the era, while at the same time remaining usable today as a small complete computer.
The most interesting part is that nothing of the original hardware was thrown away. The removed parts are set aside, ready for a possible future restoration. So the project does not destroy a vintage laptop: it puts it on pause and gives it a second life with current components.
The original power supply handles the Raspberry Pi and displayThe power supply of the NEC ProSpeed 286 stays intact and keeps doing its job. The original hard disk’s 4-pin molex connector delivers 5V and 12V. The Raspberry Pi is powered directly from the 5V, while the LCD display takes the 12V. In practice the project reuses the laptop’s power section as if it were an already wired bench power supply.
This choice greatly simplifies the assembly. No external power supply is needed, no extra outlet is needed, and no voltage conversion is needed. Moreover, the 4-pin molex connector is a standard format, so you just need to recover the right wiring and connect the two branches. Anyone who wants to rebuild the project starts right here, because without stable power the rest does not run.
- Original NEC ProSpeed 286 power supply: provides 5V and 12V
- Original hard disk 4-pin molex connector: the tap point
- Raspberry Pi: powered from the 5V
- Modern LCD display: powered from the 12V
- Original AT keyboard: connected via a PS/2 to USB adapter
- Plexiglass plate: holds the display using the original mounting holes
- New back plate: hosts external USB and audio ports
The original keyboard is an AT type and does not speak USB. So Whitesell connects it to the Raspberry Pi with a PS/2 to USB adapter. This preserves the mechanical feel of the original keys, which is half the charm of a machine like this.
The original passive display was replaced with a modern LCD panel of the same size. The new screen is fixed to a plexiglass plate that reuses the mounting holes already present in the case. As a result, nothing new needs to be drilled and the installation remains reversible. A new back plate hosts the external USB and audio ports, which the original laptop did not have.
Anyone who wants to replicate the work will find the full account of the conversion on Cory Whitesell’s project page on Hackaday.io. There you can see how the parts were connected and which choices kept the original case alive.
For those starting from scratch with a similar project, a development kit with power supply and microSD immediately covers the computing and boot side. Alternatively, a Raspberry Pi 5 board in the 2 GB version is enough for DOS emulation, which does not need much memory.
What you need to redo the conversionThe project does not require complicated soldering. You need a NEC ProSpeed 286 laptop with the case and keyboard in good condition, a Raspberry Pi, a modern LCD display with its driver board, a PS/2 to USB adapter, a 4-pin molex connector and a sheet of plexiglass cut to size. Then it takes patience to line up the holes and route the cables without forcing the case.
The software is DOS emulation. Once the Raspberry Pi boots and the keyboard responds, you configure the emulator and load the games. The machine then becomes a complete retro battlestation, with the looks of a 38-year-old laptop and the responsiveness of a modern computer.
The main limitation is the display: the modern LCD panel does not have the rendering of the old passive screen, but it is readable and reliable. Also, the original power supply, if it is still the factory one, should be checked before connecting the Raspberry Pi to it. Finally, the AT keyboard, however solid, does not have all the keys of a modern keyboard, and this is noticeable when you exit the emulator.
Source: https://hackaday.io/project/187431-retro-battlestation
Related products- Raspberry Pi 5 Starter Kit with 27 W Power Supply and 64 GB microSD
- Raspberry Pi 5 – 2 GB memory version
The post A 38-Year-Old NEC ProSpeed 286 Lives Again Thanks to a Raspberry Pi appeared first on Open Electronics.
ESP32 goes to the cloud: the Demoboard on Arduino IoT Cloud
We interface our Demoboard ESP32 with Arduino IoT Cloud, to display and control sensors remotely through a web dashboard and a smartphone app.
Recently we devoted three articles to a project we wanted in order to make prototyping easier for IoT applications and systems, based on a processing unit and a set of peripherals including both local sensors and actuators and ones that can be connected through connectors; the computing unit we chose is an ESP32 SoC with wireless connectivity, mounted on a YB555 board, while the peripherals are both local relays and buttons and pressure, temperature, air and water quality and atmospheric activity sensors, as well as interfaces such as NFC/RFID supplied as breakout boards that can be fitted to the board through suitable connectors. With this board we prepared some demo applications to explain how to use the related hardware, staying however in the local domain, that is on acquiring environmental parameters through the sensors and on managing actuators locally. All the related data was processed locally and used, for example, to be shown on the on-board OLED display or to drive local actuators.
After giving you an overview of what can be done with the Demoboard ESP32 and its expansion connectors, we take a step up in quality and move the applications towards the Internet. In particular, in this instalment we see how to connect everything to the cloud, so that sensors and actuators can be displayed and controlled remotely, through a web dashboard and a mobile smartphone application.
Arduino IoT CloudTo do this we will use not just any cloud, but the Arduino Cloud platform, and in particular the Arduino IoT Cloud application; this is because at heart our demoboard is based on Arduino-compatible hardware, which is the ESP32 wireless board: it is no coincidence that we program it with the Arduino IDE.
To use the Arduino environment’s cloud and build applications that interface with it, the first thing to do is create an Arduino account, visiting https://cloud.arduino.cc and clicking, on the web page that appears, on the “Get Started” button.
Doing so will show a form to log in to the platform, but we will select “Don’t have an account yet? Create one”. After following the necessary steps and confirming the e-mail address, we will find ourselves on the Arduino Cloud home, where we will click on the “IoT Cloud” icon.
The concepts of Thing, Cloud Variable and DeviceThe platform is based on a few very simple concepts, the main one being the “Thing”, that is the virtual representation of an object with certain characteristics, where each characteristic corresponds to a “Cloud Variable”, which in practice behaves exactly like a normal variable of the Arduino language, but can be controlled via the cloud.
Then we have the “Device”, which corresponds to a physical device, which in the case of this example is our Demoboard ESP32. By creating an ESP32 “Device”, a corresponding “Thing” and a suitable sketch, we will connect our Demoboard to the Arduino IoT Cloud.
Creating the Thing’s variablesSo let’s start by creating our “Thing”, clicking on the “Create Thing” button in the web interface. The first thing to do is give it a name, for example “Demo Board ESP32”; we will then go on to create 4 variables, because 5 is the maximum limit allowed by the free plan (for more information on paid plans the reference site is https://cloud.arduino.cc/plans ).
Working with a free account, we will therefore create four variables, one for each of the following sensors/actuators: altitude, temperature, pressure, OLED display. To do this we will click on “Add variable” for each of these and open the dialog shown in Fig. 1, where we will assign the name to each variable (the procedure must be repeated four times, once for each variable) and define the type.
Fig. 1 Creating the variables.
For the variables, we will have to define the parameters as described below:
- Name: altitude, Type: float, Variable Permission: read only, Update policy: on change
- Name: temperature, Type: float, Variable Permission: read only, Update policy: on change
- Name: pressure, Type: float, Variable Permission: read only, Update policy: on change
- Name: message, Type: string, Variable Permission: read write, Update policy: on change
After clicking on the green ADD VARIABLE button at the bottom of the window, we will reach the dialog shown in Fig. 2, where we will find the created variables listed. After creating the variables, the structure of the sketch will be created automatically: you can see an example in Fig. 3.
Fig. 2 The created variables.
Fig. 3 The sketch created with the defined variables.
At this point the next step is to create a Device to associate with the Thing we have just created. To do this, we will click on “Devices” in the top menu, and then on “Add device”; now we can create a new device which we will call ESP32, to associate its name mnemonically with the Demoboard ESP 32, which is the Device that in this application example we will connect to the Arduino cloud.
To do this, we select “Set up a 3rd party device” -> ESP32 Dev Module. In the window that appears we will be asked to give the device a name (Fig. 4) and for our purposes we can use any one we like, such as a simple “ESP32”.
Fig. 4 Creating the device to connect to the cloud.
In the next step, we will have to download the access credentials that have been created, which we will need when configuring the Thing. Once the Device has been created, we go back to the “Things” section and click on the “Associate device” entry next to the name of our thing, then on the “Associate” button, to associate our ESP32.
We then click on our thing “Demo Board ESP32”, and then on the “Configure” button in the Network section. On the page that opens we can enter our credentials for accessing the WiFi network to connect to for the cloud connection, as well as the secret key generated during the creation of the Device.
At this point our Demoboard is almost ready to be connected to the cloud; so we can physically connect the Demoboard ESP32 to the PC via USB cable, at which point the IoT Cloud editor will recognise it automatically and the sketch can be uploaded.
We then modify the sketch as shown in Listing 1, so that it can correctly send the contents of our variables to the cloud.
Listing 1/* Sketch generated by the Arduino IoT Cloud Thing “Demo board” https://create.arduino.cc/cloud/things/cbb4ac0a-4088-43ea-94b4-33794638910e Arduino IoT Cloud Variables description The following variables are automatically generated and updated when changes are made to the Thing String message; float altitude; float pressure; float temperature; Variables which are marked as READ/WRITE in the Cloud Thing will also have functions which are called when their values are changed from the Dashboard. These functions are generated with the Thing and added at the end of this sketch. */
#include “thingProperties.h” #include <Adafruit_SSD1306.h> #include <Adafruit_BMP280.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels #define SCREEN_HEIGHT 64 // OLED display height, in pixels #define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin) #define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128×64, 0x3C for 128×32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); Adafruit_BMP280 bmp;
void setup() { // Initialize serial and wait for port to open: Serial.begin(9600); // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) { Serial.println(F(“SSD1306 allocation failed”)); for(;;); // Don’t proceed, loop forever }
if (!bmp.begin(0x76)) { Serial.println(F(“Could not find a valid BMP280 sensor, check wiring!”)); while (1); }
/* Default settings from datasheet. */ bmp.setSampling(Adafruit_BMP280::MODE_NORMAL, /* Operating Mode. */ Adafruit_BMP280::SAMPLING_X2, /* Temp. oversampling */ Adafruit_BMP280::SAMPLING_X16, /* Pressure oversampling */ Adafruit_BMP280::FILTER_X16, /* Filtering. */ Adafruit_BMP280::STANDBY_MS_500); /* Standby time. */
// This delay gives the chance to wait for a Serial Monitor without blocking if none is found delay(1500);
// Defined in thingProperties.h initProperties();
// Connect to Arduino IoT Cloud ArduinoCloud.begin(ArduinoIoTPreferredConnection);
/* The following function allows you to obtain more information related to the state of network and IoT Cloud connection and errors the higher number the more granular information you’ll get. The default is 0 (only errors). Maximum is 4 */ setDebugMessageLevel(2); ArduinoCloud.printDebugInfo(); } void loop() { ArduinoCloud.update(); temperature = bmp.readTemperature(); pressure = bmp.readPressure(); altitude = bmp.readAltitude(); } void setText(String message) { display.clearDisplay(); display.setTextSize(2); // Draw 2X-scale text display.setTextColor(SSD1306_WHITE); display.setCursor(0, 0); display.println(message); display.display(); // Show initial text } /* Since Message is READ_WRITE variable, onMessageChange() is executed every time a new value is received from IoT Cloud. */ void onMessageChange() { setText(message); Serial.println(message); }
How cloud variables workAs you will notice, to make sure the variables are sent correctly to the cloud, you simply assign them to our sensors, and their values will be sent automatically.
As for the “message” variable, it is handled through the onMessageChange() callback, which is called every time we set a value for this variable from our web dashboard.
We can now finally upload the sketch by clicking on the play icon. Once the upload is finished, you can open your serial monitor and check that the board has connected correctly to the cloud.
Creating the dashboardAt this point all that is left is the final step, which consists of creating a dashboard to monitor the values coming from the sensors and to drive the OLED display. Creating a dashboard is very simple and intuitive: just click on the “Dashboards” section and then on the “Create” button.
An empty dashboard will then open, so we click on the pencil icon in the top left corner to enable edit mode and then start adding our widgets to populate the dashboard itself.
So let’s click on “Add” and select “Value”. To connect this widget to one of our cloud variables, we click on “Link variable” on the right and select, for example, the “altitude” variable we created earlier, then confirm by clicking on “Link variable” and then on “Done”. We have now created and linked our first widget; if we want, we can repeat the operation for the “temperature” and “pressure” variables too, and create dedicated widgets.
Completing the dashboard and the mobile appTo control the display, let’s create another “Value” widget and link it to the “message” variable. Once that is done, by typing any message in our widget, we will see it appear on the OLED display of our ESP32 Demoboard as well. By practising a bit with the widgets, you can get a dashboard like the one shown in Fig. 5.
Note that the same dashboard, suitably adapted, can also be used from smartphones and mobile devices running Android or iOS, by downloading the “Arduino IoT Cloud Remote” application directly from your operating system’s app stores.
Fig. 5 Example of a dashboard displaying the pressure sensor reading.
Well, with this example of connection to Arduino IoT Cloud we are done.
It goes without saying that the proposed example can be repeated for acquiring other data, coming from the various onboard sensors or sensors that can be connected to the demoboard: you just need to create the appropriate widgets to interact, through the dashboard, with the hardware selected as Device and therefore with the ESP32 Demoboard.
The post ESP32 goes to the cloud: the Demoboard on Arduino IoT Cloud appeared first on Open Electronics.
Mouser and Microchip: an e-book on the Cyber Resilience Act
Mouser Electronics, Inc., a leading distributor for new product introduction (NPI) with the broadest selection of semiconductors and electronic components, announces a new e-book in collaboration with Microchip Technology: Designing for the Cyber Resilience Act: Securing Connected Devices from First Schematic to Final Decommissioning.
As connected products are increasingly used in industrial, consumer, infrastructure and IoT applications, cybersecurity has to be addressed across the entire product lifecycle. Starting in December 2027, products with digital elements, including hardware or software with direct or indirect connections to other devices or networks, must meet the essential cybersecurity requirements of the European Union’s Cyber Resilience Act (CRA) before they can carry the CE marking and be placed on the EU market. The regulation therefore makes cybersecurity an essential condition for market access, alongside the product requirements that are already well established.
A journey through the whole security lifecycleThe new e-book follows a connected product through its entire security lifecycle. With contributions from Tim Scherer, Senior Embedded Solutions Engineer for Cyber Resilience at Microchip Technology, the text examines the scope, deadlines and reference standards of the CRA; the design decisions that define the security architecture; prototype validation; provisioning at production scale; and the management of device identity, credentials and updates during field operation, through to secure end of life.
Key topics of the e-book- How to determine whether a product falls within the scope of the CRA, carry out a risk assessment based on intended use, data and connections, and apply secure-by-design and secure-by-default principles
- Defining the fundamental building blocks of device security: a secure boot chain, firmware integrity, key protection and, where required, encryption of sensitive data
- Selecting a hardware root of trust, including secure elements that generate and protect private keys and enable cryptographic operations
- Building prototypes with pre-configured device identities, followed by planning secure provisioning of keys and certificates at industrial scale
- Ensuring secure device integration, authenticated firmware updates, credential rotation, vulnerability management and secure decommissioning throughout the product lifecycle
The e-book also explores the practical choices involved in implementing these features, including the use of Microchip’s ATECC608C secure element, the CryptoAuth Trust Platform DM320118 development board and the CryptoAuth Pro Trust EV89U05A platform. The Trust Platform Design Suite, the TrustMANAGER managed provisioning service and the keySTREAM connectivity architecture, available after registration on Microchip’s website, offer an end-to-end approach to IoT security that simplifies the management of keys and certificates as well as FOTA updates for designs based on the ATECC608.
By connecting the obligations of the CRA with the engineering solutions needed to meet them, the e-book gives design teams a practical reference model for integrating cybersecurity into connected product development from the very start of the development cycle.
Download and resourcesTo download the e-book Designing for the Cyber Resilience Act, visit the dedicated page. To browse the extensive Mouser e-book library, visit the site. For more news about Mouser and the latest product announcements, visit the newsroom.
As an authorized global distributor, Mouser offers the broadest selection of semiconductors, next-generation electronic components and the newest products for industrial automation. Mouser customers can count on original, 100% certified and fully traceable products from each of its manufacturer partners. To help speed up customer designs, Mouser’s website hosts a large library of technical resources, including a Technical Resource Center, and offers product datasheets, supplier-specific reference designs, application notes, technical design data, engineering tools and other useful information.
Thanks to Mouser’s free newsletter, engineers can keep up with the latest news on products, technologies and applications. Mouser’s email news and reference resource subscriptions can be customized to the specific and changing design needs of customers and subscribers. No other distributor gives engineers this level of customization and control over the information they receive. Discover emerging technologies, product trends and much more by subscribing today.
Mouser offers thousands of industrial automation products, in stock and ready for immediate shipment. From predictive maintenance devices and control panels to a complete range of industrial power products, sensors and safety devices, Mouser’s portfolio is available to customers to help them design, build and maintain complete automation solutions. For more information, visit the industrial automation page.
The post Mouser and Microchip: an e-book on the Cyber Resilience Act appeared first on Open Electronics.
A DIY H-shifter for driving simulators built from just two components
An H-pattern shifter for driving simulators can be built from just two basic electronic components. That is what Jason did, combining an analog joystick salvaged from a game controller with an Arduino Pro Micro. A 3D printer and ready-made firmware take care of the rest. This makes a DIY H-shifter a project within reach of anyone with a board in a drawer and a bit of filament.
The starting point is a joystick like the ones found inside many game controllers. Jason connects it to the Arduino Pro Micro with very simple wiring, so no shields, adapters or tricky soldering are needed. The two electronic components then go inside a 3D-printed prototype case, completed by a gear knob that reproduces the chosen H pattern. In practice, the mechanics of the shifter are all in the geometry of the knob and the case, while the electronics simply read the joystick’s movement.
The firmware and the shifter optionsThe firmware is already available and is loaded onto the board once everything is assembled. It is not a single fixed block: it offers many options for different shifter configurations, so it adapts to different patterns and behaviours without rewriting the code from scratch. For anyone wanting to rebuild the project, this is the part that saves the most time, because the work of reading the joystick and sending commands to the simulator is already done.
Anyone who wants to replicate the DIY H-shifter can start from just a few parts. The basic list is short:
- an analog joystick like the ones in game controllers
- an Arduino Pro Micro
- 3D-printed case and knob
- the ready-made firmware, to be loaded onto the board
If the joystick does not come from a discarded controller, there is a small analog resistive joystick that works on the same principle as the one used in the PSP1000. Instead of the Pro Micro you can also use an Arduino Micro, which carries the same ATmega32U4 and presents itself to the PC as a USB joystick or keyboard.
Case and knob: 3D printing makes the H patternThe mechanical side is all in the 3D prints. The prototype case holds the joystick and the board together, while the gear knob implements the chosen H pattern. Changing the knob changes the gear layout, so the project adapts to different configurations without touching the electronics. The result is a very low-cost H-shifter prototype, intended for a simulated driving setup rather than for surviving hours of competition.
Anyone who wants to see how the project is made and where to start will find everything on the project page on Hackaday.io, where Jason collects the work on the shifter. There you can also see which options the firmware offers and how the assembly is organised.
The interesting thing is the ratio between effort and result. Two salvaged components, a 3D print and ready-made firmware are enough to have a working H-shifter. You do not need a fully equipped workbench, and you do not need dedicated encoders or sensors. For anyone who wants to get into driving simulation without immediately buying a commercial peripheral, this DIY H-shifter is a concrete starting point.
Source: https://hackaday.io/contests
Related productsThe post A DIY H-shifter for driving simulators built from just two components appeared first on Open Electronics.
Wearable Arc Reactor Mark I: a self-contained ESP32-C3 replica
A wearable, self-contained replica of Tony Stark’s Arc Reactor Mark I, with no network connection and battery powered. On power-up it lights up immediately with an organic cyan pulse generated by a NeoPixel ring. The project is by Yiğit and takes about 4 hours to complete with Arduino IDE. The heart of it is a Seeed Studio XIAO ESP32C3, flanked by a TP4056 for charging, a 3.7 V LiPo cell and a slide switch.
The most interesting part is the coexistence of an ESP32-C3 and addressable LEDs inside a wearable shell. Two classic problems come up straight away: the Brownout Detector reboot loop and the logic levels between the microcontroller and the WS2812B. Both are solved with precise choices in the firmware and in the power supply.
The circuit: GPIO 3, a 24-LED ring and the TP4056An ESP32-C3 SuperMini drives a 24-LED WS2812B NeoPixel ring through GPIO 3, with the NEO_GRB and NEO_KHZ800 protocol. The 3.3 V logic level of GPIO 3 is enough to drive the WS2812B without a level shifter, because the lower supply voltage lowers the required input threshold. At 5 V that threshold would be about 0.7 * V_CC, roughly 3.5 V, and the microcontroller’s signal would not reach it.
Power comes from a single LiPo cell, with a voltage between 3.7 V and 4.2 V, charged through a TP4056. A slide switch turns everything on and off. Anyone who wants to rebuild the project with a different module can look at the Seeed XIAO ESP32C3 board, which is the same family as the one used here. Alternatively a mini ESP32-C3 module works well, since it has the same chip and is just as compact.
The firmware: cyan pulse and CPU at 80 MHzThe firmware pulses the brightness between a minimum of 20 and a maximum of 150, with a fixed cyan colour applied to all 24 LEDs. The RGB value set is 15, 200, 255. The initial brightness in the code is 30 and the delay between one update and the next is 25 milliseconds. This makes the pulse look organic rather than stroboscopic.
To avoid the continuous reboots caused by the Brownout Detector, the Wi-Fi and Bluetooth initialisations are removed, the CPU frequency is lowered to 80 MHz and the hardware is left to start up naturally. The ESP32-C3 Brownout Detector trips at around 2.8 V, so removing the radio and high-clock loads keeps the LiPo cell voltage far from that threshold.
- 24-LED WS2812B NeoPixel ring on GPIO 3, NEO_GRB + NEO_KHZ800 protocol
- Brightness pulse between 20 and 150, RGB colour 15, 200, 255
- 25 millisecond delay between one update and the next
- CPU at 80 MHz, Wi-Fi and Bluetooth disabled to avoid the Brownout Detector
- Powered by a 3.7 V LiPo cell with TP4056 charging and a slide switch
The shell is 3D printed in transparent PETG and white PLA, with the print scale set to 113% to fit the NeoPixel LEDs. The enlargement factor is needed precisely because the ring used in the project has 24 LEDs. The files to print are collected on Yiğit’s page with the printable files, where the parts ready for the printer can be found.
Assembly stays simple: fix the NeoPixel ring into the shell, connect the three power and data wires to the XIAO ESP32C3, solder the TP4056 to the LiPo cell and add the slide switch on the positive line. Then upload the sketch from Arduino IDE and test the pulse. In total it takes about 4 hours, printing included.
Anyone looking for a ready-made ring can find the programmable 24 x WS2812 RGB LED ring in the catalogue, the same type as the one used in this project.
The result is a wearable replica that lights up on its own, with no network and no app, with a continuous cyan pulse. Everything fits in a 3.7 V LiPo cell and a deliberately lightweight firmware, designed not to trip the Brownout Detector and not to need a level shifter.
Source: https://makerworld.com/en/models/696988-wearable-arc-reactor
Related productsThe post Wearable Arc Reactor Mark I: a self-contained ESP32-C3 replica appeared first on Open Electronics.
SECO Modular Vision 10.1 MX95: industrial HMI with NXP i.MX 95 enters mass production
SECO, a high-tech company that develops integrated edge AI infrastructure and physical AI systems, announces that its Modular Vision 10.1 MX95 has moved from the early-access pre-order phase to mass production availability. Designed for OEMs and system integrators developing or modernising industrial human-machine interfaces, the NXP i.MX 95-based platform combines computing, display, industrial connectivity and software in a solution ready to integrate, helping to simplify the path from validation to deployment and subsequent scaling. The platform is also available through DigiKey, giving customers easy access to single or small quantities for limited-volume needs, integration, validation and initial deployment.
Simplifying industrial HMI integrationDeveloping or renewing an industrial HMI often requires OEMs and system integrators to bring together multiple elements, from computing and display technology to industrial connectivity and the software environment needed to run and maintain the device over time. This can increase integration effort and complexity, particularly when companies update established machine architectures or prepare new connected products.
For these projects, the Modular Vision 10.1 MX95 offers a practical path to introducing more recent computing, connectivity and local intelligence capabilities into the next generation of industrial interfaces. Its integrated architecture is designed to support both new developments and the modernisation of existing HMI designs, helping manufacturers evolve their products without having to treat every technology layer as a separate integration project.
Which applications the Modular Vision 10.1 MX95 is ideal forThe Modular Vision 10.1 MX95 is suited to industrial applications where operators need immediate access to machine information and where local processing can add intelligence directly at the point of operation. In machine interfaces and monitoring systems, it can combine user interaction with the display of operating data and equipment status, supporting more responsive and information-rich HMIs.
The platform is also suitable for quality inspection and other Edge AI applications that benefit from real-time analysis at the edge, as well as for plant and equipment management scenarios where diagnostics, operating status and machine information must be available directly on the shop floor. These capabilities make it relevant both for new smart HMI projects and for manufacturers who want to evolve existing product generations with more advanced computing and AI capabilities.
Integrated hardware and software for simpler deploymentBuilt around the NXP i.MX 95 applications processor, the Modular Vision 10.1 MX95 combines a 10.1-inch touch display with brightness ≥400 nits and a backlight lifetime ≥30,000 hours, integrated graphics and AI acceleration up to 2.0 TOPS / 8 eTOPS, together with the connectivity required for industrial HMI applications. Designed for panel installations, the platform features IP65 front protection, integrated thermal management and a wide DC input range, supporting continuous operation in industrial environments. The platform also integrates hardware security capabilities that support FIPS 140-3 compliance, reinforcing its suitability for connected industrial deployments. Taken together, these capabilities offer OEMs a consolidated platform for applications that require display, local processing and intelligent functions at the edge.
Clea OS, SECO’s Yocto-based industrial operating system, provides the software foundation for the platform, extending the value of the hardware with capabilities designed to support security, software updates and device manageability over time. Together, this hardware-software approach helps OEMs manage deployment and lifecycle management as part of the same system architecture, rather than as separate integration layers. As cybersecurity and lifecycle requirements become increasingly important under regulations such as the Cyber Resilience Act (CRA), this integrated approach helps OEMs reduce compliance complexity while supporting the development of connected, secure industrial devices.
“For OEMs, the value of an advanced HMI platform lies not only in its technology, but in how effectively that technology can be turned into products ready for deployment in the real world,” said Lorenzo Veltroni, Chief Product and Marketing Officer at SECO. “With Modular Vision 10.1 MX95, we offer customers a consistent foundation for evolving their HMI applications with high-performance graphics, AI acceleration and secure connectivity, while simplifying integration and long-term product development.”
Available through DigiKeyThe two configurations include 4 GB RAM / 16 GB eMMC and 8 GB RAM / 64 GB eMMC options, giving customers flexibility based on application requirements. The platform is available through DigiKey, making it easy for customers to buy single or small quantities for limited-volume needs, integration, validation and initial deployment without lead time.
The post SECO Modular Vision 10.1 MX95: industrial HMI with NXP i.MX 95 enters mass production appeared first on Open Electronics.
Vishay VS-HOT200C080 200 A, 80 V MOSFET Module Now Available from Mouser
Mouser Electronics, an authorized global distributor of the latest electronic components and industrial automation products, is now distributing the new FT VS-HOT200C080 power MOSFET module from Vishay Intertechnology, rated at 200 A and 80 V. The VS-HOT200C080 is an integrated device that saves space, reduces conduction losses and increases reliability for 48 V traction inverters in light electric vehicles (LEVs) and for belt starter-generator and energy recovery systems in mild hybrid electric vehicle (MHEV) applications.
Technical features of the VS-HOT200C080 moduleThe Vishay VS-HOT200C080 200 A, 80 V power MOSFET module, available from Mouser, integrates 80 V MOSFETs in a half-bridge configuration, with the best R DS(ON) value in its class, in a compact FlatPAK HC0 package built using transfer molding. The VS-HOT200C080 also features a shunt resistor for current sensing, bypass capacitors to improve switching performance and an NTC for temperature sensing. To increase efficiency, the MOSFET’s low on-resistance cuts conduction losses by 32% compared with other solutions on the market and also reduces the board space required by 15% compared with standard discrete solutions. This device has a drain-source voltage (V DSS ) of 80 V and a continuous drain current (I D ) of 195 A (T C = +80 °C). The transfer molding technology of the power module ensures highly reliable performance over a wide operating temperature range from -55 °C to +175 °C, particularly during power-up and power-down cycles, allowing the device to meet the strict reliability requirements of the AQG-324 standard.
HC0 package and design advantagesThe HC0 package of the VS-HOT200C080 also has signal pins and power terminals arranged at different heights. This configuration lets designers use separate printed circuit boards for power and signal, simplifying the design and allowing better signal routing. To further reduce the board space occupied, the signal and power PCBs can be stacked.
More informationFor more information, visit the page dedicated to the Vishay VS-HOT200C080 power MOSFET module. For more news about Mouser and the latest product news, visit the Mouser newsroom.
As an authorized global distributor, Mouser offers the widest selection of semiconductors, next-generation electronic components and the latest industrial automation products. Mouser customers can count on genuine products, 100% certified and fully traceable, for each of their partner manufacturers. To help speed up customer projects, the Mouser website hosts a vast library of technical resources, including a Technical Resource Center, and offers product datasheets, vendor-specific reference designs, application notes, technical design data, engineering tools and other useful information.
Thanks to Mouser’s free newsletter, engineers can keep up with the latest news on products, technologies and applications. Mouser’s email news and reference resource subscriptions can be customized to the specific and changing project needs of customers and subscribers. No other distributor offers engineers such a level of customization and control over the information they receive. Discover emerging technologies, product trends and much more by subscribing today.
Mouser offers thousands of industrial automation products, in stock and ready for immediate shipment. From predictive maintenance devices and control panels to a complete range of industrial power products, sensors and safety devices, Mouser’s portfolio is available to customers to help them design, build and maintain complete automation solutions. For more information, visit the industrial automation page and follow Mouser on Facebook, LinkedIn, X and YouTube.
The post Vishay VS-HOT200C080 200 A, 80 V MOSFET Module Now Available from Mouser appeared first on Open Electronics.
DIY wireless video surveillance with two ESP32 boards
Two ESP32 modules are enough to build your own wireless video surveillance system without commercial hardware and without subscriptions. An ESP32-CAM unit captures and transmits the video stream, while a dedicated battery-powered desktop monitor receives it and displays it in real time. The project is by HVT Lab and Huy Vector and keeps everything local: the data never passes through any cloud.
The ESP32-CAM is mounted at an access point, for example an entrance gate, and transmits the video wirelessly over the local network. It can also record directly to the on-board micro SD, so storage stays local. The camera enclosure is 3D printed.
The desktop monitor with ESP32-S3 and 2.8-inch displayThe monitor is built around an ESP32-S3 board with an integrated 2.8-inch display. A touch switch handles the controls, while a rechargeable 18650 battery powers everything and recharges over USB-C. The monitor automatically discovers and pairs with the camera stream over Wi-Fi, so there is nothing to configure by hand at every power-up.
Communication can work in two ways. The first is direct, device to device. The second goes through the existing home Wi-Fi network. The choice depends on signal strength, so the system adapts to the situation without manual intervention. The monitor also has a micro SD, useful for saving the streams and reviewing them when needed.
- ESP32-CAM for capturing and transmitting the video
- ESP32-S3 with integrated 2.8-inch display for the monitor
- Touch switch for the monitor controls
- Rechargeable 18650 battery with USB-C charging
- Micro SD on camera and monitor for local storage
- Toggle power switch
- 1 mm solid brass wire for the wiring
- Decorative picture frame as the monitor enclosure
- 3D-printed enclosure for the camera
- Exposed brass wiring and custom firmware
The wiring is not hidden. The 1 mm solid brass wire stays exposed against a paper background, mounted inside a decorative picture frame. That turns the monitor into a desktop object rather than a plastic box. The camera, on the other hand, has a 3D-printed enclosure.
The firmware is custom and shared by the maker. Anyone who wants to rebuild the project can find HVT Lab and Huy Vector’s work on the maker’s site, with the code to load onto the two modules. The software side handles the transmission, the automatic pairing between camera and monitor, and recording to micro SD.
For the capture side, the ESP32-CAM Development Board combines the ESP32 and the camera on a single board, and is a convenient base for testing the video stream before building the whole system.
The project’s strong point is local control of privacy and data. There are no external services, no subscriptions, and the video stream stays on the home network. On top of that, the careful presentation, with the exposed brass and the frame, makes the monitor an object that looks good on a table. Finally, the 18650 battery makes it independent of power supplies.
Related productsThe post DIY wireless video surveillance with two ESP32 boards appeared first on Open Electronics.
Radxa Dragon Q8B: the Snapdragon 8cx Gen 3 board put through its benchmarks
The Radxa Dragon Q8B is a single board computer built around the Qualcomm Snapdragon 8cx Gen 3 SoC, with 8 cores at 3.00 GHz and an integrated Qualcomm Turnip Adreno 690 GPU. It is pitched as an alternative to the Raspberry Pi 5, so the real question is not what it promises but how much it delivers. The material gathered by geerlingguy answers with numbers measured on the bench: benchmarks, power draw at the wall, networking, GPU and language model inference. The board tested is the V1.305 version with 8 GB of RAM, bought for 209 dollars plus 20 for shipping.
The operating system under test is Ubuntu 26.04.1 LTS (Resolute Raccoon) aarch64, with Linux kernel 7.0.11-6-qcom. The desktop environment is GNOME 50.1 on Wayland with the Mutter window manager. Installed memory reports as 7.15 GiB, swap as 3.58 GiB and the root disk as 56.88 GiB in ext4. The shell is bash 5.3.9 and the terminal is Ptyxis 50.1. There is also a side note: the system topology came back incomplete, and lstopo-no-graphics -no-io had to be run to get any output, probably because support for the new SoC is not yet complete.
Geekbench, HPL and power draw at the wallOn the CPU side the results are these: Geekbench 7 scores 1465 single core and 7114 multi core, while Geekbench 6 stops at 1405 and 6302. These numbers have to be read together with the watts, because idle consumption measured at the wall is 4.9 W. Under load the picture changes quickly: stress-ng -matrix 0 takes the board to 20.9 W, Geekbench multicore to 20.4 W. The HPL benchmark is the hungriest, drawing 33 W for 123.05 Gflops, that is 3.73 Gflops per watt.
- Idle: 4.9 W
- Stress-ng -matrix 0: 20.9 W
- Geekbench multicore: 20.4 W
- HPL: 33 W for 123.05 Gflops, equal to 3.73 Gflops/W
Anyone who wants to repeat the same measurements will find the results collected in one place in the geerlingguy repository, along with the commands and test conditions. System memory was also measured with tinymembench: C copy backwards at 16233.8 MB/s, C copy at 15708.1 MB/s, C fill at 41954.8 MB/s, standard memcpy at 16778.8 MB/s and standard memset at 42158.1 MB/s. The NEON LDP/STP copy entry, taken from the framebuffer, stops at 660.1 MB/s instead.
Networking, GPU and LLM inference on CPUNetworking is the most lopsided chapter. With iperf3 against the test server the board scores 2.35 Gbps in upload, but in reverse it drops to 119 Mbps. In bidirectional mode it reaches 2.35 Gbps in upload and 365 Mbps in download. So it is worth paying close attention to the direction of traffic before drawing conclusions. On the storage side, the test runs on a 64 GB Raspberry Pi microSD: iozone scores 7.28 MB/s in random read 4K and 5.55 MB/s in random write 4K, while at 1M it moves to 67.72 MB/s in random read, 48.28 MB/s in random write, 67.01 MB/s in sequential read and 47.47 MB/s in sequential write.
The Adreno 690 GPU is measured with glmark2 2023.01 on OpenGL ES 3.2 Mesa 26.0.8-1ubuntu0.3, in an 800×600 window: score 6107. With vkmark 2025.01 it reaches 7722, while GravityMark stops at 3752. Then there is the chapter many people care about: language model inference. With llama.cpp build ff0dbb975 (11094), CPU backend and 8 threads, tinyllama-1.1b-1t-openorca.Q4_K_M.gguf (636.18 MiB, 1.10 B parameters) reaches 194.49 t/s in pp512, 132.65 t/s in pp4096, 38.81 t/s in tg128 and 116.17 t/s in pp4096+tg128, with an average consumption of 23.7 W.
Moving up a size, Llama-3.2-3B-Instruct-Q4_K_M.gguf (1.87 GiB, 3.21 B parameters) scores 72.31 t/s in pp512, 56.83 t/s in pp4096, 12.30 t/s in tg128 and 45.71 t/s in pp4096+tg128, with 24.3 W average consumption. So the larger model remains usable, but with generation times four times longer than the smaller one. Anyone looking for an ARM board to run a local assistant has a concrete, measured and repeatable reference here.
For those coming from the Raspberry world, the comparison with the kits with power supply and microSD is the most direct way to start, while the 2 GB memory version remains the entry level reference of the family. The Dragon Q8B sits higher up, with an 8-core SoC at 3.00 GHz and an Adreno 690 GPU. The price, however, has to be put on the table: 209 dollars plus 20 for shipping, with purchase on 2 June 2026 and delivery at the end of July.
Source: https://github.com/geerlingguy/sbc-reviews/issues/108
Related products- Raspberry Pi 5 Starter Kit with 27 W Power Supply and 64 GB microSD
- Raspberry Pi 5 – 2 GB memory version
The post Radxa Dragon Q8B: the Snapdragon 8cx Gen 3 board put through its benchmarks appeared first on Open Electronics.
Murrelektronik IO-Link Multiplier turns one master port into four
With the new IO-Link Multiplier, Murrelektronik expands its product range for decentralized automation. This compact solution allows IO-Link installations to be extended flexibly. The module turns one existing IO-Link master port into four fully functional IO-Link ports. This makes it possible to connect up to four standard IO-Link devices through a single master port, without additional master modules.
A flexible extension for decentralized automationThe number of intelligent sensors, actuators and I/O modules used in machines and systems is constantly growing. At the same time, the available IO-Link master ports are often limited. When a system needs to be expanded, additional master modules or fieldbuses are usually employed. This solution, however, requires more space in the control cabinet or in the field, complicates wiring and drives up costs. The IO-Link Multiplier instead offers a cost-effective alternative, allowing existing IO-Link structures to be extended directly in the field and ensuring flexible scalability.
Plug-and-play installation and simplified retrofittingCommissioning is simplified by the plug-and-play characteristics: the IO-Link Multiplier is connected to an existing IO-Link master port and provides four fully functional IO-Link ports for additional devices. This solution suits both new modular machines and the expansion and modernization of existing systems as part of retrofit projects.
Full IO-Link functionality and transparent diagnosticsFull IO-Link functionality is thus preserved: the process data, parameters and diagnostic data of all connected devices remain available. This ensures transparency right down to the field level, simplifies commissioning and makes it easier to analyze faults quickly during maintenance work. The LED status indicators on each port also allow immediate monitoring of the status directly on the device.
Flexible configuration of ports and process dataAs well as allowing up to four IO-Link devices to be connected, the four ports can alternatively be used to integrate up to eight digital inputs or four digital outputs. The 32 bytes of IO-Link process data available from the master port can be distributed flexibly across the four ports of the Multiplier and adapted to the requirements of the connected devices.
Extended cable lengths and field installationThe IO-Link Multiplier can also increase installation flexibility. As an intermediate station between the IO-Link master and the device, it allows cable lengths of up to 20 meters between the master and the Multiplier, plus another 20 meters between the Multiplier and the connected device. This gives greater freedom in the design of machines and systems.
Thanks to its compact design and IP65/67 degree of protection, the IO-Link Multiplier is designed for reliable use directly on industrial machinery. With this solution, Murrelektronik offers even more flexibility in the realization of modern machine and system projects.
The post Murrelektronik IO-Link Multiplier turns one master port into four appeared first on Open Electronics.
Microchip expands its data center portfolio for AI: PCIe Gen 6, NVMe and RAID
As AI workloads drive demand for more scalable and flexible data center architectures, organizations are looking for faster and more efficient ways to move, store and protect data. Microchip Technology is helping to meet these needs by expanding its data center solutions portfolio with new innovations in PCIe connectivity, NVMe storage and acceleration that support high-performance computing infrastructure.
“Customers are looking for technology partners that can address multiple challenges across the infrastructure stack while helping to simplify design and accelerate deployment,” said Brian McCarson, corporate vice president and GM of Microchip’s data center solutions business unit. “By continuing to expand our portfolio, we provide the building blocks needed to create more efficient, secure and adaptable platforms for today’s increasingly distributed, data-intensive computing environments.”
Switchtec PCIe 6.0 Low-Lane-Count switchDesigned to bring PCIe Gen 6 connectivity to platforms with power and space constraints, the Switchtec PCIe 6.0 Low-Lane-Count (LLC) switch offers up to 64 PCIe Gen 6 lanes, 32 ports and flexible x2, x4, x8 and x16 bifurcation options. Integrated Direct Memory Access (DMA) supports efficient peer-to-peer data movement between connected devices while reducing host CPU involvement. Like Microchip’s larger Switchtec Gen 6 devices, the LLC switch offers PCIe Multicast and partitioning capabilities, plus robust security through hardware root of trust and secure boot technologies. The new device delivers PCIe Gen 6 features with low power consumption, further reduced to extend support to a wider range of data centers and intelligent edge applications.
Flashtec NVMe 5016 controller with post-quantum securityTo address the industry’s need for secure, scalable and AI-optimized storage infrastructure, Microchip is updating its Flashtec SSD controller portfolio with an enhanced version of the PCIe Gen 5 NVMe 5016 controller. Building on the controller’s high-performance, power-optimized architecture, the updated device adds support for the Commercial National Security Algorithm Suite (CNSA) 2.0 to help customers prepare for new post-quantum security requirements.
Dual-port capability enables highly available storage architectures through redundant data paths and load balancing, while advanced virtualization, Quality of Service (QoS) management and flexible programmability help optimize performance. Together, these enhancements extend the Flashtec platform’s ability to address evolving NAND technologies, high-capacity SSD designs and next-generation deployments for enterprise, hyperscale and AI.
Adaptec SmartRAID 4300 acceleratorsMicrochip is also expanding the capabilities of its Adaptec SmartRAID 4300 NVMe RAID storage accelerators with a series of enhancements designed to address practical operational needs. The updates focus on strengthening storage security, minimizing downtime, expanding data protection and simplifying deployment across a wider range of environments. Self-encrypting drives (SED) with both local and remote key management have been added, along with RAID 6 and RAID 60 options to increase resilience and security. Broader cross-platform compatibility is made possible by support for Linux, Debian, Ubuntu and Microsoft Windows 11 environments. Additional updates such as dynamic NVMe configuration for in-service management, persistent event logging and peer-to-peer rebuilding support for greater CPU offload help reduce management overhead while minimizing service interruptions. StorageCore API support further broadens integration flexibility, allowing customers to integrate SmartRAID management into third-party tools through in-band host applications, as well as custom off-of-band BMC management frameworks.
The latest additions reflect the company’s ongoing commitment to improving the performance, availability and security of next-generation computing platforms. To learn more, visit the dedicated data center solutions website covering Microchip’s entire data center solutions portfolio.
Development toolsMicrochip’s data center portfolio is supported by a suite of development and management tools, including ChipLink software for configuration, diagnostics, telemetry and debugging of PCIe switches. Further support includes device monitoring software, firmware configuration and management, development resources for Flashtec NVMe controllers and Adaptec storage management software.
Pricing and availabilityPricing and availability may vary by device. For more information, contact one of Microchip’s authorized sales representatives or distributors worldwide (global sales and distribution).
ResourcesHigh-resolution images are available through Flickr or editorial contact (images free for publication): Application image: Flickr Microchip.
The post Microchip expands its data center portfolio for AI: PCIe Gen 6, NVMe and RAID appeared first on Open Electronics.



