Meranie polôh prstov na husliach s ESP32: 6 krokov

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 12:00

Ako hráč na husliach som vždy chcel aplikáciu alebo nástroj, ktorý by mi veľmi presne ukázal polohu mojich prstov na husliach. S týmto projektom som sa pokúsil vybudovať toto. Aj keď je to prototyp, stále môžete pridať mnoho funkcií.

Skúsil som tiež oddeliť ESP32 a rPI a tak som urobil, aby ESP32 odosielal údaje bezdrôtovo na rPi. Čo je na tomto projekte asi najťažšie.

Je tiež veľmi dôležité, aby na konci tohto projektu nebolo vo vašom počítači uložené nič, ale buď na rPI alebo ESP32.

Krok 1: Materiály a nástroje

Predtým, ako sa dostaneme k špecifikám stavby tohto projektu, potrebujeme niekoľko vecí.

1. 4x lineárny softpot: lineárne potenciometre na meranie polohy prsta (husle majú 4 struny)
2. ESP32: Modul ESP32 na čítanie údajov z lineárnych softpotov.
3. husle 4/4: husle, ktoré umiestnia lineárne mäkké hrnce na vrch.
4. Raspberry Pi s kartou SD: malinový pi, ktorý uloží našu databázu a webové stránky.
5. 10k potenciometer: potenciometer pre jas LCD
6. LCD obrazovka: LCD obrazovka, ktorá sa zobrazuje IP adresám rPi
7. Súprava spájkovania: Na spájkovanie všetkých prvkov dohromady
8. Samec-samec drôty a mužské-samičie vodiče: Káble na pripojenie všetkých prvkov
9. Micro USB kábel: Na napájanie ESP32

Krok 2: Pripojenie softpotov k ESP32

V prvom rade musíme pripojiť naše softpots k esp32. Ľavý a pravý kolík pripájame k 5V a GND. Stredný kolík pripájame k analógovému kolíku na ESP32. Potrebujeme tiež pripojiť stredný kolík s odporom 10 k ohmov a pripojiť ho k GND. Je to preto, aby náš výstup softpotov nevracal náhodnú hodnotu.

Potom pripojíme ESP32 pomocou mikro USB kábla k počítaču, aby sme naň mohli nahrať kód. Na programovanie ESP32 použijeme Arduino IDE. Najprv však musíme nainštalovať jadro Arduino pre ESP32, aby sme doň mohli nahrávať. To sa dá urobiť tu.

Potom môžeme začať písať kód.

Najprv musíme priradiť svoje piny, ku ktorým sme pripojili náš stredný kolík 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;

nepodpísané dlhé onTime;

bez znamienka dlhý softPotTime;

Potom môžeme nastaviť svoje špendlíky. A musíme spustiť náš sériový monitor a náš čas.

neplatné nastavenie () {

onTime = millis ();

Serial.begin (115200);

Serial.println ("Spustenie programu");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

void getdata (byte pdata ) {

// Prečítajte si hodnotu ADC soft potu

Potom si musíme prečítať naše piny, aby sme mohli prijímať naše údaje.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Potom vložíme hodnoty do zoznamu, aby sme ich mohli neskôr ľahko vytvoriť.

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

int Názvy = {softPotADC1, softPotADC2, softPotADC3, softPotADC4};

int softpot = mená ;

if (softpot> 10) {

pdata [0] = i;

pdata [1] = softpot;

pdata [2] = milis ();

} } }

}

Krok 3: Bezdrôtové pripojenie ESP32 a RPI

Na bezdrôtové prepojenie ESP32 a RPI použijeme knižnicu s názvom websocket. Ak chcete nainštalovať túto knižnicu, môžeme získať súbory tu. Aby sme mohli túto knižnicu používať pre ESP32, budeme musieť zmeniť nejaký kód v samotných súboroch.

Budeme musieť zmeniť MD5.c a MD5.h.

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

Tiež budeme musieť odstrániť riadky avr/io.h v súboroch sha1.

Potom môžeme knižnicu pridať do nášho Arduino IDE načrtnutím> zahrnúť knižnicu> pridať knižnicu. ZIP a potom môžeme vybrať vašu knižnicu v súbore zip.

Potom môžeme začať písať náš kód.

Najprv pre ESP32:

Vrátane našej knižnice

#include #include

Opäť priradenie našich pinov.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Priradenie nášho wifi servera

Server WiFiServer (80);

Spustenie nášho servera websocket

WebSocketServer webSocketServer;

Priradenie nášho SSID a hesla vašej wifi

const char* ssid = "vaše SSID SSID";

const char* heslo = "vaše heslo pre wifi";

neplatné nastavenie () {

Nastavenie sériového monitora

Serial.begin (115200);

Nastavenie softpotov

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Spustenie wifi a pripojenie k nej

WiFi.begin (ssid, heslo);

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

oneskorenie (1000);

Serial.println ("Pripojenie k WiFi.."); }

Serial.println („Pripojené k sieti WiFi“);

Serial.println (WiFi.localIP ());

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

void getdata (char *pdata) {

Čítanie vašich údajov

// Prečítajte si hodnotu ADC soft potu

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Umiestnenie údajov do zoznamu a ich konverzia na hexadecimálne.

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

}

