Ujjhelyzetek mérése hegedűn ESP32 segítségével: 6 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:42

Hegedűsként mindig olyan alkalmazást vagy eszközt szerettem volna, amely nagyon pontosan meg tudja mutatni az ujjaim helyzetét a hegedűn. Ezzel a projekttel ezt próbáltam megépíteni. Bár ez egy prototípus, és még sok funkciót adhat hozzá.

Megpróbáltam elválasztani az ESP32 -t és az rPI -t, és így az ESP32 -t vezeték nélkül küldtem az rPi -re. Ami talán a legnehezebb ebben a projektben.

Az is nagyon fontos, hogy a projekt végén semmi sem tárolódik a számítógépén, hanem az rPI vagy az ESP32.

Lépés: Anyagok és eszközök

Mielőtt belekezdenénk ennek a projektnek az építésébe, néhány dologra szükségünk van.

1. 4x Lineáris Softpot: Lineáris potenciométerek az ujjak helyzetének mérésére (egy hegedű 4 húros)
2. ESP32: ESP32 modul az adatok olvasásához a lineáris softpots -ból.
3. 4/4 hegedű: hegedű a lineáris lágy edények tetejére helyezéséhez.
4. egy Raspberry Pi SD kártyával: egy málna pi, amely tárolja adatbázisunkat és webhelyünket.
5. 10k potenciométer: potenciométer az LCD fényerejéhez
6. LCD-képernyő: az rPi ip-címeinek megjelenítendő LCD-képernyő
7. Forrasztókészlet: Az összes elem összeforrasztásához
8. Férfi-férfi vezetékek és hüvely-női vezetékek: Kábelek az összes elem csatlakoztatásához
9. Micro USB kábel: Az ESP32 tápellátásához

2. lépés: A softpots csatlakoztatása az ESP32 -hez

Mindenekelőtt a lágy edényeinket kell csatlakoztatnunk az esp32 -hez. A bal és a jobb oldali csapokat az 5V, illetve a GND -hez kapcsoljuk. Csatlakoztatjuk a középső csapot az ESP32 analóg tűjéhez. A középső csapot is 10 k ohmos ellenállással kell csatlakoztatnunk, és ezt a GND -hez kell csatlakoztatnunk. Ez azért van így, hogy a softpots kimenetünk ne adjon vissza véletlen értéket.

Ezután csatlakoztassuk az ESP32 -t a mikro -usb kábellel a számítógépünkhöz, hogy fel tudjuk tölteni a kódot. Az Arduino IDE -t fogjuk használni az ESP32 programozásához. De először telepítenünk kell az Arduino magot az ESP32 -hez, hogy fel tudjuk tölteni. Ezt itt lehet megtenni.

Ezután elkezdhetjük a kódírást.

Először hozzá kell rendelnünk a csapjainkat, amelyekhez a puha edények középső csapját csatlakoztattuk.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

előjel nélküli hosszú onTime;

előjel nélküli hosszú softPotTime;

Ezután beállíthatjuk csapjainkat. És el kell kezdenünk a soros monitorunkat és az időnket.

void setup () {

onTime = millis ();

Sorozat.kezdet (115200);

Serial.println ("Program indítása");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

void getdata (byte pdata ) {

// Olvassa be a lágy edény ADC értékét

Ezután el kell olvasnunk a csapjainkat, hogy megkaphassuk adatainkat.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analóg olvasat (SOFT_POT_PIN3);

int softPotADC4 = analóg olvasat (SOFT_POT_PIN4);

Ezután az értékeket egy listába tesszük, hogy később könnyen kiadhassuk.

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

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

int softpot = Nevek ;

if (softpot> 10) {

pdata [0] = i;

pdata [1] = softpot;

pdata [2] = millis ();

} } }

}

3. lépés: Az ESP32 és az RPI vezeték nélküli csatlakoztatása

Az ESP32 és az RPI vezeték nélküli csatlakoztatásához a websocket nevű könyvtárat fogjuk használni. A könyvtár telepítéséhez itt szerezhetjük be a fájlokat. Meg kell változtatnunk néhány kódot a fájlokban, hogy ezt a könyvtárat az ESP32 -hez használhassuk.

Meg kell változtatnunk az MD5.c és MD5.h.

• MD5Init - MD5InitXXX
• MD5Frissítés MD5 -re FrissítésXXX
• MD5Final - MD5FinalXXX

