ESP32 के साथ वायलिन पर उंगलियों की स्थिति को मापना: 6 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

एक वायलिन वादक के रूप में मैं हमेशा एक ऐप या टूल चाहता था जो मुझे वायलिन पर मेरी उंगलियों की स्थिति को बहुत सटीक दिखा सके। इस परियोजना के साथ मैंने इसे बनाने की कोशिश की। हालाँकि यह एक प्रोटोटाइप है और आप अभी भी कई सुविधाएँ जोड़ सकते हैं।

मैंने ESP32 और rPI को अलग करने का भी प्रयास किया और इस प्रकार मैंने ESP32 को rPi को वायरलेस डेटा भेजने के लिए बनाया। जो शायद इस प्रोजेक्ट की सबसे कठिन बात है।

यह भी बहुत महत्वपूर्ण है कि इस परियोजना के अंत में आपके कंप्यूटर पर कुछ भी संग्रहीत नहीं है लेकिन यह या तो आरपीआई या ईएसपी 32 पर है।

चरण 1: सामग्री और उपकरण

इस परियोजना के निर्माण की बारीकियों में जाने से पहले हमें कुछ चीजों की आवश्यकता है।

1. 4x रैखिक सॉफ़्टपॉट: एक उंगली की स्थिति को मापने के लिए रैखिक पोटेंशियोमीटर (एक वायलिन में 4 तार होते हैं)
2. ESP32: रैखिक सॉफ्टपॉट से डेटा पढ़ने के लिए एक ESP32 मॉड्यूल।
3. एक 4/4 वायलिन: शीर्ष पर रैखिक सॉफ्टपॉट रखने के लिए एक वायलिन।
4. एक रास्पबेरी पाई एसडी कार्ड के साथ: एक रास्पबेरी पाई जो हमारे डेटाबेस और वेबसाइट को स्टोर करेगी।
5. 10k पोटेंशियोमीटर: LCD की चमक के लिए एक पोटेंशियोमीटर
6. एलसीडी-स्क्रीन: rPi. के आईपी पतों को दिखाने के लिए एक एलसीडी स्क्रीन
7. सोल्डरिंग किट: सभी तत्वों को एक साथ मिलाने के लिए
8. पुरुष-से-पुरुष तार और पुरुष-से-महिला तार: सभी तत्वों को जोड़ने के लिए केबल
9. माइक्रो यूएसबी केबल: ESP32. को पावर देने के लिए

चरण 2: सॉफ्टपॉट्स को ESP32 से जोड़ना

सबसे पहले हमें अपने सॉफ्टपॉट्स को esp32 से कनेक्ट करना होगा। हम बाएँ और दाएँ पिन को क्रमशः 5V और GND से जोड़ते हैं। हम मध्य पिन को ESP32 पर एक एनालॉग पिन से जोड़ते हैं। हमें मध्य पिन को 10k ओम के प्रतिरोध के साथ जोड़ने और इसे GND से जोड़ने की भी आवश्यकता है। ऐसा इसलिए है ताकि सॉफ्टपॉट्स का हमारा आउटपुट रैंडम वैल्यू न लौटाए।

फिर हम ESP32 को माइक्रो यूएसबी केबल से अपने पीसी से कनेक्ट करते हैं ताकि हम उस पर कोड अपलोड कर सकें। हम ESP32 की प्रोग्रामिंग के लिए Arduino IDE का उपयोग करेंगे। लेकिन पहले हमें ESP32 के लिए Arduino कोर स्थापित करने की आवश्यकता है ताकि हम इसे अपलोड कर सकें। यह यहां किया जा सकता है।

फिर हम कोड लिखना शुरू कर सकते हैं।

सबसे पहले हमें अपना पिन असाइन करना होगा जिससे हमने सॉफ्टपॉट्स के अपने मध्य पिन को जोड़ा।

कॉन्स्ट इंट SOFT_POT_PIN1 = 34;

कॉन्स्ट इंट SOFT_POT_PIN2 = 35;

कॉन्स्ट इंट SOFT_POT_PIN3 = 32;

कॉन्स्ट इंट SOFT_POT_PIN4 = 33;

