Arduino ટાઈમર: તમારા પ્રોજેક્ટમાં સમય સાથે રમો

થોડા સમય પહેલા અમે આ વિશે વધુ માહિતી પ્રકાશિત કરી હતી millis() કાર્ય de Arduinoહવે આપણે વધુ ઊંડાણમાં જઈશું Arduino ટાઈમર, સુવિધા માટે આ સુવિધા સાથે પ્રારંભ કરવા માટે, સમજો કે આ બોર્ડ MCU સાથે સમયનું સંચાલન કેવી રીતે કરે છે, તેમજ millis().

Arduino ટાઈમર શું છે?

El Arduino ટાઈમર, અથવા ટાઈમર, એ હાર્ડવેર દ્વારા અમલમાં મુકાયેલ કાર્ય છે (માઈક્રોકન્ટ્રોલરમાં, ક્વાર્ટઝ ક્રિસ્ટલની મદદથી જે ઘડિયાળના ધબકારા ઉત્પન્ન કરે છે અને તે "લય" સેટ કરે છે, બાહ્ય હાર્ડવેર અથવા ICs 555ની જરૂર વગર) જે ઘડિયાળોને આભારી કામચલાઉ ઘટનાઓને નિયંત્રિત કરવાની મંજૂરી આપે છે. આંતરિક ઉદાહરણ તરીકે, સ્કેચ કોડથી સ્વતંત્ર રીતે, સમયાંતરે ચોક્કસ સમય માપન કરવા, વગેરે.

કલ્પના કરો કે તમે ઉપયોગ કરો છો વિલંબ() કાર્ય, આ Arduino MCU પર નિર્દિષ્ટ સમય વીતી ન જાય ત્યાં સુધી એક્ઝેક્યુશનને અવરોધિત કરશે અને પછી પ્રોગ્રામ સાથે ચાલુ રાખશે, પરંતુ ટાઈમર અવરોધિત કરશે નહીં. તે સમય હશે કારણ કે MCU એકસાથે અન્ય સૂચનાઓનો અમલ કરવાનું ચાલુ રાખશે. એ જ મોટો ફાયદો છે.

ટાઈમર સંબંધિત છે વિક્ષેપો Arduino ના, કારણ કે તેઓ અમુક ચોક્કસ કાર્યમાં હાજરી આપવા માટે તેમના દ્વારા ચલાવવામાં આવશે. બીજા શબ્દોમાં કહીએ તો, Arduino ટાઈમર એ એક કાર્ય છે જે ચોક્કસ સમયે ટ્રિગર થાય છે, એક વિક્ષેપ ફંક્શન ચલાવે છે. એટલા માટે આ વિક્ષેપો વિશે જાણવું પણ જરૂરી છે.

સ્થિતિઓ

Arduino ટાઈમર ધરાવે છે Operatingપરેટિંગ સ્થિતિઓ, આમાં તેનો ઉપયોગ કરવા સક્ષમ છે:

• PWM સિગ્નલ: તમે નિયંત્રિત કરી શકો છો Arduino પિન (~).
• CTC (સરખામણી મેચ પર ક્લીયર ટાઈમર): કાઉન્ટરની અંદરના સમયની ગણતરી કરે છે અને જ્યારે તે ટાઈમરના રજિસ્ટરમાં ઉલ્લેખિત મૂલ્ય સુધી પહોંચે છે, ત્યારે વિક્ષેપ ચલાવવામાં આવે છે.

તેની પાસે કેટલા ટાઈમર છે? ટાઈમરના પ્રકાર

ત્યાં છે 3 ટાઈમર પ્લેટો પર Arduino UNO, જો કે અન્ય ટોચની પ્લેટો પર વધુ હોઈ શકે છે:

• ટાઈમર 0: 8-બીટ, 0 થી 255 (256 સંભવિત મૂલ્યો) સુધી ગણતરી કરી શકે છે. વિલંબ(), મિલિસ(), અને માઇક્રો() જેવા કાર્યો દ્વારા વપરાય છે. પ્રોગ્રામ્સમાં ફેરફાર ન કરવા માટે તેના ફેરફારની ભલામણ કરવામાં આવતી નથી.
• ટાઈમર 1: ટાઈમર 0 ની બરાબર. યુનોમાં સર્વો લાઈબ્રેરી દ્વારા ઉપયોગમાં લેવાય છે (MEGA માટે ટાઈમર 5).
• ટાઈમર 2: 16-બીટ, અને 0 થી 65.525 (65.536 સંભવિત મૂલ્યો) ની રેન્જ હોઈ શકે છે. ટોન() ફંક્શન માટે વપરાય છે, જો તેનો ઉપયોગ ન થાય, તો તે તમારી એપ્લિકેશન માટે મુક્તપણે ઉપયોગ કરી શકાય છે.
• ટાઈમર 3, 4, 5 (માત્ર Arduino MEGA પર): બધા 16-બીટ.

