Mesurar les posicions dels dits en un violí amb ESP32: 6 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:15

Com a violinista, sempre volia una aplicació o una eina que em pogués mostrar la posició dels meus dits sobre el violí molt precisa. Amb aquest projecte vaig intentar construir això. Tot i que aquest és un prototip i encara podeu afegir moltes funcions.

També vaig intentar separar l’ESP32 i l’RPI i així vaig fer que l’ESP32 enviés dades sense fils al rPi. Què és probablement el més difícil d’aquest projecte.

També és molt important que al final d'aquest projecte no s'emmagatzemi res a l'ordinador, sinó que estigui a l'IPP o ESP32.

Pas 1: materials i eines

Abans d’entrar en els detalls específics de la construcció d’aquest projecte, necessitem algunes coses.

1. 4x Lineal Softpot: Potenciómetres lineals per mesurar la posició d'un dit (un violí té 4 cordes)
2. ESP32: un mòdul ESP32 per llegir les dades dels softpots lineals.
3. un violí 4/4: un violí per col·locar els softpots lineals a la part superior.
4. un Raspberry Pi amb targeta SD: un raspberry pi que emmagatzemarà la nostra base de dades i el nostre lloc web.
5. Potenciòmetre de 10 k: un potenciòmetre per a la brillantor de la pantalla LCD
6. Pantalla LCD: una pantalla LCD per mostrar a l'adreça IP del rPi
7. Kit de soldadura: per soldar tots els elements junts
8. Filferros masculí a masculí i filferros masculí a femení: cables per connectar tots els elements
9. Cable micro USB: per alimentar l’ESP32

Pas 2: connectar els Softpots a l'ESP32

Primer de tot, hem de connectar els nostres softpots a l’esp32. Connectem els pins esquerre i dret a 5V i GND respectivament. Connectem el pin central a un pin analògic de l’ESP32. També hem de connectar el pin central amb una resistència de 10k ohm i connectar-lo al GND. Això és perquè la nostra sortida de softpots no retorni valor aleatori.

A continuació, connectem l’ESP32 amb el cable micro usb al nostre ordinador perquè puguem penjar-hi codi. Utilitzarem l’IDE Arduino per programar l’ESP32. Però primer hem d’instal·lar el nucli Arduino per a l’ESP32 per poder carregar-lo. Això es pot fer aquí.

Després podem començar a escriure codi.

En primer lloc, hem d'assignar els nostres pins als quals hem connectat el nostre pin mitjà dels softpots.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

sense signar molt de temps;

softPotTime llarg sense signar;

Després podem configurar els nostres pins. I hem d’iniciar el nostre monitor sèrie i el nostre temps.

configuració nul·la () {

onTime = millis ();

Serial.begin (115200);

Serial.println ("Inici del programa");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

void getdata (byte pdata ) {

// Llegiu el valor ADC del soft pot

Després, hem de llegir els nostres pins per poder rebre les nostres dades.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

A continuació, posem els valors en una llista perquè puguem sortir fàcilment més endavant.

per a (int i = 0; i <4; i ++) {

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

int softpot = Noms ;

if (softpot> 10) {

pdata [0] = i;

pdata [1] = softpot;

pdata [2] = millis ();

} } }

}

Pas 3: Connectar l'ESP32 i l'RPI sense fils

Per connectar l’ESP32 i l’RPI sense fils, utilitzarem una biblioteca anomenada websocket. Per instal·lar aquesta biblioteca, podem obtenir els fitxers aquí. Haurem de canviar algun codi dels propis fitxers per poder utilitzar aquesta biblioteca per a l’ESP32.

Haurem de canviar MD5.c i MD5.h.

• MD5Init a MD5InitXXX
• MD5Update a MD5UpdateXXX
• MD5Final a MD5FinalXXX

També haurem de suprimir les línies avr / io.h dels fitxers sha1.

Després podem afegir la biblioteca al nostre IDE Arduino mitjançant un esbós> incloure biblioteca> afegir biblioteca. ZIP i, a continuació, podem seleccionar la vostra biblioteca en un fitxer zip.

Després d'això, podem començar a escriure el nostre codi.

Primer per a l’ESP32:

Incloent la nostra biblioteca

#include #include

Assignant de nou els nostres pins.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Assignació del nostre servidor wifi

Servidor WiFiServer (80);

Iniciant el nostre servidor de websocket

WebSocketServer webSocketServer;

Assignació del nostre SSID i contrasenya del vostre wifi

const char * ssid = "el vostre SSID wifi";

const char * password = "la vostra contrasenya wifi";

configuració nul·la () {

Configuració del monitor sèrie

Serial.begin (115200);

Configuració dels softpots

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Començar el nostre wifi i connectar-nos-hi

WiFi.begin (ssid, contrasenya);

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

retard (1000);

Serial.println ("Connexió a WiFi.."); }

Serial.println ("Connectat a la xarxa WiFi");

Serial.println (WiFi.localIP ());

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

void getdata (char * pdata) {

Llegint les vostres dades

// Llegiu el valor ADC del soft pot

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Col·locació de les dades en una llista i conversió a hexadecimal.

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

}

