Måling av fingerposisjoner på en fiolin med ESP32: 6 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

Som fiolinspiller ville jeg alltid ha en app eller et verktøy som kunne vise meg posisjonen til fingrene mine på fiolinen veldig presist. Med dette prosjektet prøvde jeg å bygge dette. Selv om dette er en prototype, og du fortsatt kan legge til mange funksjoner.

Jeg prøvde også å skille ESP32 og rPI, og dermed fikk jeg ESP32 til å sende data trådløst til rPi. Noe som trolig er det vanskeligste med dette prosjektet.

Det er også veldig viktig at på slutten av dette prosjektet er ingenting lagret på datamaskinen din, men det er enten på rPI eller ESP32.

Trinn 1: Materialer og verktøy

Før vi går inn på detaljene i å bygge dette prosjektet, trenger vi et par ting.

1. 4x lineær softpot: lineære potensiometre for å måle posisjonen til en finger (en fiolin har 4 strenger)
2. ESP32: En ESP32 -modul for å lese dataene fra de lineære softpots.
3. en 4/4 fiolin: en fiolin for å plassere de lineære softpottene på toppen.
4. en Raspberry Pi med et SD -kort: en bringebærpi som vil lagre vår database og nettsted.
5. 10k potensiometer: et potensiometer for lysstyrken på LCD -skjermen
6. LCD-skjerm: en LCD-skjerm som skal vises for ip-tilleggene til rPi
7. Loddesett: For lodding av alle elementene sammen
8. Mann-til-mann ledninger og mann-til-hunn ledninger: Kabler for tilkobling av alle elementene
9. Micro USB -kabel: For strømforsyning av ESP32

Trinn 2: Koble Softpots til ESP32

Først av alt må vi koble softpottene våre til esp32. Vi kobler venstre og høyre pinne til henholdsvis 5V og GND. Vi kobler den midterste pinnen til en analog pinne på ESP32. Vi må også koble den midterste pinnen med en motstand på 10k ohm og koble denne til GND. Dette er slik at produksjonen av softpots ikke returnerer tilfeldig verdi.

Deretter kobler vi ESP32 med mikro -usb -kabelen til PCen, slik at vi kan laste opp kode til den. Vi vil bruke Arduino IDE for programmering av ESP32. Men først må vi installere Arduino -kjernen for ESP32 slik at vi kan laste den opp til den. Dette kan gjøres her.

Så kan vi begynne å skrive kode.

Først må vi tildele pinnene våre som vi koblet den midterste pinnen til softpottene til.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

usignert lang tid;

usignert lang softPotTime;

Så kan vi sette opp pinnene våre. Og vi må starte vår serielle skjerm og vår tid.

ugyldig oppsett () {

onTime = millis ();

Serial.begin (115200);

Serial.println ("Programstart");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

void getdata (byte pdata ) {

// Les i mykpottens ADC -verdi

Deretter må vi lese våre pins slik at vi kan motta dataene våre.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Deretter setter vi verdiene i en liste, slik at vi enkelt kan skrive det ut senere.

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

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

int softpot = Navn ;

hvis (softpot> 10) {

pdata [0] = i;

pdata [1] = softpot;

pdata [2] = millis ();

} } }

}

Trinn 3: Koble ESP32 og RPI trådløst

For å koble ESP32 og RPI trådløst bruker vi et bibliotek som kalles websocket. For å installere dette biblioteket kan vi få filene her. Vi må endre noen kode i selve filene for å kunne bruke dette biblioteket til ESP32.

Vi må endre MD5.c og MD5.h.

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

Vi må også slette avr/io.h -linjene i sha1 -filene.

Deretter kan vi legge til biblioteket i vår Arduino IDE etter skisse> inkludere bibliotek> legge til. ZIP -bibliotek, og så kan vi velge biblioteket ditt i en zip -fil.

Etter det kan vi begynne å skrive koden vår.

Først for ESP32:

Inkludert vårt bibliotek

#include #include

Tilordner pinnene våre igjen.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Tilordner vår wifi -server

WiFiServer -server (80);

Starter vår websocket -server

WebSocketServer webSocketServer;

Tilordne SSID og passord for wifi

const char* ssid = "din wifi SSID";

const char* password = "wifi -passordet ditt";

ugyldig oppsett () {

Konfigurere den serielle skjermen

Serial.begin (115200);

Sette opp softpots

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Starter wifi og kobler til den

WiFi.begin (ssid, passord);

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

forsinkelse (1000);

Serial.println ("Koble til WiFi.."); }

Serial.println ("Koblet til WiFi -nettverket");

Serial.println (WiFi.localIP ());

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

void getdata (char *pdata) {

Lese dataene dine

// Les i mykpottens ADC -verdi

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Plassere dataene i en liste og konvertere dem til heksadesimal.

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

}

