Новини світу мікро- та наноелектроніки

Radxa Dragon Q8B: the Snapdragon 8cx Gen 3 board put through its benchmarks

Open Electronics - Ндл, 11/15/2026 - 18:00

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 wall

On 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 CPU

Networking 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

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

Open Electronics - Ндл, 11/15/2026 - 16:00

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 automation

The 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 retrofitting

Commissioning 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 diagnostics

Full 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 data

As 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 installation

The 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

Open Electronics - Ндл, 11/15/2026 - 13:00

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 switch

Designed 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 security

To 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 accelerators

Microchip 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 tools

Microchip’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 availability

Pricing and availability may vary by device. For more information, contact one of Microchip’s authorized sales representatives or distributors worldwide (global sales and distribution).

Resources

High-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.

Designing a Stacked Toolhead PCB for My DIY Pick-and-Place Machine [PnP Series — Part 4]

Reddit:Electronics - Ндл, 11/15/2026 - 11:54
Designing a Stacked Toolhead PCB for My DIY Pick-and-Place Machine [PnP Series — Part 4]

hello everyone! I've been building my own pick-and-place machine for a while now (it finally has a name: Vectra), and I just made a wrote up about the toolhead electronics.

I couldn't find a toolhead board I could just buy, so I made one: three 70 x 47 mm PCBs stacked on top of each other, i think you may like it !

submitted by /u/ntrondle
[link] [comments]

Droidputer: Cardputer apps run on an Android phone

Open Electronics - Ндл, 11/15/2026 - 11:00

Droidputer runs the Cardputer’s open source apps on an Android phone. You connect an ESP32-S3 over USB-OTG and the phone becomes the screen, keyboard, GPS and flasher. No display is needed on the board, so a bare devkit and an OTG cable are enough. Apps are recompiled on demand starting from GitHub, then the phone writes them into the ESP32-S3’s memory by itself.

The app on Google Play is v0.0.7, dated 2026-10-10. Behind it sits a build proxy on Vercel with five functions, which talks to GitHub Actions. The flow is this: the phone sends a POST /api/build request, the proxy launches the build-app.yml workflow, the workflow compiles, and the proxy returns four firmware parts to the phone along with their sha256 hashes. The phone flashes them over USB-OTG, with a reset into the ROM bootloader, writing and MD5 verification.

The M5GFX shim and the 4×14 soft keyboard

At the heart of the project is a shim that redirects every pixel write onto the ESP32-S3’s native USB-CDC. The workflow clones the app, writes the overlay and applies the shim on M5GFX 0.2.27 and M5Cardputer 1.1.1, then compiles with PlatformIO. On the phone side, the app shows full screen a mirror of what the board draws. The soft keyboard reproduces the Cardputer’s 4×14 matrix, including the fn and shift layers.

Key and GPS frames also travel over the serial channel. The GPS feed sends about 28 NMEA sentences per second, so apps that read position work without extra modules. The LauncherHub feed weighs about 3 MB with 606 entries as of 2026-09-16 and is updated at most once a day. For anyone who wants to rebuild the project from scratch, the code and scripts are in the fcavalcantirj repository.

Measured build, flash and reconnect times

The on-demand build takes about 2-4 minutes. Measurements from 2026-09-04 give 2 min 4 s warm and 4 min 8 s cold. A build already present on the proxy, with the same repo, ref, target and shim under 24 hours old, is instead retrieved in 3 seconds. The proxy limit is 6 builds in flight, reusing a successful run under 24 hours old, with artifacts that live for 7 days.

  • Flash reset-to-verified: 8 s for 467 KB and 15 s for 1.07 MB (2026-09-16)
  • Flash of 1.1 MB compressed: 14.7 s (2026-09-03)
  • Link re-established 190-330 ms after reset (2026-09-16)
  • ESP32_Flasher: 504,176 B written in 19.39 s on a freshly connected Cardputer ADV (2026-09-02)
  • Works/broken verdict decided 20 s after the flash
  • ROM bootloader wait timeout when the board stays silent: 90 s

The flasher recognises chips by their magic number: 0x9 for the ESP32-S3 and 0x30e1706f for the ESP32-C5. Among the components mentioned are also the CH9102, CH343 and CP210x, the USB-serial converters you come across on devkits. The project requires Android 8 or higher with USB-OTG host support, so an OTG cable and a phone acting as host are enough to get started.

TFT_eSPI apps on a bare ESP32-S3 and LauncherHub

Apps that use TFT_eSPI instead of M5GFX run on a bare ESP32-S3 through a TFT_eSPI 2.5.43 virtual display processor and an emulation of the Cardputer’s GPIO keyboard matrix. So the software range is not limited to what was written for M5GFX. Among the tools mentioned are also UiFlow2 and MicroPython, as well as LauncherHub and M5Burner for the app feed.

For anyone who wants to try it, the shopping list is short: an ESP32-S3-N16R8 devkit, an OTG cable and an Android 8 or higher phone. Alternatively you can start from a Cardputer ADV or a StickS3, which are the boards named by the project. The app does the rest, from build to flash, with no computer needed.

Source: https://github.com/fcavalcantirj/droidputer

The post Droidputer: Cardputer apps run on an Android phone appeared first on Open Electronics.

Found a really neat "crystal oven" in my grandpas parts

Reddit:Electronics - Ндл, 11/15/2026 - 05:17
Found a really neat "crystal oven" in my grandpas parts

Ive never seen one of these, but i guess if you needed a ultra stable oscilator circut, more than a quartz crystal could offer alone, this is the way you would do it.

Its most likely from some kind of millitary radio my grandpa took apart.

Its really neet, the thing comes appart so you can swap out the crystal inside.

Idk what i want to do with it, but maybe ill make a really accurate and power hungry quartz clock with it. Or some kind of QRP transmitter.

Realisticaly none of my projects would need something more accurate than a unheated crystal tho.

submitted by /u/Outrageous-Drink3869
[link] [comments]

İ made my multimeter rechargable

Reddit:Electronics - Сбт, 11/14/2026 - 18:43
İ made my multimeter rechargable

Instead of LDO regulators, I used 1N4007 diodes to step down the voltage; this prevents the battery from draining while the device is idle. Since the charging module did not fit into the battery compartment, I placed it inside the device; with a fully charged battery, the device can theoretically operate continuously for 140 hours.

submitted by /u/mona20117
[link] [comments]

Weekly discussion, complaint, and rant thread

Reddit:Electronics - Сбт, 11/14/2026 - 18:00

Open to anything, including discussions, complaints, and rants.

Sub rules do not apply, so don't bother reporting incivility, off-topic, or spam.

Reddit-wide rules do apply.

To see the newest posts, sort the comments by "new" (instead of "best" or "top").

submitted by /u/AutoModerator
[link] [comments]

OctoFox Book: a DIY ESP32-S3 eReader with a self-hosted library

Open Electronics - Сбт, 11/14/2026 - 18:00

OctoFox Book is a DIY eReader you build from scratch. The foundation is a LilyGo T4 ESP32-S3 board with an integrated 4.7-inch e-paper screen, so the hardest part of the project, namely driving the panel, comes already solved. Around the board there are three physical buttons for navigation, a microSD slot and a 3D-printed enclosure. The custom firmware displays the ebooks stored on the memory card, with an interface in English and Russian, Wi-Fi settings and deep sleep. Anyone looking for a DIY eReader with ESP32 finds here a self-hosted alternative to commercial readers.

The reader is paired with OctoFox Library, a personal self-hosted server for managing, collecting and syncing books. The server also covers reading, narration, accounts, collections and backups. A Companion app, meanwhile, is used to find the server, open its administration panel and pair the reader over USB. The server has a separate installer that sets up the prerequisites on its own. The reader firmware is at release candidate 0.9.0-rc.1, while the version distributed as a release candidate is 0.9.0-rc.3.

The three buttons and the 3D-printed enclosure

Navigation relies on three buttons. The UP and DOWN switches measure 8.5 x 8.5 mm, while the OK button is a round 14.3 mm diameter D-pad center button. There is also a Sleep switch measuring 5.8 x 5.8 mm with fastening and a full travel of 1.8 mm. The set of printable parts includes seven details: front and sleep_button_cap are at revision v66, the other five at v65. The set’s units of measurement are millimeters and there is no general scale factor.

  • UP and DOWN switches, 8.5 x 8.5 mm
  • Round D-pad center button, 14.3 mm diameter
  • Sleep switch, 5.8 x 5.8 mm with 1.8 mm full travel
  • Eight M2 x 6 screws for the switch mounts, two per mount
  • Four M2.5 x 8 screws for the rear cover, near the corners

