Pirkstu pozīciju mērīšana vijolē ar ESP32: 6 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:57

Kā vijoles spēlētājs es vienmēr gribēju lietotni vai rīku, kas man ļoti precīzi parādītu manu pirkstu stāvokli uz vijoles. Ar šo projektu es mēģināju to izveidot. Lai gan tas ir prototips, un jūs joprojām varētu pievienot daudzas funkcijas.

Es arī mēģināju atdalīt ESP32 un rPI, un tādējādi es liku ESP32 nosūtīt datus bezvadu režīmā uz rPi. Kas, iespējams, ir visgrūtākais šajā projektā.

Ir arī ļoti svarīgi, lai šī projekta beigās jūsu datorā nekas netiktu saglabāts, bet tas būtu vai nu rPI, vai ESP32.

1. darbība: materiāli un instrumenti

Pirms iedziļināties šī projekta veidošanas specifikā, mums ir vajadzīgas dažas lietas.

1. 4x lineārs mīkstais katls: lineārie potenciometri pirksta stāvokļa mērīšanai (vijolei ir 4 stīgas)
2. ESP32: ESP32 modulis, lai nolasītu datus no lineārajiem mīkstajiem punktiem.
3. 4/4 vijole: vijole lineāro mīksto podu novietošanai virsū.
4. Raspberry Pi ar SD karti: aveņu pi, kas saglabās mūsu datu bāzi un vietni.
5. 10k potenciometrs: potenciometrs LCD spilgtumam
6. LCD ekrāns: LCD ekrāns, ko parādīt IP adresēm
7. Lodēšanas komplekts: visu elementu lodēšanai kopā
8. Vadi no vīrieša līdz vīrietim un vadi no sievietes uz vadiem: kabeļi visu elementu savienošanai
9. Mikro USB kabelis: ESP32 barošanai

2. solis: Softpots pievienošana ESP32

Vispirms mums ir jāpievieno mūsu mīkstie katli ar esp32. Mēs savienojam kreiso un labo tapu attiecīgi ar 5V un GND. Mēs savienojam vidējo tapu ar analogo tapu ESP32. Mums arī jāpievieno vidējā tapa ar pretestību 10k omi un jāpievieno tas GND. Tas ir tāpēc, ka mūsu softpots produkcija neatgriež nejaušu vērtību.

Tad mēs savienojam ESP32 ar mikro usb kabeli savam datoram, lai mēs tajā varētu augšupielādēt kodu. ESP32 programmēšanai mēs izmantosim Arduino IDE. Bet vispirms mums ir jāinstalē Arduino kodols ESP32, lai mēs varētu to augšupielādēt. To var izdarīt šeit.

Tad mēs varam sākt rakstīt kodu.

Vispirms mums jāpiešķir mūsu tapas, kurām mēs pievienojām mīksto podu vidējo tapu.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

neparakstīts ilgi onTime;

neparakstīts garš softPotTime;

Tad mēs varam uzstādīt savas tapas. Un mums ir jāsāk sērijveida monitors un savs laiks.

void setup () {

onTime = milis ();

Serial.begin (115200);

Serial.println ("Programmas sākums");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

void getdata (baitu pdata ) {

// Nolasiet mīkstā katla ADC vērtību

Tad mums ir jāizlasa mūsu tapas, lai mēs varētu saņemt savus datus.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Tad mēs ievietojam vērtības sarakstā, lai vēlāk varētu to viegli izvadīt.

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

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

int softpot = Vārdi ;

ja (mīkstais katls> 10) {

pdata [0] = i;

pdata [1] = softpot;

pdata [2] = milis ();

} } }

}

3. darbība: ESP32 un RPI savienošana bez vadiem

ESP32 un RPI bezvadu savienošanai mēs izmantosim bibliotēku ar nosaukumu websocket. Lai instalētu šo bibliotēku, mēs varam iegūt failus šeit. Lai izmantotu šo bibliotēku ESP32, mums būs jāmaina kods pašos failos.

Mums būs jāmaina MD5.c un MD5.h.

• MD5Init uz MD5InitXXX
• MD5Atjaunināt uz MD5UpdateXXX
• MD5Final līdz MD5FinalXXX

Mums būs arī jāizdzēš avr/io.h līnijas sha1 failos.

Tad mēs varam pievienot bibliotēku mūsu Arduino IDE, ieskicējot> iekļaut bibliotēku> pievienot. ZIP bibliotēku, un tad mēs varam izvēlēties jūsu bibliotēku zip failā.

