Măsurarea pozițiilor degetelor pe o vioară cu ESP32: 6 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

În calitate de violonist, mi-am dorit întotdeauna o aplicație sau un instrument care să-mi arate poziția degetelor pe vioară foarte precisă. Cu acest proiect am încercat să construiesc acest lucru. Deși acesta este un prototip și puteți adăuga în continuare multe caracteristici.

De asemenea, am încercat să separ ESP32 și rPI și astfel am făcut ca ESP32 să trimită date fără fir către rPi. Care este probabil cel mai dificil lucru la acest proiect.

De asemenea, este foarte important ca la sfârșitul acestui proiect să nu fie stocat nimic pe computerul dvs., ci fie pe rPI, fie pe ESP32.

Pasul 1: Materiale și instrumente

Înainte de a intra în specificul construirii acestui proiect, avem nevoie de câteva lucruri.

1. 4x Linear Softpot: Potențiometre liniare pentru măsurarea poziției unui deget (o vioară are 4 corzi)
2. ESP32: Un modul ESP32 pentru a citi datele din softpot-urile liniare.
3. o vioară 4/4: o vioară pentru a plasa softpoturile liniare deasupra.
4. un Raspberry Pi cu un card SD: un raspberry pi care va stoca baza noastră de date și site-ul web.
5. Potențiometru 10k: un potențiometru pentru luminozitatea ecranului LCD
6. Ecran LCD: un ecran LCD pentru a afișa adresa IP a rPi
7. Set de lipit: Pentru lipirea tuturor elementelor mai mari
8. Fire de la bărbat la bărbat și fire de la bărbat la femeie: cabluri pentru conectarea tuturor elementelor
9. Cablu micro USB: Pentru alimentarea ESP32

Pasul 2: Conectarea softpoturilor la ESP32

În primul rând trebuie să ne conectăm softpoturile la sp32. Conectăm pinii stânga și dreapta la 5V și respectiv GND. Conectăm pinul de mijloc la un pin analogic de pe ESP32. De asemenea, trebuie să conectăm pinul de mijloc cu o rezistență de 10k ohm și să-l conectăm la GND. Acest lucru este astfel încât ieșirea noastră a softpoturilor să nu returneze valoare aleatorie.

Apoi conectăm ESP32 cu cablul micro USB la computerul nostru, astfel încât să putem încărca codul pe acesta. Vom folosi Arduino IDE pentru programarea ESP32. Dar mai întâi trebuie să instalăm nucleul Arduino pentru ESP32, astfel încât să îl putem încărca. Acest lucru se poate face aici.

Atunci putem începe să scriem cod.

Mai întâi trebuie să ne atribuim pinii la care am conectat pinul din mijloc al softpoturilor.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

nesemnat mult timp;

softPotTime lung nesemnat;

Apoi ne putem configura pinii. Și trebuie să ne pornim monitorul serial și timpul nostru.

configurare nulă () {

onTime = milis ();

Serial.begin (115200);

Serial.println ("Program start");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

nul getdata (octet pdata ) {

// Citiți valoarea ADC a soft potului

Apoi, trebuie să ne citim pinii, astfel încât să putem primi datele noastre.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Apoi punem valorile într-o listă, astfel încât să o putem reda cu ușurință mai târziu.

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

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

int softpot = Nume ;

if (softpot> 10) {

pdata [0] = i;

pdata [1] = softpot;

pdata [2] = millis ();

} } }

}

Pasul 3: Conectarea ESP32 și RPI fără fir

Pentru conectarea fără fir a ESP32 și RPI, vom folosi o bibliotecă numită websocket. Pentru a instala această bibliotecă, putem obține fișierele aici. Va trebui să schimbăm un anumit cod din fișiere în sine pentru a utiliza această bibliotecă pentru ESP32.

Va trebui să schimbăm MD5.c și MD5.h.

• MD5Init la MD5InitXXX
• MD5Update la MD5UpdateXXX
• MD5Final la MD5FinalXXX