Mounting the Sleep cap took several attempts. The v66 Sleep window measures 10.6 x 7.4 mm and the cap 8.8 x 5.6 mm. The nominal interference on the cap ribs is 0.025 mm per side. At full travel the pressure surface stays 0.6 mm higher than the body. The 2.5 mm side of the stem is oriented along the long axis of the cap. For the Sleep, travel positions from 0 to 1.8 mm in 0.1 mm steps were checked, along with tilts up to 6 degrees in eight directions and a lateral shift of the switch of plus or minus 0.15 mm. The minimum clearance in the verified states is about 0.161 mm, and a direct travel of up to 2.0 mm was also checked.

For anyone who wants to rebuild the project, the print files are editable in Blender and also available as GLB for 3D viewers. The rear cover, in the assembly, is offset by +18 mm along Z. The USB-C recess is offset by 1.5 mm toward the front panel. The smooth channels have diameters of 1.6 and 2.05 mm and are intended for tapping with a tap, with a depth margin of 1.5 mm beyond the screw tip. For M2 screws the cylindrical head is 3.8 x 2.0 mm, for M2.5 it is 4.5 x 2.5 mm. The micro-scale has a pitch of 0.8 mm and a height of up to 0.10 mm, while the height of the tentacles is about 0.9 mm.

Firmware, server and file verification

The reader firmware supports momentary and latching Sleep switches, configurable from the settings. On the software side the project brings together four distinct pieces: the AbyssBook reader firmware, the OctoFox Library self-hosted server, the Companion app and the Server Setup as a separate installer. There is also a script, source/verify_files.py, that handles checksum verification. Anyone who wants to get their hands on the code will find everything in the No-Macaron4341 repository, firmware and server included.

Anyone who wants to start from a hardware base ready for similar experiments can also look among ESP32 modules with an integrated display. One example is the wireless ESP32 board for e-Paper displays, designed to load images onto panels over Wi-Fi or Bluetooth and compatible with Arduino. It is not the project’s T4, but it is a similar base for practicing with ESP32 and e-paper panels.

Source: https://github.com/EriArk/hardware-stuff/tree/main/OctoFoxBook

Related products

The post OctoFox Book: a DIY ESP32-S3 eReader with a self-hosted library appeared first on Open Electronics.

ESP32 Demoboard: More Applications to Complete the Overview (Part 3)

Open Electronics - Сбт, 11/14/2026 - 16:00

We close our overview of the prototyping board built around the popular WiFi module with a few more applications. Third instalment.

In the previous two instalments we introduced the demoboard for the famous and very widespread ESP32 SoC from Espressif, which in this case is mounted on an ESP32 board with code YB555. Besides offering some sketches we wrote to introduce you to development with this hardware from an IoT perspective, we described the firmware in detail and created examples that we began presenting in the first and second instalments. Now we continue along this path with the last application examples that use the on-board hardware and the modules that can be connected externally through the dedicated connectors. Specifically, we will use these on-board components and external modules:

  • UP, DOWN, LEFT, RIGHT and OK buttons;
  • Servo motor;
  • 0.96″ OLED display;
  • 5V relay (RL1);
  • Red LED (LD1);
  • Green LED (LD2).

Let us recall that the heart of the demoboard is the YB555 development and prototyping board based on the ESP32 (ESP-WROOM-32), which integrates 802.11 b/g/n Wi-Fi, dual-mode Bluetooth (classic and BLE) and 25 GPIOs. It supports data rates up to 150 Mbps, has an antenna output power of 20.5 dBm and draws only 5 µA in sleep mode.

LED and button interaction

Let us start with an application in which we use the buttons on the board and show their status on the on-board OLED display (code OLED096C or code OLEDGVSCSD); this example gives an idea of how the buttons can be used and integrated into a real application, getting feedback on the display or triggering specific actions.

The sketch to upload in this case is called OLED_Pulsanti.ino, and once it is running on the ATmega2560 that governs the demoboard, the display shows which of the joystick-style buttons has been pressed, namely UP, DOWN, LEFT, RIGHT and OK (P1, P2, P3, P4, P5). The example code also lets you associate a button press with the on-board LEDs; to be precise, pressing LEFT or RIGHT lights the green LED (LD2), while pressing UP or DOWN turns on the red LED (LD1). If the OK button is pressed, both LEDs light up.

This application and the code that follows, given in Listing 1, can be integrated into others to obtain a button-management module and to link the related inputs to specific actions, which may be not only those described but also the activation of other outputs, not least the relay one.

To use the sketch you must copy the “libraries” folder found in the examples available for download among the files of this issue, under “/Documents”/Arduino”, then open the Arduino IDE and load the example code available in the “OLED_Pulsanti” folder.

Button and LED section of the ESP32 demoboard used in the button-reading exampleThe button and LED section used in the example.

Listing 1

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels

#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)

// The pins for I2C are defined by the Wire-library.

// On an arduino UNO: A4(SDA), A5(SCL)

// On an arduino MEGA 2560: 20(SDA), 21(SCL)

// On an arduino LEONARDO: 2(SDA), 3(SCL), …

#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);

#define NUMFLAKES 10 // Number of snowflakes in the animation example

#define LOGO_HEIGHT 16

#define LOGO_WIDTH 16

const int P_UP = 23;

const int P_DOWN = 4;

const int P_LEFT = 16;

const int P_RIGHT = 17;

const int P_OK = 5;

const int LEDV = 26;

const int LEDR = 25;

void setup() {

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

}

// Show initial display buffer contents on the screen —

// the library initializes this with an Adafruit splash screen.

display.display();

delay(2000); // Pause for 2 seconds

// Clear the buffer

display.clearDisplay();

display.setTextSize(2); // Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

display.setCursor(5, 0);

display.print(“** Test **”);

display.setCursor(20, 30);

display.print(” PUSH “);

// Show the display buffer on the screen. You MUST call display() after

// drawing commands to make them visible on screen!

display.display();

delay(2000);

// display.display() is NOT necessary after every single drawing command,

// unless that’s what you want…rather, you can batch up a bunch of

// drawing operations and then update the screen all at once by calling

// display.display(). These examples demonstrate both approaches…

/*

// Invert and restore display, pausing in-between

display.invertDisplay(true);

delay(1000);

display.invertDisplay(false);

delay(1000);

*/

pinMode(P_UP, INPUT_PULLUP);

pinMode(P_DOWN, INPUT_PULLUP);

pinMode(P_LEFT, INPUT_PULLUP);

pinMode(P_RIGHT, INPUT_PULLUP);

pinMode(P_OK, INPUT_PULLUP);

pinMode(LEDV, OUTPUT);

pinMode(LEDR, OUTPUT);

}

void loop()

{

display.clearDisplay();

display.setTextSize(2); // Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

switch (Ctrl_Push())

{

case 1:

Serial.println(“Push UP”);

display.setCursor(50, 30);

display.print(“UP”);

digitalWrite(LEDR,HIGH);

break;

case 2:

Serial.println(“Push DOWN”);

display.setCursor(40, 30);

display.print(“DOWN”);

digitalWrite(LEDR,HIGH);

break;

case 3:

Serial.println(“Push LEFT”);

display.setCursor(40, 30);

display.print(“LEFT”);

digitalWrite(LEDV,HIGH);

break;

case 4:

Serial.println(“Push RIGHT”);

display.setCursor(40, 30);

display.print(“RIGHT”);

digitalWrite(LEDV,HIGH);

break;

case 5:

Serial.println(“Push OK”);

display.setCursor(50, 30);

display.print(“OK”);

digitalWrite(LEDR,HIGH);

digitalWrite(LEDV,HIGH);

break;

default:

display.setCursor(40, 30);

display.print(“—-“);

digitalWrite(LEDV,LOW);

digitalWrite(LEDR,LOW);

break;

}

display.display();

delay(500);

}

int Ctrl_Push()

{

int push = 0;

if (digitalRead(P_UP)==LOW) push = 1;

if (digitalRead(P_DOWN)==LOW) push = 2;

if (digitalRead(P_LEFT)==LOW) push = 3;

if (digitalRead(P_RIGHT)==LOW) push = 4;

if (digitalRead(P_OK)==LOW) push = 5;

return push;

}

Servo control