Törölnünk kell az sha1 fájlok avr/io.h sorait is.

Ezután hozzáadhatjuk a könyvtárat az Arduino IDE -hez vázlattal> tartalmazza a könyvtárat> hozzáadjuk a. ZIP könyvtárat, majd kiválaszthatjuk könyvtárát egy zip fájlban.

Ezt követően elkezdhetjük a kód írását.

Először az ESP32 esetében:

Könyvtárunkat is beleértve

#befoglalni #befoglalni

Ismét hozzárendeljük a csapjainkat.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

A wifi szerver hozzárendelése

WiFiServer szerver (80);

Websocket szerverünk elindítása

WebSocketServer webSocketServer;

A wifi SSID -jének és jelszavának hozzárendelése

const char* ssid = "a wifi SSID";

const char* password = "a wifi jelszava";

void setup () {

A soros monitor beállítása

Sorozat.kezdet (115200);

A lágy edények beállítása

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Elindítjuk a wifi -t és csatlakozunk hozzá

WiFi.begin (ssid, jelszó);

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

késleltetés (1000);

Serial.println ("Csatlakozás WiFi -hez.."); }

Serial.println ("Csatlakozott a WiFi hálózathoz");

Serial.println (WiFi.localIP ());

szerver.begin (); késleltetés (100); }

void getdata (char *pdata) {

Az adatok olvasása

// Olvassa be a lágy edény ADC értékét

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analóg olvasat (SOFT_POT_PIN3);

int softPotADC4 = analóg olvasat (SOFT_POT_PIN4);

Az adatok listába helyezése és hexadecimálisra konvertálása.

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

}

