Automaattinen paikannusjärjestelmä Vazamentos: 11 vaihetta

2024 Kirjoittaja: John Day | [email protected]. Viimeksi muokattu: 2024-01-30 09:00

Este projeto consiste em um robô, que através da leitura realizada por um dispositivo, equipado com um sensor piezoelétrico, captura os espectros das vibrações no solo, pode identifar e localizar, com o processamento dos dados por uma rede neural, possíveis vazamentos de água em uma tubulação.

Tai prosessi tuhoaa isän ja toteuttaa algoritmin asennuksen DRAGONBOARD 410c: ssä. Os dados também são enviados para um serviço na nuvem, vastaus auxiliar no processo de Integência Artificial do projeto.

Este projeto foi desenvolvido no Hackaton Qualcomm, durante a TecnoFACENS da Faculdade de Engenharia de Sorocaba (FACENS), osallistuminen projektien valmistumiseen ja engenharia mecatrônica Eneo Juliano Bovino, Felipe Xavier, Lucas de Sousa Rodér Gomes Polo ja Ronaldo P. Gomes Polo. Também osallistuu projektiin tai aluno Daniel de Castro Pachecon valmistumiseen ja engenharia -mekanismiin Newton Paiva de Belo Horizonten yliopistossa. O projeto contou com or apoio dos graduandos de engenharia mecatrônica da FACENS, Lucas Nunes Monteiro ja Felipe Crispim da Silva Salvagnini.

Vaihe 1: Lista De Materiais

Para realização deste projeto, os seguintes materiais foram utilizados:

1 Arduino Due

1 Dragonboard 410c

2 Ajurit para motor de corrente continua contendo cada um:

4 Transistorit BC548

4 Diodot 1n4007

4 Resistres 4k7Ω ¼ W

1 Kuljettaja servomoottorilla:

1 Transistorit BC548

1 Diodot 1N4007

1 Resistres 4k7Ω ¼ W

1 USB -hiiri

1 USB -Teclado

1 Näyttö

1 kaapeli HDMI

1 Robô De Esteiras - Plataforma Zumo

1 Mini creitalheira and engrenagem

1 servomoottori 9 g

Vaihe 2: Adaptação Mecânica

Parametrit, joissa on vedenpitävä vesi, tarvikkeet, desinvolvimento de um dispositivo com pinhão e cremalheira, conforme desenhos anexados, neste caso as pecaas foram fabricadas por uma impressora 3D, devido ao fato de se trator de um nopeus execução, fixou-se tai dispositivo na plataforma zumo, hyödyntäminen fita dupla face, conferme video.

Vaihe 3: Acionamento Dos Motores

ZUMO e do dispositivo de captura -toiminnon suorittamiseen ja liikkumiseen liittyvien moottoripyörien suorittamiseen, fez-se välttämättömyyteen ja monitoimikoneiden kuljettajien kokoonpanoon, moottoripyörän moottorin ohjaimiin, moottorikoneen kuljettaja, tunnista figuras acima, lähetä kuva um motor de corrente continua ea segunda o driver para um servo motor.

Vaihe 4: Obtenção Do Áudio

Para obtenção do espectro de áudio das vibrações do solo, fori utilizado um dispositivo desenvolvido como parte do TCC de Engenharia Mecatrônica dos graduandos Lucas Nunes Monteiro e Felipe C. da Silva Salvagnini, useampia yksityiskohtia sopivuus tai TCC -soittopalvelu sähköposti [email protected].

Este dispositivo utilize-se de um sensor sensor piezoelétrico and uma placa de circuitito que realiza a filterragem amplificaçã do sinal.

Yleisimmin kiinnostavat taajuudet tai projektit, joiden taajuus on 100 Hz ja 800 Hz. Para isso o dispositivo de sensoriamento for Configurado com uma frequência de amostragem de 3 kHz para que sejam respeitada as condições do teorema de amostragem de Nyquist, on a frequência de aquisição deve estar pelo menos duas vezes acima das freasadias.