Let us now move on to a second application example that is very interesting because it deals with driving analogue servos (for model making, robotics and so on) through our demoboard; to implement it we use the dedicated servo output, which on the circuit board is the one marked CNU11, with three pins: S (1), 5V (2) and GND (3). This is the standard connection for the 2.54 mm pitch connectors used in servos, such as the one with product code SERVO206, with 1.5 kg torque, 160° rotation and 0.12 s/60° speed at 4.8V.

To drive the servos we wrote the example sketch OLED_Servo.ino, which, when run, sets the demoboard so that the servo connected to connector CNU11 first rotates 180° clockwise and then the same number of degrees anticlockwise; this code therefore performs a functional test of the servos, making their shaft complete a full rotation split into two steps corresponding to the opposite half-turns from the rest position (0 degrees). To use the sketch you must copy the “libraries” folder found in the examples available for download among the files of this issue, under “/Documents”/Arduino”, then open the Arduino IDE and load one of the example codes available in the “OLED_Servo” or “Servo” folders. The complete code for driving the servos is given in Listing 2.

Three-pin servo connector on the ESP32 demoboard, labelled S, 5V and GNDThe connector for hooking up the servo.

Listing 2

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

//for Servo

#include <Servo.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels

#define SCREEN_HEIGHT 64 // OLED displdfsfdfsfdsfdsfdsfdsay height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)

// The pins for I2C are defined by the Wire-library.

// On an arduino UNO: A4(SDA), A5(SCL)

// On an arduino MEGA 2560: 20(SDA), 21(SCL)

// On an arduino LEONARDO: 2(SDA), 3(SCL), …

#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);

#define NUMFLAKES 10 // Number of snowflakes in the animation example

#define LOGO_HEIGHT 16

#define LOGO_WIDTH 16

//for Servo

static const int servoPin = 18;

Servo servo1;

void setup()

{

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

}

// Show initial display buffer contents on the screen —

// the library initializes this with an Adafruit splash screen.

display.display();

delay(2000); // Pause for 2 seconds

// Clear the buffer

display.clearDisplay();

display.setTextSize(2); // Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

display.setCursor(5, 0);

display.print(“** Test **”);

display.setCursor(10, 30);

display.print(” Servo “);

// Show the display buffer on the screen. You MUST call display() after

// drawing commands to make them visible on screen!

display.display();

delay(2000);

// display.display() is NOT necessary after every single drawing command,

// unless that’s what you want…rather, you can batch up a bunch of

// drawing operations and then update the screen all at once by calling

// display.display(). These examples demonstrate both approaches…

/*

// Invert and restore display, pausing in-between

display.invertDisplay(true);

delay(1000);

display.invertDisplay(false);

delay(1000);

*/

servo1.attach(servoPin);

}

void loop()

{

for(int posDegrees = 0; posDegrees <= 180; posDegrees++)

{

servo1.write(posDegrees);

Serial.println(posDegrees);

delay(20);

}

for(int posDegrees = 180; posDegrees >= 0; posDegrees–)

{

servo1.write(posDegrees);

Serial.println(posDegrees);

delay(20);

}

}

Using the WiFi connection

The ESP32 module that controls the whole demoboard stands out for one feature: it has WiFi connectivity on board, and that is why we chose it: to have built-in connectivity for Internet access and to expose our applications to the network, in a perfect IoT perspective.

As for the WiFi transceiver section, it operates in a frequency range between 2.4 GHz and 2.5 GHz and its main technical characteristics are as follows:

  • IEEE 802.11 b/g/n HT40 compliance;
  • baseband and LwIP stack;
  • Sniffer / Station / SoftAP and Wi-Fi direct mode;
  • maximum data rate of 150 Mbps@11n HT40, 72 Mbps@11n HT20, 54 Mbps@11g and 11 Mbps@11b;
  • maximum transmit power 19.5 dBm@11b, 16.5 dBm@11g, 15.5 dBm@11n;
  • receive sensitivity: -97 dBm.

The transceiver is also set up to support WEP, WPA/WPA2 PSK/Enterprise connection protection modes and encryption with hardware acceleration AES / SHA2 / ECC / RSA-4096. So let’s look at the application example that uses this hardware, which has the device connect to your own WiFi network to run a connectivity test.

Once connected, the IP address assigned to the ESP module will be shown on the display. At the end the module will wait for a connection from a client inside the network, on TCP port 8088. When the connection is established, a message will provide that information and every character typed on the client terminal will be shown on the display, within the display’s capacity. If, once connected, one of the five buttons on the board is pressed, the client will receive the indication of the pressed button on its terminal.

The test sketch is called OLED_WiFi.ino and is located under the examples folder, that is under “/Documents”/Arduino”; open the Arduino IDE and load the sketch, then edit the “apn” and “ssid” variables with your own network parameters, because these will have generic parameters since we cannot know which network the code will be applied to.

In particular, in the example code, which you see in Listing 3, you must edit the following lines:

const char* ssid = “APN NAME”;

const char* password = “APN PASSWORD”;

entering in place of the quoted text APN NAME the name of your access point and in place of APN PASSWORD the password (or passkey) you use to access the WiFi network.

SERVO206 servo motor used in the ESP32 demoboard exampleThe SERVO206 servo motor

Listing 3

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

//for WiFi

#include <WiFi.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels

#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)

// The pins for I2C are defined by the Wire-library.

// On an arduino UNO: A4(SDA), A5(SCL)

// On an arduino MEGA 2560: 20(SDA), 21(SCL)

// On an arduino LEONARDO: 2(SDA), 3(SCL), …

#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);

#define NUMFLAKES 10 // Number of snowflakes in the animation example

#define LOGO_HEIGHT 16

#define LOGO_WIDTH 16

//for WiFi

const char* ssid = “APN NAME”;

const char* password = “APN PASSWORD”;

/* create a server and listen on port 8088 */

WiFiServer server(8088);

const int P_UP = 23;

const int P_DOWN = 4;

const int P_LEFT = 16;

const int P_RIGHT = 17;

const int P_OK = 5;

const int LEDV = 26;

const int LEDR = 25;

void setup() {

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

}

// Show initial display buffer contents on the screen —

// the library initializes this with an Adafruit splash screen.

display.display();

delay(2000); // Pause for 2 seconds

// Clear the buffer

display.clearDisplay();

display.setTextSize(2); // Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

display.setCursor(5, 0);

display.print(“** Test **”);

display.setCursor(5, 30);

display.print(” WiFi “);

// Show the display buffer on the screen. You MUST call display() after

// drawing commands to make them visible on screen!

display.display();

delay(2000);

// display.display() is NOT necessary after every single drawing command,

// unless that’s what you want…rather, you can batch up a bunch of

// drawing operations and then update the screen all at once by calling

// display.display(). These examples demonstrate both approaches…

/*

// Invert and restore display, pausing in-between

display.invertDisplay(true);

delay(1000);

display.invertDisplay(false);

delay(1000);

*/

pinMode(P_UP,INPUT_PULLUP);

pinMode(P_DOWN,INPUT_PULLUP);

pinMode(P_RIGHT,INPUT_PULLUP);

pinMode(P_LEFT,INPUT_PULLUP);

pinMode(P_OK,INPUT_PULLUP);

Serial.begin(9600);

OLED_Message(“Connecting to “,ssid);

Serial.print(“Connecting to “);

Serial.println(ssid);

/* connecting to WiFi */

WiFi.begin(ssid, password);

/*wait until ESP32 connect to WiFi*/

while (WiFi.status() != WL_CONNECTED)

{

delay(500);

Serial.print(“.”);

}

Serial.println(“”);

Serial.println(“WiFi connected with IP address: “);

String testo = WiFi.localIP().toString();

OLED_Message(“WiFi connected”,testo);

Serial.println(WiFi.localIP());

delay(2000);

/* start Server */

server.begin();

}

void loop()

{

/* listen for client */

WiFiClient client = server.available();

uint8_t data[30];

if (client)

{

OLED_Message(“Client Connected”,””);

Serial.println(“new client”);

display.setCursor(0, 20);

/* check client is connected */

while (client.connected())

{

switch (Ctrl_Push())

{

case 1:

Serial.print(“Push UP”);

client.write(“\nUP”);

break;

case 2:

Serial.println(“Push DOWN”);

client.write(“\nDOWN”);

break;

case 3:

Serial.println(“Push LEFT”);

client.write(“\nLEFT”);

break;

case 4:

Serial.println(“Push RIGHT”);

client.write(“\nRIGHT”);

break;

case 5:

Serial.println(“Push OK”);

client.write(“\nOK”);

break;

default:

break;

}

Attendi_Push();

if (client.available())

{

int len = client.read(data, 30);

if(len < 30)

{

data[len] = ‘\0’;

}else

{

data[30] = ‘\0’;

}

Serial.print(“client sent: “);

Serial.println((char *)data);

display.print((char *)data);

display.display();

}

}

}

OLED_Message(“Client Disconnected”,””);

}

