Feed aggregator

Guerrilla RF appoints Lauren Winslow as executive VP, sales

Semiconductor today - Wed, 11/04/2026 - 15:05
Guerrilla RF Inc (GRF) of Greensboro, NC, USA — which provides radio-frequency integrated circuits (RFICs) and monolithic microwave integrated circuits (MMICs) for wireless applications — has appointed Lauren Winslow as executive VP, sales, reporting directly to founder & CEO Ryan Pratt. In addition, following a two-week transition period, chief business officer Kellie Chong will leave the firm, effective 13 November, to pursue other opportunities...

Significantly simpler square wave circuits for frequency division by even numbers

EDN Network - Wed, 11/04/2026 - 15:00

An AND gate replaces comparators to cut a frequency divider’s chip count.

In his recent Design Idea, “Frequency division by any even number, with a 50% duty cycle output,” frequent contributor Jayapal Ramalingam presents a nice family of frequency divider circuits with symmetrical square wave outputs.

The circuit designs shown there share a topology. It comprises a ripple-carry counter, a comparator that generates a reset pulse when the counter reaches a terminal count equal to half the chosen division ratio, and a final divide-by-two square wave-generating output flip-flop. Two examples of this basic topology are shown in the Design Idea. One implements division by 10 and consists of three chips. Another divides by 48 and requires four chips.

Wow the engineering world with your unique design: Design Ideas Submission Guide

There’s certainly nothing functionally wrong with these clever designs. They work. However, I noticed an opportunity for a significant simplification and reduced parts count that arises from a familial property of ripple carry counters.

They ripple.

When a clock pulse increments the contents of such counters, zeros propagate (ripple) through the stages until ending by hitting and flipping a zero bit to a one. Consequently, detection of the chosen terminal count doesn’t require an actual comparator, but can be done with a simple AND gate. This is shown in Figure 1’s two-chip solution to the frequency-division problem.


Figure 1 This divide-by-10 circuit utilizes U2a’s AND gate to decode U1a’s ripple carry counter to get a divide by 1 + 4 = 5. This is cascaded with U2b’s division by 2 for Fout = (Fin/5)/2 = Fin/10 = a 50:50 square wave.

Here’s how it works.

Four-bit ripple counter U1a combines with 4-input AND gate U2a to create the desired division ratio. The ratio created is equal to the sum of the U1a output weights that are connected to U2. Ratios from 1 through 15 are therefore available. Figure 1’s example shows 1 + 4 = 5.

When U1a ripples up to the chosen ratio, U2a pin 6 goes to a logic “1” which resets U1a to back to zero and advances U1b by one count, toggling its least significant bit (LSB) output. U1b thus performs an additional power-of-2 division which can be any of 4 possible ratios: 2, 4, 8, or 16. Figure 1’s example of this illustrates a net division of 5 x 2 = 10.

But of course, a total of 15 x 4 = 60 possible ratios exist. Any ratio can be chosen from the sequence 2, 4, 6, … 30, 4, 8, 12, … ,60, 8, 16, 48, …, 120, 16, …, 240.

Figure 2 shows how this same concept works for a division ratio of 48, while still requiring just two chips.


Figure 2 In this divide-by-48 example, U2a decodes U1a to divide by 4+8=12, followed by U1b’s division by four for Fout = (Fin/12)/4 = Fin/48.

And Figure 3 shows division by 100, still with a 50:50 output and still implemented by just two chips.


Figure 3 In this divide-by-100 example, U1a divides by 16, then U2a decodes 1+8=9 for 16+9 = 25, followed by U1b’s division by four for Fout = (Fin/25)/4 = Fin/100.

If you build one, don’t forget to tie U2’s unused inputs to V+ or ground.

Stephen Woodward‘s relationship with EDN’s DI column goes back quite a long way. Over 200 submissions have been accepted since his first contribution back in 1974.  They have included best Design Idea of the year in 1974 and 2001.

Related Content

The post Significantly simpler square wave circuits for frequency division by even numbers appeared first on EDN.

Transitioned my 18650 parallel prototyping arrays from linear TP4056 to FM5324 10W synchronous PMICs. Huge thermal improvement!

Reddit:Electronics - Wed, 11/04/2026 - 14:46
Transitioned my 18650 parallel prototyping arrays from linear TP4056 to FM5324 10W synchronous PMICs. Huge thermal improvement!

Operating parallel Lithium-Ion grids via legacy linear chargers were making severe thermal bottlenecks during heavy switching tasks.

To optimize efficiency, I migrated the substrate power paths to the FM5324 switch-mode PMIC, achieving synchronous 5V/2A buck-charging and step-up outputs directly integrated on a perforated board.

The entire open-source firmware tracking libraries are live on our GitHub, and I've mapped the complete architectural deep-dive, including efficiency scaling metrics on Medium:

https://medium.com/@volkankutlu/engineering-high-efficiency-18650-charging-arrays-transitioning-from-tp4056-to-fm5324-10w-6da2890c6974

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

CSconnected sponsors event in Cardiff focusing on semiconductor startups

Semiconductor today - Wed, 11/04/2026 - 13:41
CSconnected Ltd, the not-for-profit organization driving the world’s first compound semiconductor cluster in South Wales, sponsored Silicon Catalyst’s ‘Forming, Storming, Norming & Performing for Semiconductor Startups’ event at Cardiff University on 28 October, as it sets out South Wales as the place for semiconductor businesses to start, scale and stay...

ESP32 Demoboard: New Demo Projects Using On-Board Hardware (Part 2)

Open Electronics - Wed, 11/04/2026 - 13:00

Let’s experiment with new demo projects using one of the most widely used WiFi modules: the ESP32 SoC. Part two.

