i.MX 8M Mini/Nano System-on-Modules (SoMs)

Beacon EmbeddedWorks’ wireless SoM features NXP’s i.MX 8M mini processor and Wi-Fi 5 and Bluetooth® 4.2 connectivity

Beacon EmbeddedWorks’ i.MX 8M Mini/Nano system-on modules (SoMs) can help customers get their product to market faster and reduce design risk. The multicore architecture of NXP’s i.MX 8M Mini/Nano applications processor provides the platform to develop a portfolio of devices on a single hardware design. The i.MX 8M Mini/Nano SoM provides security, high-performance multimedia processing including 3D graphics and high-definition video, power-efficient processing capabilities, and wireless connectivity. Beacon EmbeddedWorks is a leader in designing and developing SoMs with wireless technologies, low-power capabilities, and small form-factors. Board support package (BSP) options are continuously updated with versions of Linux, Android, and real-time operating systems. With a low stack height and compact footprint, the i.MX 8M Mini/Nano SoM is an excellent choice for next-generation medical, military, aerospace, and industrial applications where space is at a premium.

Features

  • Processor options
    • Mini: NXP i.MX 8M Mini processor with up to four Arm® Cortex®-A53 cores running up to 1.8 GHz plus an Arm Cortex-M4 core running up to 400 MHz, GPU (GCNanoUltra + GC320), and VPU
    • Nano: NXP i.MX 8M Nano processor with up to four Arm Cortex-A53 cores running up to 1.5 GHz plus an Arm Cortex-M7 core running up to 750 MHz and GPU (GC7000UL)
  • Embedded memory
    • Mini: up to 8 GB of 32-bit wide LPDDR4 memory
    • Nano: up to 4 GB of 16-bit wide LPDDR4 memory
    • eMMC, configurable
    • Quad SPI NOR Flash, configurable
  • Network connectivity
    • Wi-Fi 5 (802.11a/b/g/n/ac)
    • Bluetooth 4.2
    • BLE support
    • Ethernet 10/100/1000 MAC + PHY
    • Security
    • Integrated secure element for end-to-end security
  • USB
    • Mini: two USB 2.0 high-speed on-the-go
    • Nano: one USB 2.0 high-speed on-the-go
  • Display
    • MIPI DSI (up to four lanes)
  • Camera
    • MIPI CSI-2 (up to four lanes)
  • Audio
    • Mini: up to three synchronous audio interfaces (SAI) with support for 9 Tx and 13 Rx lanes
    • Nano: up to two synchronous audio interfaces with support for 1 Tx and 5 Rx lanes
    • S/PDIF input and output
    • Up to eight channel pulse density modulation (PDM) inputs
  • PCIe
    • Mini: 1x PCIe Gen 2.0, 1-lane
  • Serial I/O
    • Up to three UART interfaces
    • Up to three I²C interfaces
    • Up to two SPI interfaces operating as either master or slave
  • GPIO
    • Up to 87 multiplexed GPIOs supporting various peripherals such as PWMs, SDIO, UART, SPI, and I²C
  • RTC
    • Onboard ultra-low power real-time clock (RTC)
  • Debug
    • JTAG support
  • Mechanical
    • Dimensions: 28 mm x 38 mm
    • Weight: 7.7 g
  • Compliance
    • RoHS compliant
    • Reach compliant
    • Wi-Fi and Bluetooth are pre-certified for FCC and ISED

more information: https://beaconembedded.com

Micsig SATO1004 handheld oscilloscope

Micsig’s SATO1004 is a four-channel automotive oscilloscope with a comprehensive list of pre-set vehicle-related tests.

The instrument features 100MHz bandwidth, 1Gsample/s (in single channel mode), 32Mpoint memory and up to five hours of mobile use from its built-in battery, or continuous use from its 12V power adaptor.

“SATO1004 is a professional vehicle testing tool for evaluating CAN, LIN, Flex ray and K line networks, and sensors for: ABS, accelerator pedal, throttle position, fuel pressure, air flow meter, crankshaft, camshaft, knock, MAP; as well as testing 12 and 24V charging and start, charging ripple, cranking current sensors, actuators and ignition,” according to distributor Saelig, which is stocking the instrument.