void OLED_Message(String text_display1,

String text_display2)

{

int lunghezza = 0;

display.clearDisplay();

display.setTextSize(1);

// Draw 2X-scale text

display.setTextColor(SSD1306_WHITE);

display.setCursor(0, 0);

lunghezza = text_display1.length();

lunghezza=21-lunghezza;

lunghezza=lunghezza/2;

for (int i=0;i<length;i=i+1)

{

display.print(” “);

}

display.print(text_display1);

display.setCursor(0, 20);

length = text_display2.length();

length=21-length;

length=length/2;

for (int i=0;i<length;i=i+1)

{

display.print(” “);

}

display.print(text_display2);

display.display();

delay(1500);

}

int Ctrl_Push()

{

int push = 0;

if (digitalRead(P_UP)==LOW) push = 1;

if (digitalRead(P_DOWN)==LOW) push = 2;

if (digitalRead(P_LEFT)==LOW) push = 3;

if (digitalRead(P_RIGHT)==LOW) push = 4;

if (digitalRead(P_OK)==LOW) push = 5;

return push;

}

void Wait_Push()

{

while (( digitalRead(P_UP)==LOW) ||

(digitalRead(P_DOWN)==LOW) ||

(digitalRead(P_LEFT)==LOW) ||

(digitalRead(P_RIGHT)==LOW) ||

(digitalRead(P_OK)==LOW)) delay(10);

}

Scanning the I²C bus

The last example application we propose is actually a utility, since its code lets you query the I²C bus to detect what is connected to it and report on the display or through the Serial Monitor the address of every device attached to it.

As you can see in Listing 4, the code uses the wire.h library, which allows communication with I²C/TWI devices over the two lines SDA (data line) and SCL (Serial Clock), which are both on board and brought out on the expansion connector labelled I2C, which serves devices connected to the bus externally to the board.

Starting with Arduino 1.0, the library has been aligned with the other read/write libraries; for this reason, the original send() and receive() functions have been replaced by read() and write(). Recent versions of the Wire library can use timeouts to prevent a lock-up in the face of certain problems on the bus, but these are not enabled by default in current versions (it is always advisable to enable these timeouts when using the Wire library). So load the latest version of the library.

ESP32 module with its integrated WiFi transceiver highlighted as a standalone peripheralThe WiFi transceiver of the ESP32 module is a peripheral that can be used on its own

Listing 4

#include <Wire.h>

void setup()

{

Wire.begin();

Serial.begin(9600);

while (!Serial);

Serial.println(“\nI2C Scanner”);

}

void loop()

{

byte error, address;

int nDevices;

address=0x76;

Serial.println(“Scanning…”);

nDevices = 0;

for(address = 1; address < 127; address++ )

{

// The i2c_scanner uses the return value of

// the Write.endTransmisstion to see if

// a device did acknowledge to the address.

Wire.beginTransmission(address);

error = Wire.endTransmission();

if (error == 0)

{

Serial.print(“I2C device found at address 0x”);

if (address<16)

Serial.print(“0”);

Serial.print(address,HEX);

Serial.println(” !”);

nDevices++;

}

else if (error==4)

{

Serial.print(“Unknown error at address 0x”);

if (address<16)

Serial.print(“0”);

Serial.println(address,HEX);

}

}

if (nDevices == 0)

Serial.println(“No I2C devices found\n”);

else

Serial.println(“done\n”);

delay(5000); // wait 5 seconds for next scan

}

Conclusions

Well, with this example of use we end our overview of the ESP32 demoboard, which across three articles has shown you the possibilities for using the hardware, though not all of those possible, both on board and connected through the dedicated connectors. Every example came with a sketch to implement and test it. Now we leave it to you and your inventiveness to implement further applications, which you will test and debug on the demoboard, and then move out of the prototyping phase and build them for good. Happy hacking!

The post ESP32 Demoboard: More Applications to Complete the Overview (Part 3) appeared first on Open Electronics.

Top 10 Advanced IC Substrate Manufacturers in 2026: Leading Companies Powering the AI Semiconductor Revolution

ELE Times - Сбт, 11/14/2026 - 13:37

A combination of Artificial Intelligence (AI), High-Performance Computing (HPC), Cloud infrastructure and next generation semiconductor technology is creating an explosion in packaging requirements. Advanced IC substrates attach dies to printed circuit boards and provide high speed electrical signals, power, and cooling to the circuits.

These advanced substrates enable fewer interconnects, higher wiring density, and more complex semiconductor packages than conventional packaging material. New technologies such as Ajinomoto Build-up Film (ABF), Flip Chip Ball Grid Array (FC-BGA), embedded-component substrates are receiving increasing attention and usage, particularly in AI accelerators, server processors, and networking chips.

In October 2026, NVIDIA announced it was collaborating with leading substrate providers to increase manufacturing capacity by 2.5x over the next three years. This also highlights the importance of substrate makers in the global chip industry.

Below are the 10 top advanced IC substrates companies leading the industry in 2026. This list is editorially selected based on manufacturers ability, technology portfolios, and recent industry developments, not a ranking of market-share.

Top 10 Advanced IC Substrate Manufacturers

IBIDEN Co., Ltd. (Japan)

IBIDEN is an industry-leading manufacturer of high-performance IC package substrates for high-performance computer CPUs, AI servers, and high-performance computing. Offerings of the company include a range of multilayer substrates, fine-line wiring, and next-generation interconnection technologies.

With manufacturing capacity, the company can cater to the growing demand for large semiconductor packages with increasingly complex electrical interconnections. In February 2026, IBIDEN revealed a plan to invest about ¥500 billion in a project to expand production of high-performance IC substrates from FY2026 to FY2028. NVIDIA supports the production expansion to increase the IC substrate supply for AI computing.

Unimicron Technology Corporation (Taiwan)

Unimicron Technology is a world leader in manufacturing advanced IC package substrates (ABF substrates, BT substrates). We offer a wide range of product solutions that serve processor chips, graphics chips, networking and high-performance computing.

The company is cementing its place as demand for AI accelerators and custom application-specific integrated circuits (ASICs) increases, requiring larger package sizes, higher wiring density, and better electrical properties. In October this year, NVIDIA announced a capacity reservation agreement supporting Unimicron’s KF substrates manufacturing expansion in Taiwan. We anticipate more capacity will come online in 2027.

Samsung Electro-Mechanics (South Korea)

​Samsung Electro-Mechanics is a leading producer of semiconductor package substrates such as high-end FC-BGA and ABF. Its technologies enable power AI processors, server CPUs, networking chips, and other advanced semiconductor products. The company is also working on embedded passive component technologies to boost power delivery and electrical performance within complex packages.

In October 2026, Samsung Electro-Mechanics announced a strategic partnership with NVIDIA to expand dedicated ABF substrates production facilities in Sejong and Busan, South Korea. Duck-Hyun Chang, President and CEO of Samsung Electro-Mechanics stated, “It is a great honour to join NVIDIA, a global leader driving AI innovation, as a key infrastructure partner.”

Shinko Electric Industries (Japan)

Shinko Electric Industry has been a key supplier of flip chip package substrates, PBGA substrates, coreless substrates and advanced 2.3D package substrates. The company is also responsible for developing embedded component packaging and optical interconnection technology.

In October 2026, Shinko unveiled its plan to further accelerate the commercialization of mass-production technology for photonics-electronics convergence devices for next-generation AI computing. The move reflects the company’s focus on integrating advanced packaging with high-speed optical communication.

Nan Ya Printed Circuit Board Corporation (Taiwan)

Nan Ya PCB is a well-known manufacturer of standard printed circuit boards, HDI boards, and advanced semiconductor substrates. It also manufactures ABF substrates which are vital in high-performance processors, and dense semiconductor packages. The substrates serve as the dense electrical connection point between semiconductor chips and external circuit boards.

With the continued build-out of AI servers, data centres, and networking infrastructure, Nan Ya PCB is an important supplier in the high-end substrate ecosystem. Its manufacturing capacity places it among the leading companies for high-end IC substrates.

AT&S (Austria)

AT&S Austria Technologies & Systemtechnik is a leading European manufacturer of advanced printed circuit boards and premium IC substrates. The company creates technologies for AI infrastructure, high-performance computing, mobile devices, and high-speed communication.

