ვიოლინოზე თითის პოზიციის გაზომვა ESP32– ით: 6 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

როგორც მევიოლინე მე ყოველთვის მინდოდა აპლიკაცია ან ინსტრუმენტი, რომელსაც შეეძლო მეჩვენებინა ვიოლინოზე ჩემი თითების პოზიცია ძალიან ზუსტად. ამ პროექტით ვცდილობდი ამის აშენებას. მიუხედავად იმისა, რომ ეს არის პროტოტიპი და თქვენ მაინც შეგიძლიათ დაამატოთ მრავალი ფუნქცია.

მე ასევე შევეცადე გამოვყო ESP32 და rPI და ამით ESP32 გავუგზავნე მონაცემები უკაბელო rPi– ს. რაც ალბათ ყველაზე რთულია ამ პროექტში.

ასევე ძალიან მნიშვნელოვანია, რომ ამ პროექტის დასასრულს არაფერი იყოს შენახული თქვენს კომპიუტერში, მაგრამ ის არის rPI ან ESP32.

ნაბიჯი 1: მასალები და ინსტრუმენტები

ამ პროექტის მშენებლობის სპეციფიკაში შესვლამდე ჩვენ გვჭირდება რამდენიმე რამ.

1. 4x ხაზოვანი რბილი ქოთანი: ხაზოვანი პოტენომეტრები თითის პოზიციის გასაზომად (ვიოლინოს აქვს 4 სტრიქონი)
2. ESP32: ESP32 მოდული, რომ წაიკითხოთ მონაცემები წრფივი რბილი ქოთნებიდან.
3. 4/4 ვიოლინო: ვიოლინო, რომ მოათავსოთ ხაზოვანი რბილი ქოთნები თავზე.
4. Raspberry Pi SD ბარათით: ჟოლოს pi რომელიც შეინახავს ჩვენს მონაცემთა ბაზას და ვებსაიტს.
5. 10k პოტენომეტრი: პოტენომეტრი LCD ეკრანის სიკაშკაშისათვის
6. LCD ეკრანი: LCD ეკრანი, რომელიც ნაჩვენებია rPi– ის ip ადრესატებისთვის
7. შედუღების ნაკრები: ყველა ელემენტის ერთმანეთთან შესადუღებლად
8. მამაკაცი-მამაკაცი მავთულები და მამაკაცი-მდე მავთულები: კაბელები ყველა ელემენტის დასაკავშირებლად
9. მიკრო USB კაბელი: ESP32- ის დასატენად

ნაბიჯი 2: Softpots– ის დაკავშირება ESP32– თან

უპირველეს ყოვლისა, ჩვენ უნდა დავუკავშიროთ ჩვენი რბილი ქოთნები esp32– ს. ჩვენ ვუკავშირდებით მარცხენა და მარჯვენა ქინძისთავებს 5V და GND შესაბამისად. ჩვენ შუა პინს ვუკავშირდებით ანალოგიურ პინს ESP32- ზე. ჩვენ ასევე უნდა დავუკავშიროთ შუა პინი 10k ohm წინააღმდეგობით და შევაერთოთ იგი GND- თან. ეს ხდება ისე, რომ რბილი ქოთნების ჩვენი გამომუშავება არ დაუბრუნებს შემთხვევით მნიშვნელობას.

შემდეგ ჩვენ ვუკავშირდებით ESP32- ს მიკრო USB კაბელთან ჩვენს კომპიუტერთან, რათა ჩვენ მასზე ატვირთოთ კოდი. ჩვენ გამოვიყენებთ Arduino IDE– ს ESP32– ის დასაპროგრამებლად. მაგრამ ჯერ ჩვენ უნდა დავაინსტალიროთ Arduino ბირთვი ESP32– ისთვის, ასე რომ ჩვენ შეგვიძლია ატვირთოთ იგი. ეს შეიძლება გაკეთდეს აქ.

შემდეგ ჩვენ შეგვიძლია დავიწყოთ კოდის წერა.

პირველ რიგში, ჩვენ უნდა მივანიჭოთ ჩვენი ქინძისთავები, რომლებთანაც ჩვენ დავუკავშირეთ რბილი ქოთნების შუა პინი.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

ხელმოუწერელი დიდხანს;

ხელმოუწერელი გრძელი softPotTime;

შემდეგ ჩვენ შეგვიძლია დავაყენოთ ჩვენი ქინძისთავები. ჩვენ უნდა დავიწყოთ ჩვენი სერიული მონიტორი და ჩვენი დრო.

void setup () {

დრო = მილი ();

Serial.begin (115200);

Serial.println ("პროგრამის დაწყება");

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT); }

