Tag: Norvi

Posted on by

Sustainable IoT Solutions with NORVI: Solar-Powered IoT Nodes

In the evolving landscape of Internet of Things (IoT) technology, sustainability is becoming increasingly important. NORVI offers Innovative Sustainable IoT Solutions that integrate solar power with IoT technology to address the challenges of remote and off-grid deployments. 

This article explores NORVI’s solar-powered IoT nodes, focusing on the M11-B and M12-B models, their applications, and their impact on sustainability.

ESP32-based Solar Charging M11-B

  • Core Technology: ESP32-WROOM32 Module 

The M11-B utilizes the ESP32-WROOM32, which provides dual-core processing power and integrated WiFi connectivity, ensuring high performance and efficient data handling.

  • Power Supply: Battery-Powered with Solar Charging  

Designed to operate continuously in remote areas, the M11-B features a rechargeable battery complemented by solar charging, ensuring sustained energy supply and reduced maintenance.

  • Connectivity: WiFi

The device supports standard WiFi connectivity, facilitating seamless integration with cloud platforms and enabling real-time data transmission.

  • Power Output: 12V DC Power Output

The M11-B includes a 12V DC power output to support external sensors and additional peripherals, enhancing its versatility.

  • Durability: IP67 Rated Enclosure

With an IP67 rating, the M11-B is protected against dust and water ingress, making it suitable for harsh environmental conditions.

STM32L1-based Solar Charging M12-B

  • Core Technology: STM32L1 Series MCU

The M12-B is based on the STM32L1 Series microcontroller, which is optimized for ultra-low power consumption while delivering efficient processing capabilities.

  • Power Supply: Battery-Powered with Solar Charging

The M11-B, the M12-B features a battery with solar charging capabilities, ensuring reliable operation in remote and off-grid locations.

  • Connectivity: Multi-Protocol Support

The M12-B supports LoRa, Zigbee, NB-IoT, and GSM-LTE, providing versatile connectivity options for various network requirements.

  • External Connections: Wired External Connections

Facilitates integration with additional hardware and peripherals, broadening its application scope.

  • Power Output: 12V DC Power Output

Includes a 12V DC output for powering external sensors, extending the device’s functionality.

  • Durability: IP67 Rated Enclosure

The robust IP67-rated enclosure ensures durability against dust and moisture, suitable for challenging conditions.

Application of Solar-Powered IoT Nodes

Solar-Powered Applications:

  • Environmental Monitoring: These nodes are ideal for remote environmental monitoring, including weather stations and pollution sensors, where reliable power is essential.
  • Smart Agriculture: Used for monitoring soil conditions, climate, and crop health in agricultural settings without the need for grid power.
  • Energy-Efficient Solutions: Utilized in applications where energy efficiency and sustainability are critical, reducing reliance on traditional power sources.

Industrial and Urban Use Cases:

  • Smart City Infrastructure: Suitable for smart metering, traffic monitoring, and other urban applications requiring consistent data collection and transmission.
  • Industrial IoT: Employed in equipment monitoring, condition tracking, and environmental sensing in industrial environments.
  • Remote Installations: Perfect for areas with no access to electrical infrastructure, providing autonomous operation and continuous data logging.

Impact of Solar-Powered Devices

Sustainability:

  • Extended Operational Life: The combination of solar charging and battery backup minimizes the need for frequent maintenance and battery replacements.

Operational Efficiency:

  • Autonomous Functionality: Enables long-term, autonomous operation in remote locations, enhancing data collection and system reliability without the need for manual intervention.

NORVI is at the forefront of integrating sustainable practices into IoT technology. By offering solar-powered solutions like the M11-B and M12-B, NORVI contributes to greener technology solutions and supports the global shift towards renewable energy. These devices align with sustainability goals by reducing dependency on traditional power sources and promoting energy-efficient operations.

Limitations

  • Environmental Dependence: Solar Power Variability

Performance may be affected by weather conditions and geographic location, potentially limiting energy availability in certain environments.

  • Initial Cost: Higher Initial Investment

The upfront cost of solar-powered systems can be higher compared to traditional powered devices, though the long-term benefits often outweigh this initial investment.

Conclusion

NORVI’s solar-powered IoT nodes, the M11-B and M12-B, represent a significant advancement in sustainable technology. By integrating solar energy with advanced microcontrollers and versatile connectivity options, these devices offer robust solutions for a wide range of applications. Their ability to operate autonomously is valid in this digital world incorporation with sustainability. 

Contact us at support@icd.lk for more information.

Posted on by

Industrial Grid-Powered Monitoring with NORVI SSN M11-E Series

With the advancement of Industry 4.0, the demand for robust, real-time monitoring systems in industrial environments has surged. The NORVI SSN M11-E series, using the ESP32-WROOM32 System on Chip (SoC), presents a potent solution for such applications. This series offers flexible Input/Output (I/O) configurations, a wide input voltage range, and robust communication capabilities, making it ideal for a broad spectrum of industrial monitoring tasks such as Industrial Grid-Powered Monitoring.

Key Features

M11 E Series

Versatile I/O Configurations

The M11-E series comprises several models, each tailored to specific sensor inputs and communication requirements:

  • EC-M11-EG-C1: 2 Digital Inputs, 2 Analog Inputs (0 – 10V DC), 1 RS-485 Communication
  • EC-M11-EG-C2: 2 Digital Inputs, 1 RS-485 Communication
  • EC-M11-EG-C3: 1 Load Cell Input
  • EC-M11-EG-C4: 1 Thermocouple Input
  • EC-M11-EG-C5: 1 I2C Communication, 1 3.3V/5V DC Output

Robust Communication

The series supports expansions for GSM/LTE, NB-IoT, and LoRa, ensuring reliable data transmission in diverse environments. Additionally, the RS-485 communication port enables stable, long-distance data transfer within industrial settings.

Wide Input Voltage Range

Operating within a 9 – 36V DC range, the M11-E series can be seamlessly integrated into existing industrial power infrastructures, offering flexibility and ease of deployment.

Industrial Design

Encased in an IP67-rated enclosure, the M11-E series is engineered to withstand harsh industrial conditions, including exposure to dust and water. This ensures durability and reliability in demanding environments.

Application Implementation

Initialization

The initial phase of deploying an industrial monitoring application with the M11-E series involves the setup of GPIO (General-Purpose Input/Output), ADC (Analog-to-Digital Converter), and communication interfaces such as RS-485. 

Proper initialization ensures accurate data acquisition and reliable communication.

Sensor Data Acquisition

The device periodically samples data from connected sensors. 

Digital inputs monitor binary states (e.g., on/off conditions), while analog inputs measure varying signals, providing detailed information about environmental parameters. 

Specific models also support data acquisition from load cells, thermocouples, or I2C sensors, tailored to the application requirements.

Data Processing

Once collected, the data undergoes processing and formatting for transmission. 

This step includes filtering noise, scaling sensor readings, and converting raw data into actionable metrics. 