The properties of glass, such as flatness and dimensional stability and electrical performance, are better than traditional substrate materials, making it a very good candidate for even larger and more complex semiconductor packages. In September 2026, AT&S announced an expanded collaboration with Marvell Technology to ramp up advanced IC substrates capacity for next-generation AI and cloud infrastructure.

Kinsus Interconnect Technology (Taiwan)

Kinsus Interconnect Technology is an experienced player in the advanced semiconductor substrate market, producing ABF and BT substrates for high-performance processors, networking equipment and other semiconductor applications.

In an industry where larger packages, finer circuit patterns, and increased interconnection density are becoming a necessity. Demand for AI infrastructure is driving chip substrate makers like Kinsus to ramp up capacity and develop products tailored to higher, more complex chip architectures.

TOPPAN Holdings (Japan)

Toppan Holdings is strengthening its offering of advanced semiconductor packaging by adding high-density FC-BGA substrates. Its substrate technologies support high-performance computing, networking devices, and silicon solutions for AI.

A major development occurred in September this year, when Advanced Substrate Technologies (AST), a joint venture between TOPPAN and Broadcom, officially opened Singapore’s first high-end FC-BGA substrate manufacturing facility. The plant will manufacture large-body, high-layer-count substrates for cutting-edge AI computing and networking chips.

Yoshiyuki Iida, CEO of AST said, “AST’s ability to deliver large-body, high-layer-count substrates at TOPPAN’s exacting standard is helping meet a real bottleneck in AI and networking chip production.”

LG Innotek (South Korea)

LG Innotek has expanded its presence in the semiconductor substrate arena with FC-BGA, Chip-Embedding, and new glass substrate technology. In September 2026, its debut FC-BGA substrate targeting AI accelerators was exhibited at the KPCA Show 2026. The company released new chip-embedding technologies and glass substrates.

Meanwhile, the company is targeting mass production of its AI accelerator FC-BGA products in 2027 while glass substrates roadmaps point towards potential commercial supply around 2028. These innovations reveal the company’s objective to enter the fast-growing high-performance semiconductor packaging industry.

Kyocera Corporation (Japan)

Kyocera is a leading supplier of ceramic packages and advanced semiconductor package parts. In April 2026, the company revealed a new multilayer ceramic-core substrate for next-generation AI semiconductors, from AI application processors to switch ASICs.

This is used to enhance the mechanical rigidity, support high-density wiring and reduce package deformation. These features are increasingly important for larger, more complex packages. Kyocera can use the strength of fine ceramics to provide an alternative solution for the mechanical and electrical problems of advanced semiconductor packaging.

Advanced IC Substrates Fabrication in the Future

The key trends for tomorrow’s high-performance IC substrates are bigger semiconductor packages, denser wiring, improved power delivery, and more sophisticated packaging architecture. Here are the three important developments:

  1. Glass-core substrates: Designed for larger package assemblies, these offer reduced co-planarity and unevenness through greater flatness and dimensional stability, enabling higher interconnection density with finer details.
  2. Components on-boards: Including passive components and other parts within the substrates can improve power delivery and reduce electrical loss.
  3. Photonics-electronics convergence: Merging light and electrical connections could enable more rapid communication and reduce power usage in future computers.

However, this expansion is also forcing suppliers to focus on scaling up manufacturing capacity, manufacturing yield, and supply chain resilience.

Conclusion

Many of the top advanced IC substrates vendors will continue to take centre stage in the next phase of semiconductor industry growth. IBIDEN, Unimicron, Samsung Electro-Mechanics, Shinko Electric, and AT&S have all processes targeting AI accelerators, high-performance processors, and next-generation data centres.

More sophisticated substrates will increasingly enhance the connectivity, performance, reliability, and power efficiency of chip designs as their complexity continues to grow. This trend will become even more meaningful as the industry moves toward larger packages, glass-core technologies, and more advanced semiconductor integration.

The post Top 10 Advanced IC Substrate Manufacturers in 2026: Leading Companies Powering the AI Semiconductor Revolution appeared first on ELE Times.

Cyient DLM and Hindustan Shipyard Sign MoU to Advance Indigenous Maritime and Defence Electronics

ELE Times - Сбт, 11/14/2026 - 13:19

Partnership to Focus on Indigenous Electronics, Advanced Manufacturing and Lifecycle Support for Maritime and Defence Applications

Cyient DLM and Hindustan Shipyard Limited (HSL) have signed a Memorandum of Understanding (MoU) to explore collaboration in advanced electronics manufacturing and technology solutions for the maritime and defence sectors. The partnership aims to identify opportunities to develop indigenous electronics, strengthen manufacturing capabilities and provide technology support for maritime and defence applications.

The partnership combines HSL’s expertise in shipbuilding, ship repair and system integration with Cyient DLM’s capabilities in mission-critical electronics, embedded systems, power electronics, precision manufacturing, testing and product lifecycle support. Through this collaboration, both companies will explore opportunities to develop more indigenous technologies and strengthen India’s domestic manufacturing capabilities, supporting the Government of India’s Atmanirbhar Bharat initiative.

Under the framework, the two organizations will evaluate potential areas of cooperation across electronics, embedded systems, power electronics, testing, manufacturing and lifecycle support for maritime and defence applications. The companies will also explore opportunities in areas such as indigenization, obsolescence management, test and support systems, autonomous and unmanned maritime platforms, power electronics and AI-enabled maintenance solutions.

Speaking about the partnership, Rajendra Velagapudi, Managing Director & Chief Executive Officer, Cyient DLM, said, “India’s maritime and defence ecosystem presents a significant opportunity to build stronger indigenous technology and manufacturing capabilities. Our engagement with Hindustan Shipyard Limited brings together complementary strengths in shipbuilding and platform integration with Cyient DLM’s expertise in mission-critical electronics and manufacturing. We look forward to exploring opportunities where our combined capabilities can support indigenization, technology development and long-term lifecycle requirements for maritime and defence platforms.”

“This MoU provides a framework for Hindustan Shipyard Limited and Cyient DLM to explore areas where our respective capabilities can complement each other. As India strengthens its indigenous maritime and defence ecosystem, collaboration across shipbuilding, electronics, technology and lifecycle support can play an important role. We look forward to evaluating opportunities that can contribute to greater self-reliance and technology development,” said, R Adm C Raghuram, VSM (Retd,), Chairman and Managing Director, Hindustan Shipyard Limited.

The post Cyient DLM and Hindustan Shipyard Sign MoU to Advance Indigenous Maritime and Defence Electronics appeared first on ELE Times.

Molex High-Radix OCS: 544×544 optical switching for hyperscale AI

Open Electronics - Сбт, 11/14/2026 - 13:00

The move to fully optical data centre networks is already under way, but AI training clusters are growing faster than the switches that connect them. The next generation of Optical Circuit Switch (OCS) platforms has to go well beyond today’s port counts, while keeping strict limits on insertion loss and guaranteeing system-level reliability.

By replacing the traditional electronic packet process with direct, physical paths of light, optical circuit switching radically changes how data moves through the network. This shift to an all-optical core has already proven its value at hyperscale, with deployments delivering 40% energy savings and 50 times less downtime compared with traditional electronic switching (The rise of optical switching).

However, while OCS removes the bottleneck of electrical switching, it concentrates new complexity directly in the physical layer.

The AI scaling curve has quickly outgrown the first generation of OCS products. As training clusters expand to support pods with tens of thousands of GPUs, the physical layer must handle routing and density demands with no precedent in optical routing. Operators are publicly calling for switch matrices that go far beyond the 300-port limit of most current vendor capabilities.

The four attributes that define hyperscale optical circuit switching performance

The question for data centre architects is a very practical one: can OCS platforms scale their port count and manufacturing maturity quickly enough to match the pace of AI infrastructure build-out? Solving this means treating the switch and the surrounding physical layer as a single, holistic platform.

As AI training clusters expand towards hundreds of thousands of accelerators, the optical circuit switches at the centre of the network need a proportionally larger switching matrix. Port count determines the network architecture, but four attributes determine whether a high-radix switch can actually work at hyperscale.

The radix problem

The latest AI superpods require almost 14,000 optical ports each, driving demand for individual switches with more than 300 ports. To minimise network tiers across tens of thousands of GPU pods, hyperscale data centre operators are actively asking for switch matrices with thousands of ports. Scaling to this level introduces a secondary physical challenge: balancing ultra-dense optical cabling with practical field maintenance and mean time to repair (MTTR).