Pēc tam mēs varam sākt rakstīt savu kodu.

Vispirms par ESP32:

Ieskaitot mūsu bibliotēku

#iekļaut #iekļaut

Atkal piešķirot mūsu tapas.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Tiek piešķirts mūsu wifi serveris

WiFi servera serveris (80);

Tiek palaists mūsu tīmekļa ligzdas serveris

WebSocketServer webSocketServer;

Piešķirot mūsu wifi SSID un paroli

const char* ssid = "jūsu wifi SSID";

const char* parole = "jūsu wifi parole";

void setup () {

Sērijveida monitora iestatīšana

Serial.begin (115200);

Softpot uzstādīšana

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Tiek palaists mūsu wifi un izveidots savienojums ar to

WiFi.begin (ssid, parole);

kamēr (WiFi.status ()! = WL_CONNECTED) {

kavēšanās (1000);

Serial.println ("Savienojuma izveide ar WiFi.."); }

Serial.println ("Savienots ar WiFi tīklu");

Serial.println (WiFi.localIP ());

server.begin (); kavēšanās (100); }

void getdata (char *pdata) {

Jūsu datu lasīšana

// Nolasiet mīkstā katla ADC vērtību

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Datu ievietošana sarakstā un pārvēršana heksadecimālā.

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

}

