Autor:

• Lica Robert-Mihai

Un API pentru a folosi placa ARC cat mai usor. La aceasta se pot connecta 2 encodere, 2 servouri, 2 motoare DC si 2 camere Pixy2. API-ul creat ofera control asupra servourilor; control direct asupra %dc motoarelor sau se poate specifica un rpm daca se doteaza cu encodere prin folosirea unui PID; API-ul pentru camera Pixy2 a fost portat pe acest uC.

Diagrama software:


Diagrama hardware:

Componente:

1. 1 ARC Board;
2. 2 motoare DC;
3. 4 senzori hall;
4. 1 servo;
5. 1 Pixy2;
6. 1 Arduino Pro Mini;
7. 1 receiver FS-A8S 2.4Ghz Mini.

1. Placa ARC a fost construita de Haute Ecole ARC pentru competitia NXP Cup. Microcontroller-ul folosit este un ARM Cortex-M4 MK64FN1M0VLL12 (datasheet). Schematica placii si utilizarile initiale ale pinilor pot fi gasite aici: ARC-Board schematic.
2. Pe placa ARC se afla 2 punti H, prin urmare putem connecta pana la 2 motoare cu comenzi diferite.
3. Se folosesc cate 2 senzori/roata, fiecare roata are 9 magneti atasati, prin urmare rezolutia este de 40 de grade. Cei 2 senzori de pe o roata functioneaza in cuadratura pentru a obtine si directia de rotatie.
4. Un servo montat in fata masinutei controleaza directia rotilor.
5. Pentru contextul nostru, camera video poate sa recunoasca liniile de pe podea sub forma de vectori si sa intoarca pozitiile acestora in matricea de vizualizare a camerei. Mai multe detalii se pot gasi pe wiki-ul camerei: Pixy2-wiki.
6. Arduino-ul este folosit pentru a decoda semnalul iBUS venit de la receiver. Am optat pentru un periferic pentru a nu incarca uC-ul principal si deoarece am gasit o biblioteca care decodeaza acest protocol. Din pacate nu am gasit o biblioteca de Attiny pentru acest protocol.
7. Un receiver de dimensiuni mici pe 2.4Ghz compatibil cu radio telecomenzile FlySky. Este folosit pentru a da o comanda de kill masinii daca este pe cale sa se loveasca de ceva.

Biblioteca foloseste timmer-ul FTM1.

Timer& get_instance(void)
Returneaza o referinta catre obiect si la prima apelare este initializat obiectul.

  Timer& instance = Timer::get_instance();

uint32_t micros(void)
Returneaza un unsigned int ce reprezinta timpul in microsecunde de la primul apel Timer::get_instance().

  auto elapsed = instance.micros();

uint32_t millis()
Returneaza un unsigned int ce reprezinta timpul in milisecunde de la primul apel Timer::get_instance().

  auto elapsed = instance.millis();

void delayMicroseconds(uint32_t t)
Functie blocanta ce asteapta 't' microsecunde.

  instance.delayMicroseconds(500000U); // 0.5 sec

void delay(uint32_t t)
Functie blocanta ce asteapta 't' milisecunde.

  instance.delay(1000); // 1.0 sec

uint32_t add_irq_handler(void (*time_IRQn_handler)(void))
Returneaza 0 pentru success si -1 in caz de eroare.
Primeste un pointer la o functie, ce intoarce void si accepta void ca parametru, si o adauga in vectorul “irq_handlers” ce vor fi apelate la intreruperea de ceas (0.2 sec).

  instance.add_irq_handler(function);

void call_irq_handlers()
Metoda apelata de rutina de tratare a intreruperii de ceas (0.2 sec) pentru a executa toate functiile din vectorul “irq_handlers”

  instance.call_irq_handlers();

Biblioteca foloseste timmer-ul FTM2.

Servo& get_instance(void)
Returneaza o referinta catre obiect si la prima apelare este initializat obiectul.

  Servo& instance = Timer::get_instance();

void set_angle(ftm_chnl_t sv, uint16_t angle)
Primeste ca si parametru channel-ul (SV1_FTM_CHANNEL sau SV2_FTM_CHANNEL) la care este conectat servo-motorul si unghiul dorit (0 ⇐ angle ⇐ 180).

  set_angle(SV1_FTM_CHANNEL , 90U);

void set_dutycycle(ftm_chnl_t sv, uint8_t dc)
Primeste ca si parametru channel-ul (SV1_FTM_CHANNEL sau SV2_FTM_CHANNEL) la care este conectat servo-motorul si dutycycle-ul dorit (0 ⇐ dc ⇐ 100) sa fie scris pe pinul de semnal.

  set_dutycycle(SV1_FTM_CHANNEL , 2U);

Pentru mai multe detalii, consultati documentatia oficiala de pe pagina.
Pentru portare a trebuit sa implementez comunicatia pe SPI blocanta si functiile de “delay” si “millis” din <Timer.hpp>.

Configuratia de SPI este realizata in configuratorul din MCUXpresso astfel(TO_DO: adauga imagine cu configuratia).
Biblioteca de Pixy2 se asteapta ca comunicatia de SPI sa fie blocanta. Pentru viitor comunicatia sa nu mai fie blocanta si sa se foloseasca intreruperi sau eDMA.

void begin()
Pentru a fi folosit pe viitor cand configurarea nu mai este facuta din GUI-ul din MCUXpresso.

  SPI::begin();

void send(uint8_t *buf, uint8_t len)
Trimite prin SPI un vector de bytes fara a intoarce ce citeste pe SPI. Comunicatia este blocanta.

  SPI::send(buffer, n);

void recv(uint8_t *buf, uint8_t len)
Primeste prin SPI un vector de bytes in timp ce trimite pe SPI \0. Comunicatia este blocanta.

  SPI::recv(buffer, n);

TODO

TODO

TODO

TODO

TODO