A aquisição é habilitada e desabilitada através da interrupção do Arduino DUE.

Vaihe 5: Configuração Do Arduino DUE (kielitaito C)

Devido a grande quantidade de dados, cerca de 3000 täps por segundo, do type inteiro de 32 bit, gerados pelo dispositivo de sensoriamento e needarios para processamento dos algoritmos na DRAGONBOARD 410c, foi utilizado o Arduino DUE para fazer uso de uma entrada analógica com maior prosessori, prosessin tarpeellinen tai tarpeellinen Shield de interfaceamento Grove Seeed Sensor Mezzanine asennettuna DRAGONBOARD 410c -laitteeseen, jossa on mikrokontrolleri ATmega 328, prosessorin prosessorin esto -operaattori.

O Arduino DUE -konfigurointivastaanotin, jossa on komentoja enviados da plataforma QUALCOMM DRAGONBOARD 410c comunicação -sarjan kautta.

Kuten konfiguraatiot ilman Arduino -muotoa:

Realizar a aquisição dos dados;

DRAGONBOARD 410c: n lähetyslaitteet;

Käytä ohjelmaa:

#include #define Numb_Sample 3000 #define DAC_Input A0

#määrittele SERVO 7

#define PosServoMin 4 #define PosServoMax 6 #define Period 60 unsigned int Scont = 0, SNow = PosServoMin; unsigned long int DAC [Numb_Sample], ind = Numb_Sample; mitätön TC3_Handler () {TC_GetStatus (TC1, 0); if (ind <Numb_Sample) DAC [ind ++] = analoginenLue (DAC_Input); jos (Scont

1); // 50%: n käyttöjakso

TC_SetRC (tc, kanava, rc); TC_Start (tc, kanava); tc-> TC_CHANNEL [kanava]. TC_IER = TC_IER_CPCS | TC_IER_CPAS; // habilita os registradores tc-> TC_CHANNEL [kanava]. TC_IDR = ~ (TC_IER_CPCS | TC_IER_CPAS); // desabilita os registradores NVIC_EnableIRQ (irq); // habilita interrupção}

mitätön asennus ()