void loop () {

Koble til klienten din (rPI)

WiFiClient -klient = server.available ();

hvis (client.connected ()) {

forsinkelse (10);

if (webSocketServer.handshake (klient)) {

Serial.println ("Klient tilkoblet");

Sender og mottar data.

mens (client.connected ()) {

røyedata [30];

getdata (data);

Serial.println (data);

webSocketServer.sendData (data);

forsinkelse (10); // Forsinkelse nødvendig for å motta dataene riktig}

Serial.println ("Klienten koblet fra");

forsinkelse (100); }

annet {

Serial.println ("shitsfuckedyo");

} } }

Deretter for rPI i python:

Importerer bibliotekene våre

import websocketimport tid

Tilordne en global variabel i

jeg = 0

Angir maksimalt 200 meldinger som vi kan motta

nrOfMessages = 200

klasse Websocket ():

def _init _ (self):

Initialiserer websocket og kobler det til ESP32

self.ws = websocket. WebSocket ()

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

Mottar dataene våre

def arbeid (selv):

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

resultat = self.ws.recv () time.sleep (0,5) returresultat

Lukker websocket etter å ha mottatt alt

def close (self):

self.ws.close ()

Trinn 4: Koble sammen nettstedet og databasen

Når det gjelder tilkobling av vår database og nettsted, må du først opprette databasen din på pi ved å installere mariadb: sudo apt install mariadb.

Deretter kan du få tilgang til det ved å gjøre: sudo mariadb.

Da må du også opprette nettstedet ditt. Du kan gjøre dette som du vil, men du må bruke Flask og du må ha et skjema i HTML -koden din for å stoppe og starte dataene dine.

Deretter kan du sette inn denne koden for å koble databasen og nettstedet ditt (både nettstedet og databasen må begge være på pi -en din, dette kan gjøres ved å bruke distribusjonsfanen i innstillingene til pycharm)

fra flaskext.mysql importerer MySQL

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

app.config ["MYSQL_DATABASE_DB"] = "databasens navn"

app.config ["MYSQL_DATABASE_USER"] = "databasebrukeren"

app.config ["MYSQL_DATABASE_PASSWORD"] = "databasepassordet"

Funksjon for å få data ut av databasen vår.

def get_data (sql, params = None):

conn = mysql.connect ()

markør = konn. markør ()

print ("hente data")

prøve:

skrive ut (sql)

cursor.execute (sql, params)

unntatt Unntak som e:

skrive ut (e)

return False

resultat = cursor.fetchall ()

data =

for rad i resultat:

data.append (liste (rad))

cursor.close ()

conn.close ()

returnere data

Funksjon for å sette inn data i vår database

def set_data (sql, params = None):

conn = mysql.connect ()

markør = konn. markør ()

prøve:

log.debug (sql)

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

log.debug ("SQL utført")

unntatt Unntak som e:

log.exception ("Fout ved å utføre van sql: {0})". format (e))

return False

cursor.close ()

conn.close ()

returner True

Vi må også trå søknaden vår slik at du kan gjøre andre ting mens du spiller inn.

class ThreadedTask (threading. Thread):

def _init _ (self,):

Setter opp tråd

threading. Thread._ init _ (self)

Lag en liste for å lagre alle mottatte data

self.data_all =

def run (self):

tid. sover (5)

Importer din egen python -kode der du mottar dataene

importere Receive_websocket

Motta dataene dine

w = Receive_websocket. Websocket ()

Legg til dataene i listen og skriv dem ut.

for i i området (0, 200):

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

print (self.data_all)

task = ThreadedTask ()

Deretter kan du gjøre task.run () for å starte tråden og begynne å motta data.

Trinn 5: Koble alt sammen

For å kjøre nettstedet ditt fra Pi må du bruke en tjeneste:

[Enhet] Beskrivelse = uWSGI -forekomst for visning av prosjekt1 -webgrensesnitt

Etter = network.target

BindsTo = mysqld.service

Etter = mysqld.service

[Service]

Bytt til brukeren din

Bruker = pi

Gruppe = www-data

Her må du skrive inn katalogen for Flask -filen

WorkingDirectory =/home/pi/project1/web

Katalog over ini -filen din som kan bli funnet senere.

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

[Installere]

WantedBy = multi-user.target

uwsgi-flask.ini som du må plassere i katalogen du angav i ExecStart ovenfor

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

master = sanne prosesser = 5

plugins = python3

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

die-on-term = true

Nå kan du lese dataene dine og vise dem på nettstedet ditt.

Trinn 6: Ekstra: Tilkobling av LCD -skjerm

Vi kan koble til en LCD-skjerm slik at vi kan vise ip-adressen til Pi for nettstedet vårt.

importer RPi. GPIO som GPIOimporttid

importkommandoer

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

klasse Skjerm:

def _init _ (self):

GPIO.setmode (GPIO. BCM)

self.setup ()

#Funksjonssett self.stuur_instructie (0x3f) #Display self.stuur_instructie (0x0c) #On + markør self.stuur_instructie (0x01) @staticmethod def setup (): GPIO.setup (list, 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)

time.sleep (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)

time.sleep (0,005)

GPIO.output (E, GPIO. LOW)

def set_GPIO_bits (selv, byte):

for jeg i området (0, 8):

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

GPIO.output (liste , GPIO. LOW)

ellers:

GPIO.output (liste , GPIO. HIGH)

def main ():

s = Skjerm ()

teken = "Lokal IP -adresse:"

for bokstav i teken:

s.stuur_teken (bokstav)

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

print (teken2)

s.stuur_instructie (0xc0)

for bokstav 2 i teken2:

s.stuur_teken (bokstav2)

hvis _name_ == '_main_': #Program som starter herfra

prøve:

hoved()

unntatt KeyboardInterrupt:

sende

Deretter kan vi opprette en tjeneste for å starte LCD-skjermen ved oppstart.