Arduino ટાઈમર કેવી રીતે કામ કરે છે?

સક્ષમ થવા માટે Arduino ટાઈમર સાથે કામ કરો, આ વિકાસ બોર્ડના MCU માં આ બધું ઇલેક્ટ્રોનિક રીતે કેવી રીતે કાર્ય કરે છે તે જાણવું મહત્વપૂર્ણ છે:

• ઘડિયાળની આવર્તન: પ્રતિ સેકન્ડના ચક્રની સંખ્યા છે જે તે વિકસાવવા સક્ષમ છે, Arduino ના કિસ્સામાં તે 16 Mhz છે, અથવા શું સમાન છે, ઘડિયાળ સિગ્નલ એક સેકન્ડમાં 16.000.000 વખત ઓસીલેટ થાય છે (ચક્ર).
• સમયગાળો: T દ્વારા દર્શાવવામાં આવે છે, અને તે સેકન્ડમાં માપવામાં આવે છે, અને તે ચક્રનો વ્યસ્ત છે. ઉદાહરણ તરીકે, T=1/C, જે 1/16000000 = 0.0000000625 માં પરિણમશે, દરેક ચક્ર પૂર્ણ થવામાં જે સમય લાગશે. અને આવર્તન એ સમયગાળાની વ્યસ્ત છે, તેથી f = 1/T.
• ચક્ર: સમયના એકમ દીઠ થતા સિગ્નલના દરેક પુનરાવર્તનો છે. Arduino પર તે એક સેકન્ડમાં 16M હશે. અથવા સમાન શું છે, આ કિસ્સામાં, જ્યારે 16 મિલિયન ચક્ર પસાર થયા છે, ત્યારે એક સેકન્ડ પસાર થઈ ગઈ છે. તેથી, એક ચક્ર 625 એનએસ લે છે એમ કહી શકાય.
• સિગ્નલની ધાર: ઘડિયાળના સંકેતો ચોરસ હોય છે, અને કિનારીઓ વધતી અથવા ઘટી શકે છે. ધાર એ સિગ્નલની સીધી રેખા છે જ્યારે તે આમાંથી બદલાય છે:
  • 0 (નીચી) થી 1 (ઉચ્ચ): વધતી ધાર.
  • 1 (ઉચ્ચ) થી 0 (નીચું): પડતી ધાર.

કિનારીઓ મહત્વપૂર્ણ છે કારણ કે Arduino ટાઈમર સિગ્નલ કિનારી પરથી ચક્ર માપે છે. એ) હા એલ કોન્ટાડોર તે દરેક ચક્ર સાથે વધે છે અને જ્યારે તે રજિસ્ટર મૂલ્ય સુધી પહોંચે છે, ત્યારે વિક્ષેપ ચલાવવામાં આવે છે.

તેથી, એકવાર તમે આ જાણો છો, જો તમારી પાસે હોય Arduino MCU પર 16Mhz, અને 8-બીટ ટાઈમરનો ઉપયોગ કરવામાં આવે છે, એવું કહી શકાય કે 16-બીટ (256/16000000) માટે દર 4 μs (16/65536) અથવા 16000000 ms માં વિક્ષેપ આવશે. તેથી, જો તમે 16 મૂલ્ય સાથે 65535-બીટ કાઉન્ટર રજિસ્ટરને મહત્તમ પર સેટ કરો છો, તો પછી ગમે તે કાર્યને એક્ઝિક્યુટ કરવા માટે ઇન્ટરપ્ટ 4 ms પર આવશે.

જ્યારે કાઉન્ટર મહત્તમ શક્ય મૂલ્ય સુધી પહોંચે છે, તે ફરીથી 0 પર પાછા આવશે. એટલે કે, ઓવરફ્લો થાય છે અને તે શરૂઆતથી પાછું ગણાશે.

ટાઈમરના વધારાના દરને નિયંત્રિત કરવા માટે તમે પણ ઉપયોગ કરી શકો છો એક પ્રીસ્કેલર, જે મૂલ્યો 1, 8, 64, 256 અને 1024 લે છે અને સમયને આ રીતે બદલે છે:

ટાઈમર સ્પીડ (Hz) = Arduino / Prescaler ની ઘડિયાળની આવર્તન

જો તે 1 પ્રીસ્કેલર હોય તો કંટ્રોલર વધીને 16 મેગાહર્ટઝ થશે, જો તે 8 થી 2 મેગાહર્ટ્ઝ છે, જો તે 64 થી 250 કેએચઝેડ છે, વગેરે. યાદ રાખો કે કાઉન્ટર અને પ્રીસ્કેલરના મૂલ્યની સરખામણી કરવા માટે એક ટાઈમર કાઉન્ટર સ્ટેટ કમ્પેરેટર હશે જ્યાં સુધી તેઓ સમાન ન થાય અને પછી કોઈ ક્રિયા ચલાવે. તેથી, વિક્ષેપ આવર્તન સૂત્ર દ્વારા આપવામાં આવે છે:

ઇન્ટરપ્ટ સ્પીડ (Hz) = Arduino / Prescaler ઘડિયાળની આવર્તન (તુલનાત્મક રજિસ્ટર મૂલ્ય + 1)

સદનસીબે, આપણે ન જોઈએ રેકોર્ડમાં ફેરફાર કરો Arduino ટાઈમરનો, કારણ કે અમે કોડમાં ઉપયોગ કરીએ છીએ તે પુસ્તકાલયો દ્વારા તેની કાળજી લેવામાં આવશે. પરંતુ જો તેઓ ઉપયોગમાં લેવાતા નથી, તો તેઓને ગોઠવવું જોઈએ.

Arduino IDE માં ઉદાહરણો

આ બધું થોડું સારી રીતે સમજવા માટે, અહીં હું Arduino IDE માટે બે સ્કેચ કોડ બતાવું છું જેની મદદથી તમે ટાઈમરના ઉપયોગનો અનુભવ કરી શકો છો. પહેલો કોડ છે જે દર સેકન્ડે Arduino પિન 8 સાથે જોડાયેલ LEDને ઝબકશે:

#define ledPin 8
void setup()
{
  pinMode(ledPin, OUTPUT);
  // Configurar Timer1
  TCCR1A = 0;                        //Registro control A a 0, pines OC1A y OC1B deshabilitados
  TCCR1B = 0;                        //Limpia el registrador
  TCCR1B |= (1<<CS10)|(1 << CS12);   //Configura prescaler a 1024: CS12 = 1 y CS10 = 1
  TCNT1 = 0xC2F8;                    //Iniciar timer para desbordamiento a 1 segundo
                                     //65536-(16MHz/1024/1Hz - 1) = 49912 = 0xC2F8 en hexadecimal
  
  TIMSK1 |= (1 << TOIE1);           //Habilitar interrupción para Timer1
}
void loop()
{
}
ISR(TIMER1_OVF_vect)                              //Interrupción del TIMER1 
{
  TCNT1 = 0xC2F7;                                 // Reniciar Timer1
  digitalWrite(ledPin, digitalRead(ledPin) ^ 1); //Invierte el estado del LED
}

LED ના ઝબકવા અથવા ફ્લેશિંગનો પ્રોગ્રામ કરો, અગાઉના કિસ્સામાં દર સેકન્ડની જેમ, પરંતુ આ વખતે ઉપયોગ કરો CTC એટલે કે સરખામણી:

#define ledPin 8
void setup()
{
  pinMode(ledPin, OUTPUT);
  
  // Configuración Timer1
  TCCR1A = 0;                //Registro de control A a 0
  TCCR1B = 0;                //Limpiar registro
  TCNT1  = 0;                //Inicializar el temporizador
  OCR1A = 0x3D08;            //Carga el valor del registro de comparación: 16MHz/1024/1Hz -1 = 15624 = 0X3D08
  TCCR1B |= (1 << WGM12)|(1<<CS10)|(1 << CS12);   //Modo CTC, prescaler de 1024: CS12 = 1 y CS10 = 1  
  TIMSK1 |= (1 << OCIE1A);  //Habilita interrupción por igualdad de comparación
}
void loop()
{
}
ISR(TIMER1_COMPA_vect)          //Interrupción por igualdad de comparación en TIMER1
{
  digitalWrite(ledPin, digitalRead(ledPin) ^ 1);   //Invierte el estado del LED
}

Arduino પ્રોગ્રામિંગ વિશે વધુ