Sõrmeasendite mõõtmine viiulil ESP32 abil: 6 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:49

Viiuldajana tahtsin alati rakendust või tööriista, mis näitaks mulle väga täpselt sõrmede asukohta viiulil. Selle projektiga proovisin seda ehitada. Kuigi see on prototüüp ja saate siiski lisada palju funktsioone.

Üritasin eraldada ka ESP32 ja rPI ning seega panin ESP32 saatma andmeid rPi -le juhtmevabalt. Mis on selle projekti puhul ilmselt kõige keerulisem.

Samuti on väga oluline, et selle projekti lõpus ei salvestata teie arvutisse midagi, vaid see on kas rPI või ESP32.

Samm: materjalid ja tööriistad

Enne selle projekti loomise spetsiifika juurde asumist vajame mõnda asja.

1. 4x lineaarne pehme pott: lineaarsed potentsiomeetrid sõrme asendi mõõtmiseks (viiulil on 4 keelt)
2. ESP32: ESP32 moodul lineaarsete pehmete pottide andmete lugemiseks.
3. 4/4 viiul: viiul lineaarsete pehmete pottide asetamiseks.
4. Raspberry Pi koos SD -kaardiga: vaarika pi, mis salvestab meie andmebaasi ja veebisaidi.
5. 10k potentsiomeeter: potentsiomeeter LCD -ekraani heleduse jaoks
6. LCD-ekraan: LCD-ekraan, mida näidata rPi IP-aadressidele
7. Jootekomplekt: kõigi elementide jootmiseks
8. Juhtmed isast-meessoost ja isas-naisjuhtmed: Kaablid kõigi elementide ühendamiseks
9. Mikro -USB -kaabel: ESP32 toiteks

Samm: Softpottide ühendamine ESP32 -ga

Kõigepealt peame ühendama oma pehmed potid esp32 -ga. Me ühendame vasaku ja parema tihvti vastavalt 5V ja GND -ga. Ühendame keskmise tihvti ESP32 analoogpistikuga. Peame ühendama ka keskmise tihvti takistusega 10k oomi ja ühendama selle GND -ga. See on nii, et meie pehmete pottide väljund ei tagasta juhuslikku väärtust.

Seejärel ühendame ESP32 mikro -USB -kaabli abil arvutiga, et saaksime sellele koodi üles laadida. ESP32 programmeerimiseks kasutame Arduino IDE -d. Kuid kõigepealt peame ESP32 jaoks installima Arduino tuuma, et saaksime selle üles laadida. Seda saab teha siin.

Siis saame hakata koodi kirjutama.

Kõigepealt peame määrama oma tihvtid, millega me ühendasime oma pehmete pottide keskmise tihvti.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

allkirjastamata kaua onTime;

allkirjastamata pikk softPotTime;

Siis saame oma tihvtid üles seada. Ja me peame alustama oma seeriamonitori ja oma aega.

tühine seadistus () {

onTime = millis ();

Seriaalne algus (115200);

Serial.println ("Programmi algus");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

tühine getdata (bait pdata ) {

// Loe pehme poti ADC väärtus

Siis peame lugema oma nööpnõelad, et saaksime oma andmed kätte saada.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Seejärel paneme väärtused loendisse, et saaksime selle hiljem hõlpsalt väljastada.

jaoks (int i = 0; i <4; i ++) {

int Nimed = {softPotADC1, softPotADC2, softPotADC3, softPotADC4};

int softpot = Nimed ;

kui (pehme pott> 10) {

pdata [0] = i;

pdata [1] = pehme pott;

pdata [2] = millis ();

} } }

}

Samm 3: ESP32 ja RPI juhtmevaba ühendamine

ESP32 ja RPI juhtmevabaks ühendamiseks kasutame raamatukogu nimega websocket. Selle teegi installimiseks saame failid siit. Selle teegi kasutamiseks ESP32 jaoks peame failides ise koodi muutma.

Peame muutma MD5.c ja MD5.h.

• MD5Init kuni MD5InitXXX
• MD5Uuenda versiooniks MD5Uuenda XXX
• MD5Final kuni MD5FinalXXX

Samuti peame kustutama shar -failide avr/io.h read.

Seejärel saame raamatukogu lisada oma Arduino IDE -sse visandiga> lisada raamatukogu> lisada. ZIP -teek ja seejärel saame teie teegi ZIP -failina valida.

Pärast seda saame hakata oma koodi kirjutama.

Esiteks ESP32 jaoks:

Sealhulgas meie raamatukogu

#kaasama #kaasama