De asemenea, va trebui să ștergem liniile avr / io.h din fișierele sha1.

Apoi putem adăuga biblioteca la IDE-ul nostru Arduino prin schiță> includ bibliotecă> adăugați bibliotecă. ZIP și apoi vă putem selecta biblioteca într-un fișier zip.

După aceea, putem începe să ne scriem codul.

În primul rând pentru ESP32:

Inclusiv biblioteca noastră

#include #include

Atribuind din nou pinii noștri.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Atribuirea serverului nostru wifi

Server WiFi Server (80);

Lansarea serverului nostru de websocket

WebSocketServer webSocketServer;

Atribuirea SSID-ului și parolei wifi-ului dvs.

const char * ssid = "SSID-ul dvs. wifi";

const char * password = "parola ta wifi";

configurare nulă () {

Configurarea monitorului serial

Serial.begin (115200);

Configurarea softpoturilor

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Pornind wifi-ul nostru și conectându-ne la acesta

WiFi.begin (ssid, parolă);

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

întârziere (1000);

Serial.println ("Conectarea la WiFi.."); }

Serial.println ("Conectat la rețeaua WiFi");

Serial.println (WiFi.localIP ());

server.begin (); întârziere (100); }

nul getdata (char * pdata) {

Citirea datelor dvs.

// Citiți valoarea ADC a soft potului

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Plasarea datelor într-o listă și convertirea acestora în hexazecimal.

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

}

