Sales: contact@spurqlabs.com

HR: hr@spurqlabs.com

Book A Demo
Building a Solenoid Control System to Automate IoT-Based Touch Screens

Building a Solenoid Control System to Automate IoT-Based Touch Screens

by | Oct 8, 2024 | Blog

Introduction to IoT Solenoid Touch Control:

Building a solenoid control system with a Raspberry Pi to automate screen touch means using the Raspberry Pi as the main controller for IoT Solenoid Touch Control. This system uses relays to control solenoids based on user commands, allowing for automated and accurate touchscreen actions. The Raspberry Pi is perfect for this because it’s easy to program and can handle the timing and order of solenoid movements, making touchscreen automation smooth and efficient. Additionally, this IoT Solenoid Touch Control system is useful in IoT (Internet of Things) applications, enabling remote control and monitoring, and enhancing the versatility and functionality of the setup.

Components Required:

Raspberry Pi (Any model with GPIO pins):

Raspberry pi 4

In our system, the Raspberry Pi acts as the master unit, automating screen touches with solenoids and providing a central control hub for hardware interactions. Its ability to seamlessly establish SSH connections and dispatch commands makes it highly efficient in integrating with our framework.

Key benefits include:

  • Effective Solenoid Control: The Raspberry Pi oversees and monitors solenoid operations, ensuring precise and responsive automation.
  • Remote Connectivity: With internet access and the ability to connect to other devices, the Raspberry Pi enables remote control and monitoring, enhancing flexibility and convenience.
  • Command Validation and Routing: Upon receiving commands, the Raspberry Pi validates them and directs them to the appropriate hardware or slave units. For instance, it can forward a command to check the status of a smart lock, process the response, and relay the information back to the framework.

Solenoide Holder(fix the solenoid):

Solenoid control system using Raspberry Pi

A solenoid holder is crucial for ensuring the stability, protection, and efficiency of a solenoid control system. It simplifies installation and maintenance while improving the overall performance and extending the solenoid’s lifespan.

In this particular setup, the solenoid holders are custom-manufactured to meet the specific requirements of my system. Different screen setups may require differently designed holders.

Incorporating a solenoid holder in your Raspberry Pi touchscreen control system results in a more robust, reliable, and user-friendly solution.

Solenoid (Voltage matching your power supply):

Push pull solenoid

Integrating solenoids into a Raspberry Pi touchscreen setup offers an effective method for adding mechanical interactivity and automating screen touches. To ensure optimal performance, it’s essential to choose a solenoid with the right voltage, current rating, and size for your specific application.

Whether you’re automating tasks, enhancing user experience, or implementing security features, solenoids play a vital role in achieving your project goals. With careful integration and precise control, they enable you to create a dynamic and responsive system.

Relay Module (Matching solenoid voltage and current rating):

IoT Solenoid Touch Control

A relay module acts as a switch controlled by the Raspberry Pi, enabling safe and isolated control of higher-power solenoids. To ensure reliable operation, choose a relay that can handle the solenoid’s current requirements.

Relay modules simplify complex wiring by providing clear connection points for your Raspberry Pi, power supply, and the devices you wish to control. These modules often come with multiple relays (e.g., 1, 2, 4, or 8 channels), allowing independent control of several devices.

Key terminals include:

  • COM (Common): The common terminal of the relay switch, typically connected to the power supply unit you want to switch.
  • NO (Normally Open): Disconnected from the COM terminal by default. When the relay is activated, the NO terminal connects to COM, completing the circuit for your device.
  • NC (Normally Closed):  Connected to COM in the unactivated state. When the relay activates, the connection between NC and COM breaks.

Touchscreen display: 

Touchscreen Display

Touchscreens are like interactive windows on our devices. Imagine a smooth surface that reacts to your fingertip. This is the magic of touchscreens. They use hidden sensors to detect your touch and tell the device where you pressed. This lets you tap icons, swipe through menus, or even draw pictures – all directly on the screen. No more hunting for tiny buttons, just a natural and intuitive way to control your smartphones, tablets, and many other devices.

Breadboard and Jumper Wires:

Breadboard with jumper wires

Breadboard and jumper wires act as your temporary electronics workbench. They let you connect components without soldering, allowing for easy prototyping and testing. You can push wires into the breadboard’s holes to create circuits, making modifications and troubleshooting a breeze before finalizing the connections.