prázdna slučka () {

Pripojenie vášho klienta (rPI)

Klient WiFiClient = server.available ();

if (client.connected ()) {

oneskorenie (10);

if (webSocketServer.handshake (klient)) {

Serial.println („Klient pripojený“);

Odosielanie a prijímanie údajov.

while (client.connected ()) {

údaje o znakoch [30];

getdata (údaje);

Serial.println (údaje);

webSocketServer.sendData (údaje);

oneskorenie (10); // Na správne prijatie údajov je potrebné oneskorenie}

Serial.println („Klient sa odpojil“);

oneskorenie (100); }

inak {

Serial.println ("shitsfuckedyo");

} } }

Potom pre rPI v pythone:

Import našich knižníc

importovať čas importu websocket

Priradenie globálneho premenného i

i = 0

Nastavenie maximálne 200 správ, ktoré môžeme prijímať

nrOfMessages = 200

trieda Websocket ():

def _init _ (self):

Inicializujeme našu webovú zásuvku a pripojíme ju k nášmu ESP32

self.ws = websocket. WebSocket ()

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

Prijímame naše údaje

def práca (seba):

self.ws.send ("číslo správy: 0")

result = self.ws.recv () time.sleep (0,5) návratový výsledok

Zatvorenie webovej zásuvky po prijatí všetkého

defin close (self):

self.ws.close ()

Krok 4: Pripojenie vašej webovej stránky a databázy

Pokiaľ ide o prepojenie našej databázy a webovej stránky, v prvom rade budete musieť vytvoriť svoju databázu na pi inštaláciou mariadb: sudo apt install mariadb.

Potom k nemu získate prístup: sudo mariadb.

Potom budete tiež musieť vytvoriť svoj web. Môžete to urobiť, ako sa vám páči, ale musíte použiť banku a vo svojom HTML musíte mať formulár na zastavenie a spustenie údajov.

Potom môžete vložiť tento kód a prepojiť tak svoju databázu a svoj web (váš web aj databáza musia byť na vašom pi, to je možné vykonať pomocou karty nasadenia v nastaveniach pycharm)

z flaskext.mysql importovať MySQL

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

app.config ["MYSQL_DATABASE_DB"] = "názov vašej databázy"

app.config ["MYSQL_DATABASE_USER"] = "váš užívateľ databázy"

app.config ["MYSQL_DATABASE_PASSWORD"] = "heslo do vašej databázy"

Funkcia na získanie údajov z našej databázy.

def get_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

tlač („získavanie údajov“)

skús:

tlač (sql)

cursor.execute (sql, parametre)

okrem výnimky ako e:

vytlačiť (e)

vrátiť False

výsledok = cursor.fetchall ()

údaje =

pre riadok vo výsledku:

data.append (zoznam (riadok))

cursor.close ()

conn.close ()

vrátiť údaje

Funkcia na vkladanie údajov do našej databázy

def set_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

skús:

log.debug (sql)

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

log.debug ("SQL uitgevoerd")

okrem výnimky ako e:

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

vrátiť False

cursor.close ()

conn.close ()

vrátiť True

Tiež budeme musieť prevliecť našu aplikáciu, aby ste počas nahrávania mohli robiť aj iné veci.

trieda ThreadedTask (threading. Thread):

def _init _ (self,):

Nastavenie vlákna

vlákno. Vlákno._ init _ (vlastné)

Vytvorenie zoznamu na uchovávanie všetkých prijatých údajov

self.data_all =

def run (vlastné):

time.sleep (5)

Importujte svoj vlastný pythonový kód, do ktorého prijímate údaje

import receive_websocket

Prijmite svoje údaje

w = receive_websocket. Websocket ()

Pripojte svoje údaje do zoznamu a vytlačte si ich.

pre i v rozsahu (0, 200):

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

vytlačiť (self.data_all)

task = ThreadedTask ()

Potom môžete task.run () spustiť vlákno a začať prijímať údaje.

Krok 5: Prepojenie všetkého dohromady

Na spustenie vášho webu z vášho Pi musíte použiť službu:

[Unit] Description = inštancia uWSGI na obsluhu webového rozhrania project1

After = network.target

BindsTo = mysqld.service

After = mysqld.service

[Služba]

Zmeňte na svojho používateľa

Používateľ = pi

Skupina = www-dáta

Tu musíte zadať adresár súboru s fľašou

WorkingDirectory =/home/pi/project1/web

Adresár vášho súboru ini, ktorý nájdete neskôr.

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

[Inštalácia]

WantedBy = multi-user.target

uwsgi-flask.ini, ktoré musíte umiestniť do adresára, ktorý ste uviedli v programe ExecStart vyššie

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

majster = skutočné procesy = 5

pluginy = python3

socket = project1.sock chmod-socket = 660 vákuum = true

die-on-term = pravda

Teraz si môžete prečítať svoje údaje a zobraziť ich na svojom webe.

Krok 6: Extra: Pripojenie obrazovky LCD

Môžeme pripojiť LCD obrazovku, aby sme mohli ukázať IP adresu nášho Pi pre náš web.

importujte RPi. GPIO ako čas GPIOimportu

importné príkazy

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

obrazovka triedy:

def _init _ (self):

GPIO.setmode (GPIO. BCM)

self.setup ()

#Funkcia 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):

GPIO.output (E, GPIO. HIGH)

GPIO.output (RS, GPIO. LOW)

self.set_GPIO_bits (bajt)

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 (self, byte):

pre i v rozsahu (0, 8):

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

GPIO.output (zoznam , GPIO. LOW)

inak:

GPIO.output (zoznam , GPIO. HIGH)

def main ():

s = obrazovka ()

teken = "Miestna adresa IP:"

pre list v tekene:

s.stuur_teken (list)

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

tlač (teken2)

s.stuur_instructie (0xc0)

pre písmeno 2 v teken2:

s.stuur_teken (písmeno2)

if _name_ == '_main_': #Program začína odtiaľto

skús:

Hlavná()

okrem prerušenia klávesnice:

prejsť

Potom môžeme vytvoriť službu na spustenie LCD pri spustení.