Pirštų padėties smuikui matuoti naudojant ESP32: 6 žingsniai

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:48

Kaip smuikininkas aš visada norėjau programos ar įrankio, kuris galėtų labai tiksliai parodyti pirštų padėtį smuikui. Su šiuo projektu aš bandžiau tai sukurti. Nors tai yra prototipas ir vis tiek galite pridėti daug funkcijų.

Aš taip pat bandžiau atskirti ESP32 ir rPI, todėl privertiau ESP32 siųsti duomenis belaidžiu ryšiu į rPi. Tai turbūt sunkiausia šiame projekte.

Taip pat labai svarbu, kad pasibaigus šiam projektui jūsų kompiuteryje niekas nebūtų saugomas, bet jis būtų arba rPI, arba ESP32.

1 žingsnis: medžiagos ir įrankiai

Prieš pradedant šio projekto kūrimo specifiką, mums reikia kelių dalykų.

1. 4x „Linear Softpot“: linijiniai potenciometrai, skirti piršto padėčiai matuoti (smuikas turi 4 stygas)
2. ESP32: ESP32 modulis, skirtas skaityti duomenis iš linijinių minkštųjų taškų.
3. 4/4 smuikas: smuikas, skirtas viršuje pastatyti linijinius minkštus puodus.
4. „Raspberry Pi“su SD kortele: „aviečių pi“, kuriame bus saugoma mūsų duomenų bazė ir svetainė.
5. 10k potenciometras: LCD ekrano ryškumo potenciometras
6. LCD ekranas: skystųjų kristalų ekranas, rodomas IP adresams
7. Litavimo komplektas: skirtas lituoti visus elementus kartu
8. Laidai nuo vyrų iki vyrų ir laidai iš moterų: kabeliai, skirti visiems elementams sujungti
9. Mikro USB kabelis: skirtas maitinti ESP32

2 veiksmas: minkštųjų taškų prijungimas prie ESP32

Pirmiausia turime prijungti minkštus puodus prie esp32. Mes prijungiame kairįjį ir dešinįjį kaiščius atitinkamai prie 5V ir GND. Mes prijungiame vidurinį kaištį prie analoginio kaiščio ESP32. Taip pat turime prijungti vidurinį kaištį, kurio varža 10k omų, ir prijungti jį prie GND. Taip yra todėl, kad mūsų minkštųjų taškų išvestis negrąžina atsitiktinės vertės.

Tada mes prijungiame ESP32 su mikro USB kabeliu prie savo kompiuterio, kad galėtume į jį įkelti kodą. ESP32 programavimui naudosime „Arduino IDE“. Bet pirmiausia turime įdiegti „Arduino“branduolį, skirtą ESP32, kad galėtume į jį įkelti. Tai galima padaryti čia.

Tada galime pradėti rašyti kodą.

Pirmiausia turime priskirti kaiščius, prie kurių prijungėme vidurinį minkštųjų puodų kaištį.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

ilgai nepasirašytas;

nepasirašytas ilgas softPotTime;

Tada mes galime nustatyti savo kaiščius. Ir mes turime pradėti savo serijinį monitorių ir savo laiką.

void setup () {

onTime = milis ();

Serial.begin (115200);

Serial.println („Programos pradžia“);

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

void getdata (baitų pdata ) {

// Skaitykite minkšto puodo ADC reikšmę

Tada turime perskaityti kaiščius, kad galėtume gauti savo duomenis.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Tada mes įtraukiame vertes į sąrašą, kad vėliau galėtume lengvai jas išvesti.

už (int i = 0; i <4; i ++) {

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

int softpot = Vardai ;

jei (minkštasis taškas> 10) {

pdata [0] = i;

pdata [1] = minkštasis taškas;

pdata [2] = milis ();

} } }

}

3 veiksmas: prijunkite ESP32 ir RPI belaidžiu būdu

Norėdami belaidžiu ryšiu prijungti ESP32 ir RPI, naudosime biblioteką, vadinamą „websocket“. Norėdami įdiegti šią biblioteką, failus galime gauti čia. Norėdami naudoti šią biblioteką ESP32, turėsime pakeisti tam tikrą failų kodą.

Turėsime pakeisti MD5.c ir MD5.h.

• MD5Init į MD5InitXXX
• MD5Atnaujinti į MD5UpdateXXX
• MD5Final į MD5FinalXXX

Taip pat turėsime ištrinti „sha1“failų avr/io.h eilutes.

Tada galime pridėti biblioteką prie savo „Arduino IDE“eskizu> įtraukti biblioteką> pridėti. ZIP biblioteką ir tada galime pasirinkti jūsų biblioteką ZIP faile.

