María Alejandra Lozano Jiménez, Naren Arley Mantilla Ramírez

Published August 1, 2018

Electronic nose in the detection of the disease of the palms

Detection system of the disease called bud rot (PC-Pudrición de Cogollo) in the oil palm with the use of an electronic nose.

AdvancedShowcase (no instructions)923

Electronic nose in the detection of the disease of the palms

Things used in this project

Hardware components

Integrated circuit TL431BIP Texas Instrument

Gas sensor TGS

Gas sensor MQ

Intel Galileo

Integrated circuit TLC2543CN1 Texas Instruments

Integrated Circuit TLV2543IN1 Texas Instruments

Shield Sigfox Wisol

Software apps and online services

Sigfox

Story

History

In Colombia, oilpalm cultivation is one of the most important, with 130, 000 families dependenton this activity, as well as 128, 000 direct jobs and 200, 000 indirect jobs.Colombia is the first Latin American producer and the fourth largest producerin the world, with more than 420, 000 hectares of planted palm, however, thiscrop can be affected by catastrophic diseases such as Bud Rot (PC - Pudriciónde cogollo), which affects the production and profitability of the crop.

Figure 1 - Oil Palms with bud rot.

The bud rot (PC - Pudrición de cogollo) has been the mostdevastating plague of the oil palm in Latin America. The symptoms of thedisease are characterized by the rotting of all new tissues, preserving theleaves that were formed before the infection. It is for this reason that wewant to propose an IoT solution with Sigfox that consists of an electronic nosein a drone that crosses the cultivation of African palm in search of thecharacteristic odor of the disease in its beginnings since if a detection ofthe disease is achieved In time, a simple pruning of the young arrow affectedwith a chemical control may be enough to control the disease. The use of anelectronic nose allows recognizing simple and complex aromas which allows it tobe a good alternative to detect the disease. The use of the Sigfox network in our project gives us energy efficiency, since it consumes very little energy, in addition as it uses free frequencies it guarantees very little interference. It also has Ultra Narrow Band (UNB) bi-directional connectivity and simple cloud-based management from which all devices connected to the network are controlled from a single location.

Description

The electronic nose is a device composed of gas sensors sensitive to certainspecific compounds according to their configuration coupled to a patternrecognition system as a method to process the data resulting from anexperiment.

The chemical process begins when the sample is conditioned to allow its passage toa gas sensor matrix, which being resistive the set of electrodes of which theyare composed change size altering their impedance. This event originates signalsthat go through the stage of conditioning and data selection processingimplemented in an electronic stage that delivers the fingerprint of thecompound to the pattern recognition phase that allows detecting, classifyingand identifying the sample by means of the software. An electronic nose consists of a polarization module, sensing module and aconditioning and signal acquisition module.

Polarization Module

It is responsible for the energization of the other modules taking into account the power and voltage regulation that they request.

Figure 2 - Polarization module

Sensing module

As has been previously mentioned, the science of an electronic nose consists of the response of the chemical phenomenon existing between the molecules that make up the volatile to be identified and the molecules of a reference material. This process belonging to the chemical phase happens thanks to the gas sensors. So, gas sensors are devices that indicate the presence of some gas and in some cases, they are able to measure the concentration of said gas

The prototype built, has metal oxide semiconductor sensors, the which works with a film composed of oxide-metal crystals type n, in this case, tin dioxide (SnO2). In these sensors, the chemical reaction occurs when the gas makes contact with the sensor causing the electrical resistance in the sensor decreases.

A plate of size 11.5cmX13.5cm was designed with one layer and two output terminals for the signals of the sensors and power supply. Figure 3 shows the PCB trace on the left and the array of installed sensors on the right.

Figure 3 - PCB and sensor array.

The module of conditioning and acquisition of signals

Basically it consists of the process of measuring through a physical interface. The implementation of this phase in the prototype was carried out through of the Intel Galileo Generation 1 development card, figure 4.

Figure 4 - Intel Galileo

As noted, the Intel Galileo has 14 digital and 6 analog input pins, which prevents the direct connection of the 16 signals from each sensor, therefore, it uses the SPI serial data sending and scanning protocol inputs. This is done through two integrated circuits of the manufacturing house Texas Instruments: TLC2543CN1 and TLV2543IN1. These two integrated circuits are 12-bit analog to digital signal converters with switched capacitor.

Figure 5 - Red square: circuit analog to digital converter (ADC).

The Intel sends the data of the sensors of the electronic nose through the Shield Sigfox Wisol that we see in the figure 6.

Figure 6 - Shield Sigfox Wisol

Signal processing based on pattern recognition