bucle buit () {

Connexió del client (rPI)

Client WiFiClient = servidor.available ();

if (client.connected ()) {

retard (10);

if (webSocketServer.handshake (client)) {

Serial.println ("Client connectat");

Enviament i recepció de dades.

while (client.connected ()) {

dades de caràcters [30];

getdata (dades);

Serial.println (dades);

webSocketServer.sendData (dades);

retard (10); // Retard necessari per rebre les dades correctament}

Serial.println ("El client s'ha desconnectat");

retard (100); }

més {

Serial.println ("shitsfuckedyo");

} } }

A continuació, per a l'RPI a Python:

Important les nostres biblioteques

importar websocket importar temps

Assignació d'una variable global i

i = 0

Configuració d'un màxim de 200 missatges que podem rebre

nrOfMessages = 200

Websocket de classe ():

def _init _ (auto):

Inicialitzant el nostre portal web i connectant-lo al nostre ESP32

self.ws = websocket. WebSocket ()

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

Rebre les nostres dades

treball definitiu (auto):

self.ws.send ("missatge núm: 0")

result = self.ws.recv () time.sleep (0,5) resultat de retorn

Tancant el portal web després de rebre-ho tot

def close (auto):

self.ws.close ()

Pas 4: connectar el lloc web i la base de dades

Pel que fa a la connexió de la nostra base de dades i el lloc web, primer haureu de crear la vostra base de dades al pi instal·lant mariadb: sudo apt install mariadb.

A continuació, podeu accedir-hi fent: sudo mariadb.

Llavors també haureu de crear el vostre lloc web. Podeu fer-ho com vulgueu, però heu d'utilitzar Flask i heu de tenir un formulari al vostre codi HTML per aturar i iniciar les vostres dades.

A continuació, podeu inserir aquest codi per connectar la vostra base de dades i el vostre lloc web (tant el lloc web com la base de dades han d'estar al vostre pi, això es pot fer mitjançant la pestanya de desplegament a la configuració de pycharm).

des de flaskext.mysql importeu MySQL

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

app.config ["MYSQL_DATABASE_DB"] = "el nom de la vostra base de dades"

app.config ["MYSQL_DATABASE_USER"] = "usuari de la vostra base de dades"

app.config ["MYSQL_DATABASE_PASSWORD"] = "contrasenya de la vostra base de dades"

Funció per obtenir dades de la nostra base de dades.

def get_data (sql, params = Cap):

conn = mysql.connect ()

cursor = conn.cursor ()

imprimir ("obtenir dades")

provar:

imprimir (sql)

cursor.execute (sql, params)

excepte Excepció com a e:

imprimir (e)

tornar Fals

result = cursor.fetchall ()

dades =

per a la fila del resultat:

data.append (llista (fila))

cursor.close ()

conn.close ()

retornar dades

Funció per inserir dades a la nostra base de dades

def set_data (sql, params = Cap):

conn = mysql.connect ()

cursor = conn.cursor ()

provar:

log.debug (sql)

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

log.debug ("SQL uitgevoerd")

excepte Excepció com a e:

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

tornar Fals

cursor.close ()

conn.close ()

tornar True

També haurem d’enfilar la nostra aplicació perquè pugueu fer altres coses mentre esteu gravant.

classe ThreadedTask (threading. Thread):

def _init _ (auto,):

Configuració del fil

threading. Thread._ init _ (auto)

Creació d’una llista per conservar totes les dades rebudes

self.data_all =

def run (auto):

time.sleep (5)

Importeu el vostre propi codi python on rebeu les dades

importa rebre_websocket

Rebeu les vostres dades

w = receive_websocket. Websocket ()

Afegiu les vostres dades a la vostra llista i imprimiu-les.

per a l'interval (0, 200):

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

imprimir (self.data_all)

tasca = ThreadedTask ()

A continuació, podeu fer task.run () per iniciar el vostre fil i començar a rebre dades.

Pas 5: connectar-ho tot junt

Per executar el vostre lloc web des del vostre Pi, heu d’utilitzar un servei:

[Unitat] Descripció = instància uWSGI per servir la interfície web project1

Després de = network.target

BindsTo = mysqld.service

Després = mysqld.service

[Servei]

Canvieu al vostre usuari

Usuari = pi

Grup = www-data

Aquí heu d'introduir el directori del fitxer Flask

WorkingDirectory = / home / pi / project1 / web

Directori del fitxer ini que es pot trobar més endavant.

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

[Instal·la]

WantedBy = multi-usuari.target

uwsgi-flask.ini que heu de col·locar al directori que heu especificat a ExecStart anterior

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

master = veritable processos = 5

connectors = python3

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

morir a termini = cert

Ara podeu llegir les vostres dades i mostrar-les al vostre lloc web.

Pas 6: addicional: connexió de la pantalla LCD

Podem connectar una pantalla LCD per mostrar l’adreça IP del nostre Pi al nostre lloc web.

importar RPi. GPIO com a GPIOimport time

importar ordres

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

Pantalla de classe:

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

def stuur_instructie (self, byte):

Sortida GPIO (E, GPIO. HIGH)

Sortida GPIO (RS, GPIO. LOW)

self.set_GPIO_bits (byte)

time.sleep (0,005)

Sortida GPIO (E, GPIO. LOW)

def stuur_teken (self, char):

temp = ord (char)

Sortida GPIO (E, GPIO. HIGH)

Sortida GPIO (RS, GPIO. HIGH)

self.set_GPIO_bits (temp)

time.sleep (0,005)

Sortida GPIO (E, GPIO. LOW)

def set_GPIO_bits (auto, byte):

per a l'interval (0, 8):

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

GPIO.output (llista , GPIO. LOW)

en cas contrari:

GPIO.output (llista , GPIO. HIGH)

def main ():

s = Pantalla ()

teken = "Adreça IP local:"

per a lletra en teken:

s.stuur_teken (carta)

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

imprimir (teken2)

s.stuur_instructie (0xc0)

per a la lletra2 a teken2:

s.stuur_teken (carta2)

if _name_ == '_principal_': #Programa a partir d'aquí

provar:

main ()

excepte KeyboardInterrupt:

passar

A continuació, podem crear un servei per iniciar la pantalla LCD a l’inici.