Arduino టైమర్: మీ ప్రాజెక్ట్‌లలో టైమింగ్‌తో ఆడండి

కొంతకాలం క్రితం మేము దీని గురించి మరింత సమాచారాన్ని ప్రచురించాము మిల్లీస్() ఫంక్షన్ de Arduinoఇప్పుడు మనం లోతుగా పరిశీలిస్తాము Arduino టైమర్, ఫీచర్ కోసం ఈ ఫీచర్‌తో ప్రారంభించడానికి, ఈ బోర్డ్ MCUతో సమయాన్ని ఎలా నిర్వహిస్తుందో అలాగే millis()కి మించిన ఇతర ఫంక్షన్‌లను ఎలా నిర్వహిస్తుందో అర్థం చేసుకోండి.

Arduino టైమర్ అంటే ఏమిటి?

El Arduino టైమర్, లేదా టైమర్, అనేది హార్డ్‌వేర్ ద్వారా అమలు చేయబడిన ఫంక్షన్ (మైక్రోకంట్రోలర్‌లో, క్లాక్ పల్స్‌ను ఉత్పత్తి చేసే క్వార్ట్జ్ క్రిస్టల్ సహాయంతో మరియు బాహ్య హార్డ్‌వేర్ లేదా ICలు 555 అవసరం లేకుండా "రిథమ్"ని సెట్ చేస్తుంది) ఇది గడియారాలకు కృతజ్ఞతగా తాత్కాలిక ఈవెంట్‌లను నియంత్రించడానికి అనుమతిస్తుంది. అంతర్గత. ఉదాహరణకు, స్కెచ్ కోడ్‌తో సంబంధం లేకుండా ఒక పనిని విరామాలలో జరిగేలా చేయడం, ఖచ్చితమైన సమయ కొలతలు చేయడం మొదలైనవి.

మీరు ఉపయోగించారని ఊహించుకోండి ఆలస్యం () ఫంక్షన్, ఇది పేర్కొన్న సమయం ముగిసే వరకు Arduino MCUలో అమలును బ్లాక్ చేస్తుంది మరియు ప్రోగ్రామ్‌తో కొనసాగుతుంది, కానీ టైమర్ నిరోధించదు. MCU ఇతర సూచనలను ఏకకాలంలో అమలు చేయడాన్ని కొనసాగిస్తున్నందున ఇది సమయానుకూలంగా ఉంటుంది. అదే గొప్ప ప్రయోజనం.

టైమర్ దీనికి సంబంధించినది అంతరాయాలు Arduino యొక్క, వారు కొన్ని నిర్దిష్ట పనికి హాజరు కావడానికి వారి ద్వారా అమలు చేయబడతారు. మరో మాటలో చెప్పాలంటే, Arduino టైమర్ అనేది ఒక నిర్దిష్ట సమయంలో ట్రిగ్గర్ చేయబడి, అంతరాయ ఫంక్షన్‌ని అమలు చేస్తుంది. అందుకే ఈ అంతరాయాల గురించి తెలుసుకోవడం కూడా చాలా ముఖ్యం.

మోడ్‌లు

Arduino టైమర్ ఉంది 2 ఆపరేటింగ్ మోడ్‌లు, దీన్ని ఉపయోగించగలగడం:

• PWM సిగ్నల్: మీరు నియంత్రించవచ్చు ఆర్డునో పిన్స్ (~).
• CTC (పోలికపై టైమర్‌ను క్లియర్ చేయండి): కౌంటర్ లోపల సమయాన్ని గణిస్తుంది మరియు అది టైమర్‌ల రిజిస్టర్‌లో పేర్కొన్న విలువను చేరుకున్నప్పుడు, అంతరాయం అమలు చేయబడుతుంది.

దీనికి ఎన్ని టైమర్‌లు ఉన్నాయి? టైమర్‌ల రకాలు

ఉన్నాయి 3 టైమర్‌లు ప్లేట్ల మీద Arduino UNO, ఇతర టాప్ ప్లేట్‌లలో ఇంకా ఎక్కువ ఉండవచ్చు:

• టైమర్ 0: 8-బిట్, 0 నుండి 255 వరకు లెక్కించవచ్చు (256 సాధ్యమయ్యే విలువలు). ఆలస్యం(), మిల్లీస్(), మరియు మైక్రోస్() వంటి ఫంక్షన్‌ల ద్వారా ఉపయోగించబడుతుంది. ప్రోగ్రామ్‌లను మార్చకుండా దాని సవరణ సిఫార్సు చేయబడలేదు.
• టైమర్ 1: టైమర్ 0కి సమానం. UNOలోని సర్వో లైబ్రరీ ద్వారా ఉపయోగించబడుతుంది (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 ns తీసుకుంటుందని చెప్పవచ్చు.
• సిగ్నల్ అంచు: గడియార సంకేతాలు చతురస్రాకారంలో ఉంటాయి మరియు అంచులు పెరగవచ్చు లేదా పడిపోతాయి. అంచు అనేది సిగ్నల్ యొక్క సరళ రేఖ నుండి మారినప్పుడు:
  • 0 (తక్కువ) నుండి 1 (ఎక్కువ): పెరుగుతున్న అంచు.
  • 1 (ఎక్కువ) నుండి 0 (తక్కువ): పడిపోతున్న అంచు.

అంచులు ముఖ్యమైనవి ఎందుకంటే Arduino టైమర్లు సిగ్నల్ అంచుల నుండి చక్రాలను కొలుస్తాయి. ఎ) అవును ఎల్ కాంటాడర్ ఇది ప్రతి చక్రంతో పెరుగుతుంది మరియు అది రిజిస్టర్ విలువను చేరుకున్నప్పుడు, అంతరాయం అమలు చేయబడుతుంది.

అందువల్ల, మీరు దీన్ని ఒకసారి తెలుసుకుంటే, మీకు ఉంటే Arduino MCUలో 16Mhz, మరియు 8-బిట్ టైమర్ ఉపయోగించబడుతుంది, ప్రతి 16 μs (256/16000000) లేదా 4-బిట్ (16/65536) కోసం 16000000 ms అంతరాయాలు సంభవిస్తాయని చెప్పవచ్చు. కాబట్టి, మీరు 16-బిట్ కౌంటర్ రిజిస్టర్‌ను గరిష్టంగా 65535 విలువతో సెట్ చేస్తే, అది ఏ పని అయినా అమలు చేయడానికి 4 ms వద్ద అంతరాయం ఏర్పడుతుంది.

కౌంటర్ గరిష్ట సాధ్యమైన విలువను చేరుకున్నప్పుడు, అది మళ్లీ 0కి తిరిగి వస్తుంది. అంటే, ఒక ఓవర్ఫ్లో సంభవిస్తుంది మరియు అది ప్రారంభం నుండి తిరిగి లెక్కించబడుతుంది.

టైమర్ పెరుగుదల రేటును నియంత్రించడానికి మీరు కూడా ఉపయోగించవచ్చు ఒక ప్రీస్కేలర్, ఇది 1, 8, 64, 256 మరియు 1024 విలువలను తీసుకుంటుంది మరియు సమయాన్ని ఇలా మారుస్తుంది:

టైమర్ స్పీడ్ (Hz) = Arduino / Prescaler యొక్క క్లాక్ ఫ్రీక్వెన్సీ

ఇది 1 ప్రీస్కేలర్ అయినట్లయితే, కంట్రోలర్ 16 Mhzకి పెరుగుతుంది, అది 8 నుండి 2 Mhz వరకు ఉంటే, అది 64 నుండి 250 kHz వరకు ఉంటే, మరియు మొదలైనవి. కౌంటర్ మరియు ప్రీస్కేలర్ యొక్క విలువను సమానంగా ఉండే వరకు సరిపోల్చడానికి టైమర్ కౌంటర్ స్టేట్ కంపారేటర్ ఉంటుందని గుర్తుంచుకోండి, ఆపై చర్యను అమలు చేయండి. కాబట్టి, అంతరాయం ఫ్రీక్వెన్సీ సూత్రం ద్వారా ఇవ్వబడింది:

అంతరాయ వేగం (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 ప్రోగ్రామింగ్ గురించి మరింత