Meet vingerposisies op 'n viool met ESP32: 6 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

As vioolspeler wou ek altyd 'n app of 'n instrument hê wat my die posisie van my vingers op die viool baie presies kon wys. Met hierdie projek het ek probeer om dit te bou. Alhoewel dit 'n prototipe is en u nog baie funksies kan byvoeg.

Ek het ook probeer om die ESP32 en die rPI te skei en daarom het ek die ESP32 data draadloos na die rPi laat stuur. Dit is waarskynlik die moeilikste van hierdie projek.

Dit is ook baie belangrik dat aan die einde van hierdie projek niks op u rekenaar gestoor word nie, maar dit is óf op die rPI óf ESP32.

Stap 1: materiaal en gereedskap

Voordat ons die besonderhede van die bou van hierdie projek bespreek, benodig ons 'n paar dinge.

1. 4x Lineêre sagtepot: Lineêre potensiometers om die posisie van 'n vinger te meet ('n viool het 4 snare)
2. ESP32: 'n ESP32 -module om die data van die lineêre softpots te lees.
3. 'n 4/4 viool: 'n viool om die lineêre sagte potte bo -op te plaas.
4. 'n Framboos Pi met 'n SD kaart: 'n framboos pi wat ons databasis en webwerf sal stoor.
5. 10k potensiometer: 'n potensiometer vir die helderheid van die LCD
6. LCD-skerm: 'n LCD-skerm om aan die ip-addres van die rPi te wys
7. Soldeerset: Vir soldeer al die elemente saam
8. Man-tot-man-drade en man-tot-vroulike drade: Kabels om al die elemente te verbind
9. Mikro -USB -kabel: vir die voeding van die ESP32

Stap 2: Koppel die Softpots aan die ESP32

Eerstens moet ons ons softpots koppel aan die esp32. Ons verbind die linker en regter penne met onderskeidelik die 5V en GND. Ons verbind die middelste pen met 'n analoog pen op die ESP32. Ons moet ook die middelste pen met 'n weerstand van 10k ohm verbind en dit aan die GND koppel. Dit is sodat ons uitset van die softpots nie ewekansige waarde oplewer nie.

Dan koppel ons die ESP32 met die mikro -usb -kabel aan ons rekenaar sodat ons die kode kan oplaai. Ons sal die Arduino IDE gebruik vir die programmering van die ESP32. Maar eers moet ons die Arduino -kern vir die ESP32 installeer sodat ons dit kan oplaai. Dit kan hier gedoen word.

Dan kan ons begin om kode te skryf.

Eerstens moet ons ons penne toewys waaraan ons ons middelste pen van die sagte potte verbind het.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

ongetekende lang tyd;

ongetekende lang softPotTime;

Dan kan ons ons penne opsit. En ons moet ons seriële monitor en ons tyd begin.

ongeldige opstelling () {

onTime = millis ();

Serial.begin (115200);

Serial.println ("Program begin");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

ongeldige getdata (byte pdata ) {

// Lees die ADC -waarde van die sagtepot in

Dan moet ons ons penne lees sodat ons ons data kan ontvang.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Dan plaas ons die waardes in 'n lys sodat ons dit later maklik kan uitvoer.

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

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

int softpot = Name ;

as (sagtepot> 10) {

pdata [0] = i;

pdata [1] = sagtepot;

pdata [2] = millis ();

} } }

}

Stap 3: Verbind die ESP32 en die RPI draadloos

Om die ESP32 en RPI draadloos aan te sluit, gebruik ons 'n biblioteek genaamd websocket. Om hierdie biblioteek te installeer, kan ons die lêers hier kry. Ons sal 'n kode in die lêers self moet verander om hierdie biblioteek vir die ESP32 te kan gebruik.

Ons sal die MD5.c en MD5.h. moet verander

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

Ons sal ook die avr/io.h -reëls in die sha1 -lêers moet verwyder.

