Proiectul presupune crearea pe un ecran LCD a unui stickman care sa imite mișcările unei persoane aflate in fata unui XBOX 360 Kinect.

Consider ca proiectul meu reprezintă un POC pentru o idee care ar putea fi aplicată pe semafoarele din zonele turistice urmând:

• sa încurajeze respectarea semnelor de circulație, fapt care este adesea o problemă in astfel de zone;
• să anime un semafor de altfel anost.

Au fost deja implementate astfel de proiecte având efectele precizate anterior. Aveți un exemplu aici.

Am ales acest proiect din următoarele motive:

• Este mai solicitant din punct de vedere software;
• Este o ocazie bună de a înțelege cum funcționează un Kinect și API-urile puse la dispoziție de acesta;
• Mi-ar plăcea să văd ceva similar în orașele din România.

Pași de funcționare a proiectului:

1. Utilizatorul stă în fața Kinect-ului;
2. Kinect-ul va recunoaște corpul utilizatorului și va comunica cu laptop-ul;
3. Laptop-ul va trimite plăcuței Arduino datele obținute de Kinect;
4. Datele sunt folosite ca input pentru o funcție care obține o matrice booleană;
5. Matricea se trimite display-ului pe care va apărea un stickman care imită utilizatorul.

Proiectul este alcătuit din următoarele componente:

• Xbox 360 Kinect;
• Power adapter pentru Xbox 360 Kinect;
• Laptop (pentru conectarea la Kinect);
• ATmega328p;
• 3.5″ Display LCD Shield cu rezoluție 320×480.

Descriere a asamblării:

• Pe plăcuța Arduino se pune display-ul care este un shield, deci acesta ocupă majoritatea pinilor, iar pe restul îi blochează, nemaiputând fi altceva conectat.
• Plăcuța Arduino se conectează la laptop.
• Adaptorul pentru Kinect are 3 ieșiri, acesta conectându-se la:
  • Kinect;
  • Laptop;
  • Sursă de curent.

De menționat:

• Kinect-ul nu poate fi conectat direct la laptop, deoarece acesta nu poate furniza suficientă putere prin USB, deci un power adapter este necesar.
• Modelele mai noi de Kinect pot fi conectate direct la laptop, dar modelul folosit de mine este cel lansat în 2010.
• Display-ul LCD ocupă majoritatea pin-urilor de pe plăcuța Arduino, iar pe restul le face inaccesibile.

Pentru implementarea funcționalității am utilizat următoarele tehnologii (medii de dezvoltate, limbaje de programare și librării):

• Arduino IDE
  • C++
  • Pentru programarea LCD Display Shield-ului
    • LCDWIKI_GUI
    • LCDWIKI_KBV
• Processing IDE - versiunea 4.2
  • Processing
  • Pentru programarea Kinect-ului
    • SimpleOpenNI - versiunea pentru Processing 3.5.3 (Funcționează și pentru 4.2)
  • Pentru comunicarea serială cu plăcuța Arduino:
    • Serial

Deoarece Kinect-ul si plăcuța Arduino sunt conectate prin intermediul laptop-ului, vom avea pe lângă dancing_stickman.ino, pentru Arduino, și dancing_stickman.pde, un program scris în Processing, prin intermediul căruia Kinect-ul poate comunica cu plăcuța folosind USART.

Pentru Arduino nu trebuie să facem nimic diferit, în Processing însă va trebui să accesăm portul serial astfel:

import processing.serial.*;
Serial port;
 
void setup() {
  String portName = Serial.list()[SERIAL_PORT_INDEX];
  port = new Serial(this, portName, BAUD_RATE);
}

Dorim ca Kinect-ul să detecteze scheletul user-ului și gesturile acestuia. Pentru a utiliza aceste funcționalități ale Kinect-ului, vom avea nevoie și de matricea de adâncime (depth map), care calculează distanța de la Kinect la tot ceea ce vede utilizând două camere (RGB și IR) și un proiector de raze infraroșii. Aveți aici o explicație cu reprezentare vizuală.

Exemplu de harta de adâncime. Observați faptul ca brațul stâng apare negru, deși este foarte aproape de cameră, deci ne-am aștepta să apară alb. Acest fenomen este cauzat de felul în care Kinect-ul se folosește de razele infraroșii pentru a calcula distanța până la obiecte. Distanța la care Kinect-ul este cel mai eficient este de obicei între 1.5 și 4 metri.

Kinect-ul este inițializat astfel:

import SimpleOpenNI.*;
SimpleOpenNI kinect;
 
void setup() {
  kinect = new SimpleOpenNI(this);
  kinect.enableDepth(); // activează matricea de adâncime
  kinect.enableUser(); // activează recunoașterea utilizatorilor (recunoașterea corpului)
  kinect.enableHand(); // activează recunoașterea gesturilor
  kinect.startGesture(SimpleOpenNI.GESTURE_WAVE); // activează recunoașterea gestului WAVE
 
  /* se pregătește fereasta în care vom afișa matricea de adâncime */
  size(KINECT_WIDTH, KINECT_HEIGHT); // KINECT_WIDTH = 640, KINECT_HEIGHT = 480
  fill(255, 0, 0);
}
 
void draw() {
  /* actualizează fereastra cu noua matrice de adâncime */
  kinect.update();
  image(kinect.depthImage(), 0, 0);
}