ბათილი გეთდატა (ბაიტი პდატა ) {

// წაიკითხეთ რბილი ქოთნის ADC მნიშვნელობით

შემდეგ ჩვენ უნდა წავიკითხოთ ჩვენი ქინძისთავები, რათა მივიღოთ ჩვენი მონაცემები.

int softPotADC1 = analogRead (SOFT_POT_PIN1);

nt softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

შემდეგ ჩვენ ვდებთ მნიშვნელობებს სიაში, რათა შემდგომში ადვილად გამოვიტანოთ იგი.

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

int სახელები = {softPotADC1, softPotADC2, softPotADC3, softPotADC4};

int softpot = სახელები ;

if (softpot> 10) {

pdata [0] = i;

pdata [1] = რბილი ქოთანი;

pdata [2] = მილი ();

} } }

}

ნაბიჯი 3: დაუკავშირეთ ESP32 და RPI უსადენოდ

ESP32 და RPI უსადენოდ დასაკავშირებლად ჩვენ გამოვიყენებთ ბიბლიოთეკას, რომელსაც ეწოდება websocket. ამ ბიბლიოთეკის დაყენების მიზნით, ჩვენ შეგვიძლია მივიღოთ ფაილები აქ. ჩვენ დაგვჭირდება ფაილების ზოგიერთი კოდის შეცვლა, რომ გამოვიყენოთ ეს ბიბლიოთეკა ESP32– ისთვის.

ჩვენ დაგვჭირდება MD5.c და MD5.h შეცვლა.

• MD5Init to MD5InitXXX
• MD5 განახლება MD5 განახლება XXX
• MD5Final to MD5FinalXXX

ჩვენ ასევე დაგვჭირდება shar ფაილების avr/io.h ხაზების წაშლა.

შემდეგ ჩვენ შეგვიძლია დავამატოთ ბიბლიოთეკა ჩვენს Arduino IDE ესკიზით> მოიცავს ბიბლიოთეკას> დაამატეთ. ZIP ბიბლიოთეკა და შემდეგ ჩვენ შეგვიძლია ავირჩიოთ თქვენი ბიბლიოთეკა zip ფაილში.

ამის შემდეგ ჩვენ შეგვიძლია დავიწყოთ ჩვენი კოდის წერა.

პირველი ESP32– ისთვის:

მათ შორის ჩვენი ბიბლიოთეკა

#ჩართეთ #ჩართეთ

ჩვენი ქინძისთავების კვლავ მინიჭება.

const int SOFT_POT_PIN1 = 34;

const int SOFT_POT_PIN2 = 35;

const int SOFT_POT_PIN3 = 32;

const int SOFT_POT_PIN4 = 33;

ჩვენი wifi სერვერის მინიჭება

WiFiServer სერვერი (80);

ჩვენი ვებსაიტის სერვერის გაშვება

WebSocketServer webSocketServer;

მინიჭება ჩვენი SSID და პაროლი თქვენი wifi

const char* ssid = "თქვენი wifi SSID";

const char* პაროლი = "თქვენი wifi პაროლი";

void setup () {

თქვენი სერიული მონიტორის დაყენება

Serial.begin (115200);

თქვენი რბილი ქოთნების დაყენება

pinMode (SOFT_POT_PIN1, INPUT);

pinMode (SOFT_POT_PIN2, INPUT);

pinMode (SOFT_POT_PIN3, INPUT);

pinMode (SOFT_POT_PIN4, INPUT);

ვიფის დაწყება და მასთან დაკავშირება

WiFi.begin (ssid, პაროლი);

ხოლო (WiFi.status ()! = WL_CONNECTED) {

დაგვიანება (1000);

Serial.println ("WiFi- თან დაკავშირება.."); }

Serial.println ("დაკავშირებულია WiFi ქსელთან");

Serial.println (WiFi.localIP ());

server.begin (); დაგვიანება (100); }

void getdata (char *pdata) {

კითხულობს თქვენს მონაცემებს

// წაიკითხეთ რბილი ქოთნის ADC მნიშვნელობით

int softPotADC1 = analogRead (SOFT_POT_PIN1);

int softPotADC2 = analogRead (SOFT_POT_PIN2);

int softPotADC3 = analogRead (SOFT_POT_PIN3);

int softPotADC4 = analogRead (SOFT_POT_PIN4);

მონაცემების განთავსება სიაში და მათი გადაქცევა თექვსმეტობით.

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

}