Voltage level Converter:

12c bi directional logic level converter

In our project, the voltage level converter plays a critical role in ensuring communication between the Raspberry Pi and the relay module. The relay module, like some other devices, needs a specific voltage (5V) to understand and respond to commands. However, the Raspberry Pi’s GPIO pins speak a different voltage language – they can only output signals up to 3.3V.

Directly connecting the relay module to the Raspberry Pi’s GPIO pin wouldn’t work. The lower voltage wouldn’t be enough to activate the relay, causing malfunctions. Here’s where the voltage level converter comes in. It acts as a translator, boosting the Raspberry Pi’s 3.3V signal to the 5V required by the relay module. This ensures clear and compatible communication between the two devices, allowing them to work together seamlessly.

Power Supply (Separate for Raspberry Pi and Solenoid): 

IoT Solenoid Touch Control

We need two separate power supplies for safe and reliable operation.A 5V 2A power supply specifically powers your Raspberry Pi. It provides the lower voltage the Pi needs to function.A separate 24V 10A Switching Mode Power Supply (SMPS) powers the solenoid. This higher voltage and current capacity are necessary for the solenoid’s operation. Using separate power supplies isolates the Raspberry Pi’s delicate circuitry from the potentially higher power fluctuations of the solenoid, ensuring safety and proper operation of both.Each power supply is chosen to meet the specific requirements of its component: 5V for the Pi and a higher voltage/current for the solenoid.

Circuit Diagram:

IoT Solenoid Touch Control

Power Supply Connections:

  • Connect the Raspberry Pi power supply to the Raspberry Pi.
  • Connect the positive terminal of the separate power supply to one side of the solenoid.
  • Connect the negative terminal of the separate power supply to the common terminal of the relay.

Relay Module Connections:

  • Connect the Vcc pin of the relay module to the 5V pin of the Raspberry Pi.
  • Connect the GND pin of the relay module to the GND pin of the Raspberry Pi.
  • Connect a chosen GPIO pin from the Raspberry Pi (like GPIO 18) to the IN terminal of the relay module. This pin will be controlled by your Python code.
  • Connect one side of the solenoid to the Normally Open (NO) terminal of the relay module. This means the solenoid circuit is only complete when the relay is activated.

Connecting the Raspberry Pi to the Level Converter:

  • Connect a GPIO pin from the Raspberry Pi (e.g., GPIO17) to one of the LV channels (e.g., LV1) on the level converter.

Connecting the Level Converter to the Relay Module:

  • Connect the corresponding high-voltage (HV) pin (e.g., HV1) on the level converter to the IN1 pin of the relay module.
  • Connect the HV pin on the level converter to the VCC pin of the relay module (typically 5V).
  • Connect the GND pin on the HV side of the level converter to the GND pin of the relay module.

Powering the Relay Module:

  • Ensure the relay module is connected to a 5V power supply. This can be done using the 5V pin from the Raspberry Pi or a separate 5V power supply if needed. Connect this to the VCC pin of the relay module.
  • Ensure the GND of the relay module is connected to the GND of the Raspberry Pi to have a common ground.

Connecting the Relay Module to the Solenoid and 24V Power Supply:

  • Connect the NO (normally open) terminal of the relay to one terminal of the solenoid.
  • Connect the COM (common) terminal of the relay to the negative terminal of the 24V power supply.
  • Connect the other terminal of the solenoid to the positive terminal of the 24V power supply.

Software Setup:

Raspberry Pi Setup:

Let’s make setting up our Raspberry Pi with Raspbian OS, connecting it to Wi-Fi, and enabling VNC feel as straightforward as baking a fresh batch of cookies. Here’s a step-by-step guide:

1. Install Raspbian OS Using Raspberry Pi Imager:

 Download Raspberry Pi Imager:

  •  Install the Imager on our computer—it’s like the secret ingredient for our Raspberry Pi recipe.

Prepare Our Micro-SD Card: 

  • Insert our micro-SD card into our computer.
  • Open Raspberry Pi Imager.
  • Choose the Raspberry Pi OS version you want (usually the latest one). 
  • Select our SD card. Click “Write” and let the magic happen. This process might take a few minutes.

Connect Our Raspberry Pi via LAN Cable:

  • Plug one end of an ethernet cable into our Raspberry Pi’s Ethernet port. 
  • Connect the other end to our router (the one with the internet connection).

