Mjerenje položaja prstiju na violini sa ESP32: 6 koraka

2024 Autor: John Day | [email protected]. Zadnja izmjena: 2024-01-30 08:08

Kao violinista uvijek sam želio aplikaciju ili alat koji bi mi mogao pokazati položaj prstiju na violini vrlo precizan. Ovim projektom sam pokušao ovo izgraditi. Iako je ovo prototip i još uvijek možete dodati mnoge značajke.

Takođe sam pokušao da odvojim ESP32 i rPI i tako sam učinio da ESP32 šalje podatke bežično na rPi. Što je vjerovatno najteža stvar u ovom projektu.

Također je vrlo važno da se na kraju ovog projekta ništa ne pohrani na vašem računaru, već se nalazi na rPI -u ili ESP32.

Korak 1: Materijali i alati

Prije nego što uđemo u specifičnosti izgradnje ovog projekta potrebno nam je nekoliko stvari.

1. 4x linearni softpot: linearni potenciometri za mjerenje položaja prsta (violina ima 4 žice)
2. ESP32: ESP32 modul za čitanje podataka iz linearnih softpotova.
3. violina 4/4: violina za postavljanje linearnih softpotova na vrh.
4. Raspberry Pi sa SD karticom: malina pi koja će pohraniti našu bazu podataka i web stranicu.
5. 10k potenciometar: potenciometar za osvjetljenje LCD -a
6. LCD ekran: LCD ekran za prikaz ip adresama rPi-ja
7. Komplet za lemljenje: Za lemljenje svih elemenata zajedno
8. Žice muški na muški i žice muški na ženski: Kablovi za povezivanje svih elemenata
9. Mikro USB kabel: Za napajanje ESP32

Korak 2: Spajanje softpotova na ESP32

Prije svega moramo povezati naše softpotove s esp32. Priključujemo lijevi i desni pinove na 5V i GND. Srednji pin povezujemo na analogni pin na ESP32. Također moramo spojiti srednji pin otpora 10k ohma i spojiti ga na GND. To je tako da naš izlaz softpotova ne vraća slučajnu vrijednost.

Zatim povezujemo ESP32 mikro USB kablom sa računarom kako bismo na njega učitali kôd. Za programiranje ESP32 koristit ćemo Arduino IDE. Ali prvo moramo instalirati Arduino jezgro za ESP32 kako bismo ga mogli učitati. To se može učiniti ovdje.

Tada možemo početi pisati kod.

Prvo moramo dodijeliti naše pinove na koje smo povezali naš srednji pin softpotova.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

unsigned long onTime;

unsigned long softPotTime;

Tada možemo postaviti svoje igle. Moramo pokrenuti naš serijski monitor i svoje vrijeme.

void setup () {

onTime = millis ();

Serial.begin (115200);

Serial.println ("Pokretanje programa");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

void getdata (bajt pdata ) {

// Očitajte ADC vrijednost soft potke

Zatim moramo pročitati naše pinove kako bismo mogli primiti naše podatke.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Zatim stavljamo vrijednosti na popis kako bismo ih kasnije mogli lako ispisati.

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

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

int softpot = Imena ;

if (softpot> 10) {

pdata [0] = i;

pdata [1] = softpot;

pdata [2] = millis ();

} } }

}

Korak 3: Bežično povežite ESP32 i RPI

Za bežično povezivanje ESP32 i RPI koristit ćemo biblioteku koja se zove websocket. Da bismo instalirali ovu biblioteku, datoteke možemo nabaviti ovdje. Morat ćemo promijeniti neki kôd u samim datotekama da bismo mogli koristiti ovu biblioteku za ESP32.

Morat ćemo promijeniti MD5.c i MD5.h.

• MD5Init do MD5InitXXX
• MD5Update to MD5UpdateXXX
• MD5Final do MD5FinalXXX

Također ćemo morati izbrisati avr/io.h redove u sha1 datotekama.

Zatim možemo dodati biblioteku u naš Arduino IDE skicom> uključiti biblioteku> dodati. ZIP biblioteku i tada možemo odabrati vašu biblioteku u zip datoteci.

