ಮಿಲಿಸ್ (): ಆರ್ಡುನೊ ಕಾರ್ಯದ ಬಗ್ಗೆ ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಎಲ್ಲವೂ

ಆರ್ಡುನೊ ಕಾಲಾನಂತರದಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ಕಾರ್ಯಗಳ ಉತ್ತಮ ಸಂಗ್ರಹವನ್ನು ಹೊಂದಿದೆ. ಅವುಗಳಲ್ಲಿ ಒಂದು ಮಿಲಿಸ್ (), ಆರ್ಡುನೊ ಬೋರ್ಡ್ ಆನ್ ಮಾಡಿದಾಗಿನಿಂದ ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ ಸಮಯವನ್ನು ನೀಡುವ ಸೂಚನೆ. ಇದು ಅಸಂಬದ್ಧವೆಂದು ತೋರುತ್ತದೆ, ಮತ್ತು ಇದು ಯಾವಾಗ ಹಾಬ್ ಅನ್ನು ಆನ್ ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ತಿಳಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಆದರೆ ಸತ್ಯವೆಂದರೆ ಇದು ಇನ್ನೂ ಅನೇಕ ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಿಕೆಗಳನ್ನು ಹೊಂದಿದೆ.

ಮೂಲಕ ejemplo, ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಘಟನೆಗಳ ನಡುವೆ ಕಳೆದ ಸಮಯವನ್ನು ನಿರ್ಧರಿಸಲು, ಗುಂಡಿಯ ಡಿಬೌನ್ಸ್ (ಬೌನ್ಸ್) ಅನ್ನು ತಪ್ಪಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದು. ಕೋಡ್‌ನ ನಿರ್ಣಾಯಕ ಹಂತಗಳಲ್ಲಿ ಮರಣದಂಡನೆ ಸಮಯವನ್ನು ತೋರಿಸಲು ಸಹ ಇದನ್ನು ಬಳಸಬಹುದು, ಪ್ರೋಗ್ರಾಂ ನೈಜ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಮಿಲ್ಲಿಸ್ () ಕಾರ್ಯ

ನಾನು ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, ಸಮಯವನ್ನು ಅಳೆಯಲು ಆರ್ಡುನೊ ಮಿಲಿಸ್ ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಅದು ಹಾಗೆ ಮಾಡುತ್ತದೆ ಮಿಲಿಸೆಕೆಂಡುಗಳು (ಎಂಎಸ್), ಆದ್ದರಿಂದ ಅದರ ಹೆಸರು. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಈ ಕಾರ್ಯವನ್ನು ನಿಮ್ಮ ಸ್ಕೆಚ್‌ನಲ್ಲಿ ಸೇರಿಸಿದಾಗ ಅದು ನೀಡುವ ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯವು ಆ ಘಟಕದಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಿದ ತಾತ್ಕಾಲಿಕ ಡೇಟಾವಾಗಿದೆ.

ಈ ವೇರಿಯೇಬಲ್ನ ಗರಿಷ್ಠ ಮೌಲ್ಯ ಎಂದು ನೀವು ತಿಳಿದಿರಬೇಕು ಸಹಿ ಮಾಡದ ಉದ್ದ, ಅಂದರೆ, ಚಿಹ್ನೆಯಿಲ್ಲದೆ ಉದ್ದವಾಗಿದೆ. ಇದು ಮುಖ್ಯವಾಗಿದೆ, ಏಕೆಂದರೆ ಚಿಕ್ಕದನ್ನು ಬಳಸಿದರೆ, ತರ್ಕ ಸಮಸ್ಯೆಗಳು ಸಂಭವಿಸಬಹುದು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಇದು 50 ದಿನಗಳವರೆಗೆ (4.320.000.000 ಎಂಎಸ್) ಇರುತ್ತದೆ ಎಂದು ನೀವು ತಿಳಿದಿರಬೇಕು, ಅದು ಆ ಮೌಲ್ಯವನ್ನು ತಲುಪಿದ ನಂತರ ಅದು ಮರುಪ್ರಾರಂಭಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಶೂನ್ಯದಿಂದ ಮತ್ತೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಇನ್ನೊಂದು ವಿಷಯವೆಂದರೆ ಮಿಲಿಸ್ ಕಾರ್ಯ ನಿಯತಾಂಕಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ.

ಇತರ ತಾತ್ಕಾಲಿಕ ಆರ್ಡುನೊ ಕಾರ್ಯಗಳು

ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಬಳಸಲು ಆರ್ಡುನೊ ಇತರ ಸಮಯ-ಸಂಬಂಧಿತ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ. ಅವುಗಳಲ್ಲಿ ಒಂದು ಪ್ರಸಿದ್ಧ ವಿಳಂಬ (), ಆದರೆ ಇನ್ನೂ ಹೆಚ್ಚಿನವುಗಳಿವೆ:

• ವಿಳಂಬ (): ಇದು ಎಲ್ಲಾ ಆರ್ಡುನೊ ಕಾರ್ಯಗಳಲ್ಲಿ ಹೆಚ್ಚು ಬಳಕೆಯಾಗುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿದೆ. ಇದು ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ಮಿಲಿಸ್ () ಆಗಿ ಬಳಸುತ್ತದೆ. ಮತ್ತು ಇದು ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರದ ಜೊತೆಗೆ, ಸಹಿ ಮಾಡದ ಉದ್ದದ ಪ್ರಕಾರವೂ ಆಗಿರುತ್ತದೆ. ಪ್ರೋಗ್ರಾಂನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯಲ್ಲಿ ವಿರಾಮಗಳನ್ನು ಪರಿಚಯಿಸಲು ಇದನ್ನು ಮುಖ್ಯವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಅನೇಕ ಅನ್ವಯಿಕೆಗಳೊಂದಿಗೆ.
• delayMicroseconds (): ರೇಖಾಚಿತ್ರಗಳಲ್ಲಿ ಕಡಿಮೆ ಬಳಸಲಾಗುತ್ತದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ಇನ್ನೂ ಸಹಿ ಮಾಡದ ಉದ್ದವಾಗಿದೆ, ಯಾವುದೇ ರಿಟರ್ನ್ ಮೌಲ್ಯವಿಲ್ಲ, ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ಮೈಕ್ರೊ ಸೆಕೆಂಡುಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಪ್ರಸ್ತುತ, ಗರಿಷ್ಠ ಮೌಲ್ಯವನ್ನು 16383, ಮತ್ತು ಕನಿಷ್ಠ 3μ ಗಳ ಮೂಲಕ ಸಾಧಿಸಬಹುದು. ನೀವು ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಸಮಯವನ್ನು ಕಾಯಬೇಕಾದರೆ, ವಿಳಂಬ () ಅನ್ನು ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ.
• ಮೈಕ್ರೋಗಳು (): ಆರ್ಡುನೊ ಬೋರ್ಡ್ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸಿದಾಗಿನಿಂದ ಮೈಕ್ರೊ ಸೆಕೆಂಡುಗಳಲ್ಲಿ (μs) ಸಂಖ್ಯಾ ಮೌಲ್ಯವನ್ನು ಸಹ ನೀಡುತ್ತದೆ. ಅಂದರೆ, ಇದು ಮಿಲಿಸ್ () ನಂತಿದೆ, ಆದರೆ ಇನ್ನೊಂದು ಘಟಕದೊಂದಿಗೆ. ವಾಸ್ತವವಾಗಿ, ಇದು ಸಹಿ ಮಾಡದ ದೀರ್ಘ ಪ್ರಕಾರವನ್ನು ಸಹ ಬಳಸುತ್ತದೆ ಮತ್ತು ಇದು ನಿಯತಾಂಕಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ. ಆದರೆ ಇದು ಕೆಲವು ಹೆಚ್ಚುವರಿ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಹೊಂದಿದೆ, ಉದಾಹರಣೆಗೆ ಅದು ಮರುಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು ಅದು 70 ನಿಮಿಷಗಳನ್ನು ತಲುಪಿದಾಗ ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಅದರ 4 μs ರೆಸಲ್ಯೂಶನ್‌ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಅಥವಾ ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಅದು ಹಿಂದಿರುಗಿಸುವ ಮೌಲ್ಯವು ಯಾವಾಗಲೂ ನಾಲ್ಕು (4, 8, 12, 16,…) ಆಗಿರುತ್ತದೆ. 1000 μs 1 ms ಗೆ ಸಮನಾಗಿರುತ್ತದೆ ಮತ್ತು 1.000.000 1 s ಗೆ ಸಮನಾಗಿರುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.

ಆರ್ಡುನೊ ಐಡಿಇನಲ್ಲಿ ಮಿಲ್ಲಿಸ್ () ಉದಾಹರಣೆಗಳು

ಇವೆಲ್ಲವೂ ಪದಗಳು, ಮತ್ತು ಮಿಲಿಸ್ () ಕ್ರಿಯೆಯ ಉತ್ತಮ ನೋಟವು ಸರಳವಾದ ಆರ್ಡುನೊ ಐಡಿಇ ರೇಖಾಚಿತ್ರಗಳ ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ತೋರಿಸುತ್ತಿದೆ ಆದ್ದರಿಂದ ನೀವು ಕೆಲವು ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನೋಡಬಹುದು ಮತ್ತು ಪ್ರಕರಣಗಳನ್ನು ಬಳಸಬಹುದು. ಇಲ್ಲಿ ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು...

1-ಉದಾಹರಣೆ ಬಳಕೆಯನ್ನು ವಿವರಿಸಿ ಮಿಲಿಸ್‌ನಿಂದ ():

