Měření poloh prstů na houslích s ESP32: 6 kroků

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:23

Jako hráč na housle jsem vždy chtěl aplikaci nebo nástroj, který by mi velmi přesně ukázal polohu mých prstů na houslích. S tímto projektem jsem se pokusil vybudovat toto. Ačkoli se jedná o prototyp a stále můžete přidat mnoho funkcí.

Zkoušel jsem také oddělit ESP32 a rPI, a tak jsem nechal ESP32 bezdrátově posílat data do rPi. Což je na tomto projektu asi nejtěžší.

Je také velmi důležité, aby na konci tohoto projektu nebylo nic uloženo ve vašem počítači, ale bylo to buď na rPI nebo ESP32.

Krok 1: Materiály a nástroje

Než se dostaneme ke specifikům stavby tohoto projektu, potřebujeme pár věcí.

1. 4x lineární softpot: lineární potenciometry pro měření polohy prstu (housle mají 4 struny)
2. ESP32: Modul ESP32 pro čtení dat z lineárních softpotů.
3. 4/4 housle: housle k umístění lineárních softpotů na vrchol.
4. Raspberry Pi s kartou SD: malinový pi, který uloží naši databázi a webové stránky.
5. 10k potenciometr: potenciometr pro jas LCD
6. LCD obrazovka: LCD obrazovka, která se zobrazuje IP adresám rPi
7. Pájecí sada: Pro pájení všech prvků dohromady
8. Kabely typu male-to-male a male-to-female: Kabely pro připojení všech prvků
9. Micro USB kabel: Pro napájení ESP32

Krok 2: Připojení softpotů k ESP32

Nejprve musíme připojit naše softpoty k esp32. Připojte levý a pravý kolík k 5V a GND. Prostřední pin připojíme k analogovému pinu na ESP32. Potřebujeme také připojit střední kolík s odporem 10 k ohmů a připojit jej ke GND. To proto, aby náš výstup softpotů nevracel náhodnou hodnotu.

Poté připojíme ESP32 pomocí mikro USB kabelu k počítači, abychom do něj mohli nahrát kód. Pro programování ESP32 použijeme Arduino IDE. Nejprve ale musíme nainstalovat jádro Arduino pro ESP32, abychom do něj mohli nahrávat. To lze provést zde.

Pak můžeme začít psát kód.

Nejprve musíme přiřadit naše kolíky, ke kterým jsme připojili náš střední kolík softpotů.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

nepodepsaný dlouhý čas;

bez znaménka dlouhý softPotTime;

Pak můžeme nastavit naše piny. A musíme spustit náš sériový monitor a náš čas.

neplatné nastavení () {

onTime = millis ();

Serial.begin (115200);

Serial.println ("Start 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 ) {

// Přečtěte si hodnotu ADC soft potu

Poté musíme přečíst naše piny, abychom mohli přijímat naše 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);

Poté vložíme hodnoty do seznamu, abychom je mohli později snadno odeslat.

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

int Jména = {softPotADC1, softPotADC2, softPotADC3, softPotADC4};

int softpot = Jména ;

if (softpot> 10) {

pdata [0] = i;

pdata [1] = softpot;

pdata [2] = milis ();

} } }

}

Krok 3: Bezdrátové připojení ESP32 a RPI

Pro bezdrátové propojení ESP32 a RPI použijeme knihovnu s názvem websocket. K instalaci této knihovny můžeme získat soubory zde. Abychom mohli tuto knihovnu použít pro ESP32, budeme muset změnit nějaký kód v samotných souborech.

Budeme muset změnit MD5.c a MD5.h.

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

Také budeme muset odstranit avr/io.h řádky v souborech sha1.

Poté můžeme knihovnu přidat do našeho Arduino IDE pomocí skici> zahrnout knihovnu> přidat knihovnu. ZIP a poté můžeme vybrat vaši knihovnu v souboru zip.

Poté můžeme začít psát náš kód.

Nejprve pro ESP32:

Včetně naší knihovny

#include #include

Opět přiřazení našich pinů.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Přiřazení našeho wifi serveru

Server WiFiServer (80);

Spouštění našeho serveru websocket

WebSocketServer webSocketServer;

Přiřazení našeho SSID a hesla vaší wifi

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

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

neplatné nastavení () {

Nastavení sériového monitoru

Serial.begin (115200);

Nastavení softpotů

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Spuštění naší wifi a připojení k ní

WiFi.begin (ssid, heslo);

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

zpoždění (1000);

Serial.println ("Připojení k WiFi.."); }

Serial.println ("Připojeno k WiFi síti");

Serial.println (WiFi.localIP ());

server.begin (); zpoždění (100); }

void getdata (char *pdata) {

Čtení vašich dat

// Přečtěte 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);

Umístění dat do seznamu a jejich převedení na hexadecimální.

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

}

