Merjenje položaja prstov na violini z ESP32: 6 korakov

2025 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2025-01-23 15:09

Kot violinist sem si vedno želel aplikacijo ali orodje, ki bi mi lahko zelo natančno pokazalo položaj mojih prstov na violini. S tem projektom sem to poskušal zgraditi. Čeprav je to prototip in lahko še vedno dodate veliko funkcij.

Poskušal sem tudi ločiti ESP32 in rPI, zato sem ESP32 brezžično pošiljal podatke na rPi. Kar je verjetno najtežje pri tem projektu.

Zelo pomembno je tudi, da na koncu tega projekta na vašem računalniku ni nič shranjenega, ampak je bodisi na rPI ali ESP32.

Korak: Materiali in orodja

Preden se lotimo posebnosti gradnje tega projekta, potrebujemo nekaj stvari.

1. 4x Linear Softpot: Linearni potenciometri za merjenje položaja prsta (violina ima 4 strune)
2. ESP32: Modul ESP32 za branje podatkov iz linearnih softpotov.
3. violina 4/4: violina za postavitev linearnih softpotov na vrh.
4. Raspberry Pi s kartico SD: malina pi, ki bo shranjevala našo bazo podatkov in spletno mesto.
5. 10k potenciometer: potenciometer za svetlost LCD zaslona
6. LCD zaslon: LCD zaslon za prikaz naslovov ip rPi
7. Komplet za spajkanje: Za spajkanje vseh elementov skupaj
8. Moški in moški žice in žice moški-ženska: kabli za povezavo vseh elementov
9. Kabel mikro USB: Za napajanje ESP32

Korak: Priključitev mehkih točk na ESP32

Najprej moramo naše softpote povezati z esp32. Levi in desni zatič priključimo na 5V oziroma GND. Srednji zatič povežemo z analognim zatičem na ESP32. Prav tako moramo povezati srednji zatič z upornostjo 10 k ohm in ga priključiti na GND. To je zato, da naš rezultat softpotov ne vrne naključne vrednosti.

Nato priključimo ESP32 s kablom micro usb na računalnik, da lahko vanj naložimo kodo. Za programiranje ESP32 bomo uporabili Arduino IDE. Najprej pa moramo namestiti jedro Arduino za ESP32, da ga lahko naložimo. To lahko storite tukaj.

Potem lahko začnemo pisati kodo.

Najprej moramo dodeliti naše zatiče, na katere smo povezali naš srednji zatič mehkih točk.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

dolgo podpisano brez podpisa;

brez podpisa dolg softPotTime;

Potem lahko nastavimo zatiče. Začeti moramo s serijskim monitorjem in časom.

void setup () {

onTime = millis ();

Serial.begin (115200);

Serial.println ("Zagon 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 ) {

// Preberite vrednost ADC mehkega lonca

Nato moramo prebrati svoje zatiče, da lahko prejmemo svoje podatke.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogno branje (SOFT_POT_PIN2);

int softPotADC3 = analogno branje (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Nato damo vrednosti na seznam, da jih lahko pozneje enostavno prikažemo.

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] = milis ();

} } }

}

3. korak: Brezžično povežite ESP32 in RPI

Za brezžično povezavo ESP32 in RPI bomo uporabili knjižnico, imenovano websocket. Za namestitev te knjižnice lahko dobimo datoteke tukaj. Za uporabo te knjižnice za ESP32 bomo morali spremeniti nekaj kode v samih datotekah.

Morali bomo spremeniti MD5.c in MD5.h.

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

Prav tako bomo morali izbrisati vrstice avr/io.h v datotekah sha1.

Nato lahko knjižnico dodamo v naš Arduino IDE tako, da skiciramo> vključimo knjižnico> dodamo knjižnico. ZIP, nato pa lahko izberemo vašo knjižnico v datoteki zip.

Po tem lahko začnemo pisati svojo kodo.

Najprej za ESP32:

Vključno z našo knjižnico