Activarea acestor funcționalități vor declanșa si apelul funcțiilor de callback onNewUser, onLostUser, onCompletedGesture, care vor fi folosite pentru etapa de calibrare și lansare a recunoașterii corpului.

Pentru detectarea corpului utilizatorului, Kinect-ul recunoaște 15 puncte cu care formeaza scheletul: cap, gât, doi umeri, două coate, două mâini, trunchi, două șolduri, doi genunchi, două tălpi.

Exemplu de recunoaștere a scheletului peste matricea de adâncime.

Obținerea unor coordonate 2D la aceste puncte este trivială. Folosind biblioteca SimpleOpenNI se utilizează funcția getJointPositionSkeleton pentru fiecare punct pentru a obtine poziția lui în spațiul 3D, apoi se proiectează la 2D folosind convertRealWorldToProjective.

PVector getProjectiveJoint(int userID, int jointID) {
  /* Obține coordonatele 3D a punctului de pe schelet */
  PVector joint = new PVector();
  float confidence = kinect.getJointPositionSkeleton(userID, jointID, joint); // confidence poate fi folosit pentru verificarea preciziei rezultatelor
 
  /* Convertește la spațiul 2D calculând proiecția */
  PVector projectiveJoint = new PVector();
  kinect.convertRealWorldToProjective(joint, projectiveJoint);
 
  return projectiveJoint;
}

Partea mai complicată la acest proiect este transmiterea celor 15 puncte de la Kinect la Arduino, prin intermediul USART, din următoarele motive:

• Rezoluția ecranului meu LCD este de 320×480;
• Rezoluția camerei Kinect-ului este de 640×480;
• USART trimite informația serial, octet cu octet, deci putem doar sa trimitem pe rând valori cuprinse între 0 și 255.

Acest fapt înseamnă că este nevoie să fie schițat un protocol de comunicație minimal care să fie folosit de cele două dispozitive. Partea bună este totuși că această comunicație se poate produce doar într-un singur sens, de la Kinect la Arduino.

Soluția la care am ajuns a fost utilizarea funcției map(value, fromLow, fromHigh, toLow, toHigh), existentă în ambele limbaje de programare folosite, pentru a codifica coordonatele (x, y) ale punctelor astfel: Pentru trimitere de pe Kinect:

void sendCoordinateAxis(float value, int lowerBound, int upperBound) {
  int intVal = floor(between(value, lowerBound, upperBound)); 
  int asByte = (int)map(intVal, lowerBound, upperBound, 0, 255);
  port.write(asByte);
}

Pentru recepție de pe Arduino: <code cpp> int readCoordinateX() {

byte xAsByte = Serial.read();
int x = (int)map(xAsByte, 0, 255, 0, width);
Serial.println(x);
return x;

}

int readCoordinateY() {

byte yAsByte = Serial.read();
int y = (int)map(yAsByte, 0, 255, 0, height);
Serial.println(y);
return y;

} </code

• Driver Kinect pentru PC: https://k2vr.tech/docs/notready
• simple-openni: https://code.google.com/archive/p/simple-openni/downloads
• std::vector pentru Arduino: https://reference.arduino.cc/reference/en/libraries/vector/

• La momentul scrierii, nu există o librărie open-source de Kinect pentru calculatoarele cu arhitectură ARM, care să ofere toate funcționalitațile disponibile.
• Dacă folosiți un power adapter, acesta trebuie obligatoriu conectat la laptop printr-un port USB 3.0.
• Atunci când stabiliți conexiunea serială între calculator și Arduino, verificați în codul de Processing dacă portul serial folosit este cel corect.
  • Toate tutorialele spun că numele portului care trebuie folosit este Serial.list()[0], dar în cazul meu acest port era ocupat de căștile cu Bluetooth.
  • Pentru mine, Serial.list()[2] a fost numele portului serial.
• În literatura de specialitate se folosesc în mare parte versiuni de simple-openni dinainte de 1.96, care acum sunt outdated.
  • Schimbările nu sunt atât de evidente între versiuni. Recomand folosirea celei mai noi versiuni plecând de la exemplele oferite.

Probleme întâmpinate:

• Deoarece comunicarea seriala este bazata octet pe octet, va fi nevoie sa folosesc valori intre 0 si 255 si sa imi creez minimal un protocol de comunicație.
• Display-ul LCD nu are un refresh rate suficient de mare pentru a capta imagini în timp real. La momentul scrierii display-ul afișeaza poziția utilizatorului o dată la 1.6 secunde.

Resurse Software:

• http://www.lcdwiki.com/3.5inch_Arduino_Display-UNO
• https://www.instructables.com/Kinect-controls-Arduino-wired-Servos-using-Visual-/
• https://github.com/gitcnd/LCDWIKI_GUI/blob/master/LCDWIKI_GUI.h
• https://github.com/totovr/SimpleOpenNI

Resurse Hardware:

• https://www.instructables.com/Kinect-controls-Arduino-wired-Servos-using-Visual-/
• https://www.aranacorp.com/en/using-a-tft-lcd-shield-with-arduino/
• https://www.youtube.com/watch?v=NhpXJlM7-7E&ab_channel=ZinTechIdeas
• http://www.lcdwiki.com/3.5inch_Arduino_Display-UNO#Product_Video

Resurse Kinect:

• https://www.academia.edu/18712369/Arduino_and_Kinect_Projects

Export to PDF