Måling af fingerpositioner på en violin med ESP32: 6 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:29

Som violinspiller ville jeg altid have en app eller et værktøj, der kunne vise mig fingrenes position på violinen meget præcist. Med dette projekt forsøgte jeg at bygge dette. Selvom dette er en prototype, og du stadig kan tilføje mange funktioner.

Jeg forsøgte også at adskille ESP32 og rPI, og derfor fik jeg ESP32 til at sende data trådløst til rPi. Hvilket nok er det sværeste ved dette projekt.

Det er også meget vigtigt, at der ved slutningen af dette projekt ikke er gemt noget på din computer, men det er enten på rPI eller ESP32.

Trin 1: Materialer og værktøjer

Inden vi går ind i detaljerne ved at bygge dette projekt, har vi brug for et par ting.

1. 4x Lineær Softpot: Lineære Potentiometre til måling af en fingers position (en violin har 4 strenge)
2. ESP32: Et ESP32 -modul til at læse data fra de lineære softpots.
3. en 4/4 violin: en violin for at placere de lineære softpots ovenpå.
4. en Raspberry Pi med et SD -kort: en hindbærpi, der gemmer vores database og websted.
5. 10k potentiometer: et potentiometer til LCD -skærmens lysstyrke
6. LCD-skærm: en LCD-skærm, der skal vises til iP-tilføjelserne til rPi
7. Loddesæt: Til lodning af alle elementerne sammen
8. Mand-til-han-ledninger og han-til-hun-ledninger: Kabler til tilslutning af alle elementerne
9. Micro USB -kabel: Til strømforsyning af ESP32

Trin 2: Tilslutning af softpots til ESP32

Først og fremmest skal vi slutte vores softpots til esp32. Vi forbinder venstre og højre ben til henholdsvis 5V og GND. Vi forbinder den midterste pin til en analog pin på ESP32. Vi skal også forbinde den midterste pin med en modstand på 10k ohm og tilslutte denne til GND. Dette er for at vores output af softpots ikke returnerer tilfældig værdi.

Derefter forbinder vi ESP32 med mikro -usb -kablet til vores pc, så vi kan uploade kode til den. Vi vil bruge Arduino IDE til programmering af ESP32. Men først skal vi installere Arduino -kernen til ESP32, så vi kan uploade den. Dette kan gøres her.

Så kan vi begynde at skrive kode.

Først skal vi tildele vores pins, som vi forbandt vores midterste pin af softpots med.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

usigneret lang tid;

usigneret lang softPotTime;

Så kan vi opsætte vores pins. Og vi skal starte vores serielle skærm og vores tid.

ugyldig opsætning () {

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 ) {

// Læs i den bløde gryds ADC -værdi

Derefter skal vi læse vores pins, så vi kan modtage vores data.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Derefter sætter vi værdierne på en liste, så vi let kan sende det senere.

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

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

int softpot = Navne ;

hvis (softpot> 10) {

pdata [0] = i;

pdata [1] = softpot;

pdata [2] = millis ();

} } }

}

Trin 3: Tilslutning af ESP32 og RPI trådløst

Til trådløs forbindelse af ESP32 og RPI bruger vi et bibliotek kaldet websocket. For at installere dette bibliotek kan vi hente filerne her. Vi bliver nødt til at ændre noget kode i selve filerne for at kunne bruge dette bibliotek til ESP32.

Vi bliver nødt til at ændre MD5.c og MD5.h.

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

Vi bliver også nødt til at slette avr/io.h -linjerne i sha1 -filerne.

Derefter kan vi tilføje biblioteket til vores Arduino IDE ved skitse> inkludere bibliotek> tilføje. ZIP -bibliotek, og derefter kan vi vælge dit bibliotek i en zip -fil.

Derefter kan vi begynde at skrive vores kode.

Først til ESP32:

Herunder vores bibliotek

#include #include

Tildel vores pins igen.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Tildeling af vores wifi -server

WiFiServer -server (80);

Start af vores websocket server

WebSocketServer webSocketServer;

Tildeling af vores SSID og adgangskode til din wifi

const char* ssid = "dit wifi SSID";

const char* password = "din wifi adgangskode";

ugyldig opsætning () {

Opsætning af din serielle skærm

Serial.begin (115200);

Opsætning af dine softpots

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Starter vores wifi og opretter forbindelse til den

WiFi.begin (ssid, adgangskode);

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

forsinkelse (1000);

Serial.println ("Opretter forbindelse til WiFi.."); }

Serial.println ("Tilsluttet WiFi -netværket");

Serial.println (WiFi.localIP ());

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

void getdata (char *pdata) {

Læser dine data

// Læs i den bløde gryds ADC -værdi

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Placering af dataene på en liste og konvertering til hexadecimal.

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

}