Po to galime pradėti rašyti savo kodą.

Pirmiausia dėl ESP32:

Įskaitant mūsų biblioteką

#įtraukti #įtraukti

Vėl priskiriame mūsų smeigtukus.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

Priskiriame „wifi“serverį

„WiFiServer“serveris (80);

Paleidžiame žiniatinklio lizdo serverį

WebSocketServer webSocketServer;

Priskiriame jūsų „WiFi“SSID ir slaptažodį

const char* ssid = "jūsų" WiFi "SSID";

const char* password = "jūsų" wifi "slaptažodis";

void setup () {

Serijinio monitoriaus nustatymas

Serial.begin (115200);

„Softpots“nustatymas

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

Paleidžiame „wifi“ir prisijungiame prie jo

WiFi.begin (ssid, slaptažodis);

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

vėlavimas (1000);

Serial.println („Prisijungimas prie„ WiFi “..“); }

Serial.println („Prisijungta prie„ WiFi “tinklo“);

Serial.println (WiFi.localIP ());

server.begin (); vėlavimas (100); }

void getdata (char *pdata) {

Jūsų duomenų skaitymas

// Skaitykite minkšto puodo ADC reikšmę

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

Duomenų įtraukimas į sąrašą ir konvertavimas į šešioliktainius.

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

}

