ಆರ್ಡುನೊ ಮ್ಯಾಕ್ರೋಸ್: ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಅವುಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ಸಂಪೂರ್ಣ ಮಾರ್ಗದರ್ಶಿ

ಆರ್ಡುನೋ ಕ್ರಿಯಾತ್ಮಕ ಮೂಲಮಾದರಿಗಳು ಮತ್ತು ಯೋಜನೆಗಳನ್ನು ರಚಿಸುವ ಸುಲಭತೆಯಿಂದಾಗಿ, ಎಲೆಕ್ಟ್ರಾನಿಕ್ಸ್ ಜಗತ್ತಿನಲ್ಲಿ ಕ್ರಾಂತಿಯನ್ನುಂಟು ಮಾಡಿದೆ. ಆದಾಗ್ಯೂ, ತಮ್ಮ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಒಂದು ಹೆಜ್ಜೆ ಮುಂದೆ ತೆಗೆದುಕೊಂಡು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಲು, ಕೋಡ್ ಅನ್ನು ಸ್ವಚ್ಛವಾಗಿಡಲು ಮತ್ತು ದಕ್ಷತೆಯನ್ನು ಪಡೆಯಲು ಬಯಸುವವರಿಗೆ, ಮ್ಯಾಕ್ರೋಗಳು ಪ್ರಮುಖ ಸಾಧನವಾಗಿ.

ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಇದರ ಬಳಕೆಯನ್ನು ಆಳವಾಗಿ ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಆರ್ಡುನೊದಲ್ಲಿ ಮ್ಯಾಕ್ರೋಗಳು: ಅವು ಯಾವುವು, ಅವುಗಳನ್ನು ಹೇಗೆ ಬಳಸಲಾಗುತ್ತದೆ, ಅವುಗಳ ಅನುಕೂಲಗಳು ಮತ್ತು ಮಿತಿಗಳು. ಮತ್ತು ನಾವು ಇದನ್ನು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಅತ್ಯುತ್ತಮ ಸಂಪನ್ಮೂಲಗಳಿಂದ ಅತ್ಯಂತ ಸಮಗ್ರ ಮತ್ತು ಉಪಯುಕ್ತ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವ ಮೂಲಕ ಮಾಡುತ್ತೇವೆ, ನಿಜವಾಗಿಯೂ ಪ್ರಾಯೋಗಿಕವಾಗಿರಲು ಸ್ಪಷ್ಟ ಮತ್ತು ಆಧುನಿಕ ರೀತಿಯಲ್ಲಿ ಪುನಃ ಬರೆಯುತ್ತೇವೆ.

ಆರ್ಡುನೊದಲ್ಲಿ ಮ್ಯಾಕ್ರೋಗಳು ಯಾವುವು?

ಮ್ಯಾಕ್ರೋಗಳು ಪ್ರಿಪ್ರೊಸೆಸರ್ ನಿರ್ದೇಶನಗಳಾಗಿವೆ. C/C++ ನಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವ ಮೊದಲು ಪಠ್ಯವನ್ನು ಬದಲಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಸಾಂಪ್ರದಾಯಿಕ ಕಾರ್ಯದಂತೆ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಬದಲು, ಮ್ಯಾಕ್ರೋ ಮೂಲ ಪಠ್ಯದ ಭಾಗಗಳನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಅದು ಅಂತಿಮ ಬೈನರಿ ಕೋಡ್ ಹೇಗೆ ಉತ್ಪತ್ತಿಯಾಗುತ್ತದೆ ಎಂಬುದರ ಮೇಲೆ ನೇರ ಪರಿಣಾಮ..

ಪ್ರಿಪ್ರೊಸೆಸರ್ ಇದು ನಿಜವಾದ ಸಂಕಲನಕ್ಕೂ ಮೊದಲು ಚಲಿಸುತ್ತದೆ ಮತ್ತು ಈ ಪರ್ಯಾಯಗಳನ್ನು ಅನ್ವಯಿಸುವ ಜವಾಬ್ದಾರಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಆರ್ಡುನೊದಲ್ಲಿ, ಇದು ಅನುಮತಿಸುತ್ತದೆ ಸ್ಥಿರಾಂಕಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ, ಷರತ್ತುಬದ್ಧವಾಗಿ ಫೈಲ್‌ಗಳನ್ನು ಸೇರಿಸಿ ಅಥವಾ ಚಿಕ್ಕದನ್ನು ರಚಿಸಿ ಆನ್‌ಲೈನ್ ವೈಶಿಷ್ಟ್ಯಗಳು ಅದು ಸಮಯ ಮತ್ತು ಸ್ಮರಣೆಯನ್ನು ಉಳಿಸುತ್ತದೆ.