Power Up Our Raspberry Pi: 

  • Insert the micro-SD card into our Raspberry Pi. 
  • Connect the power supply to our Pi.
  •  Wait for it to boot up like a sleepy bear waking from hibernation.

Configure Wi-Fi and Enable VNC: 

Find Our Raspberry Pi’s IP Address: 

  • On our Raspberry Pi, open a terminal (you can find it in the menu or use the shortcut Ctrl+Alt+T). 
  • Type hostname -I and press Enter. This will reveal our Pi’s IP address.

Access Our Router’s Admin Interface:

  •  Open a web browser and enter our router’s IP address (usually something like 192.168.1.1) in the address bar.
  •  Log in using our router’s credentials (check the manual or the back of our router for the default username and password)

Assign a Static IP to Our Raspberry Pi:

  • Look for the DHCP settings or LAN settings section.
  • Add a new static IP entry for our Raspberry Pi using the IP address you found earlier. Save the changes.

Enable VNC on Our Raspberry Pi: 

  • On our Raspberry Pi, open the terminal again. 
  • Type sudo raspi-config and press Enter. 
  • Navigate to Interfacing Options > VNC and enable it. 
  • Exit the configuration tool.

Access Our Raspberry Pi Remotely via VNC: 

  • On our computer (not the Raspberry Pi), download a VNC viewer application (like RealVNC Viewer).
  • Open the viewer and enter our Raspberry Pi’s IP address. 
  • When prompted, enter the password you set during VNC setup on our Pi.

2. Install Python Libraries:

  • Use the Raspberry Pi terminal to install the necessary Python libraries. You’ll likely need:

3. Python Code Development:

  • Write Python code to:
    • Activate the corresponding GPIO pin based on the touched button to control the relay.
  • Python code:
import RPi.GPIO as GPIO
import time
# GPIO pin numbers for the relays
relay_pins = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
def setup():
    GPIO.setmode(GPIO.BCM)  # Use BCM GPIO numbering
    for pin in relay_pins:
        GPIO.setup(pin, GPIO.OUT)  # Set each pin as an output
        GPIO.output(pin, GPIO.HIGH)  # Initialise all relays to off (assuming active low)
 
def activate_solenoid(solenoid_number, duration=1):
    if 1 <= solenoid_number <= 12:
        pin = relay_pins[solenoid_number - 1]
        GPIO.output(pin, GPIO.LOW)  # Turn on the relay (assuming active low)
        time.sleep(duration)  # Keep the solenoid activated for the specified duration
        GPIO.output(pin, GPIO.HIGH)  # Turn off the relay
 
def cleanup():
    GPIO.cleanup()
 
def get_user_input():
    while True:
        try:
            user_input = input("Enter the solenoid number to activate (1-12), or 'q' to quit: ")
            if user_input.lower() == 'q':
                break
            solenoid_number = int(user_input)
            if 1 <= solenoid_number <= 12:
                activate_solenoid(solenoid_number)
            else:
                print("Please enter a number between 1 and 12.")
        except ValueError:
            print("Invalid input. Please enter a number between 1 and 12, or 'q' to quit.")
 
if _name_ == "_main_":
    try:
        setup()
        get_user_input()
    except KeyboardInterrupt:
        print("Program terminated")
    finally:
        cleanup()

Additional Considerations:

  • Flyback Diode: Adding a flyback diode across the solenoid protects the circuit from voltage spikes when the relay switches.
  • Status LEDs: LEDs connected to the GPIO pins can visually indicate relay and solenoid activation.
  • Security Measures: Consider password protection or other security features to control solenoid activation, especially for critical applications.

Putting it all Together:

  • Assemble the circuit on a breadboard, following the connection guidelines.
  • Flash the Raspberry Pi OS with your written Python code.
  • Design and implement the touchscreen interface using your chosen framework.
  • Test the system thoroughly to ensure proper functionality and safety.

Remember:

Always prioritize safety while working with electronics. Double-check connections and voltage ratings before powering on.

Conclusion