Dan kan ons die biblioteek by ons Arduino IDE voeg deur skets> biblioteek insluit> by te voeg. ZIP biblioteek en dan kan ons u biblioteek in 'n zip -lêer kies.

Daarna kan ons ons kode begin skryf.

Eerstens vir die ESP32:

Insluitend ons biblioteek

#include #include

Ken ons penne weer toe.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Ken ons wifi -bediener toe

WiFiServer -bediener (80);

Begin ons websocket -bediener

WebSocketServer webSocketServer;

Ken ons SSID en wagwoord van u wifi toe

const char* ssid = "jou wifi SSID";

const char* password = "jou wifi wagwoord";

ongeldige opstelling () {

Stel u seriële monitor op

Serial.begin (115200);

Stel u sagte potte op

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Begin ons wifi en maak daarmee verbinding

WiFi.begin (ssid, wagwoord);

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

vertraging (1000);

Serial.println ("Koppel aan WiFi.."); }

Serial.println ("gekoppel aan die WiFi -netwerk");

Serial.println (WiFi.localIP ());

bediener.begin (); vertraging (100); }

ongeldige getdata (char *pdata) {

Lees u data

// Lees in die sagte pot se ADC -waarde

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Plaas die data in 'n lys en omskep dit in heksadesimaal.

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

}