The 8inch 800 x 600 touchscreen has touch, drag and swipe, and shares control of the scope with knob-and-button control. An HDMI output is available to reproduce the display on a larger screen or projector. “Live screen images can be transmitted to an external projector when the oscilloscope is connected to a LAN or WiFi network. The scope can display or be remotely controlled via Wi-Fi, LAN or USB, via a PC or an Android or iOS mobile device,” said Saelig.

As well as the serial busses above, bus trigger and decode features include: UART, SPI and I2C, then 1553B and ARINC 429 trigger and decode are options.

The Standard Kit version of the scope comes with 2x passive probes, 4x BNC-banana cables, 2x pair needle probes, 2x pair alligator clips, a power adaptor with mains cable and a screen protector.

The master Master Kit has the above, plus a secondary ignition pick-up, 2x multimeter-style probe tips and a hard-shell carrying case.

Dimensions are 265 x 192 x 50mm and 1.9kg

Manufacturer Micsig is based in Shenzhen-based, and Saelig of Fairport New York is its authorised North American distributor. The Saelig SATO1004 product page can be found here

Kneron KL720 AI SoCs

Kneron KL720 AI SoC (System on a Chip) offers an ideal balance of performance, power saving, and cost for hardware makers who are looking to benefit from on-device edge Artificial Intelligence (AI). Powered by Kneron’s Neural Processing Unit (NPU) that accelerates neural network models, the KL720 SoC makes possible endless AI applications for smart devices.

The NPU core is of the KL720 is designed to accelerate major computing layers inside the Convolutional Neural Network (CNN) and Recurrent Neural Network (RNN) to off-load heavy computing from the traditional CPU or GPU structure.

Features Highlights

  • Low-power design enabled by ARM Cortex M4 CPU
  • Power to process 4K images, Full HD videos, and 3D sensing for fool-proof facial recognition and to enable innovative gesture control for gaming, shopping kiosks, and more
  • Ideal for any high-end IP Cams, Smart TVs, AI glasses and headsets, and AIoT Gateways
  • Power to drive natural language processing (NLP) for translators and AI assistants
  • All the above and more can be processed at the same on the KL720

Features

  • NPU
    • 696MHz maximum frequency
    • GOPS, 1024MAC/cycle peak throughput of 8-bit mode:
  • CPU
    • Arm® Cortex®-M4 @ 400MHz for system control
  • DSP
    • Tensilica DSP @ 500Mhz for AI assistance
  • Memory
    • 128MB SIP SDRAM, 32-bit LPDDR2-2133
    • Up to 128MB SPI NOR or NAND Flash
  • OS Support
    • CMSIS RTX
  • Power
    • 1.725W average power consumption @ Yolov3_608
    • 0.9V core voltage
    • 1.8V or 3.3V I/O voltage, grouped by I/O banks
  • Video in interface
    • 2-land MIPI-CSI-2 RX
    • DVP
  • Video out interface
    • DVP
    • LCM
  • Audio Interface
    • I2S
  • Peripheral Interface
    • I2C
    • SPI
    • UART
    • USB 2.0 OTG
    • PWM
    • GPIO
    • SDIO

Block Diagram

more information: https://www.kneron.com/solutions/soc/

Move-X Cicerone LoRa®/GNSS Board

Move-X Cicerone LoRa®/GNSS Board is a high-performance, low-power, Arduino MKR-compatible development board based on the MAMWLE LoRa Module and the u-blox MAX-M10S GNSS Module. The Cicerone Board delivers best-in-class GNSS, long-range wireless connection, and high-performance MCU processing in a low-power solution for optimal battery life.

The Cicerone Board allows users to build tracking applications worldwide with meter-level accuracy and to communicate long-range, low-power data via LoRaWAN®. The integrated Li-Po charging circuit enables the Cicerone Board to manage battery charging through the USB port.

The Move-X Cicerone LoRa/GNSS Board features a compact 63mm x 25mm form factor and is compatible with all Arduino MKR Shield Boards. These boards all share a common pinout to enable developers to easily add expansions with minimal software changes.