We introduced the demoboard for the ESP32 SoC and mentioned that, to get you into the world of development with this hardware from an IoT perspective, we wrote firmware and created examples that we began describing in the first part. Now we continue along this path by proposing demo applications that use the on-board hardware and the modules that can be connected externally through the dedicated connectors. As a reminder, the following items can be fitted to the demoboard:

  • air quality sensor, code SGP30CO2;
  • lightning sensor, code FT1324M;
  • gesture detector, code APDS9960BOUT;
  • UVB sensor, code GYLM8511;
  • pressure sensor, code BMP280;
  • NFC/RFID reader, code PN532;
  • turbidity sensor, code TORBISENS;
  • PIR sensor, code PIRMOD / code MINIPIRMOD;

Having said that, let’s pick up where we left off and start with the first application, in which we use the gesture detector.

Gesture detection

In this specific case, using a dedicated firmware (OLED_Gesture.ino) to be loaded in Arduino, we will read the hand gesture data detected by the APDS9960BOUT detector (it sits in position U5 on the demoboard) and display on screen the four detectable directions (UP-DOWN-LEFT-RIGHT), depending on the hand gesture performed.

After installing module U5, you must copy the “libraries” folder under “/Documents/Arduino” (if you haven’t changed the default folder), then open the Arduino IDE and from the “File” menu load our example code “Gesture/OLED_gesture.ino”, which you will also find in full in Listing 1.

The breakout board with which we detect gestures is shown in Fig. 1 and is based on the APDS-9960 RGB and Gesture sensor; equipped with integrated anti-UV and IR filters, four separate diodes sensitive to different directions and an I²C-compatible interface, this small breakout allows light and colour measurements, and contactless proximity and motion detection at a distance between 10 and 20 cm.

The sensor detects gestures through light radiation. The board pins used on the demoboard are the following: VL (optional IR LED power), GND (Ground), VCC (3.3V power), SDA (I²C data) and SCL (I²C clock).

Breakout board for gesture detection based on the APDS-9960 sensorFig. 1 The breakout board for gesture detection

Listing 1

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#include <SparkFun_APDS9960.h>

// Pins

#define APDS9960_INT 27 // Needs to be an interrupt pin

#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

// Global Variables

SparkFun_APDS9960 apds = SparkFun_APDS9960();

int isr_flag = 0;

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

}

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(“Gesture”);

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

*/

// Set interrupt pin as input

pinMode(APDS9960_INT, INPUT);

// Initialize Serial port

Serial.begin(9600);

Serial.println();

Serial.println(F(“——————————–“));

Serial.println(F(” OLED + APDS-9960 – GestureTest “));

Serial.println(F(“——————————–“));

// Initialize interrupt service routine

attachInterrupt(APDS9960_INT, interruptRoutine, FALLING);

// Initialize APDS-9960 (configure I2C and initial values)

if ( apds.init() ) {

Serial.println(F(“APDS-9960 initialization complete”));

} else {

Serial.println(F(“Something went wrong during APDS-9960 init!”));

}

// Start running the APDS-9960 gesture sensor engine

if ( apds.enableGestureSensor(true) ) {

Serial.println(F(“Gesture sensor is now running”));

} else {

Serial.println(F(“Something went wrong during gesture sensor init!”));

}

}

void loop()

{

if( isr_flag == 1 )

{

detachInterrupt(0);

handleGesture();

isr_flag = 0;

attachInterrupt(0, interruptRoutine, FALLING);

}

}

void interruptRoutine()

{

isr_flag = 1;

}

void handleGesture()

{

if ( apds.isGestureAvailable() )

{

display.clearDisplay();

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

display.setTextColor(SSD1306_WHITE);

display.setCursor(5, 30);

switch ( apds.readGesture() )

{

case DIR_UP:

display.print(” UP “);

break;

case DIR_DOWN:

display.print(” DOWN “);

break;

case DIR_LEFT:

display.print(” LEFT “);

break;

case DIR_RIGHT:

display.print(” RIGHT “);

break;

case DIR_NEAR:

display.print(” NEAR “);

break;

case DIR_FAR:

display.print(” FAR “);

break;

default:

display.print(” NONE “);

}

display.display(); // Show initial text

delay(100);

}

Lightning detection

Let’s now move on to the second application in this article, which sees the ESP32 demoboard used with the breakout board based on the AMS AS3935 chip, a component capable of picking up the radio-electrical disturbances caused by electric arcs and in particular atmospheric discharges (lightning, in short…) and, through appropriate processing, providing a signal that corresponds to the detection of a lightning strike and its intensity. All the signals needed to manage the IC are brought out on a row of 2.54 mm pitch pads on one side. Data connection to the outside world takes place via I²C Bus or SPI.

The lightning detector breakout board (Fig. 2) was designed to be paired with a microcontroller and to be used with Arduino hardware, whose task is to analyse the signal provided by the sensor and process it, then show on the demoboard’s OLED display the number of electrical discharges detected and the estimated distance; dedicated libraries are provided, one of which is used in this application and included in the code we developed for the purpose. The supply voltage is 5 Vdc, current draw 50 mA, maximum detection distance 40 km.

As a result of the connection, the serial output shows an indication of any lightning strikes picked up, or storm disturbances.

To implement this example application you must copy the “libraries” folder under “/Documents/Arduino”, then open the Arduino IDE and load the example in the “Sens_Fulmini” folder; this code sends to the serial output an indication of any lightning strikes picked up or disturbances due to storm-related electrical phenomena. If you also want the display on the demoboard, you need to load the OLED_Sens_Fulmini example (Listing 2), whose code makes both the display and the serial output show an indication of any lightning strikes picked up or storm disturbances.

Breakout board for lightning detection based on the AMS AS3935 chipFig. 2 Breakout board for lightning detection

Listing 2

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

//for lightning

#include <SPI.h>

#include <Wire.h>

#include “SparkFun_AS3935.h”

// Adjust the address jumpers on the underside of the product.

#define AS3935_ADDR 0x03

#define INDOOR 0x12

#define OUTDOOR 0xE

#define LIGHTNING_INT 0x08

#define DISTURBER_INT 0x04

#define NOISE_INT 0x01

#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 lightning

SparkFun_AS3935 lightning(AS3935_ADDR);

// Interrupt pin for lightning detection

const int lightningInt = 35;

const int threshVal = 10; //a higher number means better disturber rejection.

// This variable holds the number representing the lightning or non-lightning

// event issued by the lightning detector.

int intVal = 0;

int noise = 2; // Value between 1-7

int disturber = 2; // Value between 1-10

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(“Lightning”);

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

*/

while (!Serial);

// When lightning is detected the interrupt pin goes HIGH.

pinMode(lightningInt, INPUT);

Serial.println(“AS3935 Franklin Lightning Detector”);

Wire.begin(); // Begin Wire before lightning sensor.

if( !lightning.begin() )

{ // Initialize the sensor.

Serial.println (“Lightning Detector did not start up!”);

OLED_Message(“Lightning Detector”,”did not start up!”);

while(1);

}

else

{

Serial.println(“Lightning Detector Ready!”);

OLED_Message(“Lightning Detector”,”Ready!”);

delay(1500);

}

// The lightning detector defaults to an indoor setting at

// the cost of less sensitivity, if you plan on using this outdoors

// uncomment the following line:

//lightning.setIndoorOutdoor(OUTDOOR);

}