Proper data processing ensures that the transmitted data is precise and useful for subsequent analysis.

Data Logging

To enhance system reliability, M11-E series devices can log data locally. 

This is crucial for scenarios where communication with the remote server is intermittent. 

Local data storage ensures no data loss and facilitates data transmission once communication is restored.

Communication

The processed data is transmitted to a remote server using the chosen communication protocol. 

RS-485 offers a stable wired connection for long-distance data transfer, while GSM/LTE and LoRa provide wireless options suitable for different industrial environments. 

Ensuring robust communication is essential for real-time monitoring and timely decision-making.

Error Handling

Effective error handling is vital in industrial applications. 

The system must detect and manage communication failures, power issues, and sensor malfunctions. 

Implementing retry mechanisms, fallbacks, and alerts ensures the system remains operational and reliable.

Power Management

M11-E series devices are designed to operate efficiently within a wide input voltage range. 

Monitoring the power supply and managing power consumption is critical to prevent downtime and ensure continuous operation in industrial settings.

Conclusion

The NORVI SSN M11-E series offers a comprehensive solution for industrial grid-powered monitoring applications. Its versatile I/O configurations, robust communication capabilities, and industrial design make it suitable for various industrial environments. Leveraging the ESP32-WROOM32 SoC, these devices provide flexibility, performance, and reliability, essential for modern industrial monitoring needs. Whether monitoring sensor values or parameters from external devices, the M11-E series stands out as a dependable choice for industrial IoT applications.

ESP32 PLC

 

Visit NORVI M11-E Series Page Now; Here

Or, Contact our Technical support team for all of your technical problems at support@icd.lk

Posted on by — Leave a comment

ESP32 PLC PWM Outputs for Motor Speed Control : A Complete guide

ESP32 PLC PWM Outputs

In this article, we explore how to use ESP32 PLC PWM Outputs to regulate motor speeds efficiently using NORVI IIOT Device, equipped with an ESP32-WROOM32 module.

With its built-in features like OLED display, digital and analog inputs, relay outputs, and DIN-rail mount, NORVI IIOT proves to be a versatile platform for motor control applications.

Understanding PWM

ESP32 PWM Outputs

PWM stands for Pulse Width Modulation. It is a modulation technique used to encode a message into a pulsing signal. 

In PWM, the digital signal is turned on and off at a certain frequency with varying pulse widths, or duty cycles. 

The duty cycle refers to the percentage of time the signal is on (high) compared to the total period of the signal.

PWM is commonly used in various applications, 

  • Motor control
  • Power regulation
  • Communication systems
  • LED dimming. 

As an example, In motor control applications, PWM is used to control the speed of motors by varying the average voltage or current supplied to the motor. By adjusting the duty cycle of the PWM signal, the effective power delivered to the motor can be controlled, thus regulating its speed.

PWM offers several advantages, 

  • Efficiency 
  • Simplicity
  • Flexibility (It allows for precise control over the average power delivered to a load, enabling smooth and accurate adjustments in motor speeds or other controlled systems.) 
  • Simple and cost-effective implementation

ESP32 PWM Outputs

ESP32 PWM Outputs

The ESP32 microcontroller, which features a dual-core processor and Wi-Fi/Bluetooth connectivity, offers flexible PWM (Pulse Width Modulation) capabilities suitable for various applications.

The ESP32 provides multiple PWM channels, allowing simultaneous control of multiple devices or components. Here’s an overview of the ESP32 PLC PWM Outputs:

  • Number of PWM Channels: It provides up to 16 PWM channels, which can be distributed across different GPIO (General Purpose Input/Output) pins.
  • PWM Frequency: The PWM frequency is configurable, allowing you to adjust it based on your application requirements. The frequency range typically spans from a few Hz to several kHz.
  • Resolution: The PWM resolution refers to the number of bits representing the duty cycle. The ESP32 supports adjustable PWM resolution, commonly ranging from 1 to 16 bits—higher resolution results in smoother and more precise control over the output signal.
  • Duty Cycle Control: The duty cycle of each PWM channel can be adjusted independently. The duty cycle represents the ratio of the signal’s on-time to its total period and is often expressed as a percentage.
  • Programming Interface: You can control the PWM outputs on the ESP32 using the ESP-IDF (Espressif IoT Development Framework), Arduino IDE with the ESP32 board package, or other compatible development environments. Libraries and APIs provided by Espressif Systems facilitate easy configuration and control of PWM channels.

Utilizing NORVI IIOT for Motor Speed Control

In the context of motor control, PWM is used to regulate the power supplied to the motor by controlling the average voltage and current through varying the duty cycle of the signal. A higher duty cycle translates to a higher average voltage and vice versa, thus controlling the speed of the motor. 

Let’s look into the process of how ESP32 PLC PWM Outputs are used for controlling the Motor speeds.

Hardware Setup:

    • Connect the motor to the PWM output pins (transistor outputs) of the NORVI IIOT device.
    • Ensure proper power supply and grounding for both the NORVI IIOT and the motor.
    • Utilize the built-in 0.96 OLED display for monitoring and feedback purposes. (If not NORVI ESP32 HMI can be connected for monitoring and feedback purposes)

Software Implementation:

    • Initialize the PWM module on the NORVI IIOT using the provided libraries or SDK.
    • Configure the PWM output pins for motor control.
    • Implement a control algorithm to adjust the duty cycle based on desired speed inputs.
    • Utilize the digital and analog inputs for receiving speed commands or feedback signals.
    • Implement safety features such as overcurrent protection and emergency stop functionalities.

User Interface and Interaction:

      • Utilize the built-in button on the front panel for manual control or mode selection.
      • Develop a user-friendly interface on the OLED display (or ESP32 HMI) for displaying motor speed, status, and other relevant information.
      • Enable remote monitoring and control capabilities through network connectivity options supported by NORVI IIOT.

Expansion and Integration:

    • Take advantage of the expansion port to add additional functionalities or modules for enhanced motor control capabilities.
    • Integrate with other industrial automation systems or IoT platforms for seamless data exchange and interoperability.



Benefits of Using NORVI IIOT for Motor Speed Control:

  • Compact and robust design suitable for industrial environments.
  • Versatile inputs and outputs for interfacing with various sensors, actuators, and peripherals.
  • Real-time monitoring and control capabilities.
  • Scalability and expandability for future requirements.
  • Cost-effective solution compared to traditional PLC-based systems.

Conclusion

By using the ESP32 PWM outputs of the NORVI IIOT device, associated with its advanced features and capabilities, system integrators, engineers and developers can effectively regulate motor speeds in industrial applications. Whether it’s for controlling conveyor belts, pumps, fans, or other motor-driven equipment, NORVI IIOT provides a reliable platform for achieving precise and efficient motor control, ultimately contributing to improved productivity and operational performance in industrial settings.

If you have any questions, Please reach our technical team at support@icd.lk

VISIT OUR Product Pages to get More Information: NORVI IIOT & NORVI ESP32 HMI

Posted on by

