Automatic Cat Toy 🐱

Considerate animale de companie crepusculare, majoritatea pisicilor domestice își manifestă activitatea noaptea, având un nivel ridicat de energie și dorință de joacă. Din păcate, factori precum programul încărcat și dorința naturală de odihnă îi împiedică pe proprietari să interacționeze cu felinele, care tânjesc, conform studiilor, după atenție umană.

Proiectul Automatic Cat Toy își propune să rezolve această problemă, venind ca o punte de mijloc care să împace ambele părți: felina se joacă fericită, iar proprietarul are o odihnă liniștită.

Schema Bloc

Proiectul constă în implementarea unei jucării automate pentru pisici, componenta principală pe care se bazează fiind Arduino UNO ATmega328P. Vor exista, în principal, 2 moduri de funcționare, care vor putea fi selectate prin intermediul unui buton:

• Modul activ - jucăria se mișcă continuu la diferite intensități și unghiuri, care pot fi reglate prin intermediul unui potențiometru. Mișcarea se face printr-un ServoMotor, stabilizat si legat de un ansamblu special construit. În acest mod, se va aprinde un led de o anumită culoare (roșu/verde) în funcție de unghi și se va afișa pe ecran o mică animație specifică.
• Modul senzor - se aprinde un led galben, iar inițial, jucăria stă nemișcată. Mișcarea se va declanșa prin intermediul unui senzor, încadrat într-un suport, care va măsura distanța minimă față de pisică, la un nivel inferior, la care aceasta are acces. În momentul în care pisica este în zona senzorului, jucăria face o scurtă mișcare, apoi revine în starea inițială până la o nouă înregistrare pe senzor. Pe LCD se va afișa un mesaj care conține informații despre distanța la care se află pisica.

Workflow

Logica programului este ilustrată în schema de mai jos. Modul de funcționare default este modul 1, cu mișcarea în funcție de potențiometru.

Întrerupere Pin Change pe Timer 2

Pentru întreruperea de tip Pin Change de la buton, am folosit Timer-ul 2. Aici aflăm practic modul de funcționare. Inițial, am făcut următoarele configurări:

PCICR |= B00000100;   // set Timer 2
PCMSK2 |= B10000000;  // PCINT23 = PD7

Așa arată rutina de întrerupere. Am dezactivat Timer-ul 0 în timpul apăsării pentru a evita interferențe.

ISR(PCINT2_vect) {

 int buttonStatus = digitalRead(button);  // Read the current button status
 
 if (buttonStatus && !buttonPressed) {   // Button was just pressed
 
  digitalWrite(led, !digitalRead(led));  // Toggle the yellow LED status
  buttonPressed = true;                  
  TIMSK0 &= ~_BV(OCIE0A);                // Disable Timer0 interrupt during button press
  
 } else if (!buttonStatus && buttonPressed) {  // Button was just released
   buttonPressed = false;                     
   TIMSK0 |= _BV(OCIE0A);                      // Enable Timer0 interrupt during button press
 }
}

Întrerupere Compare Match pentru Timer 0 (PWM)

Ideea aici a fost să mișc servomotorul în poziții cât mai random, la un interval regulat, atunci când senzorul detectează mișcarea unui obiect apropiat. În fucția setup(), am făcut următoarele inițializări:

TCCR0A = _BV(COM0B1) | _BV(WGM00) | _BV(WGM01);  // Non-Inverting Fast PWM Mode, Fast PWM, 0-255, resets to 0
TCCR0B = _BV(WGM02) | _BV(CS02) | _BV(CS00);     // Waveform Generation Mode, Prescaler 1024
OCR0A = 31;                                      // Set TOP value
OCR0B = 15;                                      // Set initial value
TIMSK0 |= _BV(OCIE0A);                           // Enable Timer 0 Compare Match
sei();                                           // Enable interrupts

Calcule internal counter frequency

f_int = 16,000,000 / (1024 * (255 + 1)) = 16,000,000 / 262144 = 61.0352 Hz

Rutina de întrerupere, modul 2 de funcționare. În funcție de valoarea counter-ului Timer, calculez o nouă poziție de deplasare și un nou unghi pentru mișcarea servomotorului.