void loop()

{

String text_msg = “”;

if(digitalRead(lightningInt) == HIGH)

{

// Hardware has alerted us to an event, now we read the interrupt register

// to see exactly what it is.

intVal = lightning.readInterruptReg();

if(intVal == NOISE_INT)

{

OLED_Message(“Noise detected”,””);

Serial.println(“Noise.”);

// Too much noise? Uncomment the code below, a higher number means better

// noise rejection.

//lightning.setNoiseLevel(setNoiseLevel);

delay(1500);

}

else if(intVal == DISTURBER_INT)

{

OLED_Message(“Disturber detected”,””);

Serial.println(“Disturber.”);

// Too many disturbers? Uncomment the code below, a higher number means better

// disturber rejection.

lightning.watchdogThreshold(threshVal);

delay(1500);

}

else if(intVal == LIGHTNING_INT)

{

// Lightning! Now how far away is it? Distance estimation takes into

// account any previously seen events in the last 15 seconds.

byte distance = lightning.distanceToStorm();

//text_msg = String(distance) + “km away!”;

text_msg = “km away!”;

OLED_Message(“Lightning detected”,text_msg);

Serial.println(text_msg);

delay(1500);

}

}

OLED_Message(“No disturb detected”,””);

delay(500); // Slow it down.

}

void OLED_Message(String text_display1, String text_display2)

{

int length = 0;

display.clearDisplay();

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

display.setTextColor(SSD1306_WHITE);

display.setCursor(0, 20);

length = text_display1.length();

length=21-length;

length=length/2;

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

{

display.print(“ “);

}

display.print(text_display1);

display.setCursor(0, 40);

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

Reading an NFC tag

We now move on to the third application in this article, which lets us experiment with NFC short-range wireless communication technology using a dedicated breakout board to mount on the board. The board in question is the PN532, an NFC/RFID reader/writer equipped with 1 status LED, an antenna integrated on the PCB, and I²C, SPI and HSU (High Speed UART) communication interfaces.

It can work as an RFID card reader/writer, as an NFC reader with an Android smartphone, and in wireless mode with two identical devices.

It can be used with Arduino to build access control devices, etc., and demo applications such as the one described here.

The NFC breakout board can implement data communication over I²C, SPI and HSU (High Speed UART) interfaces, selectable one at a time via dip-switches. It supports RFID reading/writing, P2P communication between two identical modules, NFC with Android smartphones, and as far as RFID reading/writing is concerned it is compatible with the following standards:

  • Mifare 1k, 4k, Ultralight, DesFire cards;
  • ISO/IEC 14443-4 cards such as CD97BX, CD light, Desfire, P5CN072 (SMX);
  • Innovision Jewel cards such as the IRT5001;
  • FeliCa cards such as the RCS_860 and RCS_854.

The maximum distance at which tags can be read is between 50 and 70 mm.

The PN532 NFC tag and card reader/writer is shown in Fig. 3 and must be inserted into the female strip located at position U8 of the demoboard.

To implement the applications we make available, as usual, two example sketches: one for managing the breakout board so that it reads a tag, and the other, more complete, for displaying the data acquired from the NFC tag or card on the on-board OLED display.

As with the other examples, first you must copy the libraries folder, then open the Arduino IDE and from the “File” menu open the “NFC” folder and, among the example sketches you find inside, load the NFC.ino example, thanks to which the code of the NFC card read is sent over the serial port; you can see it in Listing 3.

The second sketch you will find is OLED_NFC.ino; by running it, the code of the NFC tag or card is shown both on the display and on the serial port.

PN532 NFC breakout board with integrated PCB antenna and status LEDFig. 3 NFC breakout board

Listing 3

#include <Wire.h>

#include <PN532_I2C.h>

#include <PN532.h>

#include <NfcAdapter.h>

PN532_I2C pn532i2c(Wire);

PN532 nfc(pn532i2c);

void setup(void) {

Serial.begin(115200);

Serial.println(“Hello!”);

nfc.begin();

uint32_t versiondata = nfc.getFirmwareVersion();

if (! versiondata) {

Serial.print(“Didn’t find PN53x board”);

while (1); // halt

}

// Got ok data, print it out!

Serial.print(“Found chip PN5”); Serial.println((versiondata>>24) & 0xFF, HEX);

Serial.print(“Firmware ver. “); Serial.print((versiondata>>16) & 0xFF, DEC);

Serial.print(‘.’); Serial.println((versiondata>>8) & 0xFF, DEC);

// Set the max number of retry attempts to read from a card

// This prevents us from waiting forever for a card, which is

// the default behaviour of the PN532.

nfc.setPassiveActivationRetries(0xFF);

// configure board to read RFID tags

nfc.SAMConfig();

Serial.println(“Waiting for an ISO14443A card”);

}

void loop(void) {

boolean success;

uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // Buffer to store the returned UID

uint8_t uidLength; // Length of the UID (4 or 7 bytes depending on ISO14443A card type)

// Wait for an ISO14443A type cards (Mifare, etc.). When one is found

// ‘uid’ will be populated with the UID, and uidLength will indicate

// if the uid is 4 bytes (Mifare Classic) or 7 bytes (Mifare Ultralight)

success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength);

if (success) {

Serial.println(“Found a card!”);

Serial.print(“UID Length: “);Serial.print(uidLength, DEC);Serial.println(“ bytes”);

Serial.print(“UID Value: “);

for (uint8_t i=0; i < uidLength; i++)

{

Serial.print(“ 0x”);Serial.print(uid[i], HEX);

}

Serial.println(“”);

// Wait 1 second before continuing

delay(1000);

}

else

{

// PN532 probably timed out waiting for a card

Serial.println(“Timed out waiting for a card”);

}

}