Määrame uuesti meie nööpnõelad.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Meie wifi serveri määramine

WiFi -serveri server (80);

Meie veebipesaserveri käivitamine

WebSocketServer webSocketServer;

Meie wifi SSID ja parooli määramine

const char* ssid = "teie wifi SSID";

const char* password = "teie wifi parool";

tühine seadistus () {

Seeriamonitori seadistamine

Seriaalne algus (115200);

Pehmete pottide seadistamine

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Meie wifi käivitamine ja sellega ühenduse loomine

WiFi.begin (ssid, parool);

samas (WiFi.status ()! = WL_CONNECTED) {

viivitus (1000);

Serial.println ("Ühendamine WiFi -ga.."); }

Serial.println ("Ühendatud WiFi -võrguga");

Serial.println (WiFi.localIP ());

server.begin (); viivitus (100); }

tühine getdata (char *pdata) {

Teie andmete lugemine

// Loe pehme poti ADC väärtus

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Andmete paigutamine loendisse ja teisendamine kuueteistkümnendsüsteemi.

sprintf (pdata, " %x, %x, %x, %x, %x", softPotADC1, softPotADC2, softPotADC3, softPotADC4, millis ());

}

void loop () {

Kliendi ühendamine (rPI)

WiFiClient klient = server.available ();

if (client.connected ()) {

viivitus (10);

if (webSocketServer.handshake (klient)) {

Serial.println ("Klient ühendatud");

Andmete saatmine ja vastuvõtmine.

while (client.connected ()) {

char andmed [30];

getdata (andmed);

Serial.println (andmed);

webSocketServer.sendData (andmed);

viivitus (10); // Andmete õigeks vastuvõtmiseks on vaja viivitust}

Serial.println ("Klient katkestas ühenduse");

viivitus (100); }

muu {

Serial.println ("shitsfuckedyo");

} } }

Seejärel pythonis rPI jaoks:

Meie raamatukogude importimine

importige veebipistik impordi aeg

Globale variabeli määramine i

i = 0

Seadistame maksimaalselt 200 sõnumit, mida saame vastu võtta

nrOfMessages = 200

klassi Websocket ():

def _init _ (ise):

Meie veebipesa vormindamine ja selle ühendamine meie ESP32 -ga

self.ws = websocket. WebSocket ()

self.ws.connect ("ws: //172.30.248.48/")

Meie andmete vastuvõtmine

def töö (ise):

self.ws.send ("sõnum nr: 0")

result = self.ws.recv () time.sleep (0.5) return result

Veebipesa sulgemine pärast kõike

def close (ise):

self.ws.close ()

Samm: veebisaidi ja andmebaasi ühendamine

Mis puutub meie andmebaasi ja veebisaidi ühendamisse, siis peate esmalt looma oma andmebaasi pi -le, installides mariadb: sudo apt install mariadb.

Seejärel pääsete juurde, tehes: sudo mariadb.

Siis peate ka oma veebisaidi looma. Saate seda teha nii, nagu soovite, kuid peate kasutama Flaski ja teil peab HTML -is olema vorm andmete peatamiseks ja käivitamiseks.

Seejärel saate selle koodi sisestada oma andmebaasi ja veebisaidi ühendamiseks (nii teie veebisait kui ka andmebaas peavad mõlemad olema teie pi -s, seda saab teha, kasutades pycharmi seadete vahekaarti juurutamine)

saidilt flaskext.mysql importige MySQL

app.config ["MYSQL_DATABASE_HOST"] = "localhost"

app.config ["MYSQL_DATABASE_DB"] = "teie andmebaasi nimi"

app.config ["MYSQL_DATABASE_USER"] = "teie andmebaasi kasutaja"

app.config ["MYSQL_DATABASE_PASSWORD"] = "teie andmebaasi parool"

Funktsioon andmete väljavõtmiseks meie andmebaasist.

def get_data (sql, params = puudub):

conn = mysql.connect ()

kursor = kursor ()

print ("andmete hankimine")

proovige:

prindi (sql)

cursor.execute (sql, params)

välja arvatud erand nagu e:

trükk (e)

tagastama Vale

tulemus = cursor.fetchall ()

andmed =

tulemuse rea jaoks:

data.append (loend (rida))

cursor.close ()

conn.close ()

andmeid tagastama

Funktsioon andmete sisestamiseks meie andmebaasi

def set_data (sql, params = puudub):

conn = mysql.connect ()

kursor = kursor ()

proovige:

log.debug (sql)

cursor.execute (sql, params) conn.commit ()

log.debug ("SQL uitgevoerd")

välja arvatud erand nagu e:

log.exception ("Fout bij uitvoeren van sql: {0})". formaat (e))

tagastama Vale

cursor.close ()

conn.close ()

tagastama Tõsi

Samuti peame oma rakendust lõimima, et saaksite salvestamise ajal muid asju teha.

klassi ThreadedTask (threading. Thread):

def _init _ (ise,):

Niidi seadistamine

niit. Teema._ init _ (ise)

Loendi koostamine kõigi vastuvõetud andmete hoidmiseks

self.data_all =

def run (ise):

uneaeg (5)

Importige oma püütoni kood sinna, kust andmed vastu võtate

importi vastuvõtja_veebipesa

Võtke oma andmed vastu

w = Receive_websocket. Websocket ()

Lisage oma andmed oma loendisse ja printige see.

i jaoks vahemikus (0, 200):

self.data_all.append (w.work (). split (","))

print (self.data_all)

ülesanne = ThreadedTask ()

Seejärel saate lõime käivitamiseks ja andmete vastuvõtmiseks teha ülesande.run ().

Samm: ühendage kõik kokku

Oma veebisaidi haldamiseks oma Pi -st peate kasutama järgmist teenust:

[Ühik] Kirjeldus = uWSGI eksemplar projekti1 veebiliidese teenindamiseks

Pärast = network.target

BindsTo = mysqld.service

Pärast = mysqld.service

[Teenus]

Muutke oma kasutajaks

Kasutaja = pi

Rühm = www-andmed

Siin peate sisestama oma kolbfaili kataloogi

WorkingDirectory =/home/pi/project1/web

Teie ini -faili kataloog, mille leiate hiljem.

ExecStart =/usr/bin/uwsgi --ini /home/pi/project1/conf/uwsgi-flask.ini

[Installi]

WantedBy = mitme kasutaja sihtmärk

uwsgi-flask.ini, mille peate paigutama ülaltoodud ExecStartis määratud kataloogi

[uwsgi] moodul = veeb: rakendus virtualenv =/home/pi/project1/env

kapten = tõelised protsessid = 5

pluginad = python3

pesa = projekt1.sock chmod-socket = 660 vaakum = tõsi

die-on-term = tõsi

Nüüd saate oma andmeid lugeda ja oma veebisaidil kuvada.

6. samm: lisa: LCD -ekraani ühendamine

Saame ühendada LCD-ekraani, et saaksime oma veebisaidi jaoks näidata oma Pi ip-aadressi.

RPi. GPIO importimine GPIO -ks importimisaeg

impordikäsklusi

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

loend = [22, 5, 6, 13, 19, 26, 20, 21]

E = 24

RS = 23

klassi ekraan:

def _init _ (ise):

GPIO.setmode (GPIO. BCM)

self.setup ()

#Funktsioonikomplekt self.stuur_instructie (0x3f) #Display self.stuur_instructie (0x0c) #On + kursor self.stuur_instructie (0x01) @staticmethod def setup (): GPIO.setup (list, GPIO. OUT) GPIO.setup ([E, RS], GPIO. OUT)

def stuur_instructie (ise, bait):

GPIO väljund (E, GPIO. HIGH)

GPIO väljund (RS, GPIO. LOW)

self.set_GPIO_bits (bait)

uneaeg (0,005)

GPIO väljund (E, GPIO. LOW)

def stuur_teken (ise, sümbol):

temp = ord (char)

GPIO väljund (E, GPIO. HIGH)

GPIO väljund (RS, GPIO. HIGH)

self.set_GPIO_bits (temp)

uneaeg (0,005)

GPIO väljund (E, GPIO. LOW)

def set_GPIO_bits (ise, bait):

i jaoks vahemikus (0, 8):

kui (bait & (2 ** i)) == 0:

GPIO.väljund (loend , GPIO. LOW)

muidu:

GPIO.väljund (loend , GPIO. HIGH)

def main ():

s = ekraan ()

teken = "Kohalik IP -aadress:"

kirja jaoks tekenis:

s.stuur_teken (kiri)

teken2 = commands.getoutput ("ip addr show wlan0 | grep -Po 'inet / K [d.]+'")

trükk (teken2)

s.stuur_instructie (0xc0)

kirja 2 jaoks teken2 -s:

s.stuur_teken (letter2)

kui _name_ == '_main_': #Programm algab siit

proovige:

peamine ()

välja arvatud klaviatuur Katkestus:

üle andma

Seejärel saame luua teenuse LCD käivitamiseks käivitamisel.