The data processing of the prototype shown, is implemented in the IoT platform of the UIS and programmed in Python language. A pattern recognition system basically consists of the stages of extraction of main characteristics, selection of the most relevant characteristics, classification of data, training of the machine and finally validation of learning.

Figure 7 - Stages of operation of electronic nose data processing in the cloud.

Butterworth digital filter: The filter is applied with a cutoff frequency Wn = 0.2 and order 1, that is, noise reduction of -20dB for each decade in frequency. This filter is applied independently to each signal.

Extraction of characteristics: This stage is responsible for carefully extracting the descriptive parameters that each signal presents, which make it unique and belonging to a classification set called `class'. Additionally, In this stage includes a compensation for temperature and humidity variability in the environment.

Feature selection: In any case that is present in the combinations of characteristics, it is used the technique of principal component analysis (PCA), which would reduce the dimensionality to a data set with a greater value of variance from the covariance matrix of the signals. This technique eliminates the redundancies or correlations that exist between the response of the sensors.

Classification and training: The algorithms described above are complemented with the classification stage, where the training of the machine according to the identified patterns. It has been decided to apply the learning algorithms based on vector support machines (SVM), which make up the family of the most powerful and popular techniques of machine learning thanks to its robustness. The technique is able to generalize well different classification problems such as regression. In this implementation of the electronic nose algorithms are developed based on the library `scikit-learn v0.19.1 'of Python, it is housed the programming of vector support machines with linear kernel, polynomial, radial and an exception in the linear kernel using `one-vs-rest 'called` LinearSVC'.

Validation of the classifier: In the same way as in the case of the classification and training stage, the `scikit-learn v0.19.1 'library of Python (Pedregosa et al., 2011) allows cross-validation of trained machines.This validation is iterated around 500 times in order to find in each case the highest error (accuracy) in which machines can fall. The size of the sample to be evaluated corresponds to 30% of the full sample size. At the end of the process, the vector support machine is chosen with the kernel that has the least prediction error.

Aplication

In the application used, a user profile is created for the developers and another for the final customer, with its respective database address and web access, as seen in the image of figure 8.

Figure 8 - Application interface.

Subsequently, all the possible options that are presented in the characteristic extraction stage are enabled, so that in the transparent selection stage there is found the highest percentage of deviation present from the use of the PCA algorithm. Classification of the classes makes use of the different available kernels, and the vector support machine is chosen with lower prediction error. Finally, the type of cross validation that allows estimating said error is applied.

Code

Testing Sensors

import os
import socket
import sys
import ast
import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator
from Personal_settings import *
from PROC_soft.funcionesadd import *


