Arduino டைமர்: உங்கள் திட்டங்களில் நேரத்துடன் விளையாடுங்கள்

சில காலங்களுக்கு முன்பு நாங்கள் அதைப் பற்றிய கூடுதல் தகவல்களை வெளியிட்டோம் மில்லிஸ்() செயல்பாடு de Arduino தான்இப்போது நாம் ஆழமாக ஆராய்வோம் Arduino டைமர், அம்சத்திற்கான இந்த அம்சத்துடன் தொடங்குவதற்கு, இந்த போர்டு MCU உடன் நேரத்தை எவ்வாறு நிர்வகிக்கிறது, அத்துடன் millis() ஐத் தாண்டிய பிற செயல்பாடுகளையும் புரிந்து கொள்ளுங்கள்.

Arduino டைமர் என்றால் என்ன?

El Arduino டைமர், அல்லது டைமர், வன்பொருள் மூலம் செயல்படுத்தப்படும் செயல்பாடு (மைக்ரோகண்ட்ரோலரில், கடிகார துடிப்புகளை உருவாக்கும் குவார்ட்ஸ் படிகத்தின் உதவியுடன் மற்றும் வெளிப்புற வன்பொருள் அல்லது IC கள் 555 தேவையில்லாமல் "ரிதம்" அமைக்கிறது) இது தற்காலிக நிகழ்வுகளை கட்டுப்படுத்த அனுமதிக்கிறது. உள். எடுத்துக்காட்டாக, ஒரு பணியை இடைவெளியில் நிகழச் செய்தல், துல்லியமான நேர அளவீடுகள் செய்தல், முதலியன, ஸ்கெட்ச் குறியீட்டிலிருந்து சுயாதீனமாக.

நீங்கள் பயன்படுத்துகிறீர்கள் என்று கற்பனை செய்து பாருங்கள் தாமதம்() செயல்பாடு, இது குறிப்பிட்ட நேரம் முடிவடையும் வரை Arduino MCU இல் செயல்படுத்துவதைத் தடுக்கும், பின்னர் நிரலைத் தொடரும், ஆனால் டைமர் தடுக்காது. MCU மற்ற வழிமுறைகளை ஒரே நேரத்தில் செயல்படுத்துவதால், இது நேரமாக இருக்கும். அதுவே பெரிய நன்மை.

டைமர் தொடர்புடையது தடங்கல்கள் Arduino இன், அவர்கள் சில குறிப்பிட்ட பணிகளில் கலந்துகொள்ள அவர்கள் மூலம் செயல்படுத்தப்படுவார்கள். வேறு வார்த்தைகளில் கூறுவதானால், Arduino டைமர் என்பது ஒரு குறிப்பிட்ட நேரத்தில் தூண்டப்பட்டு, குறுக்கீடு செயல்பாட்டைச் செயல்படுத்தும் ஒரு செயல்பாடு ஆகும். அதனால்தான் இந்த குறுக்கீடுகளைப் பற்றி தெரிந்து கொள்வதும் முக்கியம்.

முறைகள்

Arduino டைமர் உள்ளது 2 இயக்க முறைகள், இதைப் பயன்படுத்த முடியும்:

• PWM சமிக்ஞை: நீங்கள் கட்டுப்படுத்த முடியும் Arduino ஊசிகள் (~).
• CTC (பொருத்தத்தை ஒப்பிடும்போது டைமரை அழிக்கவும்): கவுண்டரில் உள்ள நேரத்தைக் கணக்கிடுகிறது மற்றும் டைமர்களின் பதிவேட்டில் குறிப்பிடப்பட்ட மதிப்பை அடையும் போது, ​​குறுக்கீடு செயல்படுத்தப்படும்.

இதில் எத்தனை டைமர்கள் உள்ளன? டைமர்களின் வகைகள்

உள்ளன 3 டைமர்கள் தட்டுகளில் Arduino UNO, மற்ற மேல் தட்டுகளில் இன்னும் அதிகமாக இருக்கலாம்:

• டைமர் 0: 8-பிட், 0 முதல் 255 வரை எண்ணலாம் (256 சாத்தியமான மதிப்புகள்). தாமதம்(), மில்லிஸ்(), மற்றும் மைக்ரோஸ்() போன்ற செயல்பாடுகளால் பயன்படுத்தப்படுகிறது. நிரல்களை மாற்றாதபடி அதன் மாற்றம் பரிந்துரைக்கப்படவில்லை.
• டைமர் 1: டைமர் 0க்கு சமம். UNO இல் உள்ள சர்வோ நூலகத்தால் பயன்படுத்தப்பட்டது (மெகாவுக்கான டைமர் 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 ns எடுக்கும் என்று கூறலாம்.
• ஒரு சமிக்ஞையின் விளிம்பு: கடிகார சமிக்ஞைகள் சதுரமாக இருக்கும், மேலும் விளிம்புகள் உயரும் அல்லது குறையும். ஒரு விளிம்பு என்பது சமிக்ஞையின் நேர் கோடு இதிலிருந்து மாறும்போது:
  • 0 (குறைவு) முதல் 1 (உயர்நிலை): உயரும் விளிம்பு.
  • 1 (உயர்) முதல் 0 (குறைவு): வீழ்ச்சி விளிம்பு.

Arduino டைமர்கள் சமிக்ஞை விளிம்புகளிலிருந்து சுழற்சிகளை அளவிடுவதால் விளிம்புகள் முக்கியம். A) ஆம் எல் contador இது ஒவ்வொரு சுழற்சியிலும் அதிகரிக்கிறது மற்றும் பதிவு மதிப்பை அடையும் போது, ​​குறுக்கீடு செயல்படுத்தப்படுகிறது.

எனவே, நீங்கள் இதை அறிந்தவுடன், உங்களிடம் இருந்தால் Arduino MCU இல் 16Mhz, மற்றும் 8-பிட் டைமர் பயன்படுத்தப்படுகிறது, ஒவ்வொரு 16 μs (256/16000000) அல்லது 4 ms 16-பிட் (65536/16000000) க்கு குறுக்கீடுகள் ஏற்படும் என்று கூறலாம். எனவே, நீங்கள் 16-பிட் கவுண்டர் பதிவேட்டை அதிகபட்சமாக 65535 மதிப்புடன் அமைத்தால், அது எந்தப் பணியாக இருந்தாலும் அதைச் செய்ய 4 ms இல் குறுக்கீடு ஏற்படும்.

கவுண்டர் அதிகபட்ச சாத்தியமான மதிப்பை அடையும் போது, அது மீண்டும் 0க்கு திரும்பும். அதாவது, ஒரு வழிதல் ஏற்படுகிறது மற்றும் அது ஆரம்பத்தில் இருந்து மீண்டும் கணக்கிடப்படும்.

டைமரின் அதிகரிப்பு விகிதத்தைக் கட்டுப்படுத்த, நீங்கள் பயன்படுத்தலாம் ஒரு prescaler, இது 1, 8, 64, 256 மற்றும் 1024 மதிப்புகளை எடுத்து, நேரத்தை இப்படி மாற்றுகிறது:

டைமர் வேகம் (Hz) = Arduino / Prescaler இன் கடிகார அதிர்வெண்

1 ப்ரீஸ்கேலராக இருந்தால், கன்ட்ரோலர் 16 மெகா ஹெர்ட்ஸ் ஆகவும், 8 முதல் 2 மெகா ஹெர்ட்ஸ் ஆகவும், 64 முதல் 250 கிஹெர்ட்ஸ் ஆகவும், மற்றும் பல. கவுண்டர் மற்றும் ப்ரீஸ்கேலரின் மதிப்பை அவை சமமாக இருக்கும் வரை ஒப்பிட்டு, ஒரு செயலைச் செயல்படுத்த, டைமர் கவுண்டர் ஸ்டேட் ஒப்பீட்டாளர் இருக்கும் என்பதை நினைவில் கொள்ளவும். அதனால், குறுக்கீடு அதிர்வெண் சூத்திரத்தால் வழங்கப்படுகிறது:

குறுக்கீடு வேகம் (Hz) = Arduino / Prescaler Clock Frequency (ஒப்பீட்டாளர் பதிவு மதிப்பு + 1)

அதிர்ஷ்டவசமாக, நாம் கூடாது பதிவுகளை மாற்றவும் Arduino டைமர்கள், குறியீட்டில் நாம் பயன்படுத்தும் நூலகங்களால் இது கவனிக்கப்படும். ஆனால் அவை பயன்படுத்தப்படாவிட்டால், அவை கட்டமைக்கப்பட வேண்டும்.

Arduino IDE இல் உள்ள எடுத்துக்காட்டுகள்

இதையெல்லாம் கொஞ்சம் நன்றாகப் புரிந்துகொள்ள, Arduino IDEக்கான இரண்டு ஸ்கெட்ச் குறியீடுகளை இங்கே காட்டுகிறேன், இதன் மூலம் டைமர்களின் பயன்பாட்டை நீங்கள் அனுபவிக்க முடியும். முதலாவது குறியீடாக ஒவ்வொரு நொடியும் Arduino pin 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
}

எல்.ஈ.டி ஒளிரும் அல்லது ஒளிரும், முந்தைய வழக்கில் ஒவ்வொரு நொடியும், ஆனால் இந்த முறை பயன்படுத்தவும் 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 நிரலாக்கத்தைப் பற்றி மேலும்