Measuring atmospheric pressure

We continue with a fourth application, in which we detect atmospheric pressure by pairing our demoboard with a pressure sensor: the BMP280 from Bosch.

It is a piezoresistive absolute barometric pressure transducer, with a measurement range of 300÷1100 hPa, mounted on a breakout board.

The special features of this sensor, besides its linearity and stability, are also highlighted by its relative accuracy, which the manufacturer states as ±0.12 hPa, equal to ±1 m of air column.

In Fig. 4 you can see the sensor mounted on its breakout board, which, after being fitted with the appropriate pin strip to be soldered into the respective pads, must be inserted into position U7 of the ESP32 demoboard.

This application also has a dedicated sketch to be uploaded in Arduino using the IDE and the USB connection; the application file is the one called OLED_Pressure.ino and it makes the display show the ambient temperature, the atmospheric pressure and the detected humidity.

To run the application you must copy the “libraries” folder under the path “/Documents/Arduino”; this loads the library for managing the pressure sensor. To make good use of the example sketch we provide, the I²C-Bus address of the breakout board must be configured to 0x76.

The code of the atmospheric pressure measurement application is the one shown in Listing 4 and it implements the acquisition of the sensor readings from the I²C-Bus and their display on the on-board OLED display.

Bosch BMP280 pressure sensor on its breakout boardFig. 4 The Bosch BMP280 sensor

Listing 4

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.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

// 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

Adafruit_BMP280 bmp; // I2C

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(15, 30);

display.print(“Pressure”);

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

*/

Serial.begin(9600);

Serial.println(F(“BMP280 test”));

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. */

}

void loop()

{

display.clearDisplay();

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

display.setTextColor(SSD1306_WHITE);

display.setCursor(5, 0);

display.print(“Temp:”);

display.setCursor(60, 0);

display.print(bmp.readTemperature());

display.print(” C”);

display.setCursor(5, 20);

display.print(“Pressure:”);

display.setCursor(60, 20);

display.print(bmp.readPressure());

display.print(” Pa”);

display.setCursor(5, 40);

display.print(“Altitude:”);

display.setCursor(60, 40);

display.print(bmp.readAltitude(1013.25));

display.print(” m”);

display.display();

delay(2000);

}

Presence detection with PIR

We close this instalment with an application in which we detect the movement of people and objects within the range of a passive infrared radar, better known as a PIR detector; for this purpose we will use a specific sketch.

The application works like this: when the PIR sensor detects movement (through connector CNU10) the relay output is activated and a warning is shown on the display. The PIR must be connected with its three contacts (positive and negative supply, output) to connector PU10, dedicated to connecting devices outside the demoboard. Whenever the passive infrared radar detects movement within its field of action, the on-board relay (RL1) stays activated for as long as the PIR output is in alarm. For example, the PIRMOD model keeps the output activated for 10 seconds after detection ends. The firmware to upload to the ESP32 to implement this test application is OLED_PIR.ino and you will find it in Listing 5; as usual, it must be uploaded through the IDE and the USB connection.

Listing 5

#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 PIR = 19;

const int RELAY = 32;

const int LEDR = 25;

int state=0;

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(25, 30);

display.print(” PIR “);

// 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(PIR, INPUT);

pinMode(RELAY, OUTPUT);

pinMode(LEDR, OUTPUT);

}

void loop()

{

display.clearDisplay();

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

display.setTextColor(SSD1306_WHITE);

Ctrl_Pir();

switch(state)

{

case 0:

display.setCursor(10, 10);

display.print(“PIR:ALARM”);

display.setCursor(10, 40);

display.print(“OUT:ON”);

digitalWrite(RELAY,HIGH);

digitalWrite(LEDR,HIGH);

break;

case 1:

display.setCursor(10, 10);

display.print(“PIR:—–“);

display.setCursor(10, 40);

display.print(“OUT:OFF”);

digitalWrite(RELAY,LOW);

digitalWrite(LEDR,LOW);

break;

default:

break;

}

display.display();

delay(500);

}

void Ctrl_Pir()

{

if (digitalRead(PIR)==LOW) state=1;

else state=0;

}

Conclusions

Well, this second instalment ends here, and in it we have shown you further capabilities offered by our ESP32 demoboard and its on-board and external peripherals. We will wrap up the survey of the devices and the demonstration applications in the next and final instalment.

Happy experimenting!

The post ESP32 Demoboard: New Demo Projects Using On-Board Hardware (Part 2) appeared first on Open Electronics.

Keysight Introduces 14-Bit XR3 Oscilloscope for High-Density, Rack-Based Test Systems

