ഇവന്റുകൾ#

ആമുഖം#

ഇവന്റുകൾ നിങ്ങളെ ഒരു ഫംഗ്ഷൻ അസിൻക്രണസ് ആയി ആരംഭിക്കാൻ അനുവദിക്കുന്നു. ഒരു ഇവന്റ് പ്രക്ഷേപണം ചെയ്യുമ്പോൾ, ഇവന്റിന്റെ കോൾബാക്ക് ഫംഗ്ഷൻ അതിന്റേതായ ടാസ്‌ക്കിൽ (ത്രെഡ്) ആരംഭിക്കുന്നു, അതിനാൽ നിങ്ങളുടെ പ്രധാന കോഡിന് അതേ സമയം പ്രവർത്തിക്കുന്നത് തുടരാനാകും.

പ്രധാനം: ഒരു event ഒബ്‌ജക്റ്റ് ഒരു കോൾബാക്ക് സംഭരിക്കുന്നു. അതേ ഇവന്റ് ഒബ്‌ജക്റ്റ് ഉപയോഗിച്ച് നിങ്ങൾ മറ്റൊരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്താൽ, അത് മുമ്പത്തെ കോൾബാക്കിനെ പകരുന്നു.

ഒരു ട്രിഗറിൽ നിന്ന് ഒന്നിലധികം കാര്യങ്ങൾ സംഭവിക്കണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഒന്നുകിൽ:

  • ഒരൊറ്റ കോൾബാക്കിൽ നിന്ന് ഒന്നിലധികം സഹായ പ്രവർത്തനങ്ങളിലേക്ക് വിളിക്കുക, അല്ലെങ്കിൽ

  • ഒന്നിലധികം ഇവന്റ് ഒബ്‌ജക്റ്റുകൾ ഉപയോഗിക്കുക, ഓരോന്നും പ്രക്ഷേപണം ചെയ്യുക.

  • ടാസ്‌ക്കുകൾ സ്വതന്ത്രമായി പ്രവർത്തിപ്പിക്കുന്നതിന് പ്രത്യേക ത്രെഡുകൾ ഉപയോഗിക്കുക.

ഒരു ഇവന്റ് സൃഷ്ടിക്കുന്നതിനും ഉപയോഗിക്കുന്നതിനും, ഈ ഘട്ടങ്ങൾ ക്രമത്തിൽ പാലിക്കുക:

  1. event ഉപയോഗിച്ച് ഇവന്റ് സൃഷ്ടിക്കുക.

  2. ഇവന്റിന്റെ കോൾബാക്ക് സജ്ജമാക്കുക ഇവന്റ് നാമം ഉപയോഗിച്ച് (ഉദാ: myEvent(myCallback);).

  3. Broadcast an event:

    • broadcast — ഒരു ഇവന്റ് ഒബ്‌ജക്റ്റിലെ എല്ലാ രജിസ്റ്റർ ചെയ്ത ഫംഗ്ഷനുകളും സമാന്തരമായി പ്രവർത്തിപ്പിക്കാൻ ട്രിഗർ ചെയ്യുന്നു.

    • broadcastAndWait — ഒരു ഇവന്റ് ഒബ്‌ജക്റ്റിലെ എല്ലാ രജിസ്റ്റർ ചെയ്ത ഫംഗ്ഷനുകളും ട്രിഗർ ചെയ്യുകയും തുടരുന്നതിന് മുമ്പ് അവ പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കുകയും ചെയ്യുന്നു.

ക്ലാസ് കൺസ്ട്രക്‌ടറുകൾ#

1 — ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ ഇല്ലാതെ ഒരു event ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു.

event();

2 — ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഒരു event ഒബ്‌ജക്റ്റ് സൃഷ്ടിക്കുന്നു.

event( void (* callback)(void) );

3 — ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ ഉപയോഗിച്ച് മറ്റൊരു ഇവന്റിൽ നിന്ന് event ഒബ്‌ജക്റ്റ് സൃഷ്ടിക്കുന്നു.

event( 
  event v, 
  void (* callback)(void) );

4 — ഒരു ആർഗ്യുമെന്റ് സ്വീകരിക്കുന്ന ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ ഉപയോഗിച്ച് event ഒബ്‌ജക്റ്റ് സൃഷ്ടിക്കുന്നു.

event( void (* callback)(void *), void *arg );

5 — ഒരു ആർഗ്യുമെന്റ് സ്വീകരിക്കുന്ന ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ ഉപയോഗിച്ച് മറ്റൊരു ഇവന്റിൽ നിന്ന് event ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു.

event( event v, void (* callback)(void *), void *arg );

ക്ലാസ് ഡിസ്ട്രക്റ്റർ#