ISR(TIMER0_COMPA_vect) {
 Time++;                     // Global volatile variable
 if (Time == 20) {
  
   // Move servo
   if (forward) {
     pos += 5;               // Increment position
     if (pos >= 180)
       forward = false;      // Reached the maximum position, change direction
   } else {
     pos -= 5;               // Decrement position
     if (pos <= 0)
       forward = true;       // Reached the starting position, change direction
   }
   move = true;
   Time = 0;                 // Reset timer
 }
}

ADC

După stabilizarea potențiometrului cu ajutorul condensatorului, am configurat citirea valorii în felul următor:

ADMUX |= B01000000;      // 5 V
ADCSRA |= B01000111;     // Prescaler 128 and Enable
ADCSRA |= (1 << ADSC);   // ADC Start Conversion
while (!(ADCSRA & (1 << ADIF))); // Wait
uint16_t result = ADC;

Apoi transform valoarea citită într-un unghi pentru servomotor, folosind funcția map. În cod se observă utilizarea unei formule pentru aproximarea rezultatului, întrucât potențiometrul, chiar și cu acel condensator în paralel, avea momente de instabilitate.

static uint16_t smoothedResult = result; 
const float smoothingFactor = 0.5;        // Smoothing factor - for more control over servo

smoothedResult = smoothingFactor * smoothedResult + (1 - smoothingFactor) * result;
int servoPosition = map(smoothedResult, 0, 1023, 0, 180); // map value to get angle
myServo.write(servoPosition); // move servo

Restul funcțiilor, elementele de sincronizare și dependențele dintre variabile sunt explicate mai detaliat în README-ul și codul din arhivă:

• drawAnimations → Afișează pe LCD titlul și animația inițială cu 5 pisici care dispar succesiv până la începerea jocului.
• updateLCD → Se scrie un mesaj pe LCD, în modul de funcționare 2, la un interval de timp, care să nu fie prea rapid (probleme cu PWM).
• moveServo() → Funcție care miscă efectiv servomotorul.
• nonBlockingServoControl() → Aceasta este o funcție care să miște servomotorul în modul de funcționare 2, la o poziție random calculată în rutina de întrerupere.

Rezultatul este o jucărie funcțională, cu un design atractiv, care îi oferă mobilitate, foarte interesantă pentru pisici, așa cum se poate observa și din demo-ul de mai sus!

Consider că rezultatul final depășește simularea inițială, cu funcții Arduino, care bifa criteriile de funcționalitate, însă la capitolul feature-uri și fiabilitate lăsa de dorit.

A fost un proiect foarte interesant, primul de până acum care implică componente fizice și lucru manual pentru design. Am lucrat cu mare drag la el, mai ales având în vedere scopul său și m-am bucurat foarte tare să îmi văd ideea pusă în practică după atâtea săptămâni. Bineînțeles, au existat și o serie de situații și evenimente neprevăzute, din care am putut trage o serie de concluzii:

• La un astfel de proiect, trebuie să ai foarte clar în minte ce vrei să faci și mai ales de ce ai nevoie exact. S-a întâmplat să am nevoie ulterior primei comenzi de rezistențe, alt tip de buton, condensator, etc.
• Există posibilitatea să nu primești componentele pe care le-ai comandat, evident o mare problemă dacă ai nevoie de ceva specific.
• Lucrul cu întreruperi și AVR este dificil, îți consumă timp, dar te face să înțelegi și să descoperi ce se află în spatele funcțiilor Arduino și poți pune în aplicare ce vezi în DataSheet.
• Să implementezi un proiect cu componente fizice este mult mai interesant ca pe TinkerCad.
• Multe biblioteci și funcții folosesc deja în spate Timer 1, deci trebuie atenție mare.
• Biblioteca LiquidCrystal nu este chiar atât de ușor de manipulat și poate cauza probleme în combinație cu rutina de întreruperi.
• Servomotorul consumă foarte mult curent/resurse și generează electrical noise care poate interfera cu modulul I2C de pe LED.
• Ar fi fost de preferat, în cazul proiectului meu, să alimentez LCD-ul la altă sursă, sau tot circuitul la o sursă peste 5V.
• Potențiometrul are fluctuații foarte mari și este foarte delicat, ajută să pui în paralel cu pinii săi un condensator.

Export to PDF