void loop () {

Tilslutning af din klient (rPI)

WiFiClient -klient = server.available ();

hvis (client.connected ()) {

forsinkelse (10);

hvis (webSocketServer.handshake (klient)) {

Serial.println ("Klient forbundet");

Afsendelse og modtagelse af data.

mens (client.connected ()) {

kuldata [30];

getdata (data);

Serial.println (data);

webSocketServer.sendData (data);

forsinkelse (10); // Forsinkelse nødvendig for at modtage dataene korrekt}

Serial.println ("Klienten afbrudt");

forsinkelse (100); }

andet {

Serial.println ("shitsfuckedyo");

} } }

Derefter for rPI i python:

Import af vores biblioteker

import websocketimport tid

Tildeling af en global variabel i

jeg = 0

Indstiller maksimalt 200 beskeder, som vi kan modtage

nrOfMessages = 200

klasse Websocket ():

def _init _ (selv):

Initialiserer vores websocket og forbinder den med vores ESP32

self.ws = websocket. WebSocket ()

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

Modtagelse af vores data

def arbejde (selv):

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

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

Lukning af websocket efter modtagelse af alt

def lukke (selv):

self.ws.close ()

Trin 4: Tilslutning af dit websted og din database

Hvad angår forbindelse af vores database og websted, skal du først og fremmest oprette din database på pi'en ved at installere mariadb: sudo apt install mariadb.

Derefter kan du få adgang til det ved at gøre: sudo mariadb.

Så skal du også oprette dit websted. Du kan gøre dette, som du vil, men du skal bruge Flask, og du skal have en formular i din HTML til at stoppe og starte dine data.

Derefter kan du indsætte denne kode for at forbinde din database og dit websted (både dit websted og database skal begge være på din pi, dette kan gøres ved at bruge fanen Implementering i indstillinger for pycharm)

fra flaskext.mysql importerer MySQL

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

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

app.config ["MYSQL_DATABASE_USER"] = "din database bruger"

app.config ["MYSQL_DATABASE_PASSWORD"] = "din database adgangskode"

Funktion til at få data ud af vores database.

def get_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

print ("henter data")

prøve:

print (sql)

cursor.execute (sql, params)

undtagen Undtagelse som e:

tryk (e)

return False

resultat = cursor.fetchall ()

data =

for række i resultat:

data.append (liste (række))

cursor.close ()

conn.close ()

returnere data

Funktion til at indsætte data i vores database

def set_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

prøve:

log.debug (sql)

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

log.debug ("SQL udført")

undtagen Undtagelse som e:

log.exception ("Fout ved udførelse af sql: {0})". format (e))

return False

cursor.close ()

conn.close ()

return True

Vi skal også tråde vores applikation, så du kan gøre andre ting, mens du optager.

class ThreadedTask (threading. Thread):

def _init _ (self,):

Opsætning af tråd

threading. Thread._ init _ (self)

Oprettelse af en liste til opbevaring af alle dine modtagne data

self.data_all =

def løb (selv):

tid. sover (5)

Importer din egen python -kode, hvor du modtager dataene

importere modtage_websocket

Modtag dine data

w = modtage_websocket. Websocket ()

Tilføj dine data på din liste, og udskriv dem.

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

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

print (self.data_all)

task = ThreadedTask ()

Derefter kan du udføre task.run () for at starte din tråd og begynde at modtage data.

Trin 5: Forbind alt sammen

For at køre dit websted fra din Pi skal du bruge en service:

[Enhed] Beskrivelse = uWSGI -forekomst til betjening af projekt1 -webgrænseflade

Efter = network.target

BindsTo = mysqld.service

Efter = mysqld.service

[Service]

Skift til din bruger

Bruger = pi

Gruppe = www-data

Her skal du indtaste dit bibliotek med din kolbe -fil

WorkingDirectory =/home/pi/project1/web

Katalog over din ini -fil, der kan findes senere.

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

[Installere]

WantedBy = multi-user.target

uwsgi-flask.ini, som du skal placere i det bibliotek, du har angivet i ExecStart ovenfor

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

master = sande processer = 5

plugins = python3

sokkel = projekt1.strøm chmod-sokkel = 660 vakuum = sand

die-on-term = true

Nu kan du læse dine data og vise dem på dit websted.

Trin 6: Ekstra: Tilslutning af LCD -skærm

Vi kan tilslutte en LCD-skærm, så vi kan vise ip-adressen på vores Pi til vores websted.

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 Skærm:

def _init _ (selv):

GPIO.setmode (GPIO. BCM)

self.setup ()

#Funktionssæt 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 (selv, 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 i i området (0, 8):

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

GPIO.output (liste , GPIO. LOW)

andet:

GPIO.output (liste , GPIO. HIGH)

def main ():

s = Skærm ()

teken = "Lokal IP -adresse:"

til bogstav i tegn:

s.stuur_teken (brev)

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

print (teken2)

s.stuur_instructie (0xc0)

for letter2 i teken2:

s.stuur_teken (letter2)

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

prøve:

main ()

undtagen KeyboardInterrupt:

passere

Derefter kan vi oprette en service til start af LCD'et ved opstart.