def testingsensors(IP,pathname):
	# Creando un socket TCP/IP
	dates=[]
	valmat=[]
	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	Rl=10.0

	# Conecta el socket en el puerto cuando el servidor esté escuchando
	server_address = (IP, 10000)
	print >>sys.stderr, 'Conectando a %s puerto %s ...' % server_address
	try:
		sock.connect(server_address)

		try:
		    message = "sensordata"
		    # Enviando datos
		    print >>sys.stderr, 'enviando "%s"' % message
		    
		    sock.sendall(message)
		    data = sock.recv(4096)
		    print >>sys.stderr, 'recibiendo "%s"' % data
		    
		    if data == "sd":
		       	print "------------------------------------------- DATA ------------------------------------------------"
		       	fig, ax = plt.subplots()
		       	x=[]
		       	valmatp=[]
		       	i=0
		       	tvent=1000

	    		while True:
	    			i+=1
	    			data2= sock.recv(4096)
	    			msg1= sock.sendall("ok1")

	    			if data2 == "datef":
	    				fecha=sock.recv(4096)
	    				msg2= sock.sendall("ok2")
	    				dates.append(fecha)
	    				#print ""
	    				#print fecha

	    			elif data2 == "value":
	    				valstr=sock.recv(4096)#Recibo los datos en string
	    				msg3= sock.sendall("ok3")
	    				valint1=ast.literal_eval(valstr) #Conviento los valores a enteros
	    				####################
	    				valint=[round((((Rl*4096.0)/((med+1)*1.0))-Rl),3) for med in valint1]
	    				####################
	    				#print valint
	    				valmat.append((valint[0:8]+valint[14:22]))#Matriz con los datos
		    			ax.clear()
		    			if (i/2-1) > tvent:
		    				for j in range(tvent):
		    					x[j]=x[j+1]
		    					valmatp[j]=valmatp[j+1]
		    				x[tvent]=(i/2-1)
		    				valmatp[tvent]=valint
		    			else:
		    				x.append((i/2-1))
		    				valmatp.append(valint)
		    			minorLocatory=MultipleLocator(1)
		    			minorLocatorx=MultipleLocator(10)
		    			ax.yaxis.set_minor_locator(minorLocatory)
		    			ax.xaxis.set_minor_locator(minorLocatorx)
		    			ax.grid(which = 'minor')#True)
		    			ax.set_title("RESPONSE OF SENSORS - SENSITIVITY - Rs")
		    			ax.set_xlabel("Time [s]")
		    			ax.set_ylabel("Rs [KOhm]")
		    			ax.axis([x[0],x[(len(x)-1)]+1,0.1,10000])
		    			ax.plot(x,valmatp)
		    			plt.yscale('log', linthreshy=0.001)
		    			#handles, labels = ax.get_legend_handles_labels()
		    			ax.legend(["Sensor 1"," Sensor 2", "Sensor 3","Sensor 4"," Sensor 5", "Sensor 6", "Sensor 7"," Sensor 8", "Ref","Ref","Ref med", "Ref down", "Ref up", "vacio"," Sensor 9", "Sensor 10", "Sensor 11"," Sensor 12", "Sensor 13", "Sensor 14"," Sensor 15", "Sensor 16", "Ref","Ref","Ref med", "Ref down", "Ref up"], loc="upper left")
		    			#              dato1,      dato2,      dato3,      dato4,     dato5,      dato6,       dato7,     dato8,   dato9, dato10, dato11,   dato12,    dato13,     0,      dato14,      dato15,       dato16,     dato17,      dato18,      dato19,      dato20,     dato21,   dato22, dato23, dato24,   dato25,     dato26]   
		    			plt.pause(0.0000000000000000000000000000000001)
		    			print x[(len(x)-1)]
		    			print valint[0:8], " | ",valint[14:22]
	    			else:
	    				print "Error: Algun problema, el servidor no está enviando ni datef ni value"
	    				break
	    			

			else:
				print "Error: El servidor no respondio la clave correcta"
				dates=[0]
				valmat=[0]

		except KeyboardInterrupt:
			plt.close()
			londates=len(dates)
			lonvalmat=len(valmat)
			if lonvalmat < londates:
				valstr=sock.recv(4096)#Recibo los datos en string
				valint=ast.literal_eval(valstr) #Conviento los valores a enteros
				valmat.append(valint)#Matriz con los datos
				print valint
			elif lonvalmat > londates:
				print "Error: Se ha perdido una fecha, por lo tanto es mas grande la matriz de datos que la de fecha"

			while True:
				print ""
				print "Do you want to save the acquired data? Y/N"
				guard=raw_input(">> ")
				if guard.lower() in ["True", "yes", "y", "ok"]:
					print "Please enter a name for the sample file: "
					namefil=raw_input(">> ")
					modentrenam = True
					if modentrenam == True:
						try:
							os.makedirs("DAQ_soft/data_training/", 0755)
							os.makedirs("DAQ_soft/data_training/dates/", 0755)
						except:
							pass
						finally:	
							SaveListVariable(namefil, valmat, "DAQ_soft/data_training")
							SaveListVariable(namefil, dates, "DAQ_soft/data_training/dates")
							break
					else:
						try:
							os.makedirs("DAQ_soft/data_test/", 0755)
							os.makedirs("DAQ_soft/data_test/dates", 0755)
						except:
							pass
						finally:
							SaveListVariable(namefil, valmat, "DAQ_soft/data_test/")
							SaveListVariable(namefil, dates, "DAQ_soft/data_test/dates")
							break
				elif guard.lower() in ["no", "n", "not", "finish"]:
					break

				else:
					print ""
					print "Please enter a valid option"


		finally:
		    print >>sys.stderr, 'Closing socket ...'
		    sock.close()


		print "DATOS RECIBIDOS FINALMENTE"
		londates=len(dates)	
		lonvalmat=len(valmat)
		if lonvalmat == londates:
			print "         DATE        |                         DATA ADC1                            |                        DATA ADC2          "
			for i in range(0,londates):
				print dates[i], " | ", valmat[i][0:8], " | ", valmat[i][8:16]
		else:
			print "Tienen longitudes diferentes el vector de fechas y la matriz de datos"

		raw_input()
		
		return ("ready")
	except KeyboardInterrupt:
		print "Dirección IP no accesible"
		raw_input()
		return ("ready")

Credits

María Alejandra Lozano Jiménez

2 projects • 2 followers

Naren Arley Mantilla Ramírez

1 project • 2 followers

Electronic nose in the detection of the disease of the palms