bucla nulă () {

Conectarea clientului dvs. (rPI)

Client WiFiClient = server.available ();

if (client.connected ()) {

întârziere (10);

if (webSocketServer.handshake (client)) {

Serial.println („Client conectat”);

Trimiterea și primirea datelor.

while (client.connected ()) {

date char [30];

getdata (date);

Serial.println (date);

webSocketServer.sendData (date);

întârziere (10); // Întârziere necesară pentru primirea corectă a datelor}

Serial.println („Clientul s-a deconectat”);

întârziere (100); }

altceva {

Serial.println ("shitsfuckedyo");

} } }

Apoi pentru rPI în python:

Importul bibliotecilor noastre

import websocket import timp

Asignarea unei variabili globale i

i = 0

Setarea a maximum 200 de mesaje pe care le putem primi

nrOfMessages = 200

clasa Websocket ():

def _init _ (auto):

Inițializarea portalului nostru web și conectarea acestuia la ESP32

self.ws = websocket. WebSocket ()

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

Primirea datelor noastre

munca def (auto):

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

result = self.ws.recv () time.sleep (0,5) rezultat de returnare

Închiderea websocket-ului după ce ați primit totul

def close (self):

self.ws.close ()

Pasul 4: Conectarea site-ului și a bazei de date

În ceea ce privește conectarea bazei de date și a site-ului nostru web, va trebui mai întâi de toate să vă creați baza de date pe pi instalând mariadb: sudo apt install mariadb.

Apoi îl puteți accesa făcând: sudo mariadb.

Apoi, va trebui, de asemenea, să vă creați site-ul web. Puteți face acest lucru oricum doriți, dar trebuie să utilizați Flask și trebuie să aveți un formular în HTML pentru oprirea și pornirea datelor.

Apoi puteți introduce acest cod pentru a vă conecta baza de date și site-ul dvs. web (atât site-ul dvs., cât și baza de date trebuie să fie ambele pe pi, acest lucru se poate face folosind fila de implementare din setările pycharm)

din flaskext.mysql import MySQL

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

app.config ["MYSQL_DATABASE_DB"] = "numele bazei de date"

app.config ["MYSQL_DATABASE_USER"] = "utilizatorul bazei de date"

app.config ["MYSQL_DATABASE_PASSWORD"] = "parola bazei de date"

Funcție pentru obținerea datelor din baza noastră de date.

def get_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

print („obținerea datelor”)

încerca:

print (sql)

cursor.execute (sql, params)

cu excepția excepției ca e:

print (e)

returnează Fals

result = cursor.fetchall ()

date =

pentru rândul rezultat:

data.append (listă (rând))

cursor.close ()

conn.close ()

returnează datele

Funcție pentru inserarea datelor în baza noastră de date

def set_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

încerca:

log.debug (sql)

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

log.debug („SQL uitgevoerd”)

cu excepția excepției ca e:

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

returnează Fals

cursor.close ()

conn.close ()

întoarce Adevărat

De asemenea, va trebui să ne conectăm aplicația, astfel încât să puteți face alte lucruri în timp ce înregistrați.

clasa ThreadedTask (threading. Thread):

def _init _ (self,):

Configurarea firului

threading. Thread._ init _ (auto)

Crearea unei liste pentru păstrarea tuturor datelor primite

self.data_all =

def run (auto):

time.sleep (5)

Importați propriul cod python unde primiți datele

import receive_websocket

Primiți datele dvs.

w = receive_websocket. Websocket ()

Adăugați datele dvs. în listă și imprimați-le.

pentru i în intervalul (0, 200):

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

print (self.data_all)

task = ThreadedTask ()

Apoi puteți face task.run () pentru a începe firul și a începe să primiți date.

Pasul 5: conectarea totul împreună

Pentru a vă rula site-ul web de pe Pi, trebuie să utilizați un serviciu:

[Unitate] Descriere = instanță uWSGI pentru a deservi interfața web project1

După = network.target

BindsTo = mysqld.service

După = mysqld.service

[Serviciu]

Treceți la utilizatorul dvs.

Utilizator = pi

Group = www-data

Aici trebuie să introduceți directorul fișierului dvs. Flask

WorkingDirectory = / home / pi / project1 / web

Directorul fișierului ini care poate fi găsit mai târziu.

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

[Instalare]

WantedBy = multi-user.target

uwsgi-flask.ini pe care trebuie să îl plasați în directorul specificat în ExecStart de mai sus

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

master = procese adevărate = 5

pluginuri = python3

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

die-on-term = adevărat

Acum puteți să vă citiți datele și să le afișați pe site-ul dvs. web.

Pasul 6: Extra: Conectarea ecranului LCD

Putem conecta un ecran LCD, astfel încât să putem afișa adresa IP a Pi-ului nostru pentru site-ul nostru web.

import RPi. GPIO ca GPIOimport timp

comenzi de import

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

Ecranul clasei:

def _init _ (auto):

GPIO.setmode (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 (list, GPIO. OUT) GPIO.setup ([E, RS], GPIO. OUT)

def stuur_instructie (self, byte):

Ieșire GPIO (E, GPIO. HIGH)

Ieșire GPIO (RS, GPIO. LOW)

self.set_GPIO_bits (octet)

time.sleep (0,005)

Ieșire GPIO (E, GPIO. LOW)

def stuur_teken (self, char):

temp = ord (char)

Ieșire GPIO (E, GPIO. HIGH)

Ieșire GPIO (RS, GPIO. HIGH)

self.set_GPIO_bits (temp)

time.sleep (0,005)

Ieșire GPIO (E, GPIO. LOW)

def set_GPIO_bits (auto, octet):

pentru i în intervalul (0, 8):

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

GPIO.output (listă , GPIO. LOW)

altceva:

GPIO.output (listă , GPIO. HIGH)

def main ():

s = Screen ()

teken = "Adresă IP locală:"

pentru scrisoare în teken:

s.stuur_teken (scrisoare)

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

print (teken2)

s.stuur_instructie (0xc0)

pentru litera 2 în teken2:

s.stuur_teken (letter2)

if _name_ == '_main_': #Program care începe de aici

încerca:

principal()

cu excepția KeyboardInterrupt:

trece

Apoi, putem crea un serviciu pentru a porni ecranul LCD la pornire.