Insertion loss

Every decibel of loss counts when the optics double up in an OCS architecture. Standard far-reach (FR) optics have link budgets limited to roughly 4 dB to 6 dB depending on the module. Any internal switch loss eats directly into those tight margins, reducing reach and the usable optical margin. Keeping to these strict budgets at scale relies on embedded testing and telemetry to continuously monitor performance and validate the optical paths.

Reliability at scale

The whole-system impact, or blast radius, of a failure in one optical switch can stall an entire AI training job. At this scale, even 99.999% component reliability can translate into unacceptable system-level downtime. High component ratings only count if they translate directly into an acceptable mean time between failures (MTBF) and overall availability. Fast recovery from failures also plays a key role, since switching latency determines whether dynamic workloads can continue without interrupting active AI jobs.

Manufacturing readiness

A lab prototype and a production-grade platform are two very different things. Hyperscale operators require vendors able to deliver thousands of units on schedule, through proven, high-volume manufacturing processes. Moving from initial designs to high-volume production depends on consistent assembly techniques and rigorous test protocols to maintain production levels.

The Molex High-Radix Optical Circuit Switch platform

Molex has developed the High-Radix Optical Circuit Switch (OCS) platform to solve the scalability limits of a major global hyperscaler. The design builds on almost twenty years of micro-electromechanical systems (MEMS) technology deployments and on more than two million devices shipped into optical networking applications.

Interior of a modern data centre with rows of server racks.Inside a modern data centre: the environment where Molex’s High-Radix Optical Circuit Switch platform is used for next-generation optical networks.
Breaking the radix barrier

At 544×544, the Molex solution is the highest-radix MEMS-based OCS announced to date. The higher radix lets architects build flatter superpod architectures with fewer switches and fewer hops. Reaching this density relies on a patented optical design that uses the full MEMS tilt range. This approach reduces the required MEMS deflection angle by 50%, allowing the system to scale massively using a proven, highly stable structural design.

Optical and switching performance

This high-radix switch maintains stable, low insertion loss across all paths, with a typical insertion loss of 3 dB. Keeping loss predictable preserves tight optical link budgets across the whole network. The 544×544 switch also supports predictable switching behaviour for dynamic reconfiguration and failure recovery, operating with a maximum switching time of under 150 ms, with development under way aiming at 100 ms. This sub-second performance lets operators quickly reroute traffic and bypass hardware failures to keep the cluster running continuously.

Designed for production deployment

Because the MEMS operates in the optical domain with no active media in the light path, the Molex High-Radix OCS platform stays agnostic to protocols and data rates, supporting from 800Gbps to 1.6Tbps and beyond without hardware changes. Operating entirely in the photonic domain keeps power consumption surprisingly low, drawing 245 watts to handle more than 500 ports. Molex supports the 544×544 switch with global optical manufacturing and advanced assembly capabilities. The assembly process relies on a mechanical build combined with software-guided calibration to establish and align all the optical connections.

A complete optical ecosystem for AI

A high-radix optical circuit switch solves the core routing challenge, but it is only one node in a vast physical network. Building a fully optical network at hyperscale requires a complete physical interconnection infrastructure.

Terminating more than a thousand fibres on a single front switch, using up to 600 pairs of LC-APC or LC-UPC adapters to keep insertion loss low, creates enormous physical density and routing demands. The ecosystem extends well beyond the chassis itself. Maintaining strict link budgets across the whole data centre floor rests on high-performance optical cable assemblies, advanced fibre management and rigorous end-to-end testing.

Building a fully optical data centre requires manufacturing depth in both the core switch and the surrounding physical layer infrastructure. By owning the entire interconnect path, Molex gives architects the complete physical ecosystem needed to build and scale fully optical data centre networks.

Discover how the Molex High-Radix OCS Platform delivers the scaling, reliability and performance required by next-generation AI data centres.

Portrait photo of Oliver Lu, a company executive.Oliver Lu, company executive, whose photo accompanies this article on Molex’s High-Radix Optical Circuit Switch platform for next-generation AI data centres.

The post Molex High-Radix OCS: 544×544 optical switching for hyperscale AI appeared first on Open Electronics.

A 1980s-style Bluetooth handset to fight smartphone addiction

Open Electronics - Сбт, 11/14/2026 - 11:00

Kevin Noki has built a 1980s-style handset that works as a Bluetooth audio peripheral. The goal is to reduce smartphone dependence, not replace the phone. In fact, the project contains no cellular modem at all: real telephony stays with a professional, regulatorily approved device. Bringing custom hardware to VoLTE is impractical in many countries anyway. So the 1980s Bluetooth handset becomes a functional retro object that sidesteps the regulatory constraints of cellular telephony.

The maker starts from an ESP32, which he already had on hand and which integrates Bluetooth. The audio quality he got, however, turned out too ‘crunchy’. So he moved to a dedicated Bluetooth module with the Hands Free Profile (HFP), designed specifically for this kind of application. HFP is the profile that hands-free systems use to handle calls and audio together, so it is the natural choice when you want a handset that behaves like a real handset.

The XPS foam case and the display with bent acrylic

The 1980s ‘brick’-style case is prototyped with XPS foam and a hand-operated hot wire cutter. No CAD, then, at least in the initial phase: the maker follows a traditional industrial design approach, the one that starts from the physical volume and refines it by hand. For the display he instead uses an acrylic bending jig, with which he applies a black LED acrylic over the screen. This way the front glass takes on the right curvature and the black hides the parts that must not emit light.

  • ESP32 as the starting point, with integrated Bluetooth
  • Dedicated Bluetooth module with Hands Free Profile (HFP) for audio
  • XPS foam case cut with a hand-operated hot wire
  • Acrylic bending jig for the display, with black LED acrylic

Anyone who wants to rebuild the project will find several useful pointers. The first is that the Bluetooth module with HFP is the critical part: it is what determines whether the voice comes out clean or ‘crunchy’. The second is that the case does not require expensive equipment, because XPS foam and a hot wire are enough to get to a solid prototype. The third is that a display with heat-bent acrylic can be made with a simple jig, as long as you do a few tests before gluing everything together.

Where to find the details to rebuild the handset

The project is sold on the maker’s site, but the video shows so many details that you can recreate your own version. So even those who do not buy the finished object can study the construction choices and adapt them. Kevin Noki’s project page on Hackaday.io collects the story of the work, and it is the place to start to understand how the trickiest steps were solved. In particular, there you can see how the maker tackled the audio problem and how he modelled the case.

For anyone who would like to approach a similar project, a convenient starting point is a development board with integrated Wi-Fi and Bluetooth, such as this ESP32 board with Wi-Fi and Bluetooth, the same family the maker starts from. The choice of audio module, however, remains the real crux: without a component with the HFP profile the handset does not behave like a hands-free unit. In short, the electronics side is within reach of a maker, while the mechanical side requires patience and a few tests with foam and acrylic.

Source: https://hackaday.io/contests

Related products

The post A 1980s-style Bluetooth handset to fight smartphone addiction appeared first on Open Electronics.

Muse Gadgets: an open source SDK for gadgets that connect to the Muse AI agent

Open Electronics - Птн, 11/13/2026 - 18:00

Muse Gadgets is an open source SDK for building devices that can connect to Meta’s Muse AI agent. The starting point is a commercial ESP32 board, or a Raspberry Pi or a Linux box. The resulting gadget displays images, handles audio input and output, and interfaces with displays, buttons, sensors and actuators. Anyone who wants to rebuild the project will find everything in the code repository published on GitHub, with both SDKs and the firmware.

Meta also pushed the project on the hardware side. It produced 5000 Muse Home Link devices and gave them away free to Muse subscribers in the United States, in the following weeks, until stocks ran out. The Muse Home Link is based on an ESP32-C5 wireless microcontroller, with dual-band WiFi 6, BLE and 802.15.4 for Zigbee and Thread. On board there are 8 MB of flash and 8 MB of PSRAM.

Muse Home Link device with an ESP32-C5 wireless microcontrollerThe Muse Home Link device
Two SDKs: ESP32 Device and Linux Device

The development path splits into two tracks. The ESP32 Device SDK is loaded onto a commercial board and adds image display, audio input and output, and the connection of sensors, actuators and buttons. The Linux Device SDK, on the other hand, turns a Raspberry Pi or a Linux box into a Muse gadget, with custom commands for sysadmin tasks or for Home Assistant.

  • ESP32 Device SDK: images, audio input and output, sensors, actuators and buttons on commercial boards.
  • Linux Device SDK: Raspberry Pi or Linux box as a Muse gadget, with custom commands for sysadmin and Home Assistant.
  • Third directory of the repository: skills for hardware of various kinds, such as Apple HomePod Mini, Brother and Epson printers, ESPHome devices, 3D printers and various TVs.