लंबे समय तक अहस्ताक्षरित;

अहस्ताक्षरित लंबा सॉफ्टपॉटटाइम;

फिर हम अपने पिन सेट कर सकते हैं। और हमें अपना सीरियल मॉनिटर और अपना समय शुरू करने की जरूरत है।

व्यर्थ व्यवस्था() {

ऑनटाइम = मिली ();

सीरियल.बेगिन (115200);

Serial.println ("कार्यक्रम प्रारंभ");

पिनमोड (SOFT_POT_PIN1, INPUT);

पिनमोड (SOFT_POT_PIN2, INPUT);

पिनमोड (SOFT_POT_PIN3, INPUT);

पिनमोड (SOFT_POT_PIN4, INPUT); }

शून्य गेटडेटा (बाइट पीडीटा ) {

// सॉफ्ट पॉट के ADC मान में पढ़ें

फिर हमें अपने पिन पढ़ने की जरूरत है ताकि हम अपना डेटा प्राप्त कर सकें।

int softPotADC1 = एनालॉगरेड (SOFT_POT_PIN1);

एनटी softPotADC2 = एनालॉग रीड (SOFT_POT_PIN2);

int softPotADC3 = एनालॉगरेड (SOFT_POT_PIN3);

int softPotADC4 = एनालॉगरेड (SOFT_POT_PIN4);

फिर हम मानों को एक सूची में डालते हैं ताकि हम इसे बाद में आसानी से आउटपुट कर सकें।

के लिए (int i=0; i <4; i++){

int नाम = {softPotADC1, softPotADC2, softPotADC3, softPotADC4};

इंट सॉफ्टपॉट = नाम ;

अगर (सॉफ्टपॉट> 10) {

पीडीटा [0] = मैं;

पीडीटा [1] = सॉफ्टपॉट;

पीडीटा [2] = मिली ();

} } }

}

चरण 3: ESP32 और RPI को वायरलेस तरीके से जोड़ना

ESP32 और RPI को वायरलेस तरीके से जोड़ने के लिए, हम websocket नामक लाइब्रेरी का उपयोग करेंगे। इस पुस्तकालय को स्थापित करने के लिए, हम यहां फाइलें प्राप्त कर सकते हैं। ESP32 के लिए इस पुस्तकालय का उपयोग करने के लिए हमें फाइलों में ही कुछ कोड बदलने की आवश्यकता होगी।

हमें MD5.c और MD5.h को बदलना होगा।

• MD5Init से MD5InitXXX
• MD5अद्यतन करने के लिए MD5अपडेटXXX
• MD5फाइनल से MD5फाइनलXXX

हमें sha1 फ़ाइलों में avr/io.h लाइनों को भी हटाना होगा।

फिर हम स्केच द्वारा अपने Arduino IDE में लाइब्रेरी जोड़ सकते हैं> लाइब्रेरी शामिल करें>. ZIP लाइब्रेरी जोड़ें और फिर हम एक ज़िप फ़ाइल में आपकी लाइब्रेरी का चयन कर सकते हैं।

उसके बाद हम अपना कोड लिखना शुरू कर सकते हैं।

ESP32 के लिए पहला:

हमारे पुस्तकालय सहित

#शामिल करें #शामिल करें

हमारे पिन फिर से असाइन करना।

कॉन्स्ट इंट SOFT_POT_PIN1 = 34;

कॉन्स्ट इंट SOFT_POT_PIN2 = 35;

कॉन्स्ट इंट SOFT_POT_PIN3 = 32;

कॉन्स्ट इंट SOFT_POT_PIN4 = 33;

हमारे वाईफाई सर्वर को असाइन करना

वाईफाई सर्वर सर्वर (80);

हमारा वेबसोकेट सर्वर शुरू करना

वेबसॉकेटसर्वर

हमारे SSID और आपके वाईफाई का पासवर्ड असाइन करना

const char* ssid = "आपका वाईफाई SSID";

कॉन्स्ट चार * पासवर्ड = "आपका वाईफाई पासवर्ड";