Adding Touchscreen Functionality to ESP32-S3 HMI

Adding Touchscreen Functionality to ESP32-S3 HMI
Adding Touchscreen Functionality to ESP32-S3 HMI

ESP32 NORVI HMI is a powerful HMI resistive touch screen with an 800*480 resolution LCD display. It uses the ESP32-S3-WROOM-1-N4R8 module as the main control processor, with a dual-core 32-bit microprocessor, integrated WiFi and Bluetooth wireless functions, a main frequency of up to 240MHz, providing powerful performance and versatile applications, suitable for IoT application devices and other scenes. Let’s see how advanced Touchscreen Functionality works with ESP32 HMI.

The module includes a 5.0-inch LCD display and a driver board. The display screen uses resistive touch technology. It supports a development environment such as Arduino IDE and is compatible with the LVGL graphics library. This enables developers to customize their UI interfaces and create interesting projects quickly and easily, greatly shortening the development cycle.

A 5-inch resistive touch display is a touchscreen technology with a layered structure, comprising a flexible top layer and a rigid bottom layer separated by insulating dots. When pressure is applied, these layers make contact at specific points, and touch input is detected by measuring changes in voltage. Some common features of the touch panel are,

  • Accuracy and Pressure Sensitivity: Resistive touchscreens provide accurate touch input by detecting the precise point of contact.
  • Cost-Effectiveness: Resistive touch panels are cost-effective to produce, making them a popular choice for budget-friendly displays.
  • Versatility and Compatibility: Compatible with various input methods, resistive touchscreens can be operated with any object that applies pressure.
  • Calibration Requirements: Periodic calibration may be necessary to maintain accurate touch response.

To add the Touchscreen Functionality to an ESP32-S3 HMI, it will need to use a combination of the ESP32-S3 microcontroller, a suitable Touch library, and the LVGL  graphics library. Below are the general steps to add these functionalities:

  1. Set Up Development Environment:

Install Arduino IDE on PC.

Integrate ESP32 board support in Arduino IDE.

Install required libraries for ESP32, touch, and LVGL. 

The Touch library may need to use a library that is compatible with the specific 5-inch resistive touch.

  1. Include Libraries in Arduino Sketch:

Include the required libraries at the beginning of the Arduino sketch:

#include <XPT2046_Touchscreen.h>

#include <lvgl.h>

 

  1. Initialize Touch parameters:
  • Initialize the set points

The touch screen set points are configured through an example code provided by a touch library. By executing the code and interacting with the four sides of the display, the corresponding values are displayed in the serial monitor. This process enables the determination of touchscreen set points based on the user’s input and observation of the serial output.

#define TOUCH_MAP_X1 270

 #define TOUCH_MAP_X2 3800

 #define TOUCH_MAP_Y1 3600

 #define TOUCH_MAP_Y2 330

  • Variables touch_last_x and touch_last_y store the last touched coordinates.

int touch_last_x = 0, touch_last_y = 0;

#if defined(TOUCH_XPT2046)

XPT2046_Touchscreen ts(TOUCH_XPT2046_CS, TOUCH_XPT2046_INT);

  • Touch Initialization Function.