The Waveshare ESP32-S3-Touch-AMOLED-1.75C devkit is one of the boards mentioned as a starting point: it mounts a 1.75-inch AMOLED touchscreen, speaker, microphone and battery. For those who prefer the Linux route, the catalogue offers a Raspberry Pi 5 starter kit with power supply and microSD, ready to be set up with the Linux Device SDK. On the ESP32 side, the catalogue also has a round HMI display with touch knob and LVGL graphics, based on ESP32-S3, useful for anyone who wants a physical interface to connect to the gadget.

SDK token and pairing with the Muse app

Before flashing or pairing a gadget, two mandatory steps are required: getting an SDK token and accepting the Gadget SDK Terms. Only then do you move on to pairing with the Muse app on iOS and Android. The procedure is carried out from Settings, Devices, after enabling developer mode. The app looks for devices with the MuseGadget prefix and connects them to the agent.

There is quite a lot of software involved. On the ESP32 side you work with ESP-IDF and with LVGL for the graphical interface; on the Linux side SDL comes into play. Integration with Home Assistant and with ESPHome devices is provided by the skills included in the third directory of the repository, together with Muse Code. Anyone who wants to understand how the project is built will find the SDKs, the firmware and the ready-to-use skills in the code repository on GitHub.

The picture is clear: Muse Gadgets is not a single device, but a set of tools for building your own. You start from an ESP32 board or a Raspberry Pi, choose the right SDK, get a token and pair everything with the Muse app. Sensors, actuators and the skills you decide to load do the rest.

Source: https://github.com/facebookincubator/muse-gadget-sdk

Related products

The post Muse Gadgets: an open source SDK for gadgets that connect to the Muse AI agent appeared first on Open Electronics.

Physical AI: Where AI meets the physical world

EDN Network - Птн, 11/13/2026 - 16:03

Artificial intelligence (AI) is moving beyond the cloud and into machines that must perceive, understand, and interact with the physical world. Unlike AI systems that primarily process digital information, physical AI must enable machines to sense their surroundings, make decisions, and act in real time.

That shift introduces new engineering challenges. A robot may recognize an object through computer vision, but knowing how tightly to grip it requires additional sensing, physical-world training data, and processing that can respond to changing conditions.

At Synaptics Tech Day 2026, EE Times executive editor Nitin Dahad explored these challenges with Satish Ganesan, senior VP and GM of Edge Interface & Sensing at Synaptics; Aashish Mehta, CEO of TacnIQ; George Chowdhury, principal analyst for robotics at ABI Research; Vincent Duchaine, co-founder and CTO of Robotiq; and Andrew Herson, head of ecosystem development for physical AI at Nvidia.

The discussion examined how physical AI is evolving, why tactile sensing matters, and what it will take to move intelligent machines from experimentation to practical deployment.

The following Q&A has been edited and condensed for clarity.

Where is physical AI creating value?

Nitin Dahad, EE Times: Where do you see physical AI creating value?

Satish Ganesan, Synaptics: Physical AI is fundamentally about enabling an inanimate object to sense, perceive, adapt, and act. The opportunity is to bring those capabilities into everyday applications, from industrial systems to humanoid robots, using multiple sensing modalities and processing information at the edge.

Andrew Herson, Nvidia: Manufacturing is one of the areas where I expect significant impact. It’s an environment with complex requirements, repetitive activities and large amounts of data, making it well suited for physical AI.

Vincent Duchaine, Robotiq: We’re starting to see a shift toward deployment. The opportunity is in automating tasks that were previously too complex or variable for conventional programming. Physical AI is beginning to make it possible to automate applications that require greater flexibility.

What does touch add that vision alone cannot provide?

Dahad: A key part of physical AI is touch sensing. What does touch add that vision alone can’t?

Ganesan: Think about gripping a glass, handling fruit, or picking up an egg. Each task requires a different amount of force. Touch sensing allows a robot to detect an object’s properties and apply the appropriate pressure. The goal is to translate physical interactions into information that processors can use to make decisions.

Duchaine: Vision has made tremendous progress, but advanced manipulation requires information that pixels alone cannot capture, including friction, texture, stiffness, and force. Touch also improves training data by showing not just whether a grasp succeeded, but whether an object was slipping or the grip was stable.

Aashish Mehta, TacnIQ: With vision alone, you can’t directly measure force feedback. Even determining finger position while holding a cup can be difficult because the hand and object obscure each other.

We’re exploring how to build three-dimensional force maps that capture deformation, soft and hard points, and other physical characteristics. That information could help robotic systems manipulate objects without relying entirely on vision.

What’s the biggest challenge in training robots for the physical world?

Dahad: What’s the hardest data problem in training robots to interact with the physical world? What data is needed to make dexterity reliable.

Duchaine: We’re not capturing enough information about physical interactions, including tactile sensing, force, and torque. We also need better annotation. It’s not enough to recognize objects. Models need to understand the relationships between objects and actions.

Mehta: We’re approaching this in three stages. First, we’re collecting large amounts of tactile data to characterize physical interactions, similar to how a baby learns through touch. We’ve collected approximately 6,000 hours of data across five industries, representing more than 10 million contacts.

Next, we’re organizing that information into physical characteristics such as slip, shear, contact duration, and material properties. Finally, we’re translating those characteristics into applications. The goal is to understand the underlying physics, so we don’t have to train a separate model for every task.

Herson: Self-annotating data will be critical. We can’t expect humans to manually annotate every interaction. By combining information from tactile sensors, inertial sensors and motor currents, robotic systems can generate data that reinforces and validates itself. That could help make dexterity more reliable.

Which applications are likely to benefit first?

Dahad: What will make robotic dexterity reliable enough for practical applications?

George Chowdhury, ABI Research: Humanoid robots represent a longer-term opportunity, but there are applications today in warehousing and manufacturing. Touch and force feedback are particularly useful for manipulating deformable or irregular objects that are difficult to handle through conventional programming. These are applications that existing system integrators can support.

Ganesan: Industrial customers need to handle everything from glass bottles to fruit and eggs, often using mechanical or vacuum-based grippers that require uniformity.

I see a parallel with autonomous vehicles. Driver-assistance features reached the market before fully autonomous driving. Similarly, individual robotic capabilities will be adopted before fully capable humanoid robots. I expect industrial applications to see more rapid adoption around 2028 and 2029.

How will multimodal sensing and edge processing improve robotic performance?

Dahad: How should sensing, perception, and processing be organized so robots can respond appropriately?

Ganesan: The future will involve multimodal sensing, combining vision with other sensors. To achieve low latency, some processing needs to happen close to the sensing elements, whether that’s in a robotic hand or elsewhere in the body.

It’s similar to the human nervous system, where nerve endings handle immediate sensing functions while more complex decisions happen elsewhere. We expect robotic architectures to evolve in a similar way, with local processing for immediate responses and central processing for higher-level decisions.

Duchaine: One challenge is the amount of visual data robots must continuously process, which can introduce delays and contribute to jerky movements. Touch and force sensing provide lower-dimensional signals that can simplify the problem.

It’s not about choosing vision over touch. The two complement each other, and physical feedback can help robots respond more quickly and smoothly.

What will signal that physical AI is ready for broader deployment?

Dahad: What’s one realistic deployment milestone you expect the industry to reach next, and what needs to happen to get there?

Herson: I’d point to lights-out manufacturing. A major milestone would be a large warehouse operating without employees on site. To get there, we need greater standardization of robotic functions and a broader ecosystem that makes deployment economically viable.

Duchaine: We’re beginning to see deployments in tasks such as packaging, where cycle time isn’t the primary requirement. The next step will be robots that are more dexterous than conventional industrial systems but don’t necessarily need to be humanoid. As they become faster and more reliable, they’ll address a wider range of applications.

Chowdhury: Broader adoption requires making robotics accessible beyond companies with enormous R&D resources. Agentic workflows could help system integrators and smaller manufacturers coordinate different robotic assets and reduce integration challenges.

Ganesan: Industrial environments will lead the adoption because robots can perform tasks independently without immediately needing to interact with people in complex settings. Those applications will establish the foundation for broader deployment and, eventually, more capable humanoid robots.

Related Content

The post Physical AI: Where AI meets the physical world appeared first on EDN.