#include #include

Spet dodeljujemo nožice.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Dodelitev našega wifi strežnika

Strežnik WiFiServer (80);

Zagon našega strežnika websocket

WebSocketServer webSocketServer;

Določimo naš SSID in geslo za vaš WiFi

const char* ssid = "vaš Wi -Fi SSID";

const char* password = "vaše geslo za wifi";

void setup () {

Nastavitev serijskega monitorja

Serial.begin (115200);

Nastavitev programskih točk

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Zagon našega WiFi in povezovanje z njim

WiFi.begin (ssid, geslo);

medtem ko (WiFi.status ()! = WL_CONNECTED) {

zamuda (1000);

Serial.println ("Povezovanje z WiFi.."); }

Serial.println ("Povezano z omrežjem WiFi");

Serial.println (WiFi.localIP ());

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

void getdata (char *pdata) {

Branje vaših podatkov

// Preberite vrednost ADC mehkega lonca

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogno branje (SOFT_POT_PIN2);

int softPotADC3 = analogno branje (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Dajanje podatkov na seznam in njihovo pretvorbo v šestnajstiško.

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

}

void loop () {

Povezovanje odjemalca (rPI)

Odjemalec WiFiClient = server.available ();

if (client.connected ()) {

zamuda (10);

if (webSocketServer.handshake (client)) {

Serial.println ("Odjemalec povezan");

Pošiljanje in prejemanje podatkov.

medtem ko (client.connected ()) {

podatki char [30];

getdata (podatki);

Serial.println (podatki);

webSocketServer.sendData (podatki);

zamuda (10); // Zakasnitev, potrebna za pravilen sprejem podatkov}

Serial.println ("Odjemalec odklopljen");

zamuda (100); }

drugače {

Serial.println ("shitsfuckedyo");

} } }

Nato za rPI v pythonu:

Uvoz naših knjižnic

uvoz websocketimport časa

Določitev globale variabel i

i = 0

Nastavitev največ 200 sporočil, ki jih lahko prejmemo

nrOfMessages = 200

razred Websocket ():

def _init _ (samo):

Inicializirajte naš spletni vtičnico in ga povežite z našim ESP32

self.ws = websocket. WebSocket ()

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

Prejemanje naših podatkov

def delo (samo):

self.ws.send ("št. sporočila: 0")

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

Zapiranje spletnega vtičnice po prejemu vsega

def close (self):

self.ws.close ()

4. korak: Povežite svoje spletno mesto in bazo podatkov

Kar zadeva povezovanje naše baze podatkov in spletnega mesta, boste morali najprej ustvariti svojo bazo podatkov na pi z namestitvijo mariadb: sudo apt install mariadb.

Do tega lahko dostopate tako: sudo mariadb.

Nato boste morali ustvariti tudi svojo spletno stran. To lahko storite tako, kot želite, vendar morate uporabiti Flask in v HTML -ju morate imeti obrazec za ustavitev in zagon podatkov.

Nato lahko vnesete to kodo, da povežete svojo bazo podatkov in vaše spletno mesto (tako vaše spletno mesto kot zbirka podatkov morata biti na vašem pi, to lahko storite z uporabo zavihka za uvajanje v nastavitvah pycharma)

iz flaskext.mysql uvozite MySQL

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

app.config ["MYSQL_DATABASE_DB"] = "ime vaše baze podatkov"

app.config ["MYSQL_DATABASE_USER"] = "vaš uporabnik baze podatkov"

app.config ["MYSQL_DATABASE_PASSWORD"] = "geslo vaše baze podatkov"

Funkcija za pridobivanje podatkov iz naše baze podatkov.

def get_data (sql, params = Brez):

conn = mysql.connect ()

cursor = conn.cursor ()

print ("pridobivanje podatkov")

poskusi:

tiskanje (sql)

cursor.execute (sql, params)

razen izjeme kot e:

tisk (e)

return False

rezultat = cursor.fetchall ()

podatki =

za vrstico v rezultatu:

data.append (seznam (vrstica))

cursor.close ()

conn.close ()

vrniti podatke

Funkcija za vstavljanje podatkov v našo bazo podatkov

def set_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

poskusi:

log.debug (sql)

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

log.debug ("SQL uitgevoerd")

razen izjeme kot e:

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

return False

cursor.close ()

conn.close ()

vrni True

Našo aplikacijo bomo morali priviti tudi v nit, da boste lahko med snemanjem počeli druge stvari.

razred ThreadedTask (threading. Thread):

def _init _ (self,):

Nastavitev niti

threading. Thread._ init _ (self)

Ustvarjanje seznama za shranjevanje vseh prejetih podatkov

self.data_all =

def run (self):

time.sleep (5)

Uvozite svojo kodo python, kjer prejemate podatke

uvoz receive_websocket

Prejemajte svoje podatke

w = sprejeti_websocket. Websocket ()

Dodajte svoje podatke na seznam in jih natisnite.

za i v območju (0, 200):

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

tiskanje (self.data_all)

opravilo = ThreadedTask ()

Nato lahko naredite task.run (), da zaženete nit in začnete prejemati podatke.

5. korak: Povežite vse skupaj

Za zagon svojega spletnega mesta s svojega Pi morate uporabiti storitev:

[Enota] Opis = primerek uWSGI, ki služi spletnemu vmesniku project1

Za = network.target

BindsTo = mysqld.service

After = mysqld.service

[Storitev]

Spremenite v svojega uporabnika

Uporabnik = pi

Skupina = www-podatki

Tukaj morate vnesti imenik datoteke Flask

WorkingDirectory =/home/pi/project1/web

Imenik vaše datoteke ini, ki ga lahko najdete pozneje.

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

[Namesti]

WantedBy = cilj za več uporabnikov

uwsgi-flask.ini, ki ga morate postaviti v imenik, ki ste ga navedli v ExecStart zgoraj

[uwsgi] modul = splet: app virtualenv =/home/pi/project1/env

master = resnični procesi = 5

vtičniki = python3

socket = project1.sock chmod-socket = 660 vakuum = res

die-on-term = res

Zdaj lahko preberete svoje podatke in jih prikažete na svojem spletnem mestu.

6. korak: Dodatno: Priključitev LCD zaslona

LCD zaslon lahko povežemo, da lahko za našo spletno stran prikažemo ip-naslov našega Pi-ja.

uvozite RPi. GPIO kot GPIOimportni čas

ukazi za uvoz

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

razred zaslon:

def _init _ (samo):

Način GPIO.set (GPIO. BCM)

self.setup ()

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

def stuur_instructie (self, byte):

Izhod GPIO (E, GPIO. HIGH)

GPIO.izhod (RS, GPIO. LOW)

self.set_GPIO_bits (bajt)

time.sleep (0,005)

Izhod GPIO (E, GPIO. LOW)

def stuur_teken (self, char):

temp = ord (char)

Izhod GPIO. (E, GPIO. HIGH)

GPIO.izhod (RS, GPIO. HIGH)

self.set_GPIO_bits (temp)

time.sleep (0,005)

Izhod GPIO (E, GPIO. LOW)

def set_GPIO_bits (self, byte):

za i v območju (0, 8):

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

Izhod GPIO. (seznam , GPIO. LOW)

drugače:

Izhod GPIO. (seznam , GPIO. HIGH)

def main ():

s = Zaslon ()

teken = "Lokalni naslov IP:"

za črko v tekenu:

s.stuur_teken (črka)

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

tiskanje (teken2)

s.stuur_instructie (0xc0)

za črko2 v teken2:

s.stuur_teken (črka2)

if _name_ == '_main_': #Program se začne od tu

poskusi:

main ()

razen KeyboardInterrupt:

prehod

Nato lahko ustvarimo storitev za zagon LCD-ja ob zagonu.