Features

  • 63mm x 25mm PCB
  • 2x push buttons: Reset, User)
  • 2x LEDs: Battery charging status (Red), User (Green)
  • Headers compatible with Arduino MKR pinout
    • SWD signals for debugging
    • RESET, BOOT0
    • +3.3V output (LDO)
    • +5V input
    • +5V output (internally MUXed between USB and +5V input)
    • VREF output
    • GNSS module’s UART (allows firmware update)
    • MAMWLE SPI
    • I2C shared by LoRa and GNSS module
    • Up to 22 digital GPIO
    • Inputs for ADC
    • PWM outputs
  • Interfaces
    • USB micro for UART, RESET/BOOT0 driver, supply input, battery charge @200mA
    • Connector for single-cell 3.7V Li-Po battery (battery shall include protection circuitry against SC, OD, OC)
    • 10-pin JTAG/SWD Debug connector for ST-LINK
    • U.FL antenna connector for GNSS L1
    • U.FL antenna for LoRaWAN®
  • Key components
    • Move-X MAMWLE Low Power Radio Module
    • u-blox MAX-M10S GNSS Module
    • Microchip Technology MCP73831 Charge Management Controller
    • Silicon Labs CP2102N USBXpress™ USB-to-UART Bridge Controller

Board Layout

more information: https://www.move-x.it/cicerone-board/

Nordic Semi announces first Wi-Fi 6 chip

Nordic Semiconductor has announced its entry into the Wi-Fi wireless IoT market with the launch of the nRF7002, an ultra-low power, dual-band Wi-Fi 6 companion IC.

Nordic Semiconductor is now one of just a few companies offering all three of the world’s most popular wireless IoT technologies: Bluetooth, Wi-Fi, and cellular IoT.

The nRF7002 is described by Nordic as a ‘companion IC’ which means it is designed to provide seamless Wi-Fi connectivity and Wi-Fi-based locationing (SSID sniffing of local Wi-Fi hubs) when used alongside Nordic’s existing products. These include the nRF52 and nRF53 Series multiprotocol Systems-on-Chip (SoCs), and nRF91 Series cellular IoT Systems-in-Package (SiPs).

The nRF7002 can also be used in conjunction with non-Nordic host devices.

The launch of the nRF7002 follows Nordic’s 2020 acquisition of the development team, core Wi-Fi expertise, and Wi-Fi IP tech assets of Imagination Technologies Group.

W-Fi forms an integral part of the smart home Matter protocol championed by Apple, Amazon, Google, Samsung, and hundreds of other companies in consumer IoT. By adding Wi-Fi to its product range Nordic will now be able to support all three wireless protocols used in Matter. Namely: Bluetooth LE for commissioning, Thread for low power mesh networking, and Wi-Fi for high-speed wireless applications.

“We were able to bring our first Wi-Fi IC to market very quickly as a result of acquiring an extremely capable Wi-Fi team alongside a portfolio of Wi-Fi assets that team had already developed,” said Nordic CTO/EVP of R&D and Strategy, Svein-Egil Nielsen. “Nordic has also ensured that developing Nordic-based Wi-Fi 6 applications will be as simple as developing any other Nordic wireless IoT application, including using the same development tools and nRF Connect SDK.”

“The new Wi-Fi team’s relentless hard work to enable Nordic to launch its first Wi-Fi product so soon deserves huge recognition,” continued Mike Davis, Nordic’s ‪Wi-Fi Systems & Software Director. “They knew Wi-Fi was the number one missing capability requested by Nordic customers. And they knew Nordic’s customers needed this capability quickly.”

The nRF7002 is supplied in a 6 x 6mm QFN package and is sampling now.

Bluetooth LE based LCD messenger using STM32

The aim of this project is to send messages via Bluetooth using a web browser or smartphone to an LCD display that is connected to the STM32 board.

1. Introduction

The project is based on STM32 Nucleo-144 which controls LCD display using BleuIO.

For this project, we will need two BleuIO USB dongles, one connected to the Nucleo board and the other to a computer, running the web script.
When the BleuIO Dongle is connected to the Nucleo board’s USB port the STM32 will recognize it and directly start advertising. This allows the Dongle on the computer port to connect with the web script.