event ഒബ്‌ജക്റ്റിനെ നശിപ്പിക്കുകയും അനുബന്ധ ഉറവിടങ്ങൾ പുറത്തുവിടുകയും ചെയ്യുന്നു.

~event();

പാരാമീറ്ററുകൾ#

പാരാമീറ്റർ

ടൈപ്പ് ചെയ്യുക

വിവരണം

callback

void (*)(void)

ഒരു പരിപാടി പ്രക്ഷേപണം ചെയ്യുമ്പോൾ നടപ്പിലാക്കുന്നതിനായി മുമ്പ് നിർവചിക്കപ്പെട്ട ഒരു ഫംഗ്ഷൻ.

v

event

പകർത്താൻ നിലവിലുള്ള ഒരു ഇവന്റ് ഒബ്‌ജക്റ്റ്.

callback

void (*)(void *)

ഒരു ശൂന്യ പോയിന്റർ ആർഗ്യുമെന്റ് സ്വീകരിച്ച് ഇവന്റ് പ്രക്ഷേപണം ചെയ്യുമ്പോൾ എക്സിക്യൂട്ട് ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ.

arg

void *

കോൾബാക്ക് ഫംഗ്ഷനിലേക്ക് കൈമാറുന്ന ഡാറ്റയിലേക്കുള്ള ഒരു പോയിന്റർ.

കുറിപ്പുകൾ#

  • ഒരു event ഒബ്‌ജക്റ്റ് ഒരു കോൾബാക്ക് സംഭരിക്കുന്നു. അതേ ഇവന്റ് ഒബ്‌ജക്റ്റ് ഉപയോഗിച്ച് നിങ്ങൾ മറ്റൊരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുകയാണെങ്കിൽ, അത് മുമ്പത്തെ കോൾബാക്കിനെ പകരുന്നു.

  • ഒരു ട്രിഗറിൽ നിന്ന് ഒന്നിലധികം കാര്യങ്ങൾ സംഭവിക്കണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഒന്നുകിൽ:

    • ഒരൊറ്റ കോൾബാക്കിൽ നിന്ന് ഒന്നിലധികം സഹായ പ്രവർത്തനങ്ങളിലേക്ക് വിളിക്കുക, അല്ലെങ്കിൽ

    • ഒന്നിലധികം ഇവന്റ് ഒബ്‌ജക്റ്റുകൾ ഉപയോഗിക്കുക, ഓരോന്നും പ്രക്ഷേപണം ചെയ്യുക.

    • ജോലികൾ സ്വതന്ത്രമായി നിർവഹിക്കുന്നതിന് പ്രത്യേക ത്രെഡുകൾ ഉപയോഗിക്കുക.

ഉദാഹരണം#

// Create a callback function
void onMyEvent() {
  Brain.Screen.print("Callback function executed!");
}

int main() {
  // Create an event called myEvent and set onMyEvent
  // as the callback function.
  event myEvent(onMyEvent);
}

അംഗ പ്രവർത്തനങ്ങൾ#

event ക്ലാസ്സിൽ ഇനിപ്പറയുന്ന അംഗ ഫംഗ്‌ഷനുകൾ ഉൾപ്പെടുന്നു:

  • operator — ഇവന്റിനായി ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ സജ്ജമാക്കുന്നു.

  • broadcast — ഇവന്റിന്റെ കോൾബാക്ക് ഫംഗ്ഷൻ സമാന്തരമായി പ്രവർത്തിപ്പിക്കാൻ ട്രിഗർ ചെയ്യുന്നു.

  • broadcastAndWait — ഇവന്റിന്റെ കോൾബാക്ക് ഫംഗ്ഷൻ ട്രിഗർ ചെയ്യുകയും പൂർത്തിയാകുന്നതിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു.

ഏതെങ്കിലും event അംഗ ഫംഗ്ഷനുകൾ വിളിക്കുന്നതിന് മുമ്പ്, താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ ഒരു event ഉദാഹരണം സൃഷ്ടിക്കണം:

/* This constructor is required when using VS Code.
Event configuration can be created with or without
a callback function as shown in the examples above. */

// Create an event without a callback
event myEvent;

// Or create an event with a callback
event myEvent(onMyEvent);

operator#

ഫംഗ്ഷൻ കോൾ ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ഇവന്റിനായി ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ സജ്ജമാക്കുന്നു.

Available Functions 
void operator()( void (* callback)() );
Parameters

പാരാമീറ്റർ

ടൈപ്പ് ചെയ്യുക

വിവരണം

callback

void (*)(void)