ბათილი მარყუჟი () {

თქვენი კლიენტის დაკავშირება (rPI)

WiFiClient client = server.available ();

if (client.connected ()) {

დაგვიანება (10);

if (webSocketServer.handshake (კლიენტი)) {

Serial.println ("კლიენტთან დაკავშირებულია");

მონაცემების გაგზავნა და მიღება.

while (client.connected ()) {

char მონაცემები [30];

getdata (მონაცემები);

Serial.println (მონაცემები);

webSocketServer.sendData (მონაცემები);

დაგვიანება (10); // მონაცემების სწორად მიღებისათვის საჭიროა შეფერხება}

Serial.println ("კლიენტი გათიშულია");

დაგვიანება (100); }

სხვა {

Serial.println ("shitsfuckedyo");

} } }

შემდეგ rPI პითონში:

ჩვენი ბიბლიოთეკების იმპორტი

ვებსაიტის იმპორტის დროის იმპორტი

გლობალური ვარიაბელის დადგენა i

i = 0

მაქსიმუმ 200 შეტყობინების დაყენება, რისი მიღებაც შეგვიძლია

nrOfMessages = 200

კლასის ვებსაიტი ():

def _init _ (self):

ჩვენი ვებსაიტის ინიციალიზაცია და დაკავშირება ჩვენს ESP32- თან

self.ws = websocket. WebSocket ()

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

ჩვენი მონაცემების მიღება

def მუშაობა (საკუთარი თავი):

self.ws.send ("შეტყობინება nr: 0")

შედეგი = self.ws.recv () დრო. ძილი (0.5) დაბრუნების შედეგი

ყველაფრის მიღების შემდეგ ვებსაიტის დახურვა

დახურვა (საკუთარი თავი):

self.ws. დახურვა ()

ნაბიჯი 4: თქვენი ვებსაიტისა და მონაცემთა ბაზის დაკავშირება

რაც შეეხება ჩვენი მონაცემთა ბაზისა და ვებსაიტის დაკავშირებას, თქვენ პირველ რიგში დაგჭირდებათ თქვენი მონაცემთა ბაზის შექმნა pi– ზე mariadb დაყენებით: sudo apt install mariadb.

შემდეგ შეგიძლიათ მიხვიდეთ ამით: sudo mariadb.

შემდეგ თქვენ ასევე უნდა შექმნათ თქვენი ვებ - გვერდი. თქვენ შეგიძლიათ ამის გაკეთება, როგორც გსურთ, მაგრამ თქვენ უნდა გამოიყენოთ Flask და თქვენ უნდა გქონდეთ ფორმა თქვენს HTML– ში თქვენი მონაცემების შესაჩერებლად და დასაწყებად.

შემდეგ თქვენ შეგიძლიათ ჩაწეროთ ეს კოდი თქვენი მონაცემთა ბაზისა და თქვენი ვებსაიტის დასაკავშირებლად (ორივე თქვენი ვებ – გვერდი და მონაცემთა ბაზა ორივე უნდა იყოს თქვენს pi– ზე, ეს შეიძლება გაკეთდეს pycharm– ის პარამეტრებში განლაგების ჩანართის გამოყენებით)

flaskext.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 (sql, params = არცერთი):

conn = mysql.connect ()

კურსორი = conn.cursor ()

დაბეჭდვა ("მონაცემების მიღება")

სცადე:

ბეჭდვა (sql)

კურსორი. შესრულება (sql, params)

გამონაკლისის გარდა e:

ბეჭდვა (ე)

დაბრუნება ცრუ

შედეგი = cursor.fetchall ()

მონაცემები =

რიგის შედეგად:

data.append (სია (მწკრივი))

კურსორი. დახურვა ()

დაკავშირება. დახურვა ()

მონაცემების დაბრუნება

ჩვენი მონაცემთა ბაზაში მონაცემების ჩასმის ფუნქცია

def set_data (sql, params = არცერთი):

conn = mysql.connect ()

კურსორი = conn.cursor ()

სცადე:

log.debug (sql)

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

log.debug ("SQL uitgevoerd")

გამონაკლისის გარდა e:

log.exception ("Fout bij uitvoeren van sql: {0})". ფორმატი (ე))

დაბრუნება ცრუ

კურსორი. დახურვა ()

დაკავშირება. დახურვა ()

დაბრუნება True

ჩვენ ასევე დაგვჭირდება ჩვენი განაცხადის თემა ისე, რომ თქვენ შეძლოთ სხვა რამის გაკეთება ჩაწერის დროს.

კლასი ThreadedTask (threading. თემა):

def _init _ (self,):

ძაფის დაყენება

ძაფი. თემა._ init _ (თვით)

შექმენით სია თქვენი ყველა მიღებული მონაცემის შესანახად

self.data_all =

def run (თვითმმართველობის):

დრო. ძილი (5)

იმპორტი თქვენი საკუთარი პითონის კოდი, სადაც იღებთ მონაცემებს

Import_websocket იმპორტი

მიიღეთ თქვენი მონაცემები

w = მიიღოს_ვებგვერდი. ვებსაიტი ()

დაამატეთ თქვენი მონაცემები თქვენს სიაში და დაბეჭდეთ.

მე დიაპაზონში (0, 200):

self.data_all.append (w.work (). გაყოფა (","))

ბეჭდვა (self.data_all)

ამოცანა = ThreadedTask ()

შემდეგ შეგიძლიათ გააკეთოთ task.run () თქვენი თემის დასაწყებად და მონაცემების მიღების დასაწყებად.

ნაბიჯი 5: ყველაფრის ერთმანეთთან დაკავშირება

თქვენი Pi– დან თქვენი ვებსაიტის გასაშვებად თქვენ უნდა გამოიყენოთ სერვისი:

[ერთეული] აღწერა = uWSGI მაგალითი, რომელიც ემსახურება project1 ვებ ინტერფეისს

შემდეგ = network.target

BindsTo = mysqld.service

შემდეგ = mysqld.service

[სერვისი]

შეცვალეთ თქვენი მომხმარებელი

მომხმარებელი = pi

ჯგუფი = www-მონაცემები

აქ თქვენ უნდა შეიყვანოთ თქვენი Flask ფაილის დირექტორია

WorkingDirectory =/home/pi/project1/ვებ

თქვენი ini ფაილის დირექტორია, რომელიც მოგვიანებით მოიძებნება.

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

[Დაინსტალირება]

WantedBy = multi-user.target

uwsgi-flask.ini, რომელიც თქვენ უნდა განათავსოთ ExecStart– ში ზემოთ მითითებულ დირექტორიაში

[uwsgi] მოდული = ვებ: აპლიკაცია virtualenv =/home/pi/project1/env

სამაგისტრო = ჭეშმარიტი პროცესები = 5

მოდულები = პითონი 3

სოკეტი = პროექტი 1. წინდები chmod-socket = 660 ვაკუუმი = ჭეშმარიტი

მარადიული = ჭეშმარიტი

ახლა თქვენ შეგიძლიათ წაიკითხოთ თქვენი მონაცემები და აჩვენოთ ისინი თქვენს ვებგვერდზე.

ნაბიჯი 6: დამატებითი: LCD ეკრანის დაკავშირება

ჩვენ შეგვიძლია დავუკავშიროთ LCD ეკრანი ისე, რომ ჩვენ ვაჩვენოთ ჩვენი Pi- ს IP მისამართი ჩვენს ვებსაიტზე.

იმპორტი RPi. GPIO როგორც GPIOimport დრო

ბრძანებების იმპორტი

GPIO.cleanup ()

D0 = 22

D1 = 5

D2 = 6

D3 = 13

D4 = 19

D5 = 26

D6 = 20

D7 = 21

სია = [22, 5, 6, 13, 19, 26, 20, 21]

E = 24

RS = 23

კლასის ეკრანი:

def _ დაწყება _ (საკუთარი თავი):

GPIO.setmode (GPIO. BCM)

self.setup ()

#ფუნქცია მითითებული self.stuur_instructie (0x3f) #ჩვენება self.stuur_instructie (0x0c) #On + კურსორზე self.stuur_instructie (0x01) @staticmethod def setup (): GPIO.setup (list, GPIO. OUT) GPIO.setup (, RS], GPIO. OUT)

def stuur_instructie (თვითმმართველობის, ბაიტი):

GPIO.output (E, GPIO. HIGH)

GPIO.output (RS, GPIO. LOW)

self.set_GPIO_bits (ბაიტი)

დრო. ძილი (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 (ტემპერატურა)

დრო. ძილი (0.005)

GPIO.output (E, GPIO. LOW)

def set_GPIO_bits (თვით, ბაიტი):

მე დიაპაზონში (0, 8):

თუ (ბაიტი და (2 ** ი)) == 0:

GPIO.output (სია , GPIO. LOW)

სხვა:

GPIO.output (სია , GPIO. HIGH)

def main ():

s = ეკრანი ()

teken = "ადგილობრივი IP მისამართი:"

თეკენის წერილისთვის:

s.stuur_teken (წერილი)

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

ბეჭდვა (teken2)

s.stuur_instructie (0xc0)

წერილში 2 teken2- ში:

s.stuur_teken (წერილი 2)

თუ _name_ == '_ მთავარი_': #პროგრამა იწყება აქედან

სცადე:

მთავარი ()

გარდა კლავიატურის უწყვეტი:

ჩაბარება

შემდეგ ჩვენ შეგვიძლია შევქმნათ სერვისი LCD– ის დასაწყებად.