leemte -lus () {

Koppel u kliënt (die rPI)

WiFiClient -kliënt = server.available ();

as (client.connected ()) {

vertraging (10);

if (webSocketServer.handshake (kliënt)) {

Serial.println ("Kliënt gekoppel");

Stuur en ontvang data.

terwyl (client.connected ()) {

char data [30];

getdata (data);

Serial.println (data);

webSocketServer.sendData (data);

vertraging (10); // Vertraging nodig om die data korrek te ontvang}

Serial.println ("Die kliënt ontkoppel");

vertraging (100); }

anders {

Serial.println ("shitsfuckedyo");

} } }

Dan vir die rPI in python:

Die invoer van ons biblioteke

invoer websocketimport tyd

Die toekenning van 'n globale veranderlike i

ek = 0

Stel 'n maksimum van 200 boodskappe in wat ons kan ontvang

nrOfMessages = 200

klas Websocket ():

def _init _ (self):

Ons websocket initialiseer en koppel dit aan ons ESP32

self.ws = websocket. WebSocket ()

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

Ontvangs van ons data

def work (self):

self.ws.send ("boodskap nr: 0")

resultaat = self.ws.recv () time.sleep (0.5) opbrengs resultaat

Maak die websocket toe nadat u alles ontvang het

def sluit (self):

self.ws.close ()

Stap 4: Koppel u webwerf en databasis

Wat die koppeling van ons databasis en webwerf betref, moet u eerstens u databasis op die pi skep deur mariadb te installeer: sudo apt install mariadb.

Dan kan u dit verkry deur: sudo mariadb.

Dan moet u ook u webwerf skep. U kan dit doen soos u wil, maar u moet Flask gebruik en u moet 'n vorm in u HTML hê om u data te stop en te begin.

Dan kan u hierdie kode invoeg om u databasis en u webwerf te verbind (beide u webwerf en databasis moet beide op u pi wees; dit kan gedoen word deur die implementeringsoortjie in die instellings van pycharm te gebruik)

vanaf flaskext.mysql voer MySQL in

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

app.config ["MYSQL_DATABASE_DB"] = "u databasisnaam"

app.config ["MYSQL_DATABASE_USER"] = "u databasisgebruiker"

app.config ["MYSQL_DATABASE_PASSWORD"] = "u databasiswagwoord"

Funksie om data uit ons databasis te haal.

def get_data (sql, params = None):

conn = mysql.connect ()

wyser = conn.cursor ()

print ("kry data")

probeer:

druk (sql)

cursor.execute (sql, params)

behalwe Uitsondering as e:

druk (e)

terugkeer vals

resultaat = cursor.fetchall ()

data =

vir ry in resultaat:

data. voeg by (lys (ry))

cursor.close ()

verbind. sluit ()

data terugstuur

Funksie om data in ons databasis in te voeg

def set_data (sql, params = None):

conn = mysql.connect ()

wyser = conn.cursor ()

probeer:

log.debug (sql)

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

log.debug ("SQL uitgevoer")

behalwe Uitsondering as e:

log.exception ("Uitvoer van SQL: {0})". formaat (e))

terugkeer vals

cursor.close ()

verbind. sluit ()

terugkeer Waar

Ons sal ook ons aansoek moet dra, sodat u ander dinge kan doen terwyl u opneem.

klas ThreadedTask (threading. Thread):

def _init _ (self,):

Stel draad op

threading. Thread._ init _ (self)

Maak 'n lys om al u ontvangde data te bewaar

self.data_all =

def run (self):

tyd. slaap (5)

Voer u eie python -kode in waar u die data ontvang

voer ontvang_websocket in

Ontvang u data

w = ontvang_websocket. Websocket ()

Voeg u data by u lys en druk dit af.

vir i in reeks (0, 200):

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

druk (self.data_all)

taak = ThreadedTask ()

Dan kan u task.run () doen om u draad te begin en data te ontvang.

Stap 5: Verbind alles saam

Om u webwerf vanaf u Pi te bestuur, moet u 'n diens gebruik:

[Eenheid] Beskrywing = uWSGI -instansie om die webkoppelvlak van project1 te bedien

Na = netwerk.doel

BindsTo = mysqld.service

Na = mysqld.service

[Diens]

Verander na u gebruiker

Gebruiker = pi

Groep = www-data

Hier moet u u gids van u Flask -lêer invoer

WorkingDirectory =/home/pi/project1/web

Gids van u ini -lêer wat later gevind kan word.

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

[Installeer]

WantedBy = multi-user.target

uwsgi-flask.ini wat u moet plaas in die gids wat u in ExecStart hierbo gespesifiseer het

[uwsgi] module = web: app virtualenv =/home/pi/project1/env

meester = ware prosesse = 5

inproppe = python3

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

sterf-op-term = waar

Nou kan u u data lees en dit op u webwerf vertoon.

Stap 6: Ekstra: Koppel LCD -skerm

Ons kan 'n LCD-skerm aansluit sodat ons die ip-adres van ons Pi vir ons webwerf kan wys.

voer RPi. GPIO in as GPIO -invoertyd

invoeropdragte

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

klas skerm:

def _init _ (self):

GPIO.setmode (GPIO. BCM)

self.setup ()

#Funksieset self.stuur_instructie (0x3f) #Toon self.stuur_instructie (0x0c) #Aan + wyser self.stuur_instructie (0x01) @staticmethod def setup (): GPIO.setup (lys, GPIO. OUT) GPIO.setup ([E, RS], GPIO. OUT)

def stuur_instructie (self, byte):

GPIO.output (E, GPIO. HIGH)

GPIO.output (RS, GPIO. LOW)

self.set_GPIO_bits (byte)

tyd. slaap (0,005)

GPIO.output (E, GPIO. LOW)

def stuur_teken (self, char):

temp = ord (char)

GPIO.output (E, GPIO. HIGH)

GPIO.output (RS, GPIO. HIGH)

self.set_GPIO_bits (temp)

tyd. slaap (0,005)

GPIO.output (E, GPIO. LOW)

def set_GPIO_bits (self, byte):

vir i in reeks (0, 8):

as (byte & (2 ** i)) == 0:

GPIO.output (lys , GPIO. LOW)

anders:

GPIO.output (lys , GPIO. HIGH)

def main ():

s = Skerm ()

teken = "Plaaslike IP -adres:"

vir letter in teken:

s.stuur_teken (brief)

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

druk (teken2)

s.stuur_instructie (0xc0)

vir letter2 in teken2:

s.stuur_teken (letter2)

as _name_ == '_main_': #Program wat van hier af begin

probeer:

hoof ()

behalwe KeyboardInterrupt:

slaag

Dan kan ons 'n diens skep om die LCD by die aanvang te begin.