With the web script on the computer, we can send messages to the LCD screen connected to STM32 using BleuIO.

We have used an STM32 Nucleo-144 development board with STM32H743ZI MCU (STM32H743ZI micro mbed-Enabled Development Nucleo-144 series ARM® Cortex®-M7 MCU 32-Bit Embedded Evaluation Board) for this example. This development board has a USB host where we connect the BleuIO dongle.

If you want to use another setup you will have to make sure it support USB Host and beware that the GPIO setup might be different and may need to be reconfigured in the .ioc file.

About the Code

The project source code is available on Github.

https://github.com/smart-sensor-devices-ab/stm32_bleuio_lcd.git

Either clone the project or download it as a zip file and unzip it, into your STM32CubeIDE workspace.

If you download the project as a zip file you will need to rename the project folder from ‘stm32_bleuio_lcd-master’ to ‘stm32_bleuio_lcd’

Connect the SDA to PF0 on the Nucleo board and SCL to PF1.

Then setup I2C2 in the STM32Cube ioc file as follows. (Make sure to change the I2C speed frequency to 50 KHz as per LCD display requirements.)

In the USBH_CDC_ReceiveCallback function in USB_HOST\usb_host.c we copy the CDC_RX_Buffer into an external variable called dongle_response that is accessible from the main.c file.

void USBH_CDC_ReceiveCallback(USBH_HandleTypeDef *phost)
{
    if(phost == &hUsbHostFS)
    {
        // Handles the data recived from the USB CDC host, here just printing it out to UART
        rx_size = USBH_CDC_GetLastReceivedDataSize(phost);
    HAL_UART_Transmit(&huart3, CDC_RX_Buffer, rx_size, HAL_MAX_DELAY);

    // Copy buffer to external dongle_response buffer
    strcpy((char *)dongle_response, (char *)CDC_RX_Buffer);

    // Reset buffer and restart the callback function to receive more data
    memset(CDC_RX_Buffer,0,RX_BUFF_SIZE);
    USBH_CDC_Receive(phost, CDC_RX_Buffer, RX_BUFF_SIZE);
    }

    return;
}

In main.c we create a simple interpreter so we can react to the data we are receiving from the dongle.

void dongle_interpreter(uint8_t * input)
{

  if(strlen((char *)input) != 0)
  {
    if(strstr((char *)input, "\r\nADVERTISING...") != NULL)
    {
      isAdvertising = true;
    }
    if(strstr((char *)input, "\r\nADVERTISING STOPPED") != NULL)
    {
      isAdvertising = false;
    }
    if(strstr((char *)input, "\r\nCONNECTED") != NULL)
    {
      isConnected = true;
      HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_SET);
    }
    if(strstr((char *)input, "\r\nDISCONNECTED") != NULL)
    {
      isConnected = false;
      HAL_GPIO_WritePin(GPIOE, GPIO_PIN_1, GPIO_PIN_RESET);
    }


    if(strstr((char *)input, "L=0") != NULL)
    {

      isLightBulbOn = false;
      //HAL_GPIO_WritePin(Lightbulb_GPIO_Port, Lightbulb_Pin, GPIO_PIN_RESET);
      lcd_clear();

      writeToDongle((uint8_t*)DONGLE_SEND_LIGHT_OFF);

      uart_buf_len = sprintf(uart_tx_buf, "\r\nClear screen\r\n");
      HAL_UART_Transmit(&huart3, (uint8_t *)uart_tx_buf, uart_buf_len, HAL_MAX_DELAY);
    }

    if(strstr((char *)input, "L=1") != NULL)
    {
        isLightBulbOn = true;
        writeToDongle((uint8_t*)DONGLE_SEND_LIGHT_ON);


        lcd_clear();

        lcd_write(input);

    }

  }
  memset(&dongle_response, 0, RSP_SIZE);
}

We put the interpreter function inside the main loop.

/* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
    MX_USB_HOST_Process();

    /* USER CODE BEGIN 3 */
    // Simple handler for uart input
    handleUartInput(uartStatus);

    // Inteprets the dongle data
    dongle_interpreter(dongle_response);

  // Starts advertising as soon as the Dongle is ready.
  if(!isAdvertising && !isConnected && isBleuIOReady)
  {
    HAL_Delay(200);
    writeToDongle((uint8_t*)DONGLE_CMD_AT_ADVSTART);
    isAdvertising = true;
  }
  }
  /* USER CODE END 3 */

Using the example project

What we will need:

Importing as an Existing Project

From STM32CubeIDE choose File>Import…

Then choose General>Existing Projects into Workspace then click ‘Next >’

Make sure you’ve chosen your workspace in ‘Select root directory:’

You should see the project “stm32_bleuio_SHT85_example”, check it, and click ‘Finish’.

Running the example

Upload the code to STM32 and run the example. The USB dongle connected to STM32 will start advertising automatically.

Send Messages to the LCD screen from a web browser

Connect the BleuIO dongle to the computer. Run the web script to connect to the other BleuIO dongle on the STM32. Now you can send messages to the LCD screen.

For this script to work, we need:

Create a simple Html file called index.html which will serve as the frontend of the script. This Html file contains some buttons that help connect and read advertised data from the remote dongle, which is connected to stm32.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link
      href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css"
      rel="stylesheet"
      integrity="sha384-1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3"
      crossorigin="anonymous"
    />
    <title>Send message to STM32 LCD display using Bluetooth LE</title>
  </head>
  <body class="mt-5">
    <div class="container mt-5">
      <h1 class="mb-5">Send message to STM32 LCD display using Bluetooth LE</h1>
      <button class="btn btn-success" id="connect">Connect</button>
      <div class="row">
        <div class="col-md-4">
          <form method="post" id="sendMsgForm" name="sendMsgForm">
            <div class="mb-3">
              <label for="msgToSend" class="form-label">Your Message</label>
              <input
                type="text"
                class="form-control"
                name="msgToSend"
                id="msgToSend"
                required
                maxlength="60"
              />
            </div>

            <button type="submit" class="btn btn-primary">Submit</button>
          </form>
        </div>
      </div>

      <br />
      <button class="btn btn-danger" id="clearScreen" disabled>
        Clear screen
      </button>
    </div>

    <script src="script.js"></script>
  </body>
</html>

Create a js file called script.js and include it at the bottom of the Html file. This js file uses the BleuIO js library to write AT commands and communicate with the other dongle.

import * as my_dongle from 'bleuio'
const dongleToConnect='[0]40:48:FD:E5:2F:17'
document.getElementById('connect').addEventListener('click', function(){
  my_dongle.at_connect()
  document.getElementById("clearScreen").disabled=false;
  document.getElementById("connect").disabled=true;
  document.getElementById("sendMsgForm").hidden=false;
})

document.getElementById("sendMsgForm").addEventListener("submit", function(event){
    event.preventDefault()
    console.log('here')

    
    my_dongle.ati().then((data)=>{
        //make central if not
        if(JSON.stringify(data).includes("Peripheral")){
            console.log('peripheral')
            my_dongle.at_central().then((x)=>{
                console.log('central now')
            })
        }        
    })
    .then(()=>{
        // connect to dongle
        my_dongle.at_getconn().then((y)=>{
            if(JSON.stringify(y).includes(dongleToConnect)){
                console.log('already connected')
            }else{
                my_dongle.at_gapconnect(dongleToConnect).then(()=>{
                    console.log('connected successfully')
                })
            }
        })
        .then(()=>{
            var theVal = "L=1 " + document.getElementById('msgToSend').value;
            console.log('Message Send 1 '+theVal)
            // send command to show data
            my_dongle.at_spssend(theVal).then(()=>{
                console.log('Message Send '+theVal)
            })
        })
        
    })
  });