व्यर्थ व्यवस्था() {

अपना सीरियल मॉनिटर सेट करना

सीरियल.बेगिन (115200);

अपने सॉफ्टपॉट सेट करना

पिनमोड (SOFT_POT_PIN1, INPUT);

पिनमोड (SOFT_POT_PIN2, INPUT);

पिनमोड (SOFT_POT_PIN3, INPUT);

पिनमोड (SOFT_POT_PIN4, INPUT);

हमारा वाईफाई शुरू करना और उससे जुड़ना

वाईफाई.बेगिन (एसएसआईडी, पासवर्ड);

जबकि (WiFi.status() != WL_CONNECTED) {

देरी (1000);

Serial.println ("वाईफाई से कनेक्ट हो रहा है.."); }

Serial.println ("वाईफाई नेटवर्क से कनेक्टेड");

Serial.println (वाईफाई.लोकलआईपी ());

सर्वर। शुरू (); देरी (100); }

शून्य गेटडेटा (चार * पीडीटा) {

आपका डेटा पढ़ना

// सॉफ्ट पॉट के ADC मान में पढ़ें

int softPotADC1 = एनालॉगरेड (SOFT_POT_PIN1);

int softPotADC2 = एनालॉग रीड (SOFT_POT_PIN2);

int softPotADC3 = एनालॉगरेड (SOFT_POT_PIN3);

int softPotADC4 = एनालॉगरेड (SOFT_POT_PIN4);

डेटा को एक सूची में रखना और इसे हेक्साडेसिमल में परिवर्तित करना।

स्प्रिंटफ (पीडीटा, "% x,% x,% x,% x,% x", सॉफ्टपोटैडसी 1, सॉफ्टपोटैडसी 2, सॉफ्टपोटैडसी 3, सॉफ्टपोटैडसी 4, मिली ());

}