In conclusion, building a solenoid control system using a Raspberry Pi for IoT-based automated screen touch demonstrates a seamless integration of hardware and software to achieve precise and automated touchscreen interactions. The Raspberry Pi’s versatility and ease of programming make it an ideal choice for controlling solenoids and managing relay operations in IoT Solenoid Touch Control systems. This system not only enhances the efficiency and accuracy of automated touch actions but also expands its potential through IoT capabilities, allowing for remote control and monitoring. By leveraging the power of the Internet of Things, the IoT Solenoid Touch Control project opens up new possibilities for automation and control in various applications, from user interface testing to interactive installations.

Click here to read more blogs like this and learn new tricks and techniques of software testing.

Exploring Arduino Communication Methods for IoT Applications.

Exploring Arduino Communication Methods for IoT Applications.

by | Aug 2, 2024 | Blog

When we hear the word Arduino, the first thing that comes to mind is a microprocessor chip assembled on a single board to help us to create an IOT friendly environment and IOT projects using Arduino communication.

This chip helps us create various projects and electronic devices, and moreover, facilitates physical interaction with the world of technology. Although it’s not only Arduino which is used in IOT Testing, other devices like raspberry pi are also used but Arduino is preferred first due to its cost and ease of handling.

However, Arduino is not just limited to a microprocessor chip. It is also a company that designs, manufactures, and supports electronic hardware and software and help to develop Arduino communication for IOT Application.

Arduino, moreover, makes the interaction between advanced technologies and the physical world easy and fun.

Additionally, Arduino is open-source, allowing anyone to contribute to and expand its capabilities.

Today in this blog we will cover Arduino and its different types of communication.

How Does Arduino communication using for IOT Application:

The main key to creating a project using any microprocessor is, therefore, to have an IoT-enabled environment.

To have an IOT enabled environment using any microprocessor is to be able to communicate or to be able to program and manage it accordingly, so is important in Arduino communication for IOT App.

Arduino communication is classified into two parts: wired and wireless, each with further subdivisions.

1. Wired Communication

Wired communication is, therefore, the most reliable and straightforward way to establish a connection. However, we won’t limit Arduino to simple wired communication. Instead, we’ll expand this wired communication into three distinct categories to develop IOT project/application using Arduino. 

These 3 categories are explain below for Arduino Communication for IOT App:

Serial Communication:

UART communication is another name for serial communication. UART stands for universal Asynchronous receiver and transmitter. 

It is mostly used for communication between Arduino and computers, but it can be applied in various other ways depending on our requirements and develop IOT application using Arduino. To establish the connection easily, we typically use the ‘Serial library’ in Arduino.

Examples for Serial Communication:

For an example let’s try to have UART communication between 2 Arduino.

  • Hardware Set-up 
  1. Connect the ground pin of both the Arduino.
  2. Connect the RX pin of first Arduino with TX pin of second Arduino and TX pin of first Arduino to second Arduino.
  3. Code Example :

Master Arduino Code:

void setup() {
Serial.begin(9600);  // Initialize serial communication at 9600 bits per second
}

void loop() {
Serial.println("Hello from Master!");  // Send a message
delay(1000);  // Wait for a second
}

Slave Arduino Code:

void setup() {
Serial.begin(9600);  // Initialize serial communication at 9600 bits per second
}

void loop() {
if (Serial.available() > 0) {  // Check if data is available to read
String message = Serial.readString();  // Read the incoming data
Serial.println("Received: " + message);  // Print the received message
}
}
Serial communication in IOT project

Here we go with a successful Arduino communication using UART

SPI Communication

SPI communication stands for Serial Peripheral Interface, which is usually used for short-distance communication and IOT projects.

The difference between serial communication and SPI communication is that, in contrast, SPI communication is synchronous and uses a clock cycle to communicate. Additionally, SPI is full-duplex communication.

In SPI you will find that there is a master slave relation where SPI has 4 wires to communicate which is MOSI (Master out Slave in) MISO (Master in Slave out) SCL (Serial clock) SS (slave select). Here, the first master sends the signal to all slaves with the identity number; consequently, the slave who has the same identity number reverts back to the master. After hearing back from the slave master, then send data to the particular slave. After the master sends the data, it then sends a clock signal to indicate that the data transfer is complete.

Examples for SPI Communication:

For example, let’s try to have SPI communication between two Arduino boards.

  • Hardware Set-up 
  1. First define the Pins and include SPI.H library in the code
  2. Here let’s consider 10, 11, 12, 13 digital pins SS, MOSI, MISO, SCK on Arduino UNO.
  3. Now let’s initialize the pins in the code:
void setup() {
SPI.begin(115200);
// Set pin modes for SS, MOSI, MISO, and SCK
pinMode(SS, OUTPUT);
pinMode(MOSI, OUTPUT);
pinMode(MISO, INPUT);
pinMode(SCK, OUTPUT);
// Set slave select (SS) pin high to disable the slave device
digitalWrite(SS, HIGH);
}

Code for the master board:

#include <SPI.h>
const int slaveSelectPin = 10;
void setup() {
SPI.begin(115200);
pinMode(slaveSelectPin, OUTPUT);
}

void loop() {
digitalWrite(slaveSelectPin, LOW);
SPI.transfer('H');
digitalWrite(slaveSelectPin, HIGH);
delay(1000);
}

Code for the Slave board:

#include <SPI.h>
const int slaveSelectPin = 10;
void setup() {
SPI.begin(115200);
pinMode(slaveSelectPin, OUTPUT);
}

void loop() {
if (digitalRead(slaveSelectPin) == LOW) {
char receivedData = SPI.transfer('L');
Serial.println(receivedData);
}
}

PFB image of Connections:

SPI Communication in IOT projects

I2C Communication

I2C Communication stands for Inter Integrated Circuit, and it is a half-duplex communication that works on a 2-wire protocol. Additionally, it has an extra overhead with start and stop bits.

I2C has an acknowledgment bit after every byte of transfer. It has a pullup resistor requirement. I2c is slower but comes with clock stretch functionality.

Examples for I2C Communication:

For an example let’s try to have I2C communication between 2 Arduino

  • Hardware Set-up

I2C pins on the Arduino Uno are SDA (A4) and SCL (A5).

  1. Connect the Ground pin of Both Arduinos.
  2. Connect the SDA pin of Master to the SDA pin of slave.
  3. Connect the SCL pin of Master to the SCL pin of Master.
  4. Master Arduino Code:
#include <Wire.h>
void setup() {
Wire.begin();  // Join I2C bus as master
}
void loop() {
 Wire.beginTransmission(8);  // Begin transmission to device with address 8
Wire.write("Hello from Master!");  // Send a message
Wire.endTransmission();  // End transmission
delay(1000);  // Wait for a second
}

Slave Arduino Code:

#include <Wire.h>

void setup() {
Wire.begin(8);  // Join I2C bus with address 8
Wire.onReceive(receiveEvent);  // Register a function to be called when data is received
}

void loop() {
// Do nothing, everything is handled in receiveEvent
}
void receiveEvent(int howMany) {
while (Wire.available()) {  // Loop through all received bytes
char c = Wire.read();  // Read each byte
Serial.print(c);  // Print the received message
}
Serial.println();
}

PFB Image of Connection

I2C Communication of Arduino

2. Wireless Communication

Sometime we want to develop the projects which need to have the flexibility due which we need to have wireless connection. Don’t worry Arduino covered you there too Arduino do have 4 types wireless communication for IOT project using Arduino.

  1. Bluetooth: As the name is very familiar to us, let’s directly move to the components which help us to attain Bluetooth connectivity. By using HC-05 and HC-06 we can attain Bluetooth connectivity using Arduino. However Bluetooth provides connectivity to a short distance.
  2. Wifi: Sometimes we don’t need short distance coverage then we can switch to the wifi or in cases where we want the internet accessibility for some of our projects we can move to wifi connection. You can use the ESP32 and ESP8266 modules for the same purpose.
  3. RF (Radio Frequency): Uses radio waves for medium-distance communication, with modules like nRF24L01 and RF433.
  4. LoRa (Long Range): Great for long-distance, low-power communication, ideal for remote monitoring systems.

Conclusion

In conclusion, Arduino offers a versatile platform for various types of communication, allowing users to create innovative and interactive projects in IOT. Through serial, SPI, and I2C communications, Arduino facilitates reliable and efficient data exchange, each method catering to different needs and scenarios for exploring Arduino communication for IOT App. 

Whether you are connecting multiple Arduinos or interfacing with other devices, understanding these communication protocols enhances your ability to leverage Arduino’s full potential in the IOT world.

https://github.com/spurqlabs/Arduino-Communication-Methods-for-IoT-Applications.

Click here to read more blogs like this.