{Serial.begin (115200); pinMode (DAC_Input, INPUT); TimerStart (TC1, 0, TC3_IRQn, 1500); // Käynnistä ajastin // TC_Stop (TC1, 0); pinMode (SERVO, OUTPUT); }

tyhjä silmukka ()

{/*// while (! Serial.available ()); char rc; // = Serial.read (); int -indeksi = 0; if (rc == 0) {while (! Serial.available ()); rc = Serial.read (); kytkin (rc) {tapaus 1: indeksi = 0; while (! Serial.available ()); while ((rc = Serial.read ())! = 0xFF) {indeksi << = 8; indeksi += rc; while (! Serial.available ()); } Sarjanjälki (0); Sarjanjälki (2); Lähetänumero (DAC [indeksi]); Sarjanjälki (0xFF); tauko; tapaus 3: while (! Serial.available ()); if ((Serial.read ()) == 0xFF) {SNow = PosServoMax; viive (500); ind = 0; // TC_Start (TC1, 0); while (ind <Numb_Sample); // TC_Stop (TC1, 0); SNow = PosServoMin; viive (500); Sarjanjälki (0); Sarjanjälki (4); Sarjanjälki (0xFF); } tauko; }} else if (rc == '2') {Serial.print ("Testaa servomoottoria / n"); while (! Serial.available ()); rc = Serial.read (); if (rc == '1') {Serial.print ("Tila 1 / n"); SNow = PosServoMax; } if (rc == '2') {Serial.print ("Tila 2 / n"); SNow = PosServoMin; }} */ SNow = PosServoMax; viive (100); SNow = PosServoMin; viive (100); }

Vaihe 6: Interfaceamento Das Tecnologias

Arduíno DUE ea DRAGONBOARD 410c -laitteen tiedonsiirtoyhteyden avulla voit aloittaa käyttöliittymän, jossa on figura acima -käyttöliittymä, tai vaihtoehtoinen käyttöliittymä, opto-optou-se pelo uso -liitäntä USB CDC -käyttö tai Arduino DUE ea DRAG KERNELin DRAGONBOARD 410c: n uudelleenlaatiminen on välttämätöntä, koska se ei ole mahdollista.

Vaihe 7: Configuração Da DRAGONBOARD 410c (Python)

Arduino DUE: n konfigurointikokoonpano, joka käsittää realisoitavan veden ja isän lähetyksen ja lähetyksen. Segue código abaixo.

Huomautus: A abordagem utilizada no código, não funcionou devido aos níveis de tensão utilizados pelo Arduíno DUE e o Mezzanine serem inkpatíveis. Tämä on myös USB-liitännän mahdollinen käyttöliittymä, joka on pakollinen KERNELin ja DRAGONBOARD 410c -laitteen kokoamiseksi.

tuonti aika tuoda sarjatuonti pandat pd tuonti numpy np: nä

# Configuração da conexão -sarja

ser = sarja.sarja (portti = '/dev/ttyAMC0', #tty96B0 ', baudrate = 250000, pariteetti = sarja. PARITY_NONE, stopbits = sarja. STOPBITS_ONE, tavua = sarja. EIGHTBITS)

ser.isOpen ()

print ('Kirjoita komennot alla. / r / nLisää sovellus poistamalla "exit".')

tulo = 1

kun taas 1: input = input (">>") if input == 'exit': ser.close () exit () elif input == 'read': ser.write (0) # Envia o comando para o Arduino DUE realar a coleta dos dados ser.write (1) # Envia o comando para tai Arduino DUE lähetin os dados coletados

lista =

i alueella (3000):

ser.write (i/256) ser.write ((i <0: out = ser.read (2) if (out == 0x0002): atual = 0 c = ser.read (1) taas (c! = 0xFF)): atual << 8 atual += cc = ser.read (1) lista.append (atual)

Vaihe 8: INTERPRETAÇÃO DOS ARQUIVOS DE AUDIO

Para poder realizar uma primeira análise dos dados obtidos através do sensor, se fez välttämättömyys ja keskustelu arquivos no format WAV, fornecidos pelos alunos autores do TCC e colaboradores do projeto, para valores numéricos, que são utilizados nos algoritmos de anALISAR. PYTHON 3 -kirjoituksen algoritmin kirjoittamiseen on mahdollista päästä käsiksi escrito -algoritmiin. Voit käyttää algoritmia, jolla voit ladata ja ladata anexo.

Tämä algoritmi ei vaadi faksen välttämättömyyttä järjestelmän toiminnalle, järjestelmälle, tai que tai Arduino DUE: lle, joka on essee dados em um array de valores numéricos.

# koodaus: utf-8

# Leitura e conversão dos audios para csv

# MÓDULOS UTILIZADOS

tuonti aalto tuonti numpy np tuonti pandat pd tuonti matplotlib.pyplot plt

# FUNÇÃO PARA CONVERTER WAV EM DADOS DO ESPECTRO E SALVAR CSV

def audio_to_csv (tiedoston_nimi): wave_file = wave.open (tiedoston_nimi+'. wav', 'rb') data_size = wave_file.getnframes () sample_rate = wave_file.getframerate () time_step = 1/sample_rate waveData = wave_file.readframes (data_s)) signal = np.fromstring (waveData, dtype = 'int32') Aika = np.linspace (alku = 0, stop = data_koko/näyte_nopeus, num = data_size, endpoint = True) df = pd.concat ([pd. DataFrame (signaali), pd. DataFrame (Aika)], akseli = 1) df.to_csv (tiedoston_nimi + '.csv', indeksi = False) return df

# CARREGANDO DATA FRAME COM OS DADOS DO AUDIO

file_name = 'Solo_com_Vazamento' df_vazamento = audio_to_csv (tiedoston_nimi) df_vazamento.columns = ['amp', 'time'] file_name = 'Solo_sem_Vazamento' df_sem_vazamento = audio_to_csv (tiedoston_nimi) df_sem] aika

# GRÁFICO DO ESPECTRO DE AUDIO

kuva, (ax1, ax2) = plt.subplots (nrows = 2, ncols = 1, figsize = (20, 10)) ax1.plot (df_vazamento ['time'], df_vazamento ['amp']) ax1.set_title ('Solo com Vazamento', fontdict = {'fontsize': 20, 'fontweight': 'bold'}) ax1.set_xlabel ('Tempo [s]', fontdict = {'fontsize': 16}) ax1.set_ylim ([-4e8, 4e8]) ax2.plot (df_sem_vazamento ['aika'], df_sem_vazamento ['amp']) ax2.set_title ('Solo sem Vazamento', fontdict = {'fontsize': 20, 'fontweight': 'bold' }) ax2.set_xlabel ('Tempo [s]', fontdict = {'fontsize': 16}) ax2.set_ylim ([-4e8, 4e8]) figure.tight_layout (h_pad = 5) plt.show ()

Vaihe 9: Anualise Visual Do Sinal

Com o PYTHON 3 realisoi Fourierin muutoksen, on taidonnäyte matematiikan toteutuksessa ja muunnoksessa, jossa on syntaalinen dominointi ja nopeus taajuusalueelle tai taajuusmuuttajan taajuudelle, on torni, joka voidaan analysoida erilaisina taajuuksina, amplitudina, que compõem aquele sinal. Pela análise visual do do gráfico da transformada de Fourier um profissional com conhecimentos específicos poderá identifar a pastência de algum vazamento na tubulação. Estes gráficos servirão para validção das análises realizadas pelo algoritmo de detecção automática.

Rajoitukset tai taajuudet 100 Hz: n ja 800 Hz: n taajuudella, fica claro ja olemassaoleva vazamentos quando se observam distúrbios nesse range de frequências.

# koodaus: utf-8# Muutoksen hyödyntämismenetelmät Fourierin muutoksen prosessissa

tuoda pandat pd -muodossa tuonti numeroina np -tuontiaallona matplotlib -tuontiplotista plt# Função que realiza a transformada de Fourier e plota os gráficos para análise def Fourier (df_list): Fs = 44100; # Taksit de amostragem em Hz Ts = 1,0/Fs; # Intervalo de amostragem y = pd.concat (df_list) t = y ['time'] # Vetor de temppos y = y ['amp'] # Vetor de amplitudit n = len (y) # Komprimentoida sinal k = np. arange (n) T = n/Fs frq = k/T frq = frq [alue (n // 2)] Y = np.fft.fft (y)/n Y = Y [alue (n // 2)] tmp = pd. DataFrame () tmp ['amp'] = abs (Y) tmp ['freq'] = frq max_lim = max (tmp ['amp'] [(tmp ['freq']> = 100) & (tmp ['freq'] <= 800)]) kuva, ax = plt. osaosat (2, 1, kuvakoko = (20, 10)) ax [0].plot (t, y) ax [0].set_xlabel ('Aika') kirves [0].set_ylabel ('Amplitude') ax [1].plot (frq, abs (Y), 'r') ax [1].set_xlim ([100, 800]) ax [1].set_ylim ([0, max_lim]) ax [1].set_xlabel ('Freq (Hz)') ax [1].set_ylabel ('| Y (freq) |') plt.show () return frq, abs (Y)# Função que realiza a carga dos dados do CSV e chama a função de Fourier def read_csv (tiedoston_nimi, init, lopullinen): df = pd.read_csv (tiedoston_nimi + '.csv') df.columns = ['amp', ' aika '] delta = final-init, jos init*44100> len (df) tai final*44100> len (df): init = (len (df)/44100) -delta, jos init = 100) & (df [' freq '] <= 800)] mx = lajiteltu (df [' amp ']) print ("Média das amplitudit:", np.round (np.mean (mx))) print ("Percentuais em relação a média das amplitudit.") print ("100 maiores amplitudit", np.mean (mx [-100:]) // df ['amp']. mean ()*100, "%", sep = "") print ("50 maiores amplitudit:", np.mean (mx [-50:]) // df ['amp']. mean ()*100, "%", sep = "") print ("10 maiores amplitudit:", np.mean (mx [-10:]) // df ['amp']. mean ()*100, "%", sep = "") print ("Maior amplitudi:", np.mean (mx [-1:]) // df ['amp']. mean ()*100, " %", sep =" ") read_csv ('Solo_com_Vazamento', 2, 10) # Exemplo de gráficos para vazamentoread_csv ('Solo_sem_Vazamento', 2, 10) # Exemplo de gráficos para sem vazamento

Vaihe 10: Algoritmo Em R Para Extração Das -ominaisuudet Dos Dados

Hyödynnä algoritmia R para realisation or processamento e extração das features (características) dos dados obtidos.

Este primeiro algoritmo realize uma extração identifada, on one ja requiredário saber se o arquivo de áudio trata-se de uma amostra vazamento detectado ou não, isso por que os dados resultantes desse processo servirão para or treinamento da rede neural utilizada.

Para quando o system estiver em modo de operação um algoritmo um pouco diferente será executado, onde não este fará a extração não identifada, gerando somente as características sem uma identifação.

Estas sisältää ora caraterísticas são propriedades acústicas compostas por varias informações referentes ao espectro de áudio capturado, abaixo seguirá uma descrição (em inglês) destas características.

Este algoritmi faz parte de um projeto disponível no GitHub e pode ser acessado através deste link, or mesmo foi modificado para atender as espescificaçõ do projeto.

O ohjelmisto, jota voit käyttää ilmaiseksi tai algoritmin, lataa tulkitseva R e do R Studio.

Lisäominaisuudet:

• meanfreq: keskimääräinen taajuus (kHz)
• sd: taajuuden keskihajonta
• mediaani: taajuuden mediaani (kHz)
• Q25: ensimmäinen kvantti (kHz)
• Q75: kolmas kvantti (kHz)
• IQR: interquantile -alue (kHz)
• vinossa: vinous (katso huomautus erikoiskuvauksessa)
• kurt: kurtosis (katso huomautus erikoiskuvauksessa)
• sp.ent: spektrinen entropia
• sfm: spektrinen tasaisuus
• tila: tilan taajuus
• centroid: taajuus centroid (katso specprop)
• peakf: huipputaajuus (taajuus, jolla on suurin energia)
• meanfun: perustaajuuden keskiarvo mitattuna akustisesta signaalista
• minfun: pienin perustaajuus mitattuna akustisesta signaalista
• maxfun: suurin perustaajuus mitattuna akustisesta signaalista
• meandom: keskimääräinen hallitseva taajuus mitattuna akustisesta signaalista
• mindom: hallitsevan taajuuden minimi mitattuna akustisesta signaalista
• maxdom: hallitsevan taajuuden maksimimäärä mitattuna akustisesta signaalista
• dfrange: hallitsevan taajuuden alue mitattuna akustisesta signaalista
• modindx: modulaatioindeksi. Laskettu perustaajuuksien vierekkäisten mittausten välisenä kertyneenä absoluuttisena erona jaettuna taajuusalueella
• etiketti: vuoto tai ilman vuotoa

Algoritmo:

paketit <- c ('tuneR', 'seewave', 'fftw', 'caTools', 'randomForest', 'warbleR', 'hiiret', 'e1071', 'rpart', 'xgboost', 'e1071') jos (pituus (setdiff (paketit, rownames (install.packages ())))> 0) {install.packages (setdiff (paketit, rownames (install.packages ())))})