Nakon toga možemo početi pisati naš kôd.

Prvo za ESP32:

Uključujući i našu biblioteku

#include #include

Ponovo dodjeljujemo naše igle.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Dodjeljivanje našeg WiFi servera

WiFiServer server (80);

Pokretanje našeg websocket servera

WebSocketServer webSocketServer;

Dodjeljivanje našeg SSID -a i lozinke za vaš WiFi

const char* ssid = "vaš WiFi WiFi";

const char* password = "vaša WiFi lozinka";

void setup () {

Postavljanje serijskog monitora

Serial.begin (115200);

Postavljanje softpotova

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Pokretanje našeg WiFi -ja i povezivanje s njim

WiFi.begin (ssid, lozinka);

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

kašnjenje (1000);

Serial.println ("Povezivanje na WiFi.."); }

Serial.println ("Povezano na WiFi mrežu");

Serial.println (WiFi.localIP ());

server.begin (); kašnjenje (100); }

void getdata (char *pdata) {{100} {101}

Čitanje vaših podataka

// Očitajte ADC vrijednost soft potke

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Postavljanje podataka na listu i njihovo pretvaranje u heksadecimalno.

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

}

void loop () {{100} {101}

Povezivanje vašeg klijenta (rPI)

WiFiClient klijent = server.available ();

if (client.connected ()) {

kašnjenje (10);

if (webSocketServer.handshake (client)) {

Serial.println ("Klijent povezan");

Slanje i primanje podataka.

while (client.connected ()) {

char podaci [30];

getdata (podaci);

Serial.println (podaci);

webSocketServer.sendData (podaci);

kašnjenje (10); // Kašnjenje potrebno za ispravan prijem podataka}

Serial.println ("Klijent je isključen");

kašnjenje (100); }

else {

Serial.println ("shitsfuckedyo");

} } }

Zatim za rPI u pythonu:

Uvoz naših biblioteka

uvoz websocketimport vremena

Određivanje globalne varijable i

i = 0

Postavljanje maksimalno 200 poruka koje možemo primiti

nrOfMessages = 200

klasa Websocket ():

def _init _ (samo):

Pokretanje našeg web priključka i njegovo povezivanje s našim ESP32

self.ws = websocket. WebSocket ()

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

Primanje naših podataka

def work (self):

self.ws.send ("br. poruke: 0")

rezultat = self.ws.recv () time.sleep (0.5) povratni rezultat

Zatvaranje websocketa nakon primitka svega

def close (self):

self.ws.close ()

Korak 4: Povezivanje vaše web stranice i baze podataka

Što se tiče povezivanja naše baze podataka i web stranice, prije svega ćete morati stvoriti svoju bazu podataka na pi instaliranjem mariadb: sudo apt install mariadb.

Tada mu možete pristupiti na sljedeći način: sudo mariadb.

Tada ćete također morati stvoriti svoju web stranicu. To možete učiniti kako god želite, ali morate koristiti Flask i morate imati obrazac u HTML -u za zaustavljanje i pokretanje podataka.

Zatim možete umetnuti ovaj kôd za povezivanje vaše baze podataka i vaše web stranice (i vaša web stranica i baza podataka moraju biti na vašem pi, to se može učiniti pomoću kartice za implementaciju u postavkama pycharma)

sa flaskext.mysql uvezite MySQL

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

app.config ["MYSQL_DATABASE_DB"] = "naziv vaše baze podataka"

app.config ["MYSQL_DATABASE_USER"] = "korisnik vaše baze podataka"

app.config ["MYSQL_DATABASE_PASSWORD"] = "lozinka vaše baze podataka"

Funkcija za uklanjanje podataka iz naše baze podataka.

def get_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

print ("dobivanje podataka")

probaj:

ispis (sql)

cursor.execute (sql, params)

osim izuzetka kao e:

ispis (e)

return False

rezultat = cursor.fetchall ()

podaci =

za red u rezultatu:

data.append (lista (red))

cursor.close ()

conn.close ()

vratiti podatke

Funkcija za umetanje podataka u našu bazu podataka

def set_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

probaj:

log.debug (sql)

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

log.debug ("SQL uitgevoerd")

osim izuzetka kao e:

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

return False

cursor.close ()

conn.close ()

return True

Također ćemo morati provući našu aplikaciju kako biste mogli raditi druge stvari dok snimate.

klasa ThreadedTask (threading. Thread):

def _init _ (self,):

Postavljanje niti

threading. Thread._ init _ (samo)

Kreiranje liste za čuvanje svih vaših primljenih podataka

self.data_all =

def run (self):

time.sleep (5)

Uvezite vlastiti python kod gdje primate podatke

import receive_websocket

Primite svoje podatke

w = receive_websocket. Websocket ()

Dodajte svoje podatke na listu i odštampajte ih.

za i u rasponu (0, 200):

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

ispis (self.data_all)

task = ThreadedTask ()

Zatim možete učiniti task.run () da pokrenete svoju nit i počnete primati podatke.

Korak 5: Povežite sve zajedno

Za pokretanje svoje web stranice s vašeg Pi morate koristiti uslugu:

[Jedinica] Opis = uWSGI instanca za opsluživanje web1 sučelja project1

After = network.target

BindsTo = mysqld.service

After = mysqld.service

[Usluga]

Promijenite na svog korisnika

Korisnik = pi

Grupa = www-podaci

Ovdje morate unijeti svoj direktorij svoje Flask datoteke

WorkingDirectory =/home/pi/project1/web

Direktorij vaše ini datoteke koji se može pronaći kasnije.

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

[Instaliraj]

WantedBy = višekorisnički cilj

uwsgi-flask.ini koji morate postaviti u direktorij koji ste naveli u ExecStart-u gore

[uwsgi] modul = web: aplikacija virtualenv =/home/pi/project1/env

master = pravi procesi = 5

dodaci = python3

socket = project1.sock chmod-socket = 660 vakuum = tačno

die-on-term = true

Sada možete pročitati svoje podatke i prikazati ih na svojoj web stranici.

Korak 6: Dodatno: Povezivanje LCD ekrana

Možemo povezati LCD ekran tako da možemo prikazati ip-adresu našeg Pi-a za našu web stranicu.

uvezite RPi. GPIO kao GPIOimport vreme

naredbe za uvoz

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

razred ekran:

def _init _ (samo):

Način rada GPIO.set (GPIO. BCM)

self.setup ()

#Skup funkcija self.stuur_instructie (0x3f) #Display self.stuur_instructie (0x0c) #On + cursor self.stuur_instructie (0x01) @staticmethod def setup (): GPIO.setup (lista, GPIO. OUT) GPIO.setup ([E, RS], GPIO. OUT)

def stuur_instructie (self, byte):

GPIO.izlaz (E, GPIO. HIGH)

GPIO.izlaz (RS, GPIO. LOW)

self.set_GPIO_bits (bajt)

time.sleep (0.005)

GPIO.izlaz (E, GPIO. LOW)

def stuur_teken (self, char):

temp = ord (char)

GPIO.izlaz (E, GPIO. HIGH)

GPIO.izlaz (RS, GPIO. HIGH)

self.set_GPIO_bits (temp)

time.sleep (0.005)

GPIO.izlaz (E, GPIO. LOW)

def set_GPIO_bits (self, byte):

za i u rasponu (0, 8):

if (bajt & (2 ** i)) == 0:

GPIO.izlaz (lista , GPIO. LOW)

drugo:

GPIO.izlaz (lista , GPIO. HIGH)

def main ():

s = Ekran ()

teken = "Lokalna IP adresa:"

za pismo u tekenu:

s.stuur_teken (slovo)

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

ispis (teken2)

s.stuur_instructie (0xc0)

za pismo2 u teken2:

s.stuur_teken (slovo 2)

if _name_ == '_main_': #Program počinje odavde

probaj:

main ()

osim KeyboardInterrupt:

pass

Tada možemo stvoriti uslugu za pokretanje LCD-a pri pokretanju.