ಮೂಲ ಉದಾಹರಣೆ: ಒಂದು ರೀತಿಯ ವ್ಯಾಖ್ಯಾನ #define LED_PIN 13 ಎಲ್ಲಾ ಕೋಡ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬದಲಾಯಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ LED_PIN ಮೂಲಕ 13 ಕಂಪೈಲ್ ಮಾಡುವ ಮೊದಲು.

ಇದು ಕ್ಷುಲ್ಲಕವೆನಿಸಬಹುದು, ಆದರೆ ಇದು ಒಂದು ನೀಡುತ್ತದೆ ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಬರೆಯಲು ಪ್ರಬಲ ಮಾರ್ಗ.

ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಬಳಸುವ ಪ್ರಯೋಜನಗಳು

ಆರ್ಡುನೊ ಯೋಜನೆಗಳಲ್ಲಿ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದರಿಂದ ಹಲವಾರು ನಿರ್ದಿಷ್ಟ ಪ್ರಯೋಜನಗಳನ್ನು ಪಡೆಯಬಹುದು:

• ಕೋಡ್ ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸಿ: ಸಾಂಕೇತಿಕ ಹೆಸರುಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡುವುದರಿಂದ, ಪ್ರತಿಯೊಂದು ಅಂಶದ ಉದ್ದೇಶವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸುಲಭವಾಗುತ್ತದೆ.
• ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ: ಕಾರ್ಯ ಕರೆಗಳನ್ನು ರಚಿಸದೆ ಇರುವ ಮೂಲಕ, ಮ್ಯಾಕ್ರೋಗಳು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವೇಗವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.
• RAM ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಿ: ಸಂಪನ್ಮೂಲ-ಸೀಮಿತ ಬೋರ್ಡ್‌ಗಳಲ್ಲಿ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ Arduino UNO.
• ಷರತ್ತುಬದ್ಧ ರೂಪಾಂತರಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ: ಬಳಸಿದ ಆರ್ಡುನೊ ಬೋರ್ಡ್ ಪ್ರಕಾರವನ್ನು ಅವಲಂಬಿಸಿ ವಿಭಿನ್ನ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಸಾಧ್ಯವಿದೆ.

ಮೂಲ ಮ್ಯಾಕ್ರೋಗಳು: #define ಬಳಸುವುದು

ನಿರ್ದೇಶನ # ವ್ಯಾಖ್ಯಾನಿಸಿ ಇದು ಹೆಚ್ಚು ಬಳಕೆಯಲ್ಲಿದೆ. ಇದನ್ನು ಎರಡಕ್ಕೂ ಬಳಸಲಾಗುತ್ತದೆ ಸ್ಥಿರ ಮೌಲ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ ಹಾಗೆ ಇಂಜೆಕ್ಟ್ ಮಾಡಲಾದ ಸ್ವಯಂಚಾಲಿತ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸಿ ಪೂರ್ವ-ಸಂಕಲನ ಸಮಯದಲ್ಲಿ.

ಉದಾಹರಣೆ 1: ಪಿನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ

#define PINLED 13

void setup() {
  pinMode(PINLED, OUTPUT);
}

void loop() {
  digitalWrite(PINLED, HIGH);
  delay(500);
  digitalWrite(PINLED, LOW);
  delay(500);
}

ಉದಾಹರಣೆ 2: ಇನ್‌ಲೈನ್ ಕಾರ್ಯವಾಗಿ ಮ್ಯಾಕ್ರೋ

int itemCounter = 0;
#define COUNT_ITEM() do { itemCounter++; } while(0)

void setup() {
  Serial.begin(9600);
  COUNT_ITEM();
  COUNT_ITEM();
}

void loop() {
  Serial.println(itemCounter);
}

ನೀವು ನೋಡುವಂತೆ, ಮಾದರಿಯ ಬಳಕೆ (0) ಮಾಡುವಾಗ { … } ಮಾಡಿ ಷರತ್ತುಬದ್ಧ ರಚನೆಗಳಲ್ಲಿ ಬಳಸಿದರೂ ಸಹ ಮ್ಯಾಕ್ರೋ ಸುರಕ್ಷಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

## ಆಪರೇಟರ್ ಮತ್ತು ಮ್ಯಾಕ್ರೋ ಜೋಡಣೆ