kirjasto (tuneR)

kirjasto (seewave) kirjasto (caTools) kirjasto (rpart) kirjasto (rpart.plot) kirjasto (randomForest) kirjasto (warbleR) kirjasto (hiiret) kirjasto (xgboost) kirjasto (e1071)

specan3 <- funktio (X, bp = c (0, 22), wl = 2048, kynnys = 5, rinnakkainen = 1) { # Jos haluat käyttää rinnakkaiskäsittelyä: kirjasto (devtools), install_github ('nathanvan/parallelsugar'), jos (luokka (X) == "data.frame") {if (kaikki (c ("sound.files", "selec", "start", "end") % % sarakkeiden nimissä (X))) {start <- as.numeric (unlist (X $ start)) end <- as.numeric (unlist (X $ end)) sound.files <- kuten.merkki (unlist (X $ sound.files)) select <- as.character (unlist (X $ selec))} else stop (liitä (liitä (c ("sound.files", "selec", "start", "end") [! (c ("sound.files", "selec", "alku", "loppu") % % sarakkeiden nimissä (X))], tiivistys = ","), "sarake (t) ei löydy datakehyksestä"))} else stop ("X ei ole tietokehys")) #jos aloitus- tai lopetuspysähdyksessä on NA -kohteita, jos (mikä tahansa (is.na (c (loppu, alku))))) pysäytys ("NA: t löytyvät alusta ja/tai lopusta") #jos loppu tai alku eivät ole numeerisia pysäytyksiä if (kaikki (luokka (loppu)! = "numeerinen" & luokka (alku)! = "numeerinen")) stop ("'end' ja 'selec' on oltava numeerisia") #jos mikä tahansa aloitus on korkeampi kuin lopetus, jos (mikä tahansa (loppu - alku <0)) stop (liitä ("Alku on korkeampi kuin en d in ", pituus (joka (loppu - alku20)) pysäytys (liitä (pituus (joka (loppu - alku> 20)))," valinta (t) pidempi kuin 20 sekuntia ") vaihtoehdot (show.error.messages = TRUE) #jos bp ei ole vektori tai pituus! = 2 askelta, jos (! is.vector (bp)) stop ("'bp' on oltava numeerinen vektori, jonka pituus on 2") else {if (! length (bp) == 2) stop ("'bp' on oltava numeerinen vektori, jonka pituus on 2")} #return varoitus jos kaikkia äänitiedostoja ei löytynyt fs <- list.files (path = getwd (), pattern = ".wav $", ignore.case = TRUE) if (pituus (ainutlaatuinen (sound.files [(sound.files % in % fs)]))! = pituus (ainutlaatuinen (sound.files))) cat (paste (pituus (ainutlaatuinen (ääni) tiedostot))-pituus (ainutlaatuinen (sound.files [(sound.files % % fs)])), ".wav-tiedostoja ei löydy")) #äänitiedostojen lukumäärä työhakemistossa ja jos 0 stop d <- mikä (sound.files % % fs) jos (pituus (d) == 0) {stop (".wav-tiedostot eivät ole työhakemistossa")} else {aloita <- aloita [d] loppu <- end [d] selec <- selec [d] sound.files <- sound.files [d]} # Jos rinnakkainen ei ole numeerinen, jos (! is.numeric (parallel)) stop ("'parallel" must olla numeerinen vektori, jonka pituus on 1 "), jos (mikä tahansa (! (rinnakkainen %% 1 == 0), rinnakkainen 1) {vaihtoehdot (varoitus = -1) jos (kaikki (Sys.info () [1] ==" Windows ", needNamespace (" parallelsugar ", hiljaa = TRUE) == TRUE)) lapp <- function (X, FUN) parallelsugar:: mclapply (X, FUN, mc.cores = parallel) else if (Sys.info () [1] == "Windows") {cat ("Windowsin käyttäjien on asennettava" parallelsugar "-paketti rinnakkaislaskentaa varten (et tee sitä nyt!)") Lapp <- pbapply:: pblapply} else lapp <- toiminto (X, FUN) rinnakkainen:: mclapply (X, FUN, mc.cores = parallel)} else lapp <- pbapply:: pblapply options (warn = 0) if (parallel == 1) cat ("Akustisten parametrien mittaaminen:") x <- as.data.frame (lapp (1: pituus (alku), funktio (i) {r <- tuneR:: readWave (tiedosto.polku (getwd (), sound.files ), alkaen = alku , to = loppu , yksiköt = "sekuntia") b katto ([email protected]/2000) - 1) b [2] < - katto ([email protected]/2000) - 1 #taajuusspektrianalyysi kappaletiedot <- seewave:: spec (r, f = [email protected], plot = FALSE) analyysi <- seewave:: specprop (songspec, f = [email protected], flim = c (0, 280/1000), plot = FALSE) #tallenna parametrit meanfreq <- analyysi $ keskiarvo/1000 sd <- analyysi $ sd/1000 mediaani <- analyysi $ mediaani/1000 Q25 < - analyysi $ QQ75 <- analyysi $ QIQR <- analyysi $ IQR/1000 vinossa <- analyysi $ vinous kurt <- analyysi $ kurtosis sp.ent <- analyysi $ sh sfm <- analyysi $ sfm-tila <- analyysi $ mode/1000 centroid <- analyysi $ cent/1000 #Frekvenssi amplitudihuippujen huippuf <- 0 #seewave:: fpeaks (kappaleiden sp, f = [email protected], wl = wl, nmax = 3, plot = FALSE) [1, 1] #Perustaajuuden parametrit ff <- seewave:: fund (r, f = [email protected], ovlp = 50, kynnys = kynnys, fmax = 280, ylim = c (0, 280/1000), plot = FALSE, wl = wl) [, 2] meanfun <-mean (ff, na.rm = T) minfun <-min (ff, na.rm = T) maxfun <-max (ff, na.rm = T) #Dominantti taajuusparametrit y <- seewave:: dfreq (r, f = [email protected], wl = wl, ylim = c (0, 280/1000), ovlp = 0, plot = F, kynnys = kynnys, kaistanpäästö = b * 1000, fftw = TRUE) [, 2] meandom <- keskiarvo (y, na.rm = TRUE) mindom <- min (y, na.rm = TRUE) maxdom <- max (y, na.rm = TOSI) dfrange <- (maxdom- mindom) kesto <- (end - start ) #modulaatioindeksin laskenta muuttuu <- vektori () for (j jossa (! on. na (y))) {muutos <- abs (y [j]- y [j + 1]) muutokset <- liitä (muutokset, muutos)} jos (mindom == maxdom) modindx <-0 muut modindx <- keskiarvo (muutokset, na.rm = T)/dfrange #save results return (c (kesto, keskiarvo, sd, mediaani, Q25, Q75, IQR, vinossa, kurt, sp.ent, sfm, tila, centroid, peakf, meanfun, minfun, maxfun, meandom, mindom, maxdom, dfrange, modindx))})) #Change result names rownames (x) <- c ("duration", "meanfreq", "sd", "mediaani", "Q25", "Q75", "IQR", "vinossa", "kurt", "sp.ent", "sfm", "mode", "centroid", "peakf", "meanfun", "minfun", "maxfun", "meandom", "mindom", "maxdom", "dfrange", "modindx") x <- data.frame (sound.files, selec, as.data.frame (t (x))) kolonnit (x) [1: 2] <- c ("sound.files", "selec") rownames (x) <- c (1: nrow (x)) return (x)}

processFolder <- function (folderName) { # Aloita tyhjällä data.frame-kehyksellä. data <- data.frame () # Hae luettelo kansion tiedostoista. list <- list.files (folderName, '\. wav') # Lisää tiedostoluettelo data.frame-käsittelyyn. for (tiedostonimi luettelossa) {rivi <- data.frame (tiedostonimi, 0, 0, 20) data <- rbind (data, rivi)} # Aseta sarakkeiden nimet. nimet (data) <- c ('sound.files', 'selec', 'start', 'end') # Siirrä käsiteltävään kansioon. setwd (folderName) # Käsittele tiedostoja. akustiikka <- specan3 (data, rinnakkainen = 1) # Siirry takaisin pääkansioon. setwd ('..') akustiikka}

sukupuoli <- toiminto (filePath) {jos (! olemassa ('genderBoosted')) {load ('model.bin')} # Asennuspolut. currentPath <- getwd () fileName <- basename (filePath) polku <- dirname (filePath) # Aseta hakemisto lukemaan tiedosto. setwd (polku) # Aloita tyhjillä tiedoilla.kehys. data <- data.frame (tiedostonimi, 0, 0, 20) # Aseta sarakkeiden nimet. nimet (data) <- c ('sound.files', 'selec', 'start', 'end') # Käsittele tiedostoja. akustiikka <- specan3 (data, rinnakkainen = 1) # Palauta polku. setwd (currentPath) ennustaa (genderCombo, newdata = akustiikka)}

# Lataa tiedot

vuoto <- processFolder ('caminho para o pasta com sample de áudio com vazamento') without_leakage <- processFolder ('caminho para o pasta com sample de áudio sem vazamento')

# Aseta tarrat.

vuoto $ label <- 1 ilman_vuodot $ label <- 2 dataa <- rbind (vuoto, ilman_vuotoa) data $ label <- kerroin (data $ label, labels = c ('vuoto', 'ilman_vuotoa'))

# Poista käyttämättömät sarakkeet.

data $ kesto <- NULL data $ sound.files <- NULL data $ selec <- NULL data $ peakf <- NULL

# Poista rivit, jotka sisältävät NA: ta.

data <- data [täydellinen. tapaukset (data),]

# Kirjoita csv -tietojoukko.

write.csv (data, file = 'features.csv', sep = ',', row.names = F)

Vaihe 11: Rederal Neural

A ideia do uso de uma rede neural, é a de realizar um reconhecimento automatizado através dos dados coletados pelo dispositivo de sensoriamento.

A rede neural utilizada é do tipo MLP (Multilayer Perceptron), model and treinado com dados previamente identifados and após esse treinamento o modelo implantado no system conseguirá realizar a identifação automática do sinal recebido, informando se naquele ponto existe um vazamento ou não.

Tämä on välttämätöntä realisation uma filtragem dos dados de entrada, pois algumas características estavam diminuindo a taxa de acerto da rede ao invés de melhora-la. Não foi realizado nenhuma abordagem estatística muito aprofundada, mas mesmo com um trabalho more pinnaficial pode-se chegar a algumas variáveis com bons desempenhos.

Parantaa kivekset tai mallit obteve um desempenho muito bom, alcançando na maioria dos testes uma taxa de decerto de 100%, como pode ser observado na imagem anexa.

Este algoritmi ja hyödyntäminen treinaarille tai mallille ja rede e retornar a taxa de acerto do mesmo. No system de detecção um algoritmo um pouco diferente seria usado, pois ele realizaria o treino ou receberia um modelo já treinado da nuvem ou de alguma outra fonte e com esse modelo realizaria as predições para cada leitura realizada.

# koodaus: utf-8

tuoda pandoja pd -muodossa

tuoda numpy np: nä sklearn.model_selection tuoda train_test_split kuten tts from sklearn.neural_network import MLPClassifier kuin MLP from sklearn.metrics tuoda luokitus_raportti cr: na sklearn.metrics tuoda confusion_matrix cm: nä

# Leitura dos dados do CSV

df = pd.read_csv ('features.csv') # Separação das entradas df_X = df [df.columns [: len (df.columns) -1] # Filtrando as entradas df_X = df_X

# Separando dados para treino e teste

X_train, X_test, Y_train, Y_test = tts (df_X, df_Y, test_size = 0,1)

# Criando -mallin hermo

modelo = MLP (alpha = 0,0001, learning_rate_init = 0,0001, hidden_layer_sizes = (50, 50, 50, 50), max_iter = 10000, aktivointi = 'tanh', ratkaisija = 'lbfgs')

# Treinando modelo

modelo.fit (X_train, Y_train) tulos = modelo.predict (X_test)

# Imprimindo resultados

raportti = cr (Y_test, tulos) mat = cm (y_pred = tulos, y_true = Y_test) print ("Matriz de confusão") print (mat, end = "\ n / n") print ("Relatório de Classificação") print (raportti)