शून्य लूप () {

अपने ग्राहक को जोड़ना (आरपीआई)

वाईफाई क्लाइंट क्लाइंट = सर्वर उपलब्ध ();

अगर (क्लाइंट.कनेक्टेड ()) {

देरी(10);

अगर (webSocketServer.handshake (क्लाइंट)) {

Serial.println ("क्लाइंट कनेक्टेड");

डेटा भेजना और प्राप्त करना।

जबकि (क्लाइंट.कनेक्टेड ()) {

चार डेटा [30];

गेटडाटा (डेटा);

Serial.println (डेटा);

webSocketServer.sendData (डेटा);

देरी(10); // डेटा को सही ढंग से प्राप्त करने में देरी की आवश्यकता है }

Serial.println ("क्लाइंट डिस्कनेक्ट हो गया");

देरी (100); }

अन्यथा {

Serial.println ("shitsfuckedyo");

} } }

फिर अजगर में आरपीआई के लिए:

हमारे पुस्तकालयों का आयात

वेबसोकेट आयात करेंआयात समय

एक ग्लोबल वेरिबेल असाइन करना i

मैं = 0

अधिकतम 200 संदेश सेट करना जो हम प्राप्त कर सकते हैं

nrOfMessages = 200

क्लास वेबसोकेट ():

def _init_(स्वयं):

हमारे वेबसोकेट को इनिशियलाइज़ करना और इसे हमारे ESP32 से जोड़ना

self.ws = websocket. WebSocket ()

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

हमारा डेटा प्राप्त करना

डीईएफ़ काम (स्वयं):

self.ws.send ("संदेश एनआर: 0")

परिणाम = self.ws.recv() time.sleep(0.5) वापसी परिणाम

सब कुछ प्राप्त करने के बाद वेबसोकेट बंद करना

डीईएफ़ पास (स्वयं):

स्वयं.डब्ल्यूएस.क्लोज़ ()

चरण 4: अपनी वेबसाइट और डेटाबेस को जोड़ना

जहां तक हमारे डेटाबेस और वेबसाइट को जोड़ने की बात है, तो आपको सबसे पहले mariadb: sudo apt install mariadb इंस्टॉल करके pi पर अपना डेटाबेस बनाना होगा।

फिर आप इसे करके acces कर सकते हैं: sudo mariadb.

फिर आपको अपनी वेबसाइट भी बनानी होगी। आप इसे अपनी पसंद के अनुसार कर सकते हैं, लेकिन आपको फ्लास्क का उपयोग करना होगा और अपने डेटा को रोकने और शुरू करने के लिए आपको अपने HTML में एक फॉर्म की आवश्यकता होगी।

फिर आप अपने डेटाबेस और अपनी वेबसाइट को जोड़ने के लिए इस कोड को सम्मिलित कर सकते हैं (आपकी वेबसाइट और डेटाबेस दोनों को आपके पीआई पर होना चाहिए, यह pycharm की सेटिंग में परिनियोजन टैब का उपयोग करके किया जा सकता है)

फ्लास्केक्स्ट.mysql से MySQL आयात करें

app.config["MYSQL_DATABASE_HOST"] = "लोकलहोस्ट"

app.config["MYSQL_DATABASE_DB"] = "आपका डेटाबेस नाम"

app.config["MYSQL_DATABASE_USER"] = "आपका डेटाबेस उपयोगकर्ता"

app.config["MYSQL_DATABASE_PASSWORD"] = "आपका डेटाबेस पासवर्ड"

हमारे डेटाबेस से डेटा प्राप्त करने के लिए कार्य।

def get_data (एसक्यूएल, पैराम्स = कोई नहीं):

कॉन = mysql.connect ()

कर्सर = conn.cursor ()

प्रिंट ("डेटा प्राप्त करना")

प्रयत्न:

प्रिंट (एसक्यूएल)

कर्सर.निष्पादन (एसक्यूएल, पैराम्स)

ई के रूप में अपवाद को छोड़कर:

प्रिंट (ई)

विवरण झूठा है

परिणाम = कर्सर। प्राप्त करें ()

डेटा =

परिणाम में पंक्ति के लिए:

data.append (सूची (पंक्ति))

कर्सर। बंद करें ()

कॉन.क्लोज़ ()

डेटा लौटाएं

हमारे डेटाबेस में डेटा डालने का कार्य

def set_data (एसक्यूएल, पैराम्स = कोई नहीं):

कॉन = mysql.connect ()

कर्सर = conn.cursor ()

प्रयत्न:

लॉग डिबग (एसक्यूएल)

कर्सर.निष्पादन (एसक्यूएल, पैराम्स) conn.commit ()

log.debug("SQL uitgevoerd")

ई के रूप में अपवाद को छोड़कर:

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

विवरण झूठा है

कर्सर। बंद करें ()

कॉन.क्लोज़ ()

रिटर्न ट्रू

हमें अपने एप्लिकेशन को थ्रेड करने की भी आवश्यकता होगी ताकि आप रिकॉर्डिंग करते समय अन्य काम कर सकें।

क्लास थ्रेडेड टास्क (थ्रेडिंग। थ्रेड):

def _init_ (स्वयं,):

धागा स्थापित करना

थ्रेडिंग। थ्रेड._init_ (स्वयं)

अपने सभी प्राप्त डेटा को रखने के लिए एक सूची बनाना

स्वयं डेटा_सब =

डीईएफ़ रन (स्वयं):

समय सो जाओ(5)

अपना खुद का पायथन कोड आयात करें जहां आप डेटा प्राप्त करते हैं

आयात प्राप्त करें_वेबसोकेट

अपना डेटा प्राप्त करें

डब्ल्यू = प्राप्त_वेबसोकेट। वेबसोकेट ()

अपनी सूची में अपना डेटा संलग्न करें और इसे प्रिंट करें।

मेरे लिए रेंज में (0, 200):

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

प्रिंट (स्वयं। डेटा_ऑल)

कार्य = थ्रेडेड टास्क ()

फिर आप अपना थ्रेड शुरू करने और डेटा प्राप्त करना शुरू करने के लिए task.run() कर सकते हैं।

चरण 5: सब कुछ एक साथ जोड़ना

अपनी वेबसाइट को अपने पीआई से चलाने के लिए आपको एक सेवा का उपयोग करना होगा:

[इकाई]विवरण=uWSGI उदाहरण प्रोजेक्ट1 वेब इंटरफेस की सेवा के लिए

बाद=नेटवर्क.लक्ष्य

BindsTo=mysqld.service

आफ्टर=mysqld.service

[सेवा]

अपने उपयोगकर्ता में बदलें

उपयोगकर्ता = पीआई

समूह = www-डेटा

यहां आपको अपनी फ्लास्क फ़ाइल की निर्देशिका दर्ज करनी होगी

वर्किंग डायरेक्टरी =/होम/पीआई/प्रोजेक्ट1/वेब

आपकी ini फ़ाइल की निर्देशिका जो बाद में मिल सकती है।

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

[इंस्टॉल]

वांटेडबाय=मल्टी-यूजर.टारगेट

uwsgi-flask.ini जिसे आपको ऊपर ExecStart में निर्दिष्ट निर्देशिका में रखने की आवश्यकता है

[uwsgi] मॉड्यूल = वेब: ऐप virtualenv = /home/pi/project1/env

मास्टर = सच्ची प्रक्रिया = 5

प्लगइन्स = python3

सॉकेट = प्रोजेक्ट 1. सॉक चामोद-सॉकेट = 660 वैक्यूम = सत्य

डाई-ऑन-टर्म = सत्य

अब आप अपना डेटा पढ़ सकते हैं और इसे अपनी वेबसाइट पर प्रदर्शित कर सकते हैं।

चरण 6: अतिरिक्त: एलसीडी स्क्रीन को जोड़ना

हम एक एलसीडी स्क्रीन कनेक्ट कर सकते हैं ताकि हम अपनी वेबसाइट के लिए अपने पीआई का आईपी-एड्रेस दिखा सकें।

RPI. GPIO को GPIOआयात समय के रूप में आयात करें

आयात आदेश

जीपीआईओ.क्लीनअप ()

डी0 = 22

डी1 = 5

डी2 = 6

डी3 = 13

डी4 = 19

डी5 = 26

डी6 = 20

डी7 = 21

सूची = [२२, ५, ६, १३, १९, २६, २०, २१]

ई = 24

आरएस = 23

कक्षा स्क्रीन:

def _init_(स्वयं):

GPIO.सेटमोड (GPIO. BCM)

सेल्फ.सेटअप ()

#Function set self.stuur_instructie(0x3f) #Display self.stuur_instructie(0x0c) #On + कर्सर self.stuur_instructie(0x01) @staticmethod def setup(): GPIO.setup(list, GPIO. OUT) GPIO.setup([E, रुपये], GPIO. OUT)

def stuur_instructie (स्वयं, बाइट):

GPIO.output (E, GPIO.high)

GPIO.output (रुपये, GPIO. LOW)

self.set_GPIO_bits (बाइट)

समय सो जाओ (0.005)

GPIO.output (ई, GPIO. LOW)

def stuur_teken (स्वयं, चार):

अस्थायी = ऑर्ड (चार)

GPIO.output (E, GPIO.high)

GPIO.output (रुपये, GPIO। उच्च)

self.set_GPIO_bits (अस्थायी)

समय सो जाओ (0.005)

GPIO.output (ई, GPIO. LOW)

def set_GPIO_bits (स्वयं, बाइट):

मेरे लिए रेंज में (0, 8):

अगर (बाइट और (2**i)) == 0:

GPIO.output (सूची , GPIO. LOW)

अन्यथा:

GPIO.output (सूची , GPIO। उच्च)

डीईएफ़ मुख्य ():

एस = स्क्रीन ()

टेकन = "स्थानीय आईपी पता:"

टेकन में पत्र के लिए:

s.stuur_teken(पत्र)

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

प्रिंट (टेकन 2)

s.stuur_instructie(0xc0)

टेकन 2 में पत्र 2 के लिए:

s.stuur_teken(letter2)

अगर _name_ == '_main_': #कार्यक्रम यहाँ से शुरू हो रहा है

प्रयत्न:

मुख्य()

कीबोर्ड इंटरप्ट को छोड़कर:

उत्तीर्ण

फिर हम स्टार्ट-अप पर एलसीडी शुरू करने के लिए एक सेवा बना सकते हैं।