ELE Times - Wed, 11/04/2026 - 12:04

Keysight Technologies has introduced the XR3, a compact 14-bit oscilloscope designed for rack-based testing systems. The instrument occupies just one rack unit (1U) and offers four-channel mixed-signal measurement capabilities. Its compact design helps save space, reduce equipment weight and minimise cabling compared with traditional benchtop oscilloscopes.

Automated testing systems used in aerospace, defence, manufacturing and physics are becoming more complex. As a result, engineers need to fit more testing and measurement equipment into limited rack space. Earlier, many systems used a single benchtop oscilloscope, but modern applications often require multiple instruments working together. However, adding more instruments increases space requirements, creates extra cabling and can cause signal timing differences. This has made it difficult for engineers to find equipment that offers both the full measurement capabilities of an oscilloscope and the compact design needed for high-density test systems.

The XR3 removes this trade off, by combining Keysight’s benchtop-class measurement performance with a compact, scalable architecture. Built around Keysight’s MegaZoom 5 custom application-specific integrated circuit (ASIC) and a 14-bit analog-to-digital converter (ADC), it delivers a 50-microvolt root mean square (µVrms) noise floor and an update rate of 1.3 million waveforms per second. Multiple instruments can be synchronized to integrate over 100 channels in a single system, while selectable bandwidths from 200 MHz to 1 GHz let engineers scale performance to the application, accelerating debug and reducing time to market.

Key benefits of the XR3 include:

  • Uncompromised performance: With 100 Mpts of memory per channel, the XR3 enables engineers to capture small signals and rare events. In addition, zoom, filters, zone triggering, and colour grading testing all run in real-time on hardware, without decreasing XR3’s 1.3 million waveforms per second update rate.
  • Expanded synchronized channel capacity: An autosensing 10 MHz reference in/out synchronizes clocks and triggers across multiple units, enabling over 100 time-correlated channels in a single multi-blade system. Hardware based auto-sync, auto-discovery and auto-deskew remove complexity from the synchronization process, providing a simplified setup.
  • Improved test system integration: Native software for protocol decodes, power supply test, and jitter analysis covers everyday debug needs. Infiniium 2026 software, native to the XR8 oscilloscope, can also run on an external controller as a unifying user interface to visualize and control multiple XR3 units from a single screen. Separately, the XR3 can be paired with Keysight’s next-generation XR8 oscilloscope to add low-noise, cost-effective high-impedance (Hi-Z) channels without the need to convert to a high-speed channel using an adapter.

Jun Chie, Vice President, Keysight Product Management, said: “Engineers building dense test systems should not have to choose between measurement performance and rack space. The XR3 brings benchtop-class capabilities to a compact, scalable platform, helping customers add synchronized channels, simplify integration, and preserve measurement confidence as their systems grow.”

The post Keysight Introduces 14-Bit XR3 Oscilloscope for High-Density, Rack-Based Test Systems appeared first on ELE Times.

Marvell’s acquisition of Lumentum could challenge Broadcom’s market leadership, says TrendForce

Semiconductor today - Wed, 11/04/2026 - 11:45
Following the announcement that data infrastructure semiconductor solutions provider Marvell Technology Inc of Santa Clara, CA, USA is acquiring Lumentum Holdings Inc of San Jose, CA, USA (which designs and makes optical and photonic products for optical networks and lasers), market research firm TrendForce notes that, if completed (subject to shareholder and regulatory approval), the acquisition would significantly strengthen Marvell’s optical technology portfolio and enable the combined company to deliver more comprehensive next-generation optical interconnect solutions...

INMP441 MEMS Microphone with ESP32: Digital Audio over I2S

Open Electronics - Wed, 11/04/2026 - 11:00

An ESP32 can listen without adding a single analog component. All it takes is an INMP441 omnidirectional MEMS microphone, wired to the I2S bus, to get 24-bit digital audio samples. The project by Rui Santos and Sara Santos is an introductory guide to this pairing, written for the Arduino IDE, and it offers three examples: measuring sound intensity in RMS, displaying the waveform, and switching an output on at the sound of a clap.

The INMP441 module is powered at 3.3 V and communicates over I2S. The L/R pin selects the channel: tied to GND it selects the left channel, tied to 3V3 it selects the right channel. The WS pin, also called LRCLK, must be connected to an ESP32 GPIO, as must the SCK pin, also called BCLK. The SD pin carries the audio data and must be connected to an ESP32 GPIO configured as an input.

Configuring the I2S driver and reading 24-bit samples

The driver is configured with two structures. The i2s_config_t sets master mode in receive, the sample rate, the bits per sample and the channel format. The i2s_pin_config_t assigns the pins. Then everything is started with i2s_driver_install, i2s_set_pin and i2s_zero_dma_buffer.

In the code the sample rate is 16000 samples per second, the buffer for the RMS calculation is 512 samples and the DMA is configured with 8 buffers. The sample buffer is of type int32_t, that is 32 bits per sample. The microphone’s audio data is 24 bits and is left-aligned inside the 32-bit word, so the sample must be shifted 8 bits to the right before any calculations. The serial monitor baud rate is 115200.

  • GPIO 40 for WS, the Word Select
  • GPIO 42 for SCK, the Serial Clock
  • GPIO 41 for SD, the Serial Data
  • L/R to GND for the left channel, to 3V3 for the right
  • Module power supply at 3.3 V

The three examples start from the same samples. In the first, the values read with i2s_read are squared, summed, averaged and then square-rooted, to obtain the RMS value, that is the indicator of sound intensity. In the second, the same samples go to the Serial Plotter, which draws the waveform. In the third, the sound level crosses a threshold and the ESP32 turns an output on or off at the sound of a clap. Anyone who wants to rebuild the circuit can find the breakout with the I2S MEMS microphone ready to use, without soldering the surface-mount component.