## ಆಪರೇಟರ್ ಒಂದು ಶಕ್ತಿಶಾಲಿ ಪ್ರಿಪ್ರೊಸೆಸರ್ ಸಾಧನವಾಗಿದೆ. ಇದು ಗುರುತಿಸುವಿಕೆಗಳನ್ನು ಜೋಡಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ನೀವು ವೇರಿಯೇಬಲ್ ಹೆಸರುಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ರಚಿಸಲು ಬಯಸಿದಾಗ ಇದು ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ:

#define GENERAR_VARIABLE(no) \
  int var##no = no;

void setup() {
  GENERAR_VARIABLE(3); // crea int var3 = 3
}

ಪ್ರಮುಖ ಎಚ್ಚರಿಕೆ: ಈ ಆಪರೇಟರ್ ಎಲ್ಲಾ ಆರ್ಡುನೊ ಬೋರ್ಡ್ ಮಾದರಿಗಳೊಂದಿಗೆ ಸಮಾನವಾಗಿ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಇದು ಯುನೊ ಅಥವಾ ಎಸ್ಪ್ಲೋರಾದಲ್ಲಿ ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡಬಹುದು, ಆದರೆ ಮೆಗಾದಲ್ಲಿ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. ಅಲ್ಲದೆ, ## ಅನ್ನು ನೇರವಾಗಿ ಬಳಸಿಕೊಂಡು ಇತರ ಮ್ಯಾಕ್ರೋಗಳ ಒಳಗೆ ಮ್ಯಾಕ್ರೋ ರಚನೆಯನ್ನು ನೀವು ನೆಸ್ಟ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಮ್ಯಾಕ್ರೋಗಳು ಮತ್ತು ಮೆಮೊರಿ ಉಳಿತಾಯ

ಆರ್ಡುನೊದಲ್ಲಿ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಬಳಸುವುದರ ಪ್ರಮುಖ ಅನುಕೂಲಗಳಲ್ಲಿ ಒಂದು RAM ಮೆಮೊರಿಯನ್ನು ಉಳಿಸಲಾಗುತ್ತಿದೆ. Arduino ಸೀಮಿತ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ಪಠ್ಯ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ನೇರವಾಗಿ RAM ಗೆ ಲೋಡ್ ಮಾಡುವುದು ಗಮನಾರ್ಹ ಸಮಸ್ಯೆಯಾಗಬಹುದು.

ಇದನ್ನು ತಪ್ಪಿಸಲು ಒಂದು ಮುಂದುವರಿದ ತಂತ್ರವೆಂದರೆ ಫೋರ್ಸ್_ಇನ್ಲೈನ್ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಮೆಮೊರಿಯಿಂದ (PROGMEM) ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡಿ:

#include <HardwareSerial.h>
#define MYSERIAL Serial
#define FORCE_INLINE __attribute__((always_inline)) inline

FORCE_INLINE void printFromFlash(const char *str) {
  char ch = pgm_read_byte(str);
  while (ch) {
    MYSERIAL.write(ch);
    ch = pgm_read_byte(++str);
  }
}

#define SERIAL_LOG(x) (MYSERIAL.print(x))
#define SERIAL_LOGLN(x) (MYSERIAL.println(x))

ಈ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಒಂದು ಯೋಜನೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದರ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡಬಹುದು, ವಿಶೇಷವಾಗಿ ಡಿಸ್ಪ್ಲೇಗಳು ಅಥವಾ ಬಹು ಸಂವೇದಕಗಳನ್ನು ಹೊಂದಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ.

ಕಾರ್ಯಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಲಾದ ಮ್ಯಾಕ್ರೋಗಳು

ಮ್ಯಾಕ್ರೋಗಳು ನಿಯತಾಂಕವಾಗಿ ರವಾನಿಸಲಾದ ಪ್ರಕಾರವನ್ನು ಆಧರಿಸಿ, ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಕರೆ ಮಾಡುವ ಕಾರ್ಯಗಳನ್ನು ಸುಗಮಗೊಳಿಸಬಹುದು. ಸ್ಪಷ್ಟ ಮತ್ತು ಸಾಕಷ್ಟು ಗ್ರಾಫಿಕ್ ಉದಾಹರಣೆಯೆಂದರೆ:

#define FUNC_LENTA(tipo) \
  { funcion_##tipo##_lenta(); }

#define FUNC_RAPIDA(tipo) \
  { funcion_##tipo##_rapida(); }

void funcion_caminar_lenta() {
  Serial.println("Andando despacio");
}

void funcion_caminar_rapida() {
  Serial.println("Andando rápido");
}

void setup() {
  Serial.begin(9600);
  FUNC_LENTA(caminar);
}

void loop() {
  FUNC_RAPIDA(caminar);
}

## ಆಪರೇಟರ್ ಮತ್ತು ಮ್ಯಾಕ್ರೋಗಳಿಗೆ ಧನ್ಯವಾದಗಳು, ನಾವು ಪುನರಾವರ್ತಿತ ರಚನೆಗಳನ್ನು ತಪ್ಪಿಸಬಹುದು ಮತ್ತು ಡೈನಾಮಿಕ್ ತರ್ಕವನ್ನು ಕೇಂದ್ರೀಕರಿಸಬಹುದು..

ಔಟ್‌ಪುಟ್ ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಿರುವ ಮ್ಯಾಕ್ರೋಗಳು

ಸಣ್ಣ ವಸ್ತುಗಳು ಅಥವಾ ಪರಿವರ್ತನೆಗಳನ್ನು ಕೋಶೀಕರಿಸಲು ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಬಳಸಲು ಸಹ ಸಾಧ್ಯವಿದೆ:

#define BOOL_OUT() (bool){false}
#define NUM_OUT(a,b) (float){a+b}
#define STR_OUT(msg) (String){msg}

void loop() {
  Serial.println(BOOL_OUT());
  Serial.println(NUM_OUT(1.2, 3.4));
  Serial.println(STR_OUT("Mensaje"));
}

ಮ್ಯಾಕ್ರೋಗಳೊಂದಿಗೆ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಮುನ್ನೆಚ್ಚರಿಕೆಗಳು

ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಅತಿಯಾಗಿ ಅಥವಾ ಅಜಾಗರೂಕತೆಯಿಂದ ಬಳಸುವುದು ಕಾರಣವಾಗಬಹುದು ಡೀಬಗ್ ಮಾಡಲು ಕಷ್ಟಕರವಾದ ದೋಷಗಳು. ಉದಾಹರಣೆಗೆ, ತಪ್ಪಾದ ಪರ್ಯಾಯಗಳನ್ನು ಮಾಡುವ ಮೂಲಕ ಅಥವಾ ಬಾಹ್ಯ ಗ್ರಂಥಾಲಯಗಳಲ್ಲಿನ ಹೆಸರುಗಳೊಂದಿಗೆ ಡಿಕ್ಕಿ ಹೊಡೆಯುವ ಹೆಸರುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ.

ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಕೆಲವು ಮೂಲಭೂತ ನಿಯಮಗಳು:

• ಅನಗತ್ಯ ಸ್ಥಳಗಳು ಅಥವಾ ಸಾಲು ವಿರಾಮಗಳನ್ನು ತಪ್ಪಿಸಿ. ಮ್ಯಾಕ್ರೋ ಒಳಗೆ.
• ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸಬೇಡಿ ಬಹು ಸಾಲುಗಳನ್ನು ಬಳಸುವ ಸಂಕೀರ್ಣ ಮ್ಯಾಕ್ರೋಗಳಲ್ಲಿ.
• ವಿಶಿಷ್ಟ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ ಅಥವಾ ಸಂಘರ್ಷಗಳನ್ನು ತಪ್ಪಿಸಲು ಪೂರ್ವಪ್ರತ್ಯಯಗಳೊಂದಿಗೆ (ಯೋಜನೆಯ ಹೆಸರಿನಂತಹವು).
• ಮ್ಯಾಕ್ರೋಗಳನ್ನು ನಿಜವಾದ ಸ್ಥಿರಾಂಕಗಳು ಅಥವಾ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸಿ ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ. ಆಧುನಿಕ C++ ಭಾಷೆಗಳು ಸ್ವಚ್ಛ, ಸುರಕ್ಷಿತ ಪರ್ಯಾಯಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

ಮತ್ತೊಂದೆಡೆ, ಮ್ಯಾಕ್ರೋಗಳ ಅತಿಯಾದ ಬಳಕೆಯು ಕೋಡ್ ಸ್ಪಷ್ಟತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ನಿರ್ವಹಣೆಗೆ ಧಕ್ಕೆಯಾಗದಂತೆ ದಕ್ಷತೆ ಮತ್ತು ಮಾಡ್ಯುಲಾರಿಟಿಯನ್ನು ಸುಧಾರಿಸುವುದು ಗುರಿಯಾಗಿರಬೇಕು.

ಷರತ್ತುಬದ್ಧ ನಿರ್ದೇಶನಗಳು ಮತ್ತು ಹೊಂದಾಣಿಕೆಯ ಸಂಕಲನ

ಸ್ಕೇಲೆಬಲ್ ಯೋಜನೆಗಳಲ್ಲಿ ಅತ್ಯಂತ ಪ್ರಾಯೋಗಿಕ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದು ಮ್ಯಾಕ್ರೋಗಳ ಬಳಕೆಯಾಗಿದೆ ಷರತ್ತುಬದ್ಧವಾಗಿ ಕೋಡ್ ರಚಿಸಿ, ಒಂದೇ ಸ್ಕೆಚ್ ವಿಭಿನ್ನ ಬೋರ್ಡ್‌ಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ನೀವು ಬಯಸಿದಾಗ ತುಂಬಾ ಉಪಯುಕ್ತವಾದದ್ದು.

ವಿಶಿಷ್ಟ ಉದಾಹರಣೆ:

#ifdef ARDUINO_MEGA
  #define LEDPIN 53
#else
  #define LEDPIN 13
#endif

ಡೀಬಗ್ ಮಾಡುವುದನ್ನು ನಿಯಂತ್ರಿಸಲು ಅಥವಾ ಕಂಪೈಲರ್ ಸಂದೇಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಸಹ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ #ಪ್ರಾಗ್ಮಾ ಸಂದೇಶ ಅಥವಾ ಕೆಲವು ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ದೋಷಗಳನ್ನು ಸೃಷ್ಟಿಸಬಹುದು #ತಪ್ಪು.

ಆಂತರಿಕ ಕಂಪೈಲರ್ ಮ್ಯಾಕ್ರೋಗಳು

AVR ಗಾಗಿ GCC ಪ್ರಿಪ್ರೊಸೆಸರ್ (Arduino ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ) ಹಲವಾರು ಒಳಗೊಂಡಿದೆ ಸಿಸ್ಟಮ್ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುವ ವಿಶೇಷ ಮ್ಯಾಕ್ರೋಗಳು, ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ತುಂಬಾ ಉಪಯುಕ್ತ:

• __ಲೈನ್__: ಪ್ರಸ್ತುತ ಸಾಲಿನ ಸಂಖ್ಯೆ.
• __ಕಡತ__: ಪ್ರಸ್ತುತ ಫೈಲ್‌ನ ಹೆಸರು.
• __ಸಮಯ__ ಮತ್ತು __ದಿನಾಂಕ__: ಸಂಕಲನ ಸಮಯ ಮತ್ತು ದಿನಾಂಕ.
• __ಕಾರ್ಯ__: ಪ್ರಸ್ತುತ ಕಾರ್ಯದ ಹೆಸರು.

ಅವು ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ, ಲಾಗ್ ರಚನೆಗಳನ್ನು ಅನುಮತಿಸುತ್ತವೆ ಮತ್ತು ಮುಖ್ಯ ಕೋಡ್ ಅನ್ನು ಆಕ್ರಮಿಸದೆ ನಿರ್ವಹಣೆ ಮತ್ತು ದೋಷ ಪತ್ತೆಹಚ್ಚುವಿಕೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತವೆ.

ಮ್ಯಾಕ್ರೋಗಳು ಆರ್ಡುನೊ ಯೋಜನೆಗಳನ್ನು ರಚಿಸಲು ಪ್ರಬಲ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ. ಅವು ನಿಮಗೆ ಸ್ಥಿರಾಂಕಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ, ಮೆಮೊರಿ ಉಳಿಸಿ, ಕೋಡ್ ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಪರಿಸರವನ್ನು ಅವಲಂಬಿಸಿ ಮತ್ತು ಸಾಲುಗಳನ್ನು ನಕಲು ಮಾಡದೆ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಬ್ಲಾಕ್‌ಗಳನ್ನು ರಚಿಸಿ. ಸಹಜವಾಗಿ, ಸೂಕ್ಷ್ಮ ದೋಷಗಳು ಅಥವಾ ಓದುವಿಕೆ ನಷ್ಟವನ್ನು ತಪ್ಪಿಸಲು ಅವುಗಳಿಗೆ ಶಿಸ್ತು, ಸ್ಪಷ್ಟತೆ ಮತ್ತು ಜ್ಞಾನದ ಅಗತ್ಯವಿರುತ್ತದೆ. ಸರಿಯಾಗಿ ಅನ್ವಯಿಸಿದಾಗ, ಅವು ಮಧ್ಯಂತರ ಮತ್ತು ಮುಂದುವರಿದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅಮೂಲ್ಯವಾದ ಆಸ್ತಿಯಾಗಿದೆ.