ഇവന്റ് പ്രക്ഷേപണം ചെയ്യുമ്പോൾ യാന്ത്രികമായി വിളിക്കപ്പെടുന്ന ഒരു മുമ്പ് നിർവചിക്കപ്പെട്ട കോൾബാക്ക് ഫംഗ്ഷൻ. ഫംഗ്ഷൻ ആവശ്യമായ കോൾബാക്ക് സിഗ്നേച്ചറുമായി പൊരുത്തപ്പെടണം. കൂടുതൽ വിവരങ്ങൾക്ക് കോൾബാക്ക് ഫംഗ്ഷനുകൾ കാണുക.
Return Values

ഈ ഫംഗ്ഷൻ ഒരു മൂല്യം തിരികെ നൽകുന്നില്ല.

Notes

  • മുമ്പത്തെ കോൾബാക്കിന് പകരമായി വീണ്ടും ഒരു കോൾബാക്ക് സജ്ജമാക്കുന്നു.

  • കോൾബാക്ക് ഫംഗ്‌ഷനിൽ പാരാമീറ്ററുകൾ ഉണ്ടാകരുത്, റിട്ടേൺ ശൂന്യമായിരിക്കും.

Examples 
void drawSquare() {
  Brain.Screen.clearScreen();
  Brain.Screen.drawRectangle(40, 40, 120, 120);
}

void drawCircle() {
  Brain.Screen.clearScreen();
  Brain.Screen.drawCircle(100, 100, 60);
}

int main() {
  // Create the event drawEvent.
  event drawEvent;

  Brain.Screen.print("Drawing a square...");

  // Set the event to drawSquare.
  drawEvent(drawSquare);

  wait(1, seconds);

  // Trigger the event.
  drawEvent.broadcast();

  wait(1, seconds);

  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.print("Drawing a circle...");

  // Replace drawSquare with drawCircle.
  drawEvent(drawCircle);

  wait(1, seconds);

  // Trigger the event a second time.
  drawEvent.broadcast();
}

broadcast#

broadcast ഇവന്റിന്റെ കോൾബാക്ക് ആരംഭിക്കുകയും ഉടനടി തുടരുകയും ചെയ്യുന്നു.

Member Functions 
void broadcast();
Parameters

ഈ ഫംഗ്ഷൻ ഒരു പാരാമീറ്ററുകളും എടുക്കുന്നില്ല.

Return Values

ഈ ഫംഗ്ഷൻ ഒരു മൂല്യം തിരികെ നൽകുന്നില്ല.

Examples 
// Create a callback function.
void onMyEvent() {
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.print("Event fired!");
}

int main() {
  Brain.Screen.print("Broadcasting in 2 seconds...");

  // Create an event called myEvent and set onMyEvent
  // as the callback function.
  event myEvent(onMyEvent);

  wait(2, seconds);

  // Trigger the event.
  myEvent.broadcast();
}

broadcastAndWait#

കോൾബാക്ക് ആരംഭിച്ച് അത് പൂർത്തിയാകുന്നതുവരെ (അല്ലെങ്കിൽ സമയം കഴിയുന്നതുവരെ) കാത്തിരിക്കുന്നു.

Available Functions 
void broadcastAndWait( int32_t timeout = 60000 );
Parameters

പാരാമീറ്റർ

ടൈപ്പ് ചെയ്യുക

വിവരണം

timeout

int32_t

കോഡ് വീണ്ടും എക്സിക്യൂട്ട് ചെയ്യാൻ തുടങ്ങുന്നതിന് മുമ്പ് കാത്തിരിക്കേണ്ട മില്ലിസെക്കൻഡുകളുടെ എണ്ണം (ഡിഫോൾട്ട് 60000 ആണ്).
Return Values

ഈ ഫംഗ്ഷൻ ഒരു മൂല്യം തിരികെ നൽകുന്നില്ല.

Notes

  • അവസാനിക്കുന്ന കോൾബാക്കുകളിൽ മാത്രം ഇത് ഉപയോഗിക്കുക (അനന്തമായ ലൂപ്പുകൾ ഇല്ല).

  • കോൾബാക്ക് പൂർത്തിയാകുന്നതുവരെയോ അല്ലെങ്കിൽ സമയം കഴിയുന്നതുവരെയോ എക്സിക്യൂഷൻ തടയുന്ന ഒരു വെയിറ്റിംഗ് ഫംഗ്ഷനാണിത്.

Examples 
void startDriving() {
  Drivetrain.drive(forward);
  wait(2, seconds);
}

int main() {
  Brain.Screen.print("Starting drive...");

  event driveEvent(startDriving);

  // Give the event time to be set.
  wait(0.25, seconds);

  // Run the event and wait until it finishes.
  driveEvent.broadcastAndWait();

  // Stop driving after 2 seconds.
  Drivetrain.stop();
  Brain.Screen.clearScreen();
  Brain.Screen.print("Drive complete!");
}
On this page