What you need to rebuild the three examples on the bench

You need an ESP32-S3 board, an INMP441 module, some jumper wires and a breadboard. On the software side, Arduino IDE and the i2s.h driver, included by default in the Arduino ESP32 core, are enough. No amplifiers, filters or external converters are needed, because the microphone already returns digital data.

Anyone who wants to follow the work from the start can find the guide by Rui Santos and Sara Santos on the maker’s site, with the wiring, the driver configuration and the three complete sketches. The same examples can be adapted to another board in the ESP32 family, by changing the GPIOs assigned to WS, SCK and SD.

Source: https://randomnerdtutorials.com/esp32-inmp441-i2s-microphone-arduino/

Related products

The post INMP441 MEMS Microphone with ESP32: Digital Audio over I2S appeared first on Open Electronics.

Saft Opens Production Lines for Next-Generation Solid-State Batteries in France

ELE Times - Wed, 11/04/2026 - 10:54

French battery maker Saft, a subsidiary of TotalEnergies. unveiled on 19 October 2026 new production lines for solid-state batteries at the plant in Bordeaux, which heralds the scale-up of battery cells based on solid electrolytes rather than liquid ones used in lithium-ion technology.

Saft’s programme includes solid electrolytes based on sulphides as well as polymer electrolytes that are capable of working at room temperature. The company is interested in use cases where the energy density, safety, and performance are particularly critical, such as aviation or space.

Solid-state batteries have garnered a lot of interest from the EV industry, as the technology has the potential to bring higher energy density to the table while mitigating some safety concerns, especially those posed by combustible liquid electrolytes. Saft said the technology could have up to 50% more energy density than traditional lithium-ion batteries, but that will depend on cell design and what battery is being compared to.

The company has also introduced a dry-electrode manufacturing process which it claims can cut production-related carbon dioxide emissions by as much as 40%.

Transitioning solid-state batteries from development to mass production has been difficult. Existing producers must prove cell quality and long cycle life, that battery material interfaces are robust and that they can be manufactured at market-competitive prices. So Saft’s announcement is an industrial milestone, and evidence that solid-state batteries are already being mass-produced for mainstream passenger EVs.

Why it matters

Having a production ability may assist the development of solid-state batteries, and also give expertise to support future applications of electric mobility.

The post Saft Opens Production Lines for Next-Generation Solid-State Batteries in France appeared first on ELE Times.

CATL Introduces Dual-Battery Architecture for Heavy-Duty Electric Trucks

ELE Times - Wed, 11/04/2026 - 10:01

Chinese battery producer CATL unveiled a dual-electric range-extender battery system for heavy-duty electric trucks on 20th October 2026. The pack features a large, swappable battery and an onboard battery that adds driving range.

The primary battery is offered with the listed capacities of 432 kWh or 513 kWh, while the further range-extension battery provides an extra 77 kWh. Operators can also simply swap out the main battery at compatible swap stations without having to wait for a charging session to complete.

The architecture aims at freight operators, who find vehicle downtime, cost of batteries, and adaptability of routes major issues in running vehicles. The primary swappable battery has been separated from the reserve battery to potentially increase utilisation of batteries and reduce some of the financial hurdles to electrify heavy trucks.

CATL is developing the system as part of its QIJI battery swapping ecosystem. The firm is planning to increase the number of sites for electric heavy-duty vehicles.

Battery swapping could benefit high-utilisation freight routes with predictable demand, but they have to use standardised batteries and vehicles built to use them, and require significant infrastructure investment and other factors to ensure stations will be viable.

Building two batteries also complicates engineering. Automakers need to look at the battery packaging for both battery packs, safety features and the control strategy.

Why it matters

Swappable batteries and the energy content stored in internal reserves could see battery electric trucks become the norm, entering the realm of the possible for commercial freight hauliers working to a timetable.

The post CATL Introduces Dual-Battery Architecture for Heavy-Duty Electric Trucks appeared first on ELE Times.

Fraunhofer Tests Silicon-Rich EV Battery Cells Beyond 1,000 Charge Cycles

ELE Times - Wed, 11/04/2026 - 09:52

Scientists at the Fraunhofer Institute for Solar Energy Systems ISE in Germany have announced a milestone for lithium-ion batteries with high silicon content. The researchers used a battery chemistry developed in the project Str Obo Batt for a test with pouch cells, which were partially assembled by Fraunhofer ISE themselves, with a capacity of 25 Ah.

The cells retained more than 83% of their initial capacity following testing and recorded a gravimetric energy density of 280 Wh/kg in a non-optimised research-well configuration, the institute said in 20 October 2026 announcements.

Silicon could make for more powerful batteries. Silicon anodes are also capable of packing in more lithium than standard graphite anodes. More silicon could translate to a higher energy density and allow for more extended driving ranges without a heavier battery.

Main engineering challenges: silicon volume expands/ contracts significantly during charge/discharge, and cycling damages the electrode and electrical contact so that it loses capacity. The anodes must therefore be stabilised, increasing the need to engineer for longer cycle life.

Fraunhofer’s reported results demonstrate progress in balancing energy density with durability. But the cells are a research product and are not yet evidence of a commercially available EV battery. Mass production, cost, operation at various temperature conditions, and fast-charge performance are yet to be demonstrated.

What it means

If the cells can be produced at scale, they would help automakers give electric cars more range with less weight in batteries.

The post Fraunhofer Tests Silicon-Rich EV Battery Cells Beyond 1,000 Charge Cycles appeared first on ELE Times.

Allye Energy Develops a 400 kW EV Charger Using Repurposed Battery Packs

ELE Times - Wed, 11/04/2026 - 09:41

British energy-storage firm Allye Energy announced the commercial availability of its MEV (MAX for EV) charging system on 27 October 2026. A battery energy-storage system is integrated with an EV charger using used electric-vehicle battery packs.