void loop () {

Kliento prijungimas (RPI)

„WiFiClient“klientas = serveris.pasiekiamas ();

if (client.connected ()) {

vėlavimas (10);

if (webSocketServer.handshake (klientas)) {

Serial.println („Klientas prijungtas“);

Duomenų siuntimas ir gavimas.

while (client.connected ()) {

char duomenys [30];

„getdata“(duomenys);

Serial.println (duomenys);

webSocketServer.sendData (duomenys);

vėlavimas (10); // Reikia atidėti, kad duomenys būtų gauti teisingai}

Serial.println („Klientas atjungtas“);

vėlavimas (100); }

Kitas {

Serial.println ("shitsfuckedyo");

} } }

Tada rPI „python“:

Importuoja mūsų bibliotekas

importuoti žiniatinklio lizdą importuoti laiką

Globale variabel priskyrimas i

i = 0

Nustatome ne daugiau kaip 200 pranešimų, kuriuos galime priimti

nrOfMessages = 200

klasės „Websocket“():

def _init _ (savarankiškai):

Inicijuojame žiniatinklio lizdą ir prijungiame jį prie ESP32

self.ws = websocket. WebSocket ()

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

Gauname mūsų duomenis

def darbas (savarankiškai):

self.ws.send ("žinutės nr: 0")

rezultatas = self.ws.recv () time.sleep (0.5) grąžinimo rezultatas

Viską gavę uždarykite žiniatinklio lizdą

def uždaryti (save):

self.ws.close ()

4 veiksmas: svetainės ir duomenų bazės prijungimas

Kalbant apie mūsų duomenų bazės ir svetainės sujungimą, pirmiausia turėsite sukurti savo duomenų bazę pi, įdiegdami mariadb: sudo apt install mariadb.

Tada galite tai padaryti atlikdami: sudo mariadb.

Tada taip pat turėsite sukurti savo svetainę. Tai galite padaryti, kaip jums patinka, bet jūs turite naudoti „Flask“ir turite turėti formą HTML, kad sustabdytumėte ir paleistumėte savo duomenis.

Tada galite įterpti šį kodą, kad sujungtumėte savo duomenų bazę ir svetainę (tiek jūsų svetainė, tiek duomenų bazė turi būti jūsų pi, tai galima padaryti naudojant diegimo skirtuką „pycharm“nustatymuose)

iš „flaskext.mysql“importuokite „MySQL“

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

app.config ["MYSQL_DATABASE_DB"] = "jūsų duomenų bazės pavadinimas"

app.config ["MYSQL_DATABASE_USER"] = "jūsų duomenų bazės vartotojas"

app.config ["MYSQL_DATABASE_PASSWORD"] = "jūsų duomenų bazės slaptažodis"

Funkcija, skirta ištraukti duomenis iš mūsų duomenų bazės.

def get_data (sql, params = Nėra):

conn = mysql.connect ()

žymeklis = conn.cursor ()

spausdinti („gauti duomenis“)

bandyti:

spausdinti (sql)

cursor.execute (sql, params)

išskyrus išimtis, pvz.:

spausdinti (e)

return False

rezultatas = cursor.fetchall ()

duomenys =

rezultato eilutei:

data.append (sąrašas (eilutė))

cursor.close ()

conn.close ()

grąžinti duomenis

Funkcija, skirta įterpti duomenis į mūsų duomenų bazę

def set_data (sql, params = Nėra):

conn = mysql.connect ()

žymeklis = jungiamasis žymeklis ()

bandyti:

log.debug (sql)

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

log.debug ("SQL uitgevoerd")

išskyrus išimtis, pvz.:

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

return False

cursor.close ()

conn.close ()

grįžti tiesa

Mes taip pat turėsime susieti savo programą, kad įrašydami galėtumėte atlikti kitus veiksmus.

klasės „ThreadedTask“(sriegimas. Siūlai):

def _init _ (save,):

Siūlo nustatymas

sriegis. Siūlas._ init _ (savarankiškai)

Sudaromas visų gautų duomenų saugojimo sąrašas

self.data_all =

def bėgti (savarankiškai):

laikas miegoti (5)

Importuokite savo „Python“kodą ten, kur gaunate duomenis

importuoti Receive_websocket

Gaukite savo duomenis

w = Receive_websocket. Websocket ()

Pridėkite savo duomenis prie sąrašo ir atsispausdinkite.

i diapazone (0, 200):

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

spausdinti (self.data_all)

task = ThreadedTask ()

Tada galite atlikti užduotį.run (), kad paleistumėte temą ir pradėtumėte gauti duomenis.

5 žingsnis: viską sujunkite

Norėdami valdyti savo svetainę iš „Pi“, turite naudoti šią paslaugą:

[Vienetas] Aprašymas = uWSGI egzempliorius, skirtas aptarnauti projekto1 žiniatinklio sąsają

Po = tinklas.tikslas

BindsTo = mysqld.service

Po = mysqld.service

[Paslauga]

Pakeiskite savo vartotoją

Vartotojas = pi

Grupė = www-duomenys

Čia turite įvesti savo kolbos failo katalogą

WorkingDirectory =/home/pi/project1/web

Ini failo katalogas, kurį rasite vėliau.

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

[Diegti]

WantedBy = kelių vartotojų tikslas

uwsgi-flask.ini, kurį turite patalpinti kataloge, kurį nurodėte aukščiau „ExecStart“

[uwsgi] modulis = žiniatinklis: programa virtualenv =/home/pi/project1/env

meistras = tikri procesai = 5

įskiepiai = python3

lizdas = projektas1.kock chmod-socket = 660 vakuumas = tiesa

die-on-term = tiesa

Dabar galite skaityti savo duomenis ir rodyti juos savo svetainėje.

6 veiksmas: papildomas: LCD ekrano prijungimas

Mes galime prijungti skystųjų kristalų ekraną, kad galėtume parodyti savo „Pi“IP adresą mūsų svetainei.

importuoti RPi. GPIO kaip GPIOimportuoti laiką

importavimo komandos

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

sąrašas = [22, 5, 6, 13, 19, 26, 20, 21]

E = 24

RS = 23

klasės ekranas:

def _init _ (savarankiškai):

GPIO.setmode (GPIO. BCM)

self.setup ()

#Funkcijų rinkinys self.stuur_instructie (0x3f) #Display self.stuur_instructie (0x0c) #On + žymeklis self.stuur_instructie (0x01) @staticmethod def setup (): GPIO.setup (sąrašas, GPIO. OUT) GPIO.setup ([E, RS], GPIO. OUT)

def stuur_instructie (savarankiškai, baitas):

GPIO išvestis (E, GPIO. HIGH)

GPIO išvestis (RS, GPIO. LOW)

self.set_GPIO_bits (baitas)

laikas miegoti (0,005)

GPIO išvestis (E, GPIO. LOW)

def stuur_teken (self, char):

temp = ord (char)

GPIO išvestis (E, GPIO. HIGH)

GPIO išvestis (RS, GPIO. HIGH)

self.set_GPIO_bits (temp)

laikas miegoti (0,005)

GPIO išvestis (E, GPIO. LOW)

def set_GPIO_bits (savarankiškas, baitas):

i diapazone (0, 8):

jei (baitas & (2 ** i)) == 0:

GPIO. išvestis (sąrašas , GPIO. LOW)

Kitas:

GPIO. išvestis (sąrašas , GPIO. HIGH)

def main ():

s = ekranas ()

teken = "Vietinis IP adresas:"

laiškas teken:

s.stuur_teken (laiškas)

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

spausdinti (teken2)

s.stuur_instructie (0xc0)

„letter2“„teken2“:

s.stuur_teken (raidė2)

jei _vardas_ == '_main_': #programa prasideda nuo čia

bandyti:

pagrindinis ()

išskyrus klaviatūrąInterrupt:

praeiti

Tada galime sukurti paslaugą LCD paleidimui paleidžiant.