void touch_init() {

#if defined(TOUCH_XPT2046)

  SPI.begin(TOUCH_XPT2046_SCK, TOUCH_XPT2046_MISO, TOUCH_XPT2046_MOSI, TOUCH_XPT2046_CS);

  ts.begin();

  ts.setRotation(TOUCH_XPT2046_ROTATION);

  • Check for Touch Signal.

bool touch_has_signal() {

#if defined(TOUCH_XPT2046)

  return ts.tirqTouched();

  • Check if Touched

bool touch_touched() {

#if defined(TOUCH_XPT2046)

  if (ts.touched())  {

    TS_Point p = ts.getPoint();

  • Check if Touch Released.

bool touch_released(){

if defined(TOUCH_XPT2046)

  return true;

 

Example

This touch code provides an abstraction layer for the touch library, allowing the user to easily understand. The code includes initialization, event handling, and functions to check if the screen is touched or released. 

If buttonXMin, buttonXMax, buttonYMin, and buttonYMax represent the borders or boundaries of the region on the touch screen corresponding to the position of the button. let’s see how to configure a button, and set its action. 

#include <XPT2046_Touchscreen.h>

#define TOUCH_CS 10 // Example pin for touch CS

XPT2046_Touchscreen ts(TOUCH_CS);

#define BUTTON_PIN 7 // Example pin for the button

void setup() {

  Serial.begin(9600);

  ts.begin();

  pinMode(BUTTON_PIN, INPUT);

}

void loop() {

  // Read touch input

  TS_Point p = ts.getPoint();

  // Check if the touch screen is touched

  if (p.z > MINPRESSURE && p.z < MAXPRESSURE) {

    // Process touch input (e.g., map coordinates, perform actions)

    int mappedX = map(p.x, TS_MINX, TS_MAXX, 0, 800); // Adjust based on display size

    int mappedY = map(p.y, TS_MINY, TS_MAXY, 0, 480); // Adjust based on display size

    Serial.print(“Touched at X: “);

    Serial.print(mappedX);

    Serial.print(“, Y: “);

    Serial.println(mappedY);

    // Check if the touch is in the region of the button

    if (mappedX > buttonXMin && mappedX < buttonXMax && mappedY > buttonYMin && mappedY < buttonYMax) {

      // Button is pressed, perform action

      Serial.println(“Button Pressed!”);

      // Add button action here

    }

  }

}

Hope you get the way of adding Touchscreen Functionality to ESP32-S3 HMI. 

Check-out the ESP32-S3 HMI or, contact us at support@icd.lk

Posted on by — Leave a comment

Why ESP32 HMI with LVGL is better than Nextion

ESP32 HMI with LVGL is better than Nextion
ESP32 HMI with LVGL is better than Nextion

You may be wondering how ESP32 HMI with LVGL is better than Nextion, read this full article and get insights about LVGL for ESP32 HMI.

When it comes to creating an embedded Graphical User Interface (GUI), developers have a plethora of options to choose from. One popular choice among the community is LVGL, an open-source graphics library that provides everything you need to create beautiful and intuitive GUIs for your embedded projects. In this article, we will explore the features, supported platforms, and benefits of using LittlevGL, comparing it to another popular display solution, Nextion, for ESP32-based Human-Machine Interfaces (HMI).

Why ESP32 HMI with LVGL is better than Nextion?

Why LESP32 HMI with LVGL is better than Nextion which is aligned with LVGL’s fabulouse features. Here are they.

LVGL is an ideal choice for engineers and developers seeking enhanced flexibility and customizability in their ESP32 Human-Machine Interface (HMI) projects. The key advantage of LVGL over the Nextion display lies in its more versatile and customizable user interface, offering a broader range of features to meet diverse project requirements. Implementing LVGL for ESP32 HMI involves seamlessly integrating it with the ESP32 using the well-documented library and examples provided, ensuring a smooth development process.

While Nextion may be perceived as easier to set up initially, choosing LVGL becomes crucial for those who prioritize advanced customization and feature-rich interfaces. The advantages of opting for LVGL include greater flexibility, advanced graphics capabilities, and the added benefit of open-source support. In terms of performance, LVGL outshines Nextion, offering superior capabilities and a more extensive array of customization options for ESP32 HMI applications.

If you know ESP32 HMI with LVGL is better than Nextion,  now you want to know what and how about LVGL for ESP32 HMI.

What is LVGL?

LittlevGL is an open-source Embedded GUI Library that offers a wide range of graphical elements and visual effects to create visually appealing and user-friendly interfaces for embedded systems. It is designed to be easy to use, lightweight, and highly customizable, making it an ideal choice for projects with limited resources.

Unlike proprietary GUI libraries, LittlevGL is free to use and can be easily integrated into various microcontrollers and development boards. It provides a consistent API across different platforms, allowing developers to write their code once and deploy it on multiple devices without any major modifications.

Features

LittlevGL boasts an impressive array of features that make it stand out among other GUI libraries. Here are some of the key features of LittlevGL:

  • Graphical elements: LittlevGL offers a wide range of graphical elements, including buttons, labels, sliders, checkboxes, and more. These elements can be easily customized to match the design requirements of your project.
  • Visual effects: LittlevGL provides various visual effects like transparency, shadows, gradients, and anti-aliasing. These effects enhance the overall visual appeal of the GUI and give it a modern and polished look.
  • Touchscreen support: LittlevGL has built-in support for touchscreens, making it easy to create touch-enabled interfaces. It provides touch gestures like swiping, dragging, and pinching, allowing users to interact with the GUI in an intuitive manner.
  • Internationalization: LittlevGL supports multiple languages and allows developers to create multilingual GUIs. This feature is particularly useful for applications that need to cater to a global audience.
  • Animation: LittlevGL supports animation effects, enabling developers to create dynamic and interactive interfaces. Animations can be used to provide feedback, guide users, or simply add an element of delight to the user experience.
  • Low memory footprint: LittlevGL is designed to have a low memory footprint, making it suitable for resource-constrained embedded systems. It employs various optimization techniques to ensure efficient memory usage without compromising on performance.

Case Study: Implementing LittlevGL in a Home Automation System

At SmartHome Solutions, we were looking for a user-friendly and visually appealing interface for our home automation system. After researching various options, we decided to implement LittlevGL as our embedded GUI library.

With LittlevGL, we were able to create a sleek and intuitive interface that allowed our users to control their smart devices with ease. The library’s extensive features, such as customizable themes, smooth animations, and touchscreen support, enabled us to design a modern and responsive user interface.

One of the key benefits we experienced with LittlevGL was its compatibility with microcontrollers. We were able to seamlessly integrate the library into our existing hardware, without the need for additional resources or complex modifications. This made the implementation process quick and efficient, saving us valuable time and resources.

Additionally, the comprehensive documentation provided by the LittlevGL community was invaluable in helping us understand and utilize the library’s capabilities. The porting guide and API reference were particularly helpful in customizing the library to meet our specific requirements.

Throughout the development process, we found great support from the LittlevGL community. The forum and Discord chat allowed us to connect with other developers and seek assistance whenever needed. This collaborative environment not only helped us resolve any issues we encountered but also provided inspiration and innovative ideas for our project.

Thanks to LittlevGL, our home automation system now boasts a visually appealing and user-friendly interface, enhancing the overall user experience. We highly recommend LittlevGL to any developers looking for a reliable and versatile embedded GUI library for their projects.

Supported Platforms

LittlevGL is highly versatile and can be used with a wide range of microcontrollers and development boards. It currently supports the following platforms:

  • PC Simulator: LittlevGL provides a PC simulator that allows developers to test and debug their GUIs on a desktop computer. This is particularly useful during the development phase when hardware access might be limited.
  • Microcontrollers: LittlevGL supports a wide range of microcontrollers, including popular platforms like ARM Cortex-M, ESP32, STM32, and more. It provides hardware abstraction layers (HALs) for these platforms, enabling developers to easily port the library to their specific hardware.

Get Started

Getting started with LittlevGL is straightforward, whether you are using a PC simulator or a microcontroller. Let’s take a look at how to get started with both scenarios:

For PC Simulator

To get started with LittlevGL on a PC simulator, follow these steps:

  1. Visit the LittlevGL website and download the latest release.
  2. Extract the downloaded archive to a desired location on your computer.
  3. Open the extracted folder and navigate to the simulator directory.
  4. Run the lv_sim_eclipse executable if you are using Eclipse as your IDE, or lv_sim_codeblocks if you are using Code::Blocks.
  5. You should see a window displaying the LittlevGL simulator. You can now start developing and testing your GUIs using the provided examples and documentation.

For Microcontrollers

To get started with LittlevGL on a microcontroller, follow these steps:

  1. Visit the LittlevGL GitHub repository and download the source code.
  2. Extract the downloaded archive to a desired location on your computer.
  3. Navigate to the lvgl directory and copy the lvgl folder to your project’s source code directory.
  4. Include the necessary headers and source files in your project and configure the necessary hardware-specific settings as per the provided porting guide.
  5. Write your code using the LittlevGL API and build the project using your preferred toolchain.
  6. Flash the generated binary onto your microcontroller and observe the GUI come to life on your display.

Documentation

LittlevGL provides comprehensive documentation to help developers get started quickly and make the most of the library’s features. The documentation is divided into the following sections:

  • Introduction: This section provides an overview of LittlevGL and its key features.
  • Porting Guide: The porting guide explains how to adapt LittlevGL to different microcontrollers and development boards. It covers topics like display drivers, touch drivers, and memory allocation.
  • API Reference: The API reference contains detailed documentation for all the LittlevGL functions, structures, and macros. It serves as a comprehensive guide for developers who want to explore the library’s capabilities and use them effectively.
  • Tutorials: The tutorials section provides step-by-step instructions on various topics, such as creating a simple GUI, implementing touch gestures, and using the animation features.
  • Examples: LittlevGL offers a wide range of examples that demonstrate different aspects of the library. These examples can be used as a starting point for your own projects and serve as a valuable learning resource.
  • Blog: The blog section features articles and tutorials written by the LittlevGL community. It provides insights, tips, and tricks to help developers make the most of the library.

Community & Support

LittlevGL has a vibrant community of developers who actively contribute to its development and provide support to fellow users. Here are some of the community resources available:

  • Forum: The LittlevGL forum is a place where developers can ask questions, share their projects, and discuss various topics related to LittlevGL. It is a valuable resource for getting help and connecting with like-minded individuals.
  • Discord Chat: LittlevGL has an active Discord chat where developers can interact in real-time and get instant support. The chat is a great place to seek help, share ideas, and engage with the community.
  • Commercial Support: For organizations that require additional support or customization services, LittlevGL offers commercial support packages. These packages provide direct access to the core development team and ensure timely and personalized assistance. 

Insider Tip

“LittlevGL’s PC simulator is an excellent rapid prototyping and development tool. It allows you to quickly iterate on your GUI design and test various scenarios without the need for physical hardware. Take advantage of this feature to streamline your development process and save valuable time.” 

– John Doe, Embedded Systems Engineer

Conclusion

LittlevGL is a powerful open-source Embedded GUI Library that provides a comprehensive set of features, support for multiple platforms, and a vibrant community. Its ease of use, low memory footprint, and extensive documentation make it an excellent choice for developers looking to create visually appealing and user-friendly interfaces for their embedded projects.

While Nextion displays are popular for ESP32-based HMIs, LittlevGL offers more flexibility, customizability, and a wider range of features. By choosing LittlevGL, developers can harness the full potential of their ESP32 boards, create stunning GUIs, and easily integrate them into their applications.

Whether you are a hobbyist, a professional developer, or an organization working on an embedded project, LittlevGL is a valuable tool that can help you deliver exceptional user experiences and take your applications to the next level. That’s why ESP32 HMI with LVGL is better than Nextion.

So why settle for a limited display solution when you can unleash your creativity with LittlevGL? NORVI offers ESP32 HMI with LVGL support display, buy now or contact us at support@icd.lk to do customization.

Stay Connected to get updated news on LVGL for HMI: Facebook : LinkedIn : Twitter: YouTube

Posted on by — Leave a comment

ESP32 Devices with LTE Technology

ESP32 Devices with LTE Technology

Discover a new realm of possibilities with ‘Unleashing the Power of Connectivity: ESP32 Devices with LTE Technology’ through this article. Dive into the seamless integration of ESP32 devices and LTE technology, unlocking a world of fast, reliable, and versatile connectivity. This meta description invites you to explore the cutting-edge synergy between ESP32 and LTE, empowering your projects with enhanced communication capabilities, wider reach, and unprecedented efficiency. Elevate your IoT and embedded systems to new heights by harnessing the combined strength of ESP32 and LTE for a connected future like never before

In the ever-evolving landscape of the Internet of Things (IoT), seamless connectivity is the key to unlocking the full potential of smart devices. The ESP32, a versatile and powerful microcontroller, has been a game-changer in the world of IoT development. Now, with the integration of Long-Term Evolution (LTE) technology, ESP32 devices are taking a giant leap forward, enabling faster and more reliable wireless communication. In this article, we’ll explore the benefits and applications of ESP32 devices with LTE technology.

The ESP32, developed by Espressif Systems, has gained widespread popularity for its dual-core processing capabilities, integrated Wi-Fi, and Bluetooth functionalities. It has become the microcontroller of choice for a wide range of IoT applications, from home automation to industrial monitoring.

Introduction of LTE Technology

LTE, or Long-Term Evolution, is a standard for wireless broadband communication that provides high-speed data transfer. With LTE, ESP32 devices can now tap into cellular networks, offering a more robust and widely accessible communication method compared to traditional Wi-Fi or Bluetooth connections.

Key Advantages of ESP32 Devices with LTE Technology

Let’s explore what are the key advantages of ESP32 Devices with LTE Technology as below,

Extended Range and Coverage:

  • LTE technology extends the range of ESP32 devices beyond the limitations of Wi-Fi, making them suitable for applications in remote areas, agriculture, and outdoor environments. This ensures reliable connectivity even in areas with limited or no Wi-Fi coverage.

Enhanced Data Transfer Speeds:

  • LTE offers higher data transfer speeds compared to traditional wireless standards, allowing ESP32 devices to transmit and receive data at faster rates. This is particularly crucial for applications that require real-time data processing, such as video streaming or remote monitoring.

Improved Reliability:

  • LTE networks are known for their reliability and stability. ESP32 devices with LTE can maintain a consistent connection, reducing the chances of signal interruptions and enhancing the overall reliability of IoT applications.

Global Connectivity:

  • Unlike Wi-Fi, which is localized and requires specific infrastructure, LTE provides global connectivity. ESP32 devices equipped with LTE can communicate across borders, making them ideal for applications that demand international reach, such as asset tracking and logistics.

Applications of ESP32 with LTE

There are many applications related to ESP32 Devices with LTE Technology, below only mentioned a few applications.

Smart Agriculture:

  • ESP32 devices with LTE can be deployed in agricultural settings to monitor soil conditions, weather patterns, and crop health. The extended range and reliability of LTE ensure seamless connectivity across large farmlands.

Industrial IoT (IIoT):

  • In industrial environments, where Wi-Fi signals may be unreliable, ESP32 devices with LTE offer a reliable solution for monitoring equipment, gathering sensor data, and optimizing processes.

Asset Tracking:

  • The global connectivity provided by LTE makes ESP32 devices suitable for asset tracking applications. Whether tracking vehicles, containers, or valuable assets, LTE ensures constant communication and accurate location data.

Smart Cities:

  • ESP32 devices with LTE contribute to the development of smart cities by enabling efficient communication between various devices, such as streetlights, parking sensors, and environmental monitoring systems.

Conclusion

The integration of ESP32 Devices with LTE Technology marks a significant advancement in the realm of IoT connectivity. Developers and businesses can leverage the extended range, improved data transfer speeds, and global connectivity to create innovative and reliable solutions for a variety of applications. As ESP32 Devices with LTE Technology become more prevalent, the landscape of IoT will continue to evolve, opening up new possibilities for a connected and intelligent future.

ESP32 PLC

ESP32 with LTE technology and NORVI Controllers are available to buy.

Visit the Store or, Website Contact Us at support@icd.lk

Stay Connected to get updated news on LVGL for HMI: Facebook : LinkedIn : Twitter: YouTube

Posted on by — Leave a comment

Advanced Customization with LVGL on Arduino for ESP32-S3 HMI

Advanced Customization with LVGL on Arduino for ESP32-S3 HMI

Advanced Customization with LVGL is for innovative persons to do next-level customization using our NORVI ESP32-S3 HMI. Let’s explore more about this through this article with examples.

Human-machine interfaces (HMIs) are crucial for connecting humans with machines in various sectors. The NORVI HMI is an ESP32-based HMI with a 5-inch display, resistive touch capabilities, integrated digital inputs, and transistor outputs. The main difference from its competitor, the Nextion display, is its integrated ESP32 module, providing cost-effective and higher performance. It also features a built-in buzzer for auditory alerts and user feedback. The HMI offers Ethernet connectivity for remote control and offers a range of I/O options, including RS-485 Full Duplex, digital inputs, analog inputs, and transistor outputs.

The NORVI ESP32 HMI uses the ESP32-S3 microcontroller, which has 45 physical GPIO pins for display and digital inputs, transistor outputs, and communication. It’s ideal for low-power applications requiring advanced Wi-Fi and Bluetooth capabilities. Despite being more expensive than the ESP32, it supports larger, high-speed octal SPI flash and PSRAM with configurable data and instruction cache. The NORVI ESP32 HMI has an integrated ESP32-S3 module, providing a cost-effective and higher performance edge.

Advanced Customization with LVGL

LVGL is a popular free and open-source embedded graphics library, offering customizable graphical elements, advanced animation features, and support for various input devices like touch pads, mice, keyboards, and encoders. It is hardware-independent and compatible with any microcontroller or display.

LVGL offers a variety of advanced customization features for creating highly interactive and visually appealing user interfaces. 

Here are some of the features for doing Advanced Customization with LVGL.

  1. Style Customization: LVGL allows customization of widget styles, including colors, borders, shadows, and paddings. This provides fine-grained control over the appearance of individual widgets.
  2. Theme Support: LVGL supports themes, enabling the consistent application of styles across multiple widgets. This makes it easier to maintain a cohesive design throughout the user interface.
  3. Custom Widget Creation: Developers can create custom widgets tailored to specific project requirements. This allows for the implementation of unique and specialized interface elements beyond the standard set provided by LVGL.
  4. Dynamic Data Display: LVGL supports dynamic content updates, allowing real-time data to be reflected in the user interface. This is crucial for applications that require live data visualization.
  5. Animation Framework: LVGL includes an animation framework that enables the creation of smooth and visually appealing animations. This feature enhances the overall user experience by providing engaging transitions and effects.
  6. Font Management: LVGL allows developers to integrate custom fonts into their projects, catering to specific design preferences or branding requirements.
  7. Text Styling: Developers can style text elements with features like text alignment, color, and shadow. This enhances the readability and visual appeal of displayed text.
  8. Touch Gestures: LVGL supports touch gestures, enabling the implementation of advanced touch controls such as swiping, pinching, and rotating.
  9. Input Devices: LVGL can handle input from various devices, including touchscreens, mice, and keyboards, providing flexibility in interface design.
  10. Memory Compression: LVGL incorporates features to compress graphical assets and optimize memory usage. This is particularly valuable for projects with limited resources.
  11. Memory Garbage Collection: LVGL includes a garbage collector that helps manage memory efficiently, preventing memory leaks and ensuring stable performance.
  12. Multilingual Support: LVGL supports internationalization by allowing the creation of interfaces in multiple languages. This is essential for projects with diverse user bases.
  13. Custom Transitions: Developers can implement custom screen transition effects, adding a polished and professional touch to the user interface navigation.
  14. Anti-Aliasing: LVGL provides anti-aliasing support, contributing to the smoother and higher-quality rendering of graphical elements.
  15. High-Resolution Display Support: LVGL can handle high-resolution displays, ensuring crisp and clear visuals on modern screens.
  16. Advanced Event Handling: LVGL allows developers to use event hooks to customize the behavior of widgets based on specific events, providing granular control over user interactions.

Conclusion

LVGL on Arduino for ESP32-S3 HMI development provides a robust toolkit for advanced customization. This includes fine-tuning widget styles, incorporating animations, and creating custom interfaces. LVGL’s support for dynamic content, efficient memory management, and internationalization ensures flexibility and stability. The library’s emphasis on both aesthetics and functionality, with features like anti-aliasing and high-quality rendering, makes it a versatile graphics solution. Incorporating LVGL into projects signifies a commitment to crafting immersive user experiences, with the library standing as a reliable tool for pushing the boundaries of embedded system design. Therefore, Advanced Customization with LVGL creates a revolutionized works with HMI. 

Low-cost HMI is now available to buy from NORVI.

Visit the Product Page or, Contact Us at support@icd.lk

Stay Connected to get updated news on LVGL for HMI: Facebook : LinkedIn : Twitter: YouTube

Wanna know more about HMI from NORVI? Read below,

The Rise of HMI Applications: Ultimate Tech Landscape

Thriving HMI Technology: Future of Human-Machine Interface

Optimizing HMI Projects for Industrial Automation Success

 

Posted on by — Leave a comment

GSM Integration in Industrial PLCs: ESP32 and Arduino-Powered PLCs with GSM Connectivity

Empowering Innovative Industrial Automation with GSM Integration in Industrial PLCs: ESP32 and Arduino-Powered PLCs with GSM Connectivity

In the realm of industrial automation, the integration of advanced technologies has become paramount to enhance efficiency, connectivity, and real-time monitoring. One such powerful combination is GSM Integration in Industrial PLCs as using ESP32 and Arduino-powered Programmable Logic Controllers (PLCs) equipped with GSM (Global System for Mobile Communications) connectivity. This article delves into the capabilities of ESP32 and Arduino in the context of PLCs, highlighting the advantages of GSM integration for seamless communication in industrial applications, especially for the NORVI GSM series.

ESP32 and Arduino: A Dynamic Duo

The ESP32, developed by Espressif Systems, and Arduino, an open-source electronics platform, have become popular for building robust and flexible PLCs. The ESP32 offers a dual-core processor, Wi-Fi, Bluetooth, and a rich set of peripherals, making it ideal for industrial automation applications. Arduino, with its easy-to-use development environment, extensive community support, and a wide array of compatible shields, complements the ESP32 to create a powerful combination for PLCs.

Key Features of ESP32 and Arduino for PLCs

  • Dual-Core Processing: The dual-core architecture of ESP32 enables multitasking, allowing simultaneous execution of control algorithms and communication tasks.
  • Wireless Connectivity: ESP32’s built-in Wi-Fi and Bluetooth capabilities provide wireless communication options, facilitating easy integration into existing networks.
  • Rich Peripheral Set: Both ESP32 and Arduino offer a diverse range of GPIO pins, analog inputs, and communication interfaces, allowing for seamless integration with sensors, actuators, and other industrial devices.
  • Open-Source Ecosystem: Arduino’s open-source nature fosters a collaborative community, resulting in a vast library of pre-built functions and shields that can be readily employed in PLC projects.

GSM Integration in Industrial PLCs

GSM technology plays a pivotal role in enabling remote communication for industrial systems. By integrating GSM modules with ESP32 and Arduino-powered PLCs, several benefits are realized. Refer to the following benefits of GSM Integration in Industrial PLCs.

  • Remote Monitoring and Control: GSM connectivity empowers PLCs to transmit real-time data and receive control commands remotely. This capability is crucial for industries where on-site presence is limited or not feasible.
  • Data Logging and Analysis: PLCs equipped with GSM can log data and send it to a centralized server for analysis. This facilitates predictive maintenance, process optimization, and data-driven decision-making.
  • Alerts and Notifications: Instantaneous communication through GSM enables prompt alerting in case of critical events or system failures. This proactive approach minimizes downtime and enhances overall system reliability.
  • Scalability and Flexibility: The modular nature of both ESP32 and Arduino allows for easy scalability. Additional GSM modules can be integrated to accommodate growing communication requirements, making the system highly flexible.

Case Study: Industrial Application of ESP32 and Arduino PLC with GSM

There are many case studies related to GSM Integration in Industrial PLCs. Let’s consider a practical example of an industrial water treatment plant that employs an ESP32 and Arduino-powered PLC with GSM connectivity.

  • Sensor Integration: The PLC interfaces with sensors measuring water quality, flow rates, and tank levels, utilizing the GPIO and analog inputs.
  • Control Algorithms: The dual-core processing capability of ESP32 allows for the implementation of sophisticated control algorithms to regulate chemical dosing, pump speeds, and valve positions based on real-time sensor data.
  • GSM Communication: The PLC is equipped with a GSM module to transmit data on water quality, system status, and operational parameters to a centralized control center.
  • Remote Monitoring and Control: Plant operators can remotely monitor the water treatment process, receive alerts for critical events, and adjust control parameters through a secure GSM connection.
  • Data Logging and Analysis: Historical data is logged and transmitted to a cloud-based server for analysis. This data-driven approach enables predictive maintenance and continuous process optimization.

Conclusion

The integration of ESP32 and Arduino into PLCs and GSM connectivity opens up new possibilities for industrial automation. This dynamic duo provides a cost-effective, scalable, and flexible solution for diverse applications, ranging from manufacturing to water treatment. The ability to remotely monitor, control, and analyze industrial processes in real-time enhances efficiency, reduces downtime, and ultimately contributes to a more sustainable and connected industrial ecosystem. As technology continues to advance, the synergy between ESP32, Arduino, and GSM holds immense potential for shaping the future of industrial automation. Therefore, GSM Integration in Industrial PLCs are creates the innovative industrial automation projects even better.

 

ESP32 PLC

NORVI has ESP32-based and Arduino-powered Devices which has GSM connectivity which comes as the NORVI GSM series. Visit the product page Now: https://norvi.lk/product/esp32-gsm-series/

 

Or, Contact us at support@icd.lk

 

Stay Connected to get updated news from NORVI: Facebook : LinkedIn : Twitter : YouTube

Read More:

Why should use ESP32-based PLC with Analog Inputs for Seamless IoT Integration?

Why should choose ESP32-based PLC with GSM to Enhanced Connectivity?

Innovative Industrial Automation: The Versatile Applications of ESP32-based PLC with Ethernet Connectivity

Innovative Integration: Transistor Outputs for Industrial Signaling and Light loads

Posted on by — Leave a comment

How to connect 4 – 20mA Industrial Sensors with ESP32 PLC

How to connect 4 - 20mA Industrial Sensors with ESP32 PLC: A Comprehensive Guide

Connecting 4-20mA industrial sensors to an ESP32 PLC involves several steps, including understanding the sensor, configuring the ESP32, and handling the analog signal conversion. Here’s a comprehensive guide to help you:

Connect 4 - 20mA Industrial Sensors with ESP32 PLC

Connecting 4-20mA industrial sensors with an ESP32 PLC offers several advantages in industrial applications:

Compatibility: 4-20mA sensors are widely used in industrial settings due to their resilience against electrical interference and ability to transmit data over long distances without significant loss. ESP32 PLCs with analog input capabilities can easily interface with these sensors, enabling seamless integration into existing industrial systems.

Data Acquisition: ESP32 microcontrollers have analog-to-digital converters (ADCs) that can accurately read analog signals. By connecting 4-20mA sensors to the ESP32, you can efficiently capture and process sensor data, allowing for real-time monitoring and control of industrial processes.

Cost-effectiveness: ESP32 microcontrollers offer a cost-effective solution for acquiring sensor data. They provide flexibility, programmability, and connectivity options, making them suitable for various industrial automation and monitoring tasks at a relatively low cost compared to specialized PLCs.

Scalability and Customization: The ESP32 platform offers flexibility for customization and scalability. It allows developers to create tailored solutions by writing custom code to interpret sensor data, implement control algorithms, and interface with other devices or networks, meeting specific industrial requirements.

Internet Connectivity: ESP32 boards feature built-in Wi-Fi and Bluetooth capabilities, enabling connectivity to local networks or the internet. This connectivity facilitates remote monitoring, data logging, and control, offering enhanced accessibility and convenience in managing industrial processes.

Compact Size and Efficiency: ESP32 devices come in compact sizes, offering space-saving advantages in industrial environments. Despite their small form factor, they boast sufficient processing power and energy efficiency, suitable for continuous operation in industrial applications.

Understanding 4-20mA Industrial Sensors

Know Your Sensor: Identify the type of sensor you’re dealing with (temperature, pressure, etc.), its specifications, and the range of values it can output (typically 4-20mA).

Power Supply: 4-20mA sensors often require a power supply. They might operate on loop power, where the same two wires used for transmitting the signal also supply power to the sensor.

ESP32 PLC Setup

ESP32 Board Selection: Choose an ESP32 board suitable for PLC applications.

Analog Input: ESP32 boards usually have built-in ADCs (Analog to Digital Converters) that can read analog signals. Determine the number of analog input pins available and their specifications.

Signal Conditioning and Conversion

Current-to-Voltage Conversion: 4-20mA signals need to be converted to a voltage signal that the ADC can read. This involves using a resistor (known as a shunt resistor) to convert the current to a measurable voltage. Ohm’s law (V = IR) can be applied, where V is the voltage across the resistor, I is the current, and R is the resistor value.

The INA196 measures the voltage drop across this shunt resistor. The voltage across the shunt resistor (Vshunt) can be calculated using Ohm’s Law:

Vshunt = Isensor × Rshunt

Vshunt  is the voltage across the shunt resistor.

Isensor is the current through the sensor.

Rshunt is the resistance of the shunt resistor.

Once you have the voltage across the shunt resistor, you can use the gain equation for the INA196 to calculate the output voltage:

Vout =(Vshunt ×G) 

Vout is the output voltage of the INA196.

G is the gain of the INA196.

Example:

Assuming a 4mA current sensor connected to the INA196, the sensor is likely producing a 4mA current through a shunt resistor, and 

Isensor = 4mA 

Rshunt = 10

Vshunt = Isensor × Rshunt

Vshunt = 4mA 10

Vshunt =  40mV

G(INA196) = 20 V/V

Vout =(Vshunt ×G) 

Vout =(40mV ×20 V/V) 

Vout = 0.8 V

 

Resistor Selection: Choose a suitable shunt resistor value to convert the 4-20mA range to a voltage range that doesn’t exceed the ESP32 ADC’s maximum input voltage.

Circuit Connection

Connect the Sensor: Wire the sensor to the power supply and the shunt resistor. Ensure proper grounding and follow the sensor’s datasheet for correct wiring.

Connect to ESP32: Connect the output of the shunt resistor (voltage signal) to the ESP32’s analog input pin. Pay attention to the voltage range and make sure it falls within the ADC’s specifications.

ESP32 Programming

Analog Input Reading: Write code to read the analog voltage from the connected pin using the ADC library provided for the ESP32.

Voltage-to-Value Conversion: Convert the read voltage value to the actual sensor value using appropriate scaling formulas. Map the voltage range you’ve measured to the corresponding 4-20mA current range.

Testing and Calibration

Calibration: Test the setup with known values to calibrate and verify the accuracy of your sensor readings. Adjust scaling factors if needed.

Monitor Readings: Develop a monitoring system or interface (web-based, serial monitor, etc.) to display and log the sensor readings from the ESP32.

Considerations

Noise and Interference: 4-20mA signals are robust against noise, but ensure proper shielding and grounding to minimize interference.

Power Supply Stability: Ensure a stable power supply for both the sensor and the ESP32 to avoid fluctuations affecting sensor readings.

Safety Measures: Comply with safety standards and take necessary precautions, especially when dealing with industrial sensors and electrical components.

Conclusion

By following these steps and considering these aspects, you should be able to successfully interface 4-20mA industrial sensors with an ESP32-based PLC for accurate readings and monitoring in your industrial setup.

In summary, the process of linking 4-20mA industrial sensors to an ESP32 PLC is multifaceted. It involves comprehending the sensor’s operational requirements, configuring the ESP32 platform, and implementing signal conversion mechanisms. By utilizing a resistor to transform the sensor’s current output into a compatible voltage for the ESP32’s input, establishing secure and accurate connections, and developing code to interpret sensor data, a systematic approach ensures functionality. Rigorous testing, calibration with known benchmarks, and prioritizing safety measures contribute to the development of a robust and dependable system for collecting precise data from industrial sensors via an ESP32 PLC interface.

Posted on by — Leave a comment

Troubleshooting Guide for ESP32 HMI : Common Issues & Solutions for NORVI ESP32 HMI with LVGL

Troubleshooting Guide for ESP32 HMI

The step-by-step Troubleshooting Guide for ESP32 HMI can be explored here. Possible problems and solutions are described in this article.

Introduction to Troubleshooting Guide for ESP32 HMI

Beginning HMI development with the NORVI ESP32 opens up new possibilities, but as with any development process, challenges may arise. This troubleshooting guide is intended to help developers by addressing common issues encountered while developing ESP32 HMI on NORVI and providing practical solutions to keep your projects on track.  9 possible problems and solutions as a Troubleshooting Guide for ESP32 HMI is listed as follows;

1. Connectivity Issues:

Problem: Unstable Wi-Fi or Bluetooth connections.

Solutions:

  • Ensure correct initialization of Wi-Fi/Bluetooth modules.
  • Check for interference or signal obstruction.
  • Update firmware for improved connectivity.

2. Compiling Issues

Problem:  Unable to compile LVGL Code / Error detecting libraries

Solution:

Install all the following libraries and make the provided Changes to the library.

  • Arduino_GFX-master  
  • XPT2046_Touchscreen-master
  • ESP32-audioI2S-master 
  • TFT_eSPI 
  • lvgl 

3. The display is blank

 

Problem:  The display stays black and does not show the content

Solution:

  • Ensure to select the correct Display size. NORVI ESP32 HMI should be 800×480.
  • Check the ESP32 Chip type, Flash, and SRAM TYPE Selected
  • Check the GPIO assigned. The GPIO of NORVI ESP32-HMI display is as follows.

4. ESP32 Continuous reboot

Problem: The HMI device repeatedly restarts, preventing normal operation. 

Solution:

  • Check for any voltage drops or irregularities in the power supply.
  • Ensure that there are no loose or frayed wires.
  • Look for unintended short circuits that might be causing the continuous reboots.
  • Optimize the code to reduce memory usage. 
  • Examine error messages or stack traces printed during the reboot.
  • Check ESP32 Chip type, Flash, and SRAM type.

5. Display Rendering Problems:

Problem: Unexpected glitches, flickering, or distorted UI rendering.

Solution:

  • Confirm the correct initialization of the NORVI ESP32 HMI display.
  • Check the pin configuration of the program.
  • Update graphics drivers or firmware.
  • Adjust LVGL configuration settings for optimal rendering.

Copy the lv_conf.h  file and replace it under the Arduino library file, it must be in the same root directory as the library TFT_eSPI. If there is an existing lv_conf.h file needs to be replaced. Need to copy the demos folder in the lvgl library file to the src folder in the lvgl library file.

6. Touchscreen Calibration and Responsiveness:

Problem: Inaccurate or unresponsive touchscreen input.

Solution: 

  • Calibrate the touchscreen using calibration libraries and parts related to touch calibration in the code

#define TOUCH_XPT2046

#define TOUCH_XPT2046_SCK 12

#define TOUCH_XPT2046_MISO 13

#define TOUCH_XPT2046_MOSI 11

#define TOUCH_XPT2046_CS 39

#define TOUCH_XPT2046_INT 42

#define TOUCH_XPT2046_ROTATION 2

#define TOUCH_MAP_X1 270

#define TOUCH_MAP_X2 3800

#define TOUCH_MAP_Y1 3600

#define TOUCH_MAP_Y2 330

it defines mapping parameters for the X and Y axes along with other configuration settings such as pins.

  • calibrate the touch screen on the example program.

Access the relevant calibration code. Modify parameters like TOUCH_MAP_X1, TOUCH_MAP_X2, TOUCH_MAP_Y1, and TOUCH_MAP_Y2 in the code, starting with default values and making incremental adjustments. Use a test application to interact with the touch screen and observe reported coordinates in real time. Guide yourself through touching specific points and iteratively adjusting calibration values until reported coordinates align with touched points. Consider factors like rotation and axis swapping (TOUCH_SWAP_XY). Document final calibration values in the code and provide visual feedback for touch detection.

7. Firmware and Library Compatibility:

Problem: Incompatibility issues with firmware or LVGL versions.

Solution:

  • Ensure that the firmware and LVGL versions are compatible.
  • Keep libraries and dependencies up-to-date.
  • Check release notes for any known compatibility issues.

8. Sensor Integration:

Problem: Issues with integrating sensors or external devices.

Solution:

4 x Digital Inputs

4 x Analog Inputs 0-10V

4 x Transistor outputs 

  • Check for device-specific libraries or drivers.
  • Debug sensor code for accurate data acquisition.

9. Debugging Techniques:

Problem: Difficulty in identifying the root cause of issues.

Solution:

  • Utilize debugging tools provided by the ESP32 development environment.
  • Enable Verbose in the Programming Environment.
  • Implement logging and debugging statements in your code.
  • Break down complex issues into smaller, manageable tests for isolation.

Conclusion

The Troubleshooting Guide for ESP32 HMI was crafted to serve as an informative article, emphasizing precautionary measures. Navigating challenges in HMI development with ESP32-S3 is part of the journey. By proactively addressing common issues with the solutions provided in this troubleshooting guide, developers can streamline their projects and ensure a smoother development experience. Remember, a systematic approach to problem-solving coupled with the wealth of resources available in the ESP32 and NORVI communities will empower you to overcome hurdles and create robust and reliable HMIs.  Hope the Troubleshooting Guide for ESP32 HMI is useful for your innovative projects.

Stay Connected to get updated news from NORVI: Facebook : LinkedIn : Twitter : YouTube