The solution tackles one of the biggest problems facing the electrification of fleets: the relatively low electrical capacity at some depots. High-powered chargers may need costly grid upgrades, new electrical connection points, and extended infrastructure work.

Instead of drawing the power from the grid at the point of charging, for which it would need to draw from the network, the Allye MEV accrues energy from the electrical grid and dispenses it when vehicles require a charge. The system, the company says, is capable of outputting up to 400 kW across two cars at the same time, even on a 16-amp supply.

This strategy could enable fleet managers to make use of high-power charging at stations where the grid has limited capacity. It could also give old EV batteries a second life before they need to be recycled.

The system is designed and assembled in the UK, and the company said the batteries are sourced from UK-registered vehicles and around 95% of the material is from British sources.

However, the maximum charging output is not continuous under every working condition. Performance is dependent on energy in reserve, the condition of the battery, what is required in terms of charging, and the speed at which the energy reserves can be recovered.

Why it matters

This sort of battery-integrated charging capability could speed up commercial EV deployment without needing a large-scale depot upgrade right away.

The post Allye Energy Develops a 400 kW EV Charger Using Repurposed Battery Packs appeared first on ELE Times.

Ford Fathom Integrates Bidirectional Power Technology to Turn EVs into Home Energy Sources

ELE Times - Wed, 11/04/2026 - 09:28

Ford has announced its upcoming all-electric Fathom pickup. This all-electric pickup truck from Fathom may make electric vehicles a bit more practical.

In a 27th October statement, Ford said the 2027 Fathom is expected to deliver more than 10kW of AC power. The vehicle should also enable home energy management by allowing drivers to tap into the battery when electric prices are high, and act as a backup in outages.

Common EV batteries store electric power as direct current (DC); however, most of the devices in our homes run on alternating current (AC). Bidirectional systems thus require power-conversion equipment to enable energy to flow between the vehicle and the home. Adding more of this ability to the car would also be cheaper hardware-wise and easier to install.

Ford says its system will support the company’s Home Power Station and, for backup operation, a home backup panel that’s compatible. The system is designed to enable vehicle-to-home (V2H) capabilities.

This demonstrates how electric vehicle (EV) engineering is opening up to energy management in the home. But final power levels will be governed by the equipment used, the installation specifications, the state of charge of the batteries and local power grid laws. The showable power figures must not be mistaken for verified real-world capabilities.

Why it matters

Power electronics that can send power in both directions in an EV could someday mean the car can become a mobile energy-storage station, with no need for backup batteries and generators.

The post Ford Fathom Integrates Bidirectional Power Technology to Turn EVs into Home Energy Sources appeared first on ELE Times.

India Launches Next-Generation Offshore Patrol Vessel Srishti

ELE Times - Wed, 11/04/2026 - 09:18

India has further advanced its indigenous naval build-up with the launching of a Next Generation Offshore Patrol Vessel (NGOPV) named Srishti at Goa Shipyard Limited (GSL) on 27 October 2026.

The ship is Yard 1283, launched as part of a push by the Indian Navy to develop an indigenous design and build programme. The project is part of India’s broader drive towards self-reliance in defence manufacturing and production of sophisticated naval platforms in the country.

The upcoming offshore patrol vessels will conduct surveillance, search and rescue, offshore asset protection, humanitarian assistance/disaster relief, and counter-piracy operations.

They allow navies to make their presence felt in portions of the ocean and respond to events outside the immediate proximity of large combat ships. This is particularly important for safeguarding offshore installations and sea traffic.

The Ministry of Defence stated that the construction of the NGOPV class is progressing at two shipyards, namely Goa Shipyard Limited at Goa and Garden Reach Shipbuilders and Engineers at Kolkata. This concurrent construction of the class was undertaken to enhance the participation of domestic industry and to develop the indigenous shipbuilding ecosystem.

The launch is a construction event and not a delivery to service. There is still work to do with additional fitting out, testing, and acceptance before the ship will be ready to carry out operations.

The programme embodies the role of contemporary indigenous platforms and their importance to furthering maritime awareness and national security. It also highlights the role of indigenous shipyards in the design, building, and future support of India’s navy.

The post India Launches Next-Generation Offshore Patrol Vessel Srishti appeared first on ELE Times.

India Partners with Sarvam to Develop Indigenous AI for the Armed Forces

ELE Times - Wed, 11/04/2026 - 09:13

India is also increasing its efforts on sovereign defence AI via a five-year MoU between HQ Integrated Defence Staff (IDS) and the Bengaluru-headquartered AI firm Sarvam.

The pact lays down a policy and framework for the use of AI applications across the Indian Army, Navy, and Air Force. It covers research, knowledge management, training, and decision support to develop AI skills aligned with the needs of the armed forces.

As per the print report, work will be overseen by Sarvam’s national-security department, called Chanakya. Possible emphasis areas may include target acquisition, data fusion, and decision support for the military’s sensor-to-shooter process-the whole chain from the collection of information by sensors through to the systems used to counter the threat.

AI can assist armed forces with processing and analysing the vast amount of data collected by sensors like radars, satellites, and drones. Cross-referencing between platforms can help, for instance, the armed forces to detect patterns, filter critical data from less important data, and provide assessments faster.

Indigenous development would also help the country to gain control over critical data, as well as model deployment, and future improvements. The MoU does not form a reference to that which has already been produced or deployed in the field, but provides a generic basis for that cooperation.

The partnership is also in the context of defence forces elsewhere in the world ramping up investments in AI-supported intelligence, logistics, surveillance, and planning. In defence uses in particular, reliability, cyber security, data integrity, and human controls continue to be critical where AI output may impact decisions.

The deal is yet another indication of how India is trying to strengthen home-grown AI capacity for national security purposes, rather than dependence on foreign players, yet again.

The post India Partners with Sarvam to Develop Indigenous AI for the Armed Forces appeared first on ELE Times.