Trick Shot II Runs on a Nokia 3310 With a Custom Board

Open Electronics - Птн, 11/13/2026 - 16:00

Hoani has recreated the Nokia 3310 gaming experience on a custom board, fitted inside the shell of a real phone that has been emptied out. The board runs Trick Shot II, a ball-bouncing game, through a graphics engine written in Go. The idea came from a game jam where the goal was to write a game while respecting the constraints of the Nokia 3310 user interface. Those constraints are a 94 x 48 pixel greyscale LCD, a buzzer and a numeric keypad.

The result is not a software emulation: it is a custom board that fits into the original shell. On top of it sit a Pi Pico, the Nokia 3310 LCD and a key layout that mirrors the phone’s. So the game runs on real hardware, with the real screen and the real keys.

The Go game engine and the graphics and sound APIs

The software heart of the project is a game engine written in Go. The engine provides APIs for both graphics and sound, so the game does not talk directly to the screen or the buzzer. This keeps the Trick Shot II code separate from the hardware side. What’s more, anyone who wants to write another game can reuse the same engine and the same APIs.

The interface constraints are rigid and this shows in the code. The Nokia 3310 LCD has a resolution of 94 x 48 pixels, so every sprite and every screen has to be drawn within that space. The buzzer adds sound, the numeric keypad provides the controls. Trick Shot II uses exactly these few elements for the ball bouncing.

The build: Pi Pico, LCD and keypad in the emptied shell

The custom board holds the Pi Pico, the Nokia 3310 LCD and the keys. The shell of a real Nokia 3310 is emptied out to house all of it, so the board has to follow the internal shapes of the phone. The first prototype did not fit perfectly because the board was 1.6 mm thick instead of 1 mm. A detail that seems minor, but decisive when the space is that of a twenty-year-old shell.

  • Pi Pico as the brain of the board
  • Nokia 3310 LCD at 94 x 48 pixels
  • keypad with the Nokia key layout
  • 1 mm board to fit the original shell
  • Go game engine with graphics and sound APIs
  • Trick Shot II as a ball-bouncing game

Anyone who wants to start from a ready base for the firmware can use a Raspberry Pi Pico, the board that acts as the brain in the project: it is worth testing the game engine on the Pico before soldering the final board.

The project came out of a game jam, so the starting point was the constraint, not the hardware. The challenge was to write a game that fit inside a 94 x 48 pixel greyscale LCD, with a buzzer and a numeric keypad. From there came the decision to rebuild the phone entirely, shell included. If you want to see how Hoani’s work is put together, the project page on Hackaday.io collects the story of the project and its evolution.

Rebuilding this project means working on three fronts at once. The first is the board, which has to stay under one millimetre thick. The second is the firmware on the Pi Pico, with the Go engine and its APIs. The third is the shell, to be recovered and emptied without breaking the fittings. Finally there is the game, Trick Shot II, to run on all of this.

Source: https://hackaday.io/contests

Related products

The post Trick Shot II Runs on a Nokia 3310 With a Custom Board appeared first on Open Electronics.

The tchotchke

EDN Network - Птн, 11/13/2026 - 15:00

Things aren’t always as useless as they seem (and are claimed by others) to be. All it takes is a bit of engineering imagination.

There was a Candid Camera episode many years ago where Alan Funt showed what was said to be a useless machine. It was a Bud box with nine NE-2 neon lamps mounted three-by-three in rubber grommets, and with each lamp blinking on and off at its own individual rate.

Each lamp was part of a relaxation oscillator. Since the oscillators were not synchronized to each other, the blinking pattern of the nine lamps looked random.

You remember what a relaxation oscillator is/was, right? Typically, it was a 90 volt battery, a 0.1 µF capacitor in parallel with an NE-2, and a multi-mega-ohm resistor feeding them (Figure 1).


Figure 1 The circuit for a relaxation oscillator is simplicity exemplified.

Alan Funt and Durwood Kirby explained to viewers that this box was utterly and absolutely useless, and that it served no purpose of any kind. So they took it out to the street and asked passersby what it might be good for.

The big joke was that as useless as this thing supposedly was, people still tried very hard (but without success) to envision a purpose for it. That was the big joke. Ha ha ha. Let’s laugh at all these silly people with their silly ideas.

What nobody came up with was the possibility that this thing might serve, say, as a children’s night light, for example, or a blinky little friend sitting on a night table near the crib or bed. I don’t know for sure, but just maybe this thing wasn’t really the useless tchotchke it was cracked up to be.

Seen any truly useless things lately? And got any other ideas for this particular supposedly useless one? Reader thoughts are as-always welcomed in the comments!

John Dunn is an electronics consultant and a graduate of The Polytechnic Institute of Brooklyn (BSEE) and of New York University (MSEE).

Related Content

The post The tchotchke appeared first on EDN.

A 3D-printed case for the TFT module with EC11 encoder and ESP32-C3

Open Electronics - Птн, 11/13/2026 - 13:00

A knob that turns, a button that clicks and a display that responds. The project brings all of this together in a 3D-printed case that houses a 1.8-inch module with a TFT display, an EC11 rotary encoder and a pushbutton, plus an ESP32-C3 module. The example code shows the encoder count and the pressed state of the encoder and the button on screen. So anyone looking for a physical interface for an ESP32 board finds a ready-assembled starting point here.

The 1.8-inch module is not a bare display: it integrates the ST7735S driver, the EC11 encoder and a pushbutton on the same PCB. Instead of wiring three separate components, you connect a single module. The display works at 160 pixels wide by 128 high, values that the code sets directly in its configuration.

1.8-inch TFT module with ST7735S driver and EC11 encoder1.8-inch TFT module with ST7735S driver and EC11 encoder
Assembly: four M3 screws and a mount for the ESP32-C3

The case consists of three printed parts: front, back and a mount for the ESP32-C3. The TFT module with encoder and button is screwed to the front panel with four 4mm M3 screws. The mount holds the board in the right position, so the connections are not under strain. As a result, assembly needs no glue and no improvised brackets.

For the electronics you need a compact development board with integrated Wi-Fi and Bluetooth radio, from the same family as the module used here. Assembly stays simple: four holes, four screws and the module is fixed in place.

PCB screwed to the front panel with the mount for the ESP32-C3Screw the PCB to the front panel with the mount for the ESP32-C3
Firmware: interrupts on the encoder and debounce on the button

The code is uploaded from the Arduino IDE with the ESP32 board package installed. To enter boot mode, hold the BOOT and RESET buttons down together, then compile and upload the sketch. The serial port runs at 115200 baud. The firmware uses interrupts on the ENC_A pin for movement and on the ENC_S pin for the encoder press, while the SWITCH button is read with a 10-millisecond software debounce.

The screen updates with a 500-millisecond timeout, so it does not redraw on every pulse. The encoder counter starts at 50 and is clamped between 0 and 99. The display also shows the pressed state of the encoder and the button, so you can immediately check whether everything responds.

  • TFT module display: 1.8 inches
  • Resolution set in the code: 160 x 128 pixels
  • Encoder counter: starts at 50, clamped between 0 and 99
  • Screen refresh timeout: 500 milliseconds
  • Serial port speed: 115200 baud
  • Button debounce: 10 milliseconds
  • Mounting screws: four 4mm M3

Anyone who wants to rebuild the project will find the starting point for the code and the assembly on the project page on Hackster.io. The libraries to install are Adafruit_GFX, Adafruit_ST7735 and SPI. The ESP32 board package for the Arduino IDE completes what is needed.

The result is a single unit with a knob, a button and a screen, driven by an ESP32-C3. There is no need to solder three separate modules, because the 1.8-inch module already contains them. And the test firmware is ready: upload it, turn the knob and watch the number change.

Source: https://www.hackster.io/john-bradnam/interfacing-a-1-8in-tft-display-rotary-enc-switch-module-c5f8a6

Related products

The post A 3D-printed case for the TFT module with EC11 encoder and ESP32-C3 appeared first on Open Electronics.

<new>

Semiconductor today - Птн, 11/13/2026 - 11:15
Navitas Semiconductor Corp of Torrance, CA, USA — which provides GaNFast gallium nitride (GaN), GeneSiC silicon carbide (SiC) power semiconductors and integrated voltage regulator (IVR) technologies — has filed a lawsuit in the US District Court for the Eastern District of Texas charging Renesas Electronics Corp of Tokyo, Japan with six counts of patent infringement...

Сторінки

Subscribe to Кафедра Електронної Інженерії підбірка - Новини світу мікро- та наноелектроніки