unsigned long inicio, fin, transcurrido;  // Declarar las variables a usar
void setup(){
   Serial.begin(9600);  //Iniciar la comunicación serial
}
void loop(){
   inicio=millis();  //Consultar ms desde que inició la ejecución del sketch
   delay(1000);  //Espera 1 segundo
   fin=millis();  //Consultar ms fin del sketch
   transcurrido=fin-inicio;  //Calcula el tiempo desde la última lectura
   Serial.println(transcurrido);  //Muestra el resultado en el monitor serial
   delay(500);  //Esperar medio segundo
}

ಎರಡು ಸರಣಿ ಸಂದೇಶಗಳ ನಡುವಿನ ಸಮಯವನ್ನು ಅಳೆಯಿರಿ:

unsigned long tiempo1 = 0;  //Declaramos las variables e iniciamos a 0
unsigned long tiempo2 = 0;
unsigned long diferenciaTiempo = 0;
void setup() {
  Serial.begin(9600);
  Serial.println("Envía la letra A/a por la terminal serial");
}

void loop() {
  if(Serial.available() > 0){
     char datoRecibido = Serial.read();
     if(datoRecibido == 'A' || datoRecibido == 'a'){
        tiempo1 = millis();
        Serial.println("Envía la letra B/b por la terminal Serial");
     }
     else if(datoRecibido == 'b' && datoRecibido == 'B'){
        tiempo2 = millis();
        diferenciaTiempo = tiempo1-tiempo2;
        Serial.print("El tiempo transcurrido entre el primer y último dato enviado es: ");
        Serial.print(diferenciaTiempo);
     }
   }
}

ಮಾಡಿ ಎಲ್ಇಡಿ ಮಿಟುಕಿಸಿ ಮಿಲಿಸ್ () ನೊಂದಿಗೆ:

int estadoLed;  //Almacena el estado del LED (Encendido o apagado)
int periodo = 100;  //Tiempo que está el LED encendido o apagado
unsigned long tiempoAnterior = 0;  //Almacena tiempo de referencia para comparar
void setup() {
    pinMode(13,OUTPUT);  //Configura el pin 13 como salida para el LED
}
void loop() {
  if(millis()-tiempoAnterior>=periodo){  //Evalúa si ha transcurrido el periodo programado
    estadoLed=!estadoLed;  //Cambia el estado del LED cada 100ms
    digitalWrite(13,estadoLed);  //Actualiza el estado del LED al actual
    tiempoAnterior=millis();  //Almacena el tiempo actual como referencia
    }
}

ಎ ರಚಿಸಿ ಸರಳ ಸೀಕ್ವೆನ್ಸರ್ ಮಿಲಿಸ್ () ಬಳಸಿ ವಿಭಿನ್ನ ಸಮಯದ ಮಧ್ಯಂತರದಲ್ಲಿ ಸರಣಿ ಮಾನಿಟರ್ ಮೂಲಕ ಪಠ್ಯವನ್ನು ಕಳುಹಿಸಲು:

#define INTERVALO_MENSAJE1 3000
#define INTERVALO_MENSAJE2 5000
#define INTERVALO_MENSAJE3 7000
#define INTERVALO_MENSAJE4 15000
 
unsigned long tiempo_1 = 0;
unsigned long tiempo_2 = 0;
unsigned long tiempo_3 = 0;
unsigned long tiempo_4 = 0;
 
void print_tiempo(unsigned long tiempo_millis);
 
void setup() {
    Serial.begin(9600);
}
 
void loop() {
    if(millis() > tiempo_1 + INTERVALO_MENSAJE1){
        tiempo_1 = millis();
        print_tiempo(tiempo_1);
        Serial.println("Soy");
    }
   
    if(millis() > tiempo_2 + INTERVALO_MENSAJE2){
        tiempo_2 = millis();
        print_tiempo(tiempo_2);
        Serial.println("Un mensaje");
    }
   
    if(millis() > tiempo_3 + INTERVALO_MENSAJE3){
        tiempo_3 = millis();
        print_tiempo(tiempo_3);
        Serial.println("De");
    }
   
    if(millis() > tiempo_4 + INTERVALO_MENSAJE4){
        tiempo_4 = millis();
        print_tiempo(tiempo_4);
        Serial.println("Esperanza");
    }
}
 
void print_tiempo(unsigned long tiempo_millis){
    Serial.print("Tiempo: ");
    Serial.print(tiempo_millis/1000);
    Serial.print("s - ");
}

ಅದಕ್ಕಾಗಿ ನಿಮಗೆ ಈಗಾಗಲೇ ತಿಳಿದಿದೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ನೀವು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು ಪಿಡಿಎಫ್ನಲ್ಲಿ ಉಚಿತ ಆರ್ಡುನೊ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕೋರ್ಸ್.