1 Introduction
Agricultural greenhouses are a necessary condition for agricultural development, and it is becoming more and more important to integrate high-tech into agricultural greenhouses. The monitoring of agricultural greenhouse data will make the greenhouses intelligent. This design realizes remote data monitoring and automatic control of the greenhouse, conducts roving detection of environmental data in the greenhouse, and uses 4G technology as the core to realize remote data transmission, so as to adapt the equipment to various complex and remote environments. Based on the ARM-Linux platform, this design uses sensors such as temperature and humidity, light intensity, and carbon dioxide concentration and 4G technology to realize remote data transmission and remote control of equipment, which overcomes traditional manual methods and saves workload. Through threshold setting and system analysis, real-time Adjust the greenhouse environment and realize equipment automation and informatization.
2. Scheme design
2.1 System requirement analysis
The intelligent greenhouse monitoring system is the command center of the entire greenhouse. This system builds an intelligent greenhouse based on the Linux system. This system is based on the I.MX6ULL+Linux operating system solution of ARMV7. The I.MX6ULL microprocessor produced by NXP, as well as peripheral circuits, temperature and humidity, light, CO2, soil moisture sensors, and 4G modules constitute an intelligent monitoring system. The system has the following characteristics:
- Systematic design: This system adopts systematic design, and the number of sensors is adjusted according to the actual situation to meet different needs.
- 4G module wireless communication: to adapt to various complex environments, ensure data transmission under 3G and 4G communication through the MQTT protocol.
- Remote monitoring: Based on 4G technology, use MQTT protocol to connect with Alibaba Cloud to realize remote monitoring of data.
2.2 System software requirement analysis
In embedded system applications, there are two technical conditions that must be considered for system security. One prerequisite is that the entire hardware system itself must be able to ensure that the hardware is stable and reliable, and the other prerequisite is to ensure that the software system itself is stable and reliable. And it is required to consider the effective cooperation with other hardware to the greatest extent when writing the software. The writing of software usually has a high degree of system complexity, while Linux embedded system refers to an embedded hardware system with complete system security, stability, real-time performance, high concurrency, and complete and clear functional structure. , high portability, and open source. The system design mainly adopts the software system design optimization scheme on the following four technical levels:
User interaction layer: users monitor agricultural greenhouses in real time through mobile terminals.
System kernel layer: This layer is the driver of various sensor devices. The driver is compiled together with the kernel, and the data is collected through the sensors in the greenhouse.
Transport layer: use 4G technology to connect to Alibaba Cloud through MQTT protocol.
Acquisition layer: Responsible for real-time collection of greenhouse data.
2.3 Monitoring program design
This system uses embedded ARM+Linux to realize the monitoring of the greenhouse, making the system safer and more stable, and realizes the two-way control between the mobile terminal and the device terminal through 4G technology. The specific plan is shown in the figure below:
Figure 2-1 Monitoring scheme design
3. Hardware design
3.1 Core hardware design
3.1.1 Introduction to I.MX 6 ULL _ _ _ _ _
This system uses the NXP i.MX6ULL processor as the main controller. I.MX6ULL is a single-core CPU produced and developed by NXP. Numerous functions and powerful and stable peripheral interfaces are also integrated within the scope of the core chip. I.MX6ULL is a processor based on the ARMV7 instruction set, with extremely high performance memory and processing logic unit, I.MX6ULL has a variety of internal expansion devices, LCD, NAND flash memory and Flash system, USB data interface, UART, sensor interface. I.MX6ULL has a very high cost performance.
3.1.2 Storage module _ _ _
This system mainly uses a large-capacity NAND flash disk or high-speed FLASH card with a 512MB system memory chip as the external main memory of the system, which is used to store files and system program codes, user data, etc. The data storage capacity of Nand-flash should be large enough, which is suitable for real-time storage of a large amount of data information. I.MX6ULL provides an interface for the storage, and transmits signals to the external data of the storage through the interface, and NAND FLASH is mainly used for storage later. module to store the root filesystem.
3.2 Design of data acquisition module
The main task of the acquisition module is to collect environmental data such as environmental temperature and humidity, CO2 concentration, light intensity, soil humidity, etc., perform calculations on the data and transmit them to Alibaba Cloud. Considering the size and power consumption, it is necessary to select appropriate hardware devices.
3.2.1 Sensor _ _ _ _
Environmental temperature and humidity sensor: The temperature and humidity detector adopts a new integrated digital temperature sensor DHT11, which can directly measure the temperature and humidity analog detection signal on site and output it into a digital signal, which is more convenient to use. The technical parameters are more accurate.
Light sensor: The light sensor is a light sensor composed of solar sensor components, which can convert the light of 0~65000LX into a voltage signal.
Soil moisture sensor: The soil moisture sensor measures the soil moisture through the conductivity of the exposed parallel lines, and reads the soil moisture value through A/D signal conversion.
CO2 sensor: The C02 sensor adopts SGP30, which has the advantages of simple use and high density.
3. 2. 2 4G module _ _
The 4G module adopts Quectel EC20Mini, which can seamlessly switch between 3G and 4G networks. It can also work normally in remote areas with 3G and 4G networks.
4. Functional renderings
4.1 System software development
Since the wireless monitoring application system developed by the greenhouse currently mainly realizes real-time automatic wireless collection and storage analysis of monitoring data, real-time intelligent alarm processing control and remote two-way remote wireless real-time video remote control communication. After we have completed some basic software design and program testing of the above-mentioned hardware environment, we will then focus more on the design of some related software environments that we need in the wireless monitoring application system project. Generally speaking, the system design and development of the software system is to achieve the required work goals on the basis of the Linux development and operation environment platform based on an embedded development system. After the hardware design system of booting and starting system and file system database is established and designed, the next step will be to design the related equipment software and drive system and write the related application program environment. All of the device driver codes have the standard interface functions of the Linux kernel, and should be rewritten in the writing of each interface module code. The device driver framework of the device driver in this system design document is written and implemented by using a character device driver framework code provided by a kernel file based on the Linux platform, and the completed character is rewritten The driver framework code of the device will be compiled together with the kernel file.
4.1.1 Character Device Driver Framework _
(1) Registration/deregistration of modules
After the driver module is successfully registered, the Linux system kernel will start to allocate the corresponding address space for its module. After the registered module is configured, use the midprobe command to load the driver module, and use the rmmod function to automatically unload the loaded and unloaded driver module. The commands used by modprob are called by the init() system of module_, and rmmod is called by the exit() system of module_. The driver manages the registration and unloading of the driver module through these two functions.
(2) Apply for a device number
In the Linux system, each device will correspond to a device number. When writing a driver program, you must first ask the kernel to apply for a device number.
(3) Add character device
Everything in the Linux system is a file, and a character device is added to the Linux system through the cdev_add function provided by the kernel. Abstract devices as files.
(4) Create a node
Everything under Linux is a file, and the devices we use will be abstracted into driver files, which are so-called nodes. First, create a class class, register the node class through the function class_create, and then create a character device through device_create.
4.1.2 System calls _ _ _
The system call is the transition from the user state to the kernel state. It is the only way for the user to access the kernel through the API function provided by the system, thereby accessing the corresponding system resources. The relationship can be briefly described by the following figure:
Figure 4-1 System call
The kernel provides a series of services, resources, and supports a series of functions. Applications use the services, resources, and various functions provided by the kernel by calling system call API functions.
In the driver, the call of the C library function in the application is realized through the members of the file_operations structure. The specific description is as follows:
Figure 4-2 C library call
4.2 Development of mobile application software
As an application software, the mobile terminal is an important technical component of the application system. After the collected sensor data information is processed by the computer, the data is directly uploaded to the database Alibaba Cloud and then automatically transferred to the mobile terminal. The mobile terminal will transfer the data to the mobile terminal. The sensor data information is analyzed and displayed and updated to the database synchronously, which also realizes real-time dynamic storage of greenhouse environmental information and draws curves. The mobile terminal can also perform remote threshold setting and equipment control to achieve manual or automatic adjustment of the greenhouse environment.
4.2.1 Application software development tools and platforms
(1) Programming tool Qt is mainly used as the programming tool for remote monitoring software development, and the main programming language for basic applications is C++. Qt development has the following obvious outstanding advantages: First, Qt integrates and uses a large number of UI controls, supporting technologies such as ADO database, ODBC, QSLITE database and other advanced database interactive access technologies; secondly, it has a set of powerful and efficient interconnection The machine help and document system can quickly and conveniently perform quick queries of various help or information resources, such as searching for a certain keyword or calling API functions.
(2) The database system selected for the database is a lightweight qslite database with an embedded design. This series of databases is open source, free, streamlined, and occupies a relatively small amount of running memory for the database.
(3) The equipment used in the hardware part is the EC204G module developed by Quectel Communications Company. After using this communication module, it can automatically realize the point-to-point communication connection between the server and the remote host computer equipment and the batch sending and transmission of remote short message data packets. and receive.
4.2.2 Display of remote monitoring software results
(1) Main interface
The remote monitoring software can check the environmental data of the greenhouse at any time through the mobile phone, and remotely control the equipment to adjust the environment of the greenhouse. The remote monitoring software adopts a modular design. Users can click on the corresponding module to view according to the viewing content. The main interface is as shown in the figure:
Figure 4-3 Main interface
(2) Data monitoring interface
Data monitoring monitors the environmental data of the greenhouse in real time, and the sampling time is 1 second. When the equipment is turned on automatically and the greenhouse environment exceeds the threshold setting, the equipment terminal returns the equipment status to the mobile terminal, which is recorded by cloud messages, as shown in the figure:
Figure 4-4 Data detection interface
(3) Data analysis interface
The data analysis interface records the data variables of 24 hours a day by drawing a graph, and counts the daily maximum and minimum temperature and humidity, CO2 concentration, and light intensity, which can be visually observed through the graph.
Figure 4-5 Data analysis interface
(4) Device control interface
On the device control interface, you can turn on/off the device by clicking the corresponding device icon. If the device is turned on/off successfully, the device will return the device status to the mobile terminal, and there will be a cloud message record. As shown in the picture:
Figure 4-6 Device control interface
(5) Threshold setting interface
The mobile terminal can remotely set the threshold and synchronize it to the device side, and save it through the database. After the automation is turned on, the device will realize device automation through threshold management. When the threshold is set successfully, the device will return a message to the mobile terminal. Set time by cloud message record.
Figure 4-7 Threshold setting interface
(6) Other function interface
On-duty personnel and plot management and plant encyclopedia are managed through the qslite database as auxiliary functions to manage and monitor the greenhouse in more detail. As shown in the picture:
Figure 4-8 Other function interface
5. Core code
/*
* This file is auto-generated. DO NOT MODIFY.
*/
package org.kde.necessitas.ministro;
public interface IMinistro extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements org.kde.necessitas.ministro.IMinistro
{
private static final java.lang.String DESCRIPTOR = "org.kde.necessitas.ministro.IMinistro";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an org.kde.necessitas.ministro.IMinistro interface,
* generating a proxy if needed.
*/
public static org.kde.necessitas.ministro.IMinistro asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof org.kde.necessitas.ministro.IMinistro))) {
return ((org.kde.necessitas.ministro.IMinistro)iin);
}
return new org.kde.necessitas.ministro.IMinistro.Stub.Proxy(obj);
}
@Override public android.os.IBinder asBinder()
{
return this;
}
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
java.lang.String descriptor = DESCRIPTOR;
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(descriptor);
return true;
}
case TRANSACTION_requestLoader:
{
data.enforceInterface(descriptor);
org.kde.necessitas.ministro.IMinistroCallback _arg0;
_arg0 = org.kde.necessitas.ministro.IMinistroCallback.Stub.asInterface(data.readStrongBinder());
android.os.Bundle _arg1;
if ((0!=data.readInt())) {
_arg1 = android.os.Bundle.CREATOR.createFromParcel(data);
}
else {
_arg1 = null;
}
this.requestLoader(_arg0, _arg1);
reply.writeNoException();
return true;
}
default:
{
return super.onTransact(code, data, reply, flags);
}
}
}
private static class Proxy implements org.kde.necessitas.ministro.IMinistro
{
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
@Override public android.os.IBinder asBinder()
{
return mRemote;
}
public java.lang.String getInterfaceDescriptor()
{
return DESCRIPTOR;
}
/**
* Check/download required libs to run the application
*
* param callback - interface used by Minsitro service to notify the client when the loader is ready
* param parameters
* parameters fields:
* * Key Name Key type Explanations
* "sources" StringArray Sources list from where Ministro will download the libs. Make sure you are using ONLY secure locations.
* "repository" String Overwrites the default Ministro repository. Possible values: default, stable, testing and unstable
* "required.modules" StringArray Required modules by your application
* "application.title" String Application name, used to show more informations to user
* "qt.provider" String Qt libs provider, currently only "necessitas" is supported.
* "minimum.ministro.api" Integer Minimum Ministro API level, used to check if Ministro service compatible with your application. Current API Level is 3 !
* "minimum.qt.version" Integer Minimim Qt version (e.g. 0x040800, which means Qt 4.8.0, check http://qt-project.org/doc/qt-4.8/qtglobal.html#QT_VERSION)!
*/
@Override public void requestLoader(org.kde.necessitas.ministro.IMinistroCallback callback, android.os.Bundle parameters) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeStrongBinder((((callback!=null))?(callback.asBinder()):(null)));
if ((parameters!=null)) {
_data.writeInt(1);
parameters.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_requestLoader, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_requestLoader = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
}
/**
* Check/download required libs to run the application
*
* param callback - interface used by Minsitro service to notify the client when the loader is ready
* param parameters
* parameters fields:
* * Key Name Key type Explanations
* "sources" StringArray Sources list from where Ministro will download the libs. Make sure you are using ONLY secure locations.
* "repository" String Overwrites the default Ministro repository. Possible values: default, stable, testing and unstable
* "required.modules" StringArray Required modules by your application
* "application.title" String Application name, used to show more informations to user
* "qt.provider" String Qt libs provider, currently only "necessitas" is supported.
* "minimum.ministro.api" Integer Minimum Ministro API level, used to check if Ministro service compatible with your application. Current API Level is 3 !
* "minimum.qt.version" Integer Minimim Qt version (e.g. 0x040800, which means Qt 4.8.0, check http://qt-project.org/doc/qt-4.8/qtglobal.html#QT_VERSION)!
*/
public void requestLoader(org.kde.necessitas.ministro.IMinistroCallback callback, android.os.Bundle parameters) throws android.os.RemoteException;
}
/* AUTO-GENERATED FILE. DO NOT MODIFY.
*
* This class was automatically generated by the
* aapt tool from the resource data it found. It
* should not be modified by hand.
*/
package org.qtproject.example.untitled;
public final class R {
public static final class array {
public static final int bundled_libs=0x7f010000;
public static final int load_local_libs=0x7f010001;
public static final int qt_libs=0x7f010002;
public static final int qt_sources=0x7f010003;
}
public static final class layout {
public static final int splash=0x7f020000;
}
public static final class string {
public static final int fatal_error_msg=0x7f030000;
public static final int ministro_needed_msg=0x7f030001;
public static final int ministro_not_found_msg=0x7f030002;
public static final int unsupported_android_version=0x7f030003;
}
}
[{"outputType":{"type":"APK"},"apkData":{"type":"MAIN","splits":[],"versionCode":1,"versionName":"1.0","enabled":true,"outputFile":"android-build-debug.apk","fullName":"debug","baseName":"debug"},"path":"android-build-debug.apk","properties":{}}]
[{"outputType":{"type":"MERGED_MANIFESTS"},"apkData":{"type":"MAIN","splits":[],"versionCode":1,"versionName":"1.0","enabled":true,"outputFile":"android-build-debug.apk","fullName":"debug","baseName":"debug"},"path":"AndroidManifest.xml","properties":{"packageId":"org.qtproject.example.untitled","split":"","minSdkVersion":"21"}}]
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.qtproject.example.untitled"
android:installLocation="auto"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="21"
android:targetSdkVersion="28" />
<!--
The following comment will be replaced upon deployment with default permissions based on the dependencies of the application.
Remove the comment if you do not require these default permissions.
-->
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<!--
The following comment will be replaced upon deployment with default features based on the dependencies of the application.
Remove the comment if you do not require these default features.
-->
<supports-screens
android:anyDensity="true"
android:largeScreens="true"
android:normalScreens="true"
android:smallScreens="true" />
<application
android:name="org.qtproject.qt5.android.bindings.QtApplication"
android:debuggable="true"
android:extractNativeLibs="true"
android:hardwareAccelerated="true"
android:label="untitled" >
<activity
android:name="org.qtproject.qt5.android.bindings.QtActivity"
android:configChanges="orientation|uiMode|screenLayout|screenSize|smallestScreenSize|layoutDirection|locale|fontScale|keyboard|keyboardHidden|navigation|mcc|mnc|density"
android:label="untitled"
android:launchMode="singleTop"
android:screenOrientation="unspecified" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
<!-- Application arguments -->
<!-- meta-data android:name="android.app.arguments" android:value="arg1 arg2 arg3"/ -->
<!-- Application arguments -->
<meta-data
android:name="android.app.lib_name"
android:value="untitled" />
<meta-data
android:name="android.app.qt_sources_resource_id"
android:resource="@array/qt_sources" />
<meta-data
android:name="android.app.repository"
android:value="default" />
<meta-data
android:name="android.app.qt_libs_resource_id"
android:resource="@array/qt_libs" />
<meta-data
android:name="android.app.bundled_libs_resource_id"
android:resource="@array/bundled_libs" />
<!-- Deploy Qt libs as part of package -->
<meta-data
android:name="android.app.bundle_local_qt_libs"
android:value="1" />
<!-- Run with local libs -->
<meta-data
android:name="android.app.use_local_qt_libs"
android:value="1" />
<meta-data
android:name="android.app.libs_prefix"
android:value="/data/local/tmp/qt/" />
<meta-data
android:name="android.app.load_local_libs_resource_id"
android:resource="@array/load_local_libs" />
<meta-data
android:name="android.app.load_local_jars"
android:value="jar/QtAndroid.jar:jar/QtAndroidBearer.jar" />
<meta-data
android:name="android.app.static_init_classes"
android:value="" />
<!-- Used to specify custom system library path to run with local system libs -->
<!-- <meta-data android:name="android.app.system_libs_prefix" android:value="/system/lib/"/> -->
<!-- Messages maps -->
<meta-data
android:name="android.app.ministro_not_found_msg"
android:value="@string/ministro_not_found_msg" />
<meta-data
android:name="android.app.ministro_needed_msg"
android:value="@string/ministro_needed_msg" />
<meta-data
android:name="android.app.fatal_error_msg"
android:value="@string/fatal_error_msg" />
<meta-data
android:name="android.app.unsupported_android_version"
android:value="@string/unsupported_android_version" />
<!-- Messages maps -->
<!-- Splash screen -->
<!--
Orientation-specific (portrait/landscape) data is checked first. If not available for current orientation,
then android.app.splash_screen_drawable. For best results, use together with splash_screen_sticky and
use hideSplashScreen() with a fade-out animation from Qt Android Extras to hide the splash screen when you
are done populating your window with content.
-->
<!-- meta-data android:name="android.app.splash_screen_drawable_portrait" android:resource="@drawable/logo_portrait" / -->
<!-- meta-data android:name="android.app.splash_screen_drawable_landscape" android:resource="@drawable/logo_landscape" / -->
<!-- meta-data android:name="android.app.splash_screen_drawable" android:resource="@drawable/logo"/ -->
<!-- meta-data android:name="android.app.splash_screen_sticky" android:value="true"/ -->
<!-- Splash screen -->
<!-- Background running -->
<!--
Warning: changing this value to true may cause unexpected crashes if the
application still try to draw after
"applicationStateChanged(Qt::ApplicationSuspended)"
signal is sent!
-->
<meta-data
android:name="android.app.background_running"
android:value="false" />
<!-- Background running -->
<!-- auto screen scale factor -->
<meta-data
android:name="android.app.auto_screen_scale_factor"
android:value="false" />
<!-- auto screen scale factor -->
<!-- extract android style -->
<!--
available android:values :
* default - In most cases this will be the same as "full", but it can also be something else if needed, e.g., for compatibility reasons
* full - useful QWidget & Quick Controls 1 apps
* minimal - useful for Quick Controls 2 apps, it is much faster than "full"
* none - useful for apps that don't use any of the above Qt modules
-->
<meta-data
android:name="android.app.extract_android_style"
android:value="default" />
<!-- extract android style -->
</activity>
<!-- For adding service(s) please check: https://wiki.qt.io/AndroidServices -->
</application>
</manifest>6. Reference Papers
Table of contents
1.1 Subject background and research significance
1.2 Purpose and significance of topic selection
2 Scheme design of greenhouse monitoring system
2.1 System requirements analysis
2.2 Analysis of System Software Requirements
3.1.1 Introduction to i.MX6ULL
3.2 Data acquisition module design
4 Build an embedded development platform
4.1 Software system requirements analysis and process design
4.2 Build a cross-compilation environment
4.2.1 Introduction to cross-compilation environment
4.2.2 Cross-compilation tool installation
4.3 TFTP and NFS service construction
4.3.1 Functions of TFTP and NFS
4.4.2 U-boot configuration and porting
4.4.3 Configure bootcmd and bootargs environment variables
4.5 Linux Kernel Cutting and Porting
4.5.2 Cutting and porting of the kernel
4.6 Root file system construction
4.6.1 Introduction to root file system
4.6.2 BusyBox build root file system
5 System software and application software
5.1 System software development
5.1.1 Character Device Driver Framework
5.2 Development of mobile application software
5.2.1 Application software development tools and platforms
5.2.2 Display of remote monitoring software results
7. Summary
With the optimization of the greenhouse environment in facility agriculture, intelligent greenhouse system monitoring equipment and equipment management will be the common key research and hot spot of many other related countries in the world in the future. This subject is mainly based on the latest ARM microprocessor and 4G technology to design and develop a new generation of intelligent greenhouse environment monitoring equipment system. The system has got rid of the traditional fieldbus technology in the past. Adopting today's advanced radio frequency technology, it is more suitable for the new development of my country's modern facility agricultural production. And through 4G technology, it gets rid of the limitation of equipment application in remote mountainous areas and complex environments.
The main research results of the paper are as follows:
(1) This chapter discusses and analyzes in detail the actual monitoring and application of the current agricultural greenhouse system in my country, the basic software and hardware requirements of the greenhouse control system, the selection of functional indicators, and the overall functional design characteristics of the control system. The most popular application of embedded operating system is analyzed and compared, and the embedded or Linux operating system is selected as the mainstream operating system to realize the goal of this application system.
(2) Software and hardware selection, software including USB disk-boot, Linux system kernel and root directory file system, Qt mobile terminal application development. In terms of hardware, it is necessary to choose a development board suitable for wireless monitoring equipment, 4G modules and sensors that realize wireless mobile communication functions.
(3) Successfully built an embedded development platform, introduced the transplantation of u-boot, the transplantation and startup process of the kernel, and the construction of the root file system.
(4) The device control end writes a set of corresponding version of the character device driver by using the character device driver framework provided in the Linux operating system kernel, and provides an interface function for the upper application program, and the application program can automatically read through this interface function Sensor data can be directly and automatically uploaded to Alibaba Cloud through 4G technology.
(5) The mobile terminal has successfully completed the remote monitoring of the data, realizing the establishment of the database; realizing remote manual or automatic management of equipment, realizing data query and curve display.
This system realizes operations such as greenhouse remote information collection, query, statistics and charts, and equipment automation control. More powerful functions have yet to be perfected.
Likes, likes, collections, and attention to private letters Author communication