void loop () {

Az ügyfél csatlakoztatása (rPI)

WiFiClient kliens = szerver.available ();

if (client.connected ()) {

késleltetés (10);

if (webSocketServer.handshake (kliens)) {

Serial.println ("Kliens csatlakoztatva");

Adatok küldése és fogadása.

while (client.connected ()) {

char adatok [30];

getdata (adatok);

Serial.println (adatok);

webSocketServer.sendData (adatok);

késleltetés (10); // Késleltetés szükséges az adatok helyes fogadásához}

Serial.println ("Az ügyfél leválasztva");

késleltetés (100); }

más {

Serial.println ("shitsfuckedyo");

} } }

Ezután az rPI -hez a pythonban:

Könyvtáraink importálása

websocket importálása idő

Globale variabel kiosztása i

i = 0

Maximum 200 üzenet beállítása, amelyeket fogadhatunk

nrOfMessages = 200

osztályú Websocket ():

def _init _ (saját):

Websocketünk inicializálása és csatlakoztatása az ESP32 -hez

self.ws = websocket. WebSocket ()

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

Adataink fogadása

def munka (ön):

self.ws.send ("üzenet száma: 0")

eredmény = self.ws.recv () time.sleep (0.5) visszatérési eredmény

A websocket bezárása, miután mindent megkapott

def close (self):

self.ws.close ()

4. lépés: A webhely és az adatbázis összekapcsolása

Ami az adatbázisunk és webhelyünk összekapcsolását illeti, először is létre kell hoznia az adatbázisát a pi -n a mariadb: sudo apt install mariadb telepítésével.

Ezután hozzáférhet a következőhöz: sudo mariadb.

Ezután létre kell hoznia a webhelyét. Ezt tetszés szerint megteheti, de használnia kell a Lombikot, és rendelkeznie kell egy űrlappal a HTML -ben az adatok leállításához és elindításához.

Ezután beillesztheti ezt a kódot az adatbázis és a webhely összekapcsolásához (mind a webhelyének, mind az adatbázisnak a pi -n kell lennie, ezt megteheti a pycharm beállításainak telepítési lapjának használatával)

a flaskext.mysql -ből importálja a MySQL -t

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

app.config ["MYSQL_DATABASE_DB"] = "az adatbázis neve"

app.config ["MYSQL_DATABASE_USER"] = "az adatbázis felhasználója"

app.config ["MYSQL_DATABASE_PASSWORD"] = "az adatbázis jelszava"

Funkció az adatok eltávolítására az adatbázisunkból.

def get_data (sql, params = Nincs):

conn = mysql.connect ()

kurzor = conn.cursor ()

nyomtatás ("adatok beszerzése")

próbáld ki:

nyomtatás (sql)

cursor.execute (sql, params)

kivéve a kivételt, mint pl.

nyomtatás (e)

return hamis

eredmény = cursor.fetchall ()

adatok =

sorban az eredményben:

data.append (lista (sor))

cursor.close ()

conn.close ()

visszaadási adatokat

Funkció adatok beillesztéséhez adatbázisunkba

def set_data (sql, params = Nincs):

conn = mysql.connect ()

kurzor = conn.cursor ()

próbáld ki:

log.debug (sql)

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

log.debug ("SQL uitgevoerd")

kivéve a kivételt, mint pl.

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

return hamis

cursor.close ()

conn.close ()

return True

Szükségünk lesz arra is, hogy az alkalmazásunkat szálakkal lássuk el, hogy rögzítés közben más dolgokat is elvégezhessen.

osztályú ThreadedTask (threading. Thread):

def _init _ (saját,):

Szál beállítása

szál. Szál._ init _ (saját)

Lista létrehozása az összes fogadott adat tárolására

self.data_all =

def run (self):

time.sleep (5)

Importálja saját python kódját, ahonnan az adatokat kapja

Receive_websocket importálása

Fogadja el adatait

w = Receive_websocket. Websocket ()

Adja hozzá adatait a listához és nyomtassa ki.

i (0, 200) tartományban:

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

nyomtatás (self.data_all)

feladat = ThreadedTask ()

Ezután a task.run () segítségével elindíthatja a szálat, és elkezdheti fogadni az adatokat.

5. lépés: Minden összekapcsolása

A webhely Pi -ről történő futtatásához használnia kell egy szolgáltatást:

[Egység] Leírás = uWSGI példány a project1 webes felület kiszolgálására

Utána = network.target

BindsTo = mysqld.service

After = mysqld.szolgáltatás

[Szolgáltatás]

Váltson a felhasználóra

Felhasználó = pi

Csoport = www-adatok

Itt meg kell adnia a Flask fájl könyvtárát

WorkingDirectory =/home/pi/project1/web

Az ini fájl könyvtára, amely később megtalálható.

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

[Telepítés]

WantedBy = többfelhasználós.cél

uwsgi-flask.ini, amelyet el kell helyeznie a fenti ExecStartban megadott könyvtárba

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

mester = valódi folyamatok = 5

plugins = python3

aljzat = project1.sock chmod-socket = 660 vákuum = igaz

die-on-term = igaz

Most már olvashatja adatait, és megjelenítheti azokat webhelyén.

6. lépés: Extra: LCD képernyő csatlakoztatása

Csatlakoztathatunk egy LCD képernyőt, hogy meg tudjuk mutatni a Pi weboldalunkhoz tartozó ip-címét.

importálja az RPi. GPIO fájlt GPIO -ként

importparancsok

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

osztályú képernyő:

def _init _ (saját):

GPIO.setmode (GPIO. BCM)

self.setup ()

#Funkciókészlet self.stuur_instructie (0x3f) #Display self.stuur_instructie (0x0c) #On + kurzor self.stuur_instructie (0x01) @staticmethod def setup (): GPIO.setup (lista, GPIO. OUT) GPIO.setup ([E, RS], GPIO. OUT)

def stuur_instructie (önálló, bájt):

GPIO kimenet (E, GPIO. HIGH)

GPIO kimenet (RS, GPIO. LOW)

self.set_GPIO_bits (bájt)

time.sleep (0.005)

GPIO.kimenet (E, GPIO. LOW)

def stuur_teken (self, char):

temp = ord (char)

GPIO kimenet (E, GPIO. HIGH)

GPIO kimenet (RS, GPIO. HIGH)

self.set_GPIO_bits (temp)

time.sleep (0.005)

GPIO.kimenet (E, GPIO. LOW)

def set_GPIO_bits (önálló, bájt):

i (0, 8) tartományban:

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

GPIO. kimenet (lista , GPIO. LOW)

más:

GPIO. output (lista , GPIO. HIGH)

def main ():

s = Képernyő ()

teken = "Helyi IP -cím:"

a tekeni levélhez:

s.stuur_teken (levél)

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

nyomtatás (teken2)

s.stuur_instructie (0xc0)

a letter2 -hez teken2 -ben:

s.stuur_teken (levél2)

if _name_ == '_main_': #A program innen indul

próbáld ki:

fő()

A billentyűzet megszakítása kivételével:

passz

Ezután létrehozhatunk egy szolgáltatást az LCD indításához indításkor.