document.getElementById('clearScreen').addEventListener('click', function(){
    my_dongle.ati().then((data)=>{
        //make central if not
        if(JSON.stringify(data).includes("Peripheral")){
            console.log('peripheral')
            my_dongle.at_central().then((x)=>{
                console.log('central now')
            })
        }
    })
    .then(()=>{
        // connect to dongle
        my_dongle.at_getconn().then((y)=>{
            if(JSON.stringify(y).includes(dongleToConnect)){
                console.log('already connected')
            }else{
                my_dongle.at_gapconnect(dongleToConnect).then(()=>{
                    console.log('connected successfully')
                })
            }
        })
        .then(()=>{
            // send command to clear the screen
            my_dongle.at_spssend('L=0').then(()=>{
                console.log('Screen Cleared')
            })
        })
        
    })
})

The script has a button to connect to the COM port on the computer. There is a text field where you can write your message. Your messages will be displayed on an LCD screen connected to the STM32 board.

To connect to the BleuIO dongle on the STM32, make sure the STM32 is powered up and a BleuIO dongle is connected to it.

Get the MAC address

Follow the steps to get the MAC address of the dongle that is connected to STM32:

  • Open this site https://bleuio.com/web_terminal.html and click connect to dongle.
  • Select the appropriate port to connect.
  • Once it says connected, type ATI. This will show dongle information and current status.
  • If the dongle is on the peripheral role, set it to central by typing AT+CENTRAL
  • Now do a gap scan by typing AT+GAPSCAN
  • Once you see your dongle on the list, stop the scan by pressing control+c
  • Copy the ID and paste it into the script (script.js) line #2

Run the web script

You will need a web bundler. You can use parcel.js

Once parcel js is installed, go to the root directory of the web script and type “parcel index.html”. This will start your development environment.

Open the script on a browser. For this example, we opened http://localhost:1234

You can easily connect to the dongle and send your message to the LCD screen. The response will show on the browser console screen.

The web script looks like this

Output

The message will show on the LCD screen.

Video of working project

The EPIC-TGH7 Brings High-End Computing to the 4″ EPIC Board

AAEON, a global leader in industrial computing, has introduced the world to the next generation of single board computers with the release of the EPIC-TGH7, which holds the distinction of being the first board of its kind to host Intel® 11th Generation Xeon®/Core™ processors.

With such an advanced processor package, the EPIC-TGH7 offers 8 cores and 16 threads to increase processing speed and power for intensive, high-end computing. However, this advancement has not sacrificed power-efficiency, with the EPIC-TGH7 providing up to 45W with Xeon®-level performance.

Hosting up to 8 USB ports, dual LAN ports, and a PCIe[x8] slot; the EPIC-TGH7 enables PCIe4.0 speeds of up to 16GT/s, despite retaining the same EPIC board form factor measuring just 4.53″ x 6.50″ (115mm x 165mm).

AAEON believes this combination of I/O density and high-speed expansion will be particularly applicable to healthcare imaging and military defense applications, with the board being able to accommodate the advanced graphics required for such uses.

In addition to healthcare imaging and military defense applications, the EPIC-TGH7 lends itself to use in digital signage, providing 4 simultaneous displays via an I/O featuring HDMI, VGA, Dual Channel 24/48bit LVDS, and DP ports. Such a myriad of options is designed to give users a diverse selection of display configurations to suit their project needs.

For more information regarding the EPIC-TGH7, please visit its product page, or contact an AAEON sales representative directly.

Accurate Acoustic Sensor – Sound Frequency to Voltage Converter

The project presented here is a sensitive sound sensor. The circuit converts sound frequency and outputs DC voltage.  The board consists of LM358 OPAMP and LM2907 IC. LM358 is used as a dual-stage microphone preamplifier and LM2907 acts as a frequency to voltage converter. The circuit provides analog voltage output when it detects sound. The output of the sensor is proportional to the audio sound frequency detected through the condenser microphone. The output voltage swings from 3.5V to 10.8V proportional to frequency 330Hz to 933Hz. Output is zero when the sound frequency is below 330Hz. Users may try with other frequency ranges, which can be changed using the following formula, Vo = R9 × C6 × VCC × f. The sensor has better response and accuracy than many sound sensors available on the market. The operating Supply is 12V DC and consumes 20mA current. Jumper J1 and J2 are closed for normal microphone operation.

Accurate Acoustic Sensor – Sound Frequency to Voltage Converter – [Link]

TOP PCB Companies