AUKUS Advances Three Advanced Underwater Sensor Payloads for Uncrewed Submarines

ELE Times - Wed, 11/04/2026 - 09:06

The United Kingdom will lead the next stage of developing three advanced sensor and mission payloads for uncrewed underwater vehicles (UUVs) under the AUKUS security partnership between Australia, the UK and the United States.

Announced after the Maritime Big Play exercise in San Diego, the programme is intended to improve underwater surveillance and strengthen cooperation between allied uncrewed maritime systems.

The payloads are a synthetic aperture sonar, a deployable anti-submarine warfare sensor, and a deployable non-kinetic effecter. Synthetic aperture sonar can return higher-resolution images of the bottom and objects below the water. The third payload is working to generate non-kinetic effects, deploying anti-submarine warfare sensors in order to detect and classify underwater threats.

Together, these skills might allow surveillance of whole swaths of the oceans to uncover dangers or damage to essential subsea assets like communication cables or other critical infrastructure.

This programme is included in AUKUS Pillar II, the pillar dedicated to collaboration on advanced defence technologies. The partners are working towards greater interoperability to enable uncrewed systems that each country develops to work better with those developed by other nations.

According to the UK Ministry of Defence, the payloads are set to become part of the three nations’ uncrewed underwater vehicle fleet from 2027. This is a target, not a statement of fact that all three products are already operational.

The research also underscores the idea of a hybrid navy, with crewed ships and submarines working side by side with autonomous vehicles. The systems could increase the range of surveillance and reduce the need for personnel to travel into dangerous underwater scenarios.

The post AUKUS Advances Three Advanced Underwater Sensor Payloads for Uncrewed Submarines appeared first on ELE Times.

Енергомоніторинг корпусів КПІ ім. Ігоря Сікорського

Новини - Wed, 11/04/2026 - 09:00
Енергомоніторинг корпусів КПІ ім. Ігоря Сікорського
Image
kpi ср, 11/04/2026 - 09:00
Текст

Пропонуємо вашій увазі публічний дашборд корпусів КПІ ім. Ігоря Сікорського: показники енергомоніторингу та візуалізація даних.

Saab and General Atomics Test Airborne Early-Warning Radar on Uncrewed MQ-9B

ELE Times - Wed, 11/04/2026 - 08:59

Saab and General Atomics Aeronautical Systems, Inc. (GA-ASI) have announced the successful flight demonstration of unmanned airborne early-warning (AEW) capabilities, combining Saab’s Loyal Eye radar with the MQ-9B remotely piloted aircraft.

The flight was conducted from GA-ASI’s Desert Horizon Flight Operations Facilities in Southern California. “The integrated system proved effective at detecting, tracking, and classifying airborne targets,” the companies said. “The systems were also able to concurrently track multiple airborne and maritime targets at extended ranges, including instrumented fighter and commercial aircraft.”

Historically, manned aircraft carrying high-performance radars have been used for airborne early warning. A related option is to integrate these capabilities on a long-endurance uncrewed platform for further increased surveillance coverage with less exposure of the aircrew.

The MQ-9B can also work side-by-side with dedicated crewed AEW and command-and-control aircraft. Its endurance and long loiter time could enable the military to monitor a vast area and increase situational awareness in challenging operational environments.

Saab’s LoyalEye radar is intended to deliver uninterrupted airborne surveillance. On the MQ-9B, it is installed using payload pods, offering flexibility for integrating the radar with the aircraft.

The most recent test is an indication of the companies’ progress in assessing the integrated capability, following a previous flight in May 2026. The companies have disclosed interest from potential customers, but the release does not state that a production order has been received.

This is part of a larger trend of dispersing sensors across crewed and uncrewed vessels and platforms, which could increase the amount of early warning and surveillance coverage.

The post Saab and General Atomics Test Airborne Early-Warning Radar on Uncrewed MQ-9B appeared first on ELE Times.

Leonardo Taps Shield AI Software to Advance Autonomous Military Helicopter

ELE Times - Wed, 11/04/2026 - 08:53

European aerospace and defence firm Leonardo has announced it will be partnering with US-based Shield AI to further develop autonomous mission capabilities for its Proteus uncrewed rotorcraft, pushing forward on the path to AI-enabled military aviation.

According to the deal. Leonardo will use the Hivemind software development kit of Shield AI to develop and integrate mission-autonomy capabilities. This document is aimed at supporting rotary-wing ISR, ASW, and logistics capabilities in contested operating areas. Further details were not disclosed.

The Proteus platform has a modular payload bay allowing for mission-specific payloads, providing a lot of flexibility in the type of missions the vehicles can undertake, such as maritime surveillance, transport, and other naval-related tasks. Proteus is an uncrewed vertical take-off and landing technology demonstrator developed by Leonardo in collaboration with the Royal Navy and UK Defence Innovation.

Hivemind software allows engineers to plan autonomous aircraft behaviour so that a mission can be adapted to operate on a range of platforms in different operating environments. The contract has allowed Leonardo to maintain the capability to adapt to changing mission requirements.

The collaboration is a complement to Proteus’ first flight earlier this year in 2026, when the autonomy capability developed by Leonardo was integrated into the aircraft. The new pact is intended to follow up on this work rather than imply that the platform has gone live.

AI-powered uncrewed rotorcraft might one day enable navies to undertake sustained surveillance, without requiring aircrew to undertake sustained surveillance, without requiring aircrew to deploy on dangerous mission. Nevertheless, autonomous mission execution, reliability, and safe integration with crewed aircraft continue to be development challenges.

This collaboration demonstrates how defence manufacturers are beginning to combine proven aircraft engineering with flexible AI software.

The post Leonardo Taps Shield AI Software to Advance Autonomous Military Helicopter appeared first on ELE Times.

Pages

Subscribe to Кафедра Електронної Інженерії aggregator