Avishek Hardin at Arduino Project Hub designed a lightweight mobile using a GSM module, an Arduino UNO, and a Nextion touch screen display. The lightweight mobile has the following features:
- Make calls
- Receive calls
- Send SMS
- Receive SMS
- Delete SMS
In this project, he uses a GSM SIM900A module to establish the cellular communication. The GSM SIM900A is an all-in-one cellular module that lets you add voice, SMS, and data to embedded projects. It works on frequencies 900/1800MHz and uses the RS232 standard to communicate with MCUs. Baud rate of this module is adjustable from 9600 to 115200 through specific AT Commands.
This GSM mobile features a Nextion touch display to take input from the user and visualize the GUI. Its easy-to-use configuration software (Nextion Editor) allows you to design your own interfaces using GUI commands. All GUI data is stored in Nextion display instead of the master MCU. Thus, lots of program space in MCUs can be saved efficiently and it makes the development procedure effortless. The Nextion displays communicate with microcontrollers over UART which is supported by a wide range of MCUs.
- Arduino Uno.
- SIM900A GSM module.
- Nextion TFT Intelligent LCD Touch display.
- SIM card.
- Connecting wires.
- External mic & speaker.
Connect the Nextion display and the GSM module with your Arduino using following instructions:
- Nextion +5V to Arduino VDD_5v.
- Nextion RX to Arduino pin 11
- Nextion Tx to Arduino pin 10
- Nextion GND to Arduino GND_0v.
- GSM Rx to Arduino pin 1
- GSM TX to Arduino pin 0
- GSM GND to Arduino GND_0v.
Program The Nextion Display
First of all, you need to design an HMI file using Nextion Editor. This editor allows you to design the interfaces using plug-and-play components like text, button, progress bar, pictures, gauge, checkbox, radio box, and much more. You can set codes and properties for each of these components later.
In this project, 8 different pages are used to design the GUI. All the icons used are easily available on the internet. Icons are resized and modified using an open source tool paint.net. Touch events like press and release are also covered when components are touched. More information on Nextion display commands can be found on this wiki page.
Steps To Upload
- Load the .HMI file into the editor. Link to the Github repository is here.
- Compile the .HMI file (just under the menu bar).
- Go to File > Open build folder > Copy the .tft file > Paste into SD card. Note: make sure the SD card is formatted to FAT32.
- Once copied, insert the SD card into the Nextion display and then turn the power on.
- Wait for the .tft to upload.
- Power off the Nextion, securely remove the SD card and then again power on the display.
- Now you should see your new interfaces on the Nextion Display.
Program The Arduino
The Arduino is the brain of this project. It takes input from the Nextion display, sends commands to GSM module to create the cellular connection, and shows information on the display. This project does not use any Nextion library due to lack of documentations and difficulties to understand. Moving on without using libraries seems tough but it is really not.
The code can be found on the Github repository. Simply download it and upload to the Arduino board using the Arduino IDE. If you are using some other board than Arduino UNO, then don’t forget to select that specific board in Arduino IDE before uploading.
Open the Serial Monitor, you should see the AT command log for each event triggered from the Nextion Display.
By default, the GSM module has an SMS buffer size of 20. Unfortunately, this Arduino-based mobile cannot display all the 20 messages at once on the Nextion display as it gives a buffer overflow while compiling the Nextion code. Hence, the Nextion display is programmed to show maximum 10 messages at once. If 10 or more SMS are present on the GSM buffer, the Low memory warning icon will be displayed on the Nextion display.
Watch the demonstration video to understand how this Arduino-based lightweight GSMmobile works.
ePaper displays (EPDs) are becoming a trend in application, just like the display used in Amazon Kindle, for their low power consumption due to the to the underlying ‘bistable’ display technology. These displays can continue to show information without any power at all. It is only required while updating the display with new information, otherwise there won’t be any power consumption.
Providing such revolutionary displays to your applications will be a professional approach. For this, a new crowdfunding campaign is providing Paperino, an easy-to-use, micro ePaper shield for the Particle & Arduino community. Paperino simplifies driving ePaper displays with clean, simple, and short script examples.
Thanks to the plug-and-play shield for particle family, Paperino can be used with the following boards: Photon, Electron, or Bluz without manual wiring. It can also be wired easily to be connected with Arduino and other compatible boards.
Paperino is lightweight and thinner than other ePaper products because it uses a glass-free ePaper display from Plastic Logic. It weighs 1.2 grams and is only 0.5 mm thick.
Supports Four Gray Levels
Unlike many other ePaper products out there, Paperino can support four gray levels instead of two (black and white).
Fast, Partial Updates
You don’t have to wait for slow, full screen updates to load. With Paperino, you can quickly update only parts of the screen.
The integrated accelerometer lets you interact with your Paperino in all sorts of ways, including tap sensing. Tap sensing capability can trigger screen updates or wake up your microcontroller.
The Paperino breakout board can be used for manually wiring your favourite, Arduino-compatible microcontroller with 3.3 V and >4kb of free RAM.
- Resolution: 148 x 70 px
- Pixel density: 150 ppi
- Grey levels: 4
- Weight: 1.2 g
- Thickness: 500 µm
- Power consumption: 4.5 mA (mean current for typical image update)
- Operating conditions: 0°C .. 40°C
- Storage conditions: -25°C .. 50°C
You can pre-order your own Paperino for $20 and with a driver board for $30. The crowdfunding campaign still has 16 days to go, and you can learn more details by checking it out.
Our friends on educ8s.tv published a new video! Check it out.
Hello guys, I am Nick and welcome to educ8s.tv a channel that is all about DIY electronics projects with Arduino, Raspberry Pi, ESP8266 and other popular boards. Subscribe to the channel now if you don’t want to miss any future videos. In this video we are going learn how to use this inexpensive character LCD display with Arduino. After we learn how to use the display we are going to build something useful. A simple real time clock. Let’s start.
20×4 I2C Character LCD display with Arduino Uno – [Link]
Sometimes it may be necessary to use a display when making a hardware project, but one confusing thing is the size of the display and the required pins to control it. This tutorial will show you how to use a small I2C OLED display with Arduino using only two wires.
The display used in this tutorial has a very small (2.7 x 2.8cm) OLED screen, that is similar to Arduino Pro Mini size, with 128 x 64 screen resolution. The OLED Driver IC is SSD1306, a single-chip CMOS OLED/PLED driver with controller for organic / polymer light emitting diode dot-matrix graphic display system. The module has only 4 pins, two of them are the supply pins, while the others are SCL and SDA, I2C protocol pins, which will be used to control the display.
Using I2C SSD1306 OLED Display With Arduino – [Link]
Rex Niven @ edn.com has a design idea on how to drive a character LCD using only one wire.
This hardware interface Design Idea reduces the connection to just one wire, allowing a basic microcontroller with limited I/O to drive a large display, either directly, through a standard interface, or even an opto-isolator.
One wire controls LCD module – [Link]
Nextion display by ITead allows users to design their own interfaces all by themselves, even if they don’t have any coding background knowledge and can go with different platforms. This tool is the best solution to replace traditional TFT LCD and LED Nixie tube. Customers can use the software – Nextion Editor to design interfaces.
With the new capacitive 7-inch Nextion, you can build your own HMI with minimal design effort since all of the data and control signals are provided by the device to interface directly to the display. This offers enormous advantage to the designer in development time and cost saving and takes away all of the burden of low level design.
Nextion will help you quickly design visually in hours not weeks, turn long coding work into simple drag and drop operation, at a reasonable cost. What you only need, is interface a serial port to Nextion disply hardware. Check this demo to see how quickly and easily an application can be designed by dragging and dropping objections to the virtual screen on a WYSIWYG design IDE – Nextion Editor.
This is the second version of Nextion, where you can find a capacitive multi-touch display and a good looking bezel along with additional features in the software IDE. Below are the specifications of new Nextion:
4D Systems, the manufacturer of intelligent graphics solutions, has announced a new 3.2” smart display module as part of the ‘ gen4 ’ series, which had been designed specifically for ease of integration and use, with careful consideration for space requirements and functionality.
These modules features a 3.2” color TFT display with options for Cover Lens Bezel (CLB), Resistive Touch and Capacitive Touch. The display is capable of Touch Detection, microSD memory Storage, GPIO and Communications, along with multiple millisecond resolution timers, and Audio Generation. gen4 modules have 30 pin ZIF socket for a 30 pin FPC cable, for easy and simple connection to an application or a motherboard.
The gen4 display modules are powered by the 4D Systems Diablo16 graphics processor that offers an array of functionality and options for any Designer / Integrator / User. Diablo16 is a custom embedded 4DGL graphics controller designed to interface with many popular OLED and LCD display panels.
gen4 display modules features:
- Powerful 3.2” Intelligent LCD-TFT display module powered by DIABLO16.
- 240 x 320 Resolution, RGB 65K true to life colours, TFT Screen with integrated 4-wire Resistive Touch Panel (on DT model only).
- 6 banks of 32750 bytes of Flash memory for User Application Code and Data.
- 32Kb of SRAM purely for the User.
- 16 General Purpose I/O pins for user interfacing, which include 4 configurable Analog Inputs.
- The GPIO is variously configurable for alternative functions such as:
- 3x I2C channels available.
- 1x SPI dedicated for SD Card and 3x configurable SPI channels available.
- 1x dedicated and 3x configurable TTL Serial comm ports available.
- Up to 6 GPIO can be used as Pin Counters.
- Up to 6 GPIO for PWM (simple and Servo).
- Up to 10 GPIO for Pulse Output.
- Up to 14 GPIO can be configured for Quadrature Encoder Inputs (2 channels).
- 30pin FPC connection, for all signals, power, communications, GPIO and programming.
- On-board latch type micro-SD memory card connector for multimedia storage and data logging purposes.
- DOS compatible file access (FAT16 format) as well as low level access to card memory.
- Dedicated PWM Audio pin driven by WAV files from micro-SD card, and for sound generation, for an external amplifier.
- Display full colour images, animations, icons and video clips.
- Supports all available Windows fonts.
- 4.0V to 5.5V range operation (single supply).
- Module dimensions:
- (D): 95.7 x 57.1 x 6.3mm.
- (D-CLB): 98.8 x 72.6 x 7.4mm.
- (DT): 95.7 x 57.1 x 7.5mm.
- (DCT-CLB): 98.8 x 72.6 x 8.3mm.
- 4x mounting tabs with 3.2mm holes for mechanical mounting using M3 screws.
- RoHS and REACH compliant.
- CE Compliant – please ask for CE declarations from our Support Team.
The intelligent gen4 displays can be programmed via Workshop4 IDE. It provides an integrated software development platform for all of the 4D family of processors and modules. The IDE combines the Editor, Compiler, Linker and Downloader to develop complete 4DGL application code.
gen4 modules are available in 4 models:
- gen4-uLCD-32D (non Touch, without Cover Lens Bezel)
- gen4-uLCD-32DT (Resistive Touch, without Cover Lens Bezel)
- gen4-uLCD-32D-CLB (non Touch, Cover Lens Bezel)
- gen4-uLCD-32DCT-CLB (Capacitive Touch, with Cover Lens Bezel)
The module is available on the official website with a range of $55 to $79 including interface board, 150mm FFC cable, and a quick start guide. Starter kits are also available from $75 to $99.
circuitbasics.com has a tutorial on how to setup an LCD with Arduino.
In this tutorial, I’ll explain how to set up an LCD display on an Arduino, and show you all the functions available to program it (with examples). The display I’m using here is a 16×2 LCD display that I bought for under $10 on Amazon. LCDs are really useful in projects that output data, and they can make your project a lot more interesting and interactive.
How to Set Up and Program an LCD Display on an Arduino – [Link]
We covered 4Duino in one of our previous blog posts. 4Duino is a 2.4” Arduino based programmable display module. In our article today, we are presenting a hands-on experience with this product by building a simple project. Many thanks to 4D Systems for sending us a sample and giving us a chance to try this new product.
4Duino – An Introduction and a Weather API Demo – [Link]