void loop () {

Klienta savienošana (RPI)

WiFiClient klients = server.available ();

ja (client.connected ()) {

kavēšanās (10);

if (webSocketServer.handshake (klients)) {

Serial.println ("Klients savienots");

Datu sūtīšana un saņemšana.

while (client.connected ()) {

char dati [30];

getdata (dati);

Serial.println (dati);

webSocketServer.sendData (dati);

kavēšanās (10); // Nepieciešama aizkave, lai pareizi saņemtu datus}

Serial.println ("Klients atvienots");

kavēšanās (100); }

cits {

Serial.println ("shitsfuckedyo");

} } }

Tad par rPI python:

Importē mūsu bibliotēkas

importēt websocketimportēt laiku

Globale variabel piešķiršana i

i = 0

Maksimāli 200 ziņu iestatīšana, ko mēs varam saņemt

nrOfMessages = 200

klases Websocket ():

def _init _ (sevi):

Mūsu tīmekļa ligzdas inicializēšana un savienošana ar mūsu ESP32

self.ws = websocket. WebSocket ()

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

Mūsu datu saņemšana

def darbs (pats):

self.ws.send ("ziņojums nr: 0")

rezultāts = self.ws.recv () time.sleep (0.5) atgriešanās rezultāts

Tīmekļa ligzdas aizvēršana pēc visa saņemšanas

def aizvērt (sevi):

self.ws.close ()

4. darbība. Savas vietnes un datu bāzes savienošana

Kas attiecas uz mūsu datubāzes un vietnes savienošanu, jums vispirms ir jāizveido datu bāze pi, instalējot mariadb: sudo apt install mariadb.

Pēc tam varat piekļūt, veicot šādas darbības: sudo mariadb.

Tad jums arī būs jāizveido sava vietne. Jūs varat to darīt, kā vēlaties, taču jums ir jāizmanto kolba, un jums ir jābūt veidlapai HTML, lai apturētu un sāktu savus datus.

Tad jūs varat ievietot šo kodu, lai savienotu savu datu bāzi un vietni (gan jūsu vietnei, gan datu bāzei ir jābūt jūsu pi, to var izdarīt, izmantojot pycharm iestatījumu cilni Izvietošana)

no flaskext.mysql importēt MySQL

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

app.config ["MYSQL_DATABASE_DB"] = "jūsu datu bāzes nosaukums"

app.config ["MYSQL_DATABASE_USER"] = "jūsu datu bāzes lietotājs"

app.config ["MYSQL_DATABASE_PASSWORD"] = "jūsu datu bāzes parole"

Funkcija datu iegūšanai no mūsu datu bāzes.

def get_data (sql, params = nav):

conn = mysql.connect ()

kursors = savienojuma kursors ()

drukāt ("iegūt datus")

pamēģini:

drukāt (sql)

cursor.execute (sql, params)

izņemot izņēmumu, piemēram:

drukāt (e)

atgriešanās False

rezultāts = cursor.fetchall ()

dati =

rindas rezultātam:

data.append (saraksts (rinda))

cursor.close ()

conn.close ()

atgriezt datus

Funkcija datu ievietošanai mūsu datu bāzē

def set_data (sql, params = nav):

conn = mysql.connect ()

kursors = savienojuma kursors ()

pamēģini:

log.debug (sql)

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

log.debug ("SQL uitgevoerd")

izņemot izņēmumu, piemēram:

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

atgriešanās False

cursor.close ()

conn.close ()

atgriezties True

Mums arī vajadzēs pavedināt mūsu lietojumprogrammu, lai ierakstīšanas laikā jūs varētu darīt citas lietas.

klases ThreadedTask (threading. Thread):

def _init _ (sevi,):

Vītnes iestatīšana

pavediens. Vītne._ init _ (self)

Saraksta izveide visu saņemto datu glabāšanai

self.data_all =

def run (self):

laiks. miegs (5)

Importējiet savu pitona kodu, kur saņemat datus

importēt Receive_websocket

Saņemiet savus datus

w = Receive_websocket. Websocket ()

Pievienojiet savus datus savam sarakstam un izdrukājiet.

i diapazonā (0, 200):

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

drukāt (self.data_all)

uzdevums = ThreadedTask ()

Pēc tam varat veikt uzdevumu task.run (), lai sāktu pavedienu un sāktu saņemt datus.

5. solis: visu savienojiet kopā

Lai palaistu savu vietni no sava Pi, jums jāizmanto pakalpojums:

[Vienība] Apraksts = uWSGI instance projekta1 tīmekļa saskarnes apkalpošanai

Pēc = network.target

BindsTo = mysqld.service

Pēc = mysqld.service

[Apkalpošana]

Mainīt uz savu lietotāju

Lietotājs = pi

Grupa = www-dati

Šeit jums jāievada kolbas faila direktorijs

WorkingDirectory =/home/pi/project1/web

Ini faila katalogs, kuru var atrast vēlāk.

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

[Uzstādīt]

WantedBy = vairāku lietotāju mērķis

uwsgi-flask.ini, kas jāievieto direktorijā, kuru norādījāt iepriekš vietnē ExecStart

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

meistars = patiesie procesi = 5

spraudņi = python3

ligzda = projekts1.sock chmod-socket = 660 vakuums = true

die-on-term = taisnība

Tagad jūs varat lasīt savus datus un parādīt tos savā vietnē.

6. darbība: papildus: LCD ekrāna pievienošana

Mēs varam savienot LCD ekrānu, lai mēs varētu parādīt mūsu Pi ip adresi mūsu vietnei.

importēt RPi. GPIO kā GPIOimportēt laiku

importēšanas komandas

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

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

E = 24

RS = 23

klases ekrāns:

def _init _ (sevi):

GPIO.setmode (GPIO. BCM)

self.setup ()

#Funkciju kopa self.stuur_instructie (0x3f) #Display self.stuur_instructie (0x0c) #On + kursors self.stuur_instructie (0x01) @staticmethod def setup (): GPIO.setup (saraksts, GPIO. OUT) GPIO.setup ([E, RS], GPIO. OUT)

def stuur_instructie (self, baits):

GPIO izeja (E, GPIO. HIGH)

GPIO izeja (RS, GPIO. LOW)

self.set_GPIO_bits (baits)

miega laiks (0,005)

GPIO izeja (E, GPIO. LOW)

def stuur_teken (self, char):

temp = ord (char)

GPIO izeja (E, GPIO. HIGH)

GPIO izeja (RS, GPIO. HIGH)

self.set_GPIO_bits (temp)

miega laiks (0,005)

GPIO izeja (E, GPIO. LOW)

def set_GPIO_bits (self, baits):

i diapazonā (0, 8):

ja (baits & (2 ** i)) == 0:

GPIO.output (saraksts , GPIO. LOW)

cits:

GPIO.izvade (saraksts , GPIO. HIGH)

def main ():

s = ekrāns ()

teken = "Vietējā IP adrese:"

burtam tekenā:

s.stuur_teken (vēstule)

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

drukāt (teken2)

s.stuur_instructie (0xc0)

2. burtam teken2:

s.stuur_teken (burts2)

ja _name_ == '_main_': #programma sākas no šejienes

pamēģini:

galvenais ()

izņemot tastatūruPārtraukums:

iziet

Pēc tam mēs varam izveidot pakalpojumu LCD ieslēgšanai palaišanas laikā.