prázdná smyčka () {

Připojení vašeho klienta (rPI)

Klient WiFiClient = server.available ();

if (client.connected ()) {

zpoždění (10);

if (webSocketServer.handshake (client)) {

Serial.println („Klient připojen“);

Odesílání a příjem dat.

while (client.connected ()) {

char data [30];

getdata (data);

Serial.println (data);

webSocketServer.sendData (data);

zpoždění (10); // Ke správnému přijetí dat je nutné zpoždění}

Serial.println ("Klient odpojen");

zpoždění (100); }

jinak {

Serial.println ("shitsfuckedyo");

} } }

Pak pro rPI v pythonu:

Import našich knihoven

importovat čas websocketimportu

Přiřazení globálního proměnného i

i = 0

Nastavení maximálně 200 zpráv, které můžeme přijímat

nrOfMessages = 200

třída Websocket ():

def _init _ (self):

Inicializace našeho websocketu a jeho připojení k našemu ESP32

self.ws = websocket. WebSocket ()

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

Příjem našich dat

def práce (vlastní):

self.ws.send ("zpráva č. 0")

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

Zavření webové zásuvky po obdržení všeho

def close (self):

self.ws.close ()

Krok 4: Propojení vašeho webu a databáze

Pokud jde o propojení naší databáze a webu, budete nejprve muset vytvořit svou databázi na pi instalací mariadb: sudo apt install mariadb.

Pak k němu můžete přistoupit pomocí: sudo mariadb.

Poté budete také muset vytvořit svůj web. Můžete to dělat, jak chcete, ale musíte použít Flask a v HTML musíte mít formulář pro zastavení a spuštění dat.

Poté můžete vložit tento kód a propojit tak svou databázi a svůj web (váš web i databáze musí být na vašem pi, to lze provést pomocí karty nasazení v nastavení pycharm)

z flaskext.mysql importovat MySQL

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

app.config ["MYSQL_DATABASE_DB"] = "název vaší databáze"

app.config ["MYSQL_DATABASE_USER"] = "váš uživatel databáze"

app.config ["MYSQL_DATABASE_PASSWORD"] = "heslo vaší databáze"

Funkce pro získání dat z naší databáze.

def get_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

tisk („získávání dat“)

Snaž se:

tisk (sql)

cursor.execute (sql, parametry)

kromě výjimky jako e:

tisk (e)

vrátit False

result = cursor.fetchall ()

data =

pro řádek ve výsledku:

data.append (seznam (řádek))

cursor.close ()

conn.close ()

vrátit data

Funkce pro vkládání dat do naší databáze

def set_data (sql, params = None):

conn = mysql.connect ()

cursor = conn.cursor ()

Snaž se:

log.debug (sql)

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

log.debug ("SQL uitgevoerd")

kromě výjimky jako e:

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

vrátit False

cursor.close ()

conn.close ()

vrátit True

Také budeme muset vláknit naši aplikaci, abyste mohli během nahrávání dělat další věci.

třída ThreadedTask (threading. Thread):

def _init _ (self,):

Nastavení vlákna

Thread. Thread._ init _ (self)

Vytvoření seznamu pro uchování všech přijatých dat

self.data_all =

def run (vlastní):

time.sleep (5)

Importujte svůj vlastní kód pythonu, odkud data přijímáte

importovat receive_websocket

Přijměte svá data

w = receive_websocket. Websocket ()

Připojte svá data do seznamu a vytiskněte je.

pro i v rozsahu (0, 200):

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

tisk (self.data_all)

task = ThreadedTask ()

Poté můžete task.run () spustit vlákno a začít přijímat data.

Krok 5: Propojení všeho dohromady

Ke spuštění vašeho webu z vašeho Pi musíte použít službu:

[Jednotka] Popis = instance uWSGI k obsluze webového rozhraní project1

After = network.target

BindsTo = mysqld.service

After = mysqld.service

[Servis]

Změnit na svého uživatele

Uživatel = pí

Skupina = www-data

Zde musíte zadat adresář vašeho souboru Flask

WorkingDirectory =/home/pi/project1/web

Adresář vašeho souboru INI, který najdete později.

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

[Nainstalujte]

WantedBy = multi-user.target

uwsgi-flask.ini, které musíte umístit do adresáře, který jste zadali v ExecStart výše

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

master = skutečné procesy = 5

pluginy = python3

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

die-on-term = pravda

Nyní si můžete přečíst svá data a zobrazit je na svém webu.

Krok 6: Extra: Připojení obrazovky LCD

Můžeme připojit LCD obrazovku, abychom mohli ukázat IP adresu našeho Pi pro náš web.

importovat RPi. GPIO jako čas GPIOimportu

importovat příkazy

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

obrazovka třídy:

def _init _ (self):

GPIO.setmode (GPIO. BCM)

self.setup ()

#Sada funkcí self.stuur_instructie (0x3f) #Display self.stuur_instructie (0x0c) #On + kurzor self.stuur_instructie (0x01) @staticmethod def setup (): GPIO.setup (seznam, 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 (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 (self, byte):

pro i v rozsahu (0, 8):

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

GPIO.output (seznam , GPIO. LOW)

jiný:

GPIO.output (seznam , GPIO. HIGH)

def main ():

s = obrazovka ()

teken = "Místní IP adresa:"

pro dopis v tekenu:

s.stuur_teken (dopis)

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

tisk (teken2)

s.stuur_instructie (0xc0)

pro letter2 v teken2:

s.stuur_teken (letter2)

if _name_ == '_main_': #Program začíná odtud

Snaž se:

hlavní()

kromě KeyboardInterrupt:

složit

Poté můžeme vytvořit službu pro spuštění LCD při spuštění.