வீடு பதிக்கப்பட்ட
Arduino freertos டுடோரியல் 1
பதிக்கப்பட்ட

Arduino freertos டுடோரியல் 1

Anonim

உட்பொதிக்கப்பட்ட சாதனங்களுக்குள் இருக்கும் OS ஐ RTOS (நிகழ்நேர இயக்க முறைமை) என்று அழைக்கப்படுகிறது. உட்பொதிக்கப்பட்ட சாதனங்களில், நிகழ்நேர பணிகள் முக்கியமானவை, அங்கு நேரம் மிக முக்கியமான பாத்திரத்தை வகிக்கிறது. நிகழ்நேர பணிகள் டைம் டிடர்மினிஸ்டிக் என்றால் எந்த நிகழ்விற்கும் பதிலளிக்கும் நேரம் எப்போதும் நிலையானது, இதனால் எந்தவொரு குறிப்பிட்ட நிகழ்வும் ஒரு குறிப்பிட்ட நேரத்தில் நிகழும் என்று உத்தரவாதம் அளிக்க முடியும். RTOS பயன்பாடுகளை மிகவும் துல்லியமான நேரம் மற்றும் அதிக அளவு நம்பகத்தன்மையுடன் இயக்க வடிவமைக்கப்பட்டுள்ளது. RTOS ஒரு ஒற்றை மையத்துடன் பல பணிகளுக்கு உதவுகிறது.

RTOS, பொது நோக்கத்திற்கான OS மற்றும் RTOS க்கு இடையிலான வேறுபாடு, பல்வேறு வகையான RTOS போன்றவற்றைப் பற்றி நீங்கள் அதிகம் தெரிந்து கொள்ளக்கூடிய உட்பொதிக்கப்பட்ட கணினிகளில் RTOS ஐ எவ்வாறு பயன்படுத்துவது என்பது குறித்த ஒரு டுடோரியலை நாங்கள் ஏற்கனவே விவரித்தோம்.

இந்த டுடோரியலில், நாங்கள் FreeRTOS உடன் தொடங்குவோம். FreeRTOS என்பது உட்பொதிக்கப்பட்ட சாதனங்களுக்கான RTOS இன் ஒரு வகுப்பாகும், இது 8/16-பிட் மைக்ரோகண்ட்ரோலர்களில் இயக்கப்படும் அளவுக்கு சிறியது, இருப்பினும் அதன் பயன்பாடு இந்த மைக்ரோகண்ட்ரோலர்களுடன் மட்டுப்படுத்தப்படவில்லை. இது முற்றிலும் திறந்த மூலமாகும், இதன் குறியீடு கிதுபில் கிடைக்கிறது. RTOS இன் சில அடிப்படைக் கருத்துக்கள் நமக்குத் தெரிந்தால், FreeRTOS ஐப் பயன்படுத்துவது மிகவும் எளிதானது, ஏனெனில் இது நன்கு ஆவணப்படுத்தப்பட்ட API களைக் கொண்டுள்ளது, இது குறியீட்டின் பின்தளத்தில் பகுதியை அறியாமல் குறியீட்டில் நேரடியாகப் பயன்படுத்தலாம். முழுமையான FreeRTOS ஆவணங்களை இங்கே காணலாம்.

FreeRTOS 8-பிட் MCU இல் இயங்க முடியும் என்பதால், இது Arduino Uno போர்டிலும் இயக்கப்படலாம். நாம் FreeRTOS நூலகத்தைப் பதிவிறக்கம் செய்து பின்னர் API களைப் பயன்படுத்தி குறியீட்டை செயல்படுத்தத் தொடங்க வேண்டும். இந்த டுடோரியல் ஒரு முழுமையான தொடக்கக்காரருக்கானது, தலைப்புகள் கீழே உள்ளன, இந்த Arduino FreeRTOS டுடோரியலில் நாங்கள் காண்போம்:

  1. RTOS எவ்வாறு செயல்படுகிறது
  2. RTOS இல் அடிக்கடி பயன்படுத்தப்படும் சில சொற்கள்
  3. Arduino IDE இல் FreeRTOS ஐ நிறுவுகிறது
  4. FreeRTOS பணிகளை எவ்வாறு உருவாக்குவது

RTOS எவ்வாறு இயங்குகிறது?

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

இப்போது, ​​ஒரு விநாடி இடைவெளியில் எல்.ஈ.டி ஒளிரும் பணியை உருவாக்கி, இந்த பணியை அதிக முன்னுரிமையில் வைக்க விரும்பினால், ஆர்.டி.ஓ.எஸ் கர்னலில் என்ன நடக்கிறது என்று பார்ப்போம்.

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

இயங்காத பணியை இயங்கும் நிலைக்கு மாற்றுவதைக் காண்பிப்பதால் மாநில வரைபடத்தின் கீழே .

புதிதாக உருவாக்கப்பட்ட ஒவ்வொரு பணியும் தயார் நிலையில் செல்கிறது (இயங்காத நிலையில் ஒரு பகுதி). உருவாக்கப்பட்ட பணி (பணி 1) மற்ற பணிகளை விட அதிக முன்னுரிமையைக் கொண்டிருந்தால், அது இயங்கும் நிலைக்கு நகரும். இந்த இயங்கும் பணி மற்ற பணியால் முன்கூட்டியே இருந்தால், அது மீண்டும் தயாராக நிலைக்குச் செல்லும். ஏபிஐ தடுப்பதன் மூலம் பணி 1 தடுக்கப்பட்டால், பயனரால் வரையறுக்கப்பட்ட நேரம் முடிவடையும் வரை CPU இந்த பணியில் ஈடுபடாது.

சஸ்பென்ட் ஏபிஐகளைப் பயன்படுத்தி இயங்கும் நிலையில் டாஸ்க் 1 இடைநீக்கம் செய்யப்பட்டால், டாஸ்க் 1 இடைநீக்கம் செய்யப்பட்ட நிலைக்குச் செல்லும், அது மீண்டும் திட்டமிடுபவருக்கு கிடைக்காது. இடைநிறுத்தப்பட்ட நிலையில் நீங்கள் பணி 1 ஐ மீண்டும் தொடங்கினால், அது தொகுதி வரைபடத்தில் நீங்கள் காணக்கூடியபடி மீண்டும் தயாராக நிலைக்குச் செல்லும்.

பணிகள் எவ்வாறு இயங்குகின்றன மற்றும் அவற்றின் மாநிலங்களை மாற்றுகின்றன என்பதற்கான அடிப்படை யோசனை இதுதான். இந்த டுடோரியலில், FreeRTOS API ஐப் பயன்படுத்தி Arduino Uno இல் இரண்டு பணிகளை செயல்படுத்துவோம்.

RTOS இல் அடிக்கடி பயன்படுத்தப்படும் சொற்கள்

1. பணி: இது ஒரு குறியீட்டின் ஒரு பகுதி, இது CPU இல் இயக்க திட்டமிடப்பட்டுள்ளது.

2. திட்டமிடுபவர்: தயாராக உள்ள மாநில பட்டியலிலிருந்து இயங்கும் நிலைக்கு ஒரு பணியைத் தேர்ந்தெடுப்பது பொறுப்பு. திட்டமிடல்கள் பெரும்பாலும் செயல்படுத்தப்படுகின்றன, எனவே அவை எல்லா கணினி வளங்களையும் பிஸியாக வைத்திருக்கின்றன (சுமை சமநிலையைப் போல).

3. தடுப்பு: இது ஏற்கனவே இயக்கும் பணியை அதன் ஒத்துழைப்பு இல்லாமல் இயங்கும் நிலையில் இருந்து அகற்றும் நோக்கத்துடன் தற்காலிகமாக குறுக்கிடும் செயல்.

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

5. திட்டமிடல் கொள்கைகளின் வகைகள்:

  1. முன்கூட்டியே திட்டமிடல்: இந்த வகை திட்டமிடலில், பணிகள் முன்னுரிமைகளை கருத்தில் கொள்ளாமல் சம நேர துண்டுகளுடன் இயங்குகின்றன.
  2. முன்னுரிமை அடிப்படையிலான முன்னுரிமை: அதிக முன்னுரிமை பணி முதலில் இயங்கும்.
  3. கூட்டுறவு திட்டமிடல்: இயங்கும் பணிகளின் ஒத்துழைப்புடன் மட்டுமே சூழல் மாறுதல் நடக்கும். பணி மகசூல் அழைக்கப்படும் வரை பணி தொடர்ந்து இயங்கும்.

6. கர்னல் பொருள்கள்: சில வேலையைச் செய்வதற்கான பணியை சமிக்ஞை செய்ய, ஒத்திசைவு செயல்முறை பயன்படுத்தப்படுகிறது. இந்த செயல்முறையைச் செய்ய கர்னல் பொருள்கள் பயன்படுத்தப்படுகின்றன. சில கர்னல் பொருள்கள் நிகழ்வுகள், செமாஃபோர்ஸ், வரிசைகள், முடெக்ஸ், அஞ்சல் பெட்டிகள் போன்றவை. வரவிருக்கும் டுடோரியல்களில் இந்த பொருட்களை எவ்வாறு பயன்படுத்துவது என்று பார்ப்போம்.

மேலேயுள்ள கலந்துரையாடலில் இருந்து, RTOS கருத்தைப் பற்றிய சில அடிப்படை யோசனைகள் கிடைத்துள்ளன, இப்போது நாம் Arduino இல் FreeRTOS திட்டத்தை செயல்படுத்த முடியும். எனவே, Arduino IDE இல் FreeRTOS நூலகங்களை நிறுவுவதன் மூலம் தொடங்குவோம்.

Arduino FreeRTOS நூலகத்தை நிறுவுதல்

1. Arduino IDE ஐத் திறந்து ஸ்கெட்ச் -> நூலகத்தைச் சேர்க்கவும் -> நூலகங்களை நிர்வகிக்கவும் . FreeRTOS ஐத் தேடி, கீழே காட்டப்பட்டுள்ளபடி நூலகத்தை நிறுவவும்.

நீங்கள் கிதுபிலிருந்து நூலகத்தைப் பதிவிறக்கம் செய்து. ஸ்கெட்ச்-> நூலகத்தைச் சேர்க்கவும் ->.zip கோப்பைச் சேர்க்கவும்.zip கோப்பைச் சேர்க்கலாம் .

இப்போது, ​​Arduino IDE ஐ மறுதொடக்கம் செய்யுங்கள். இந்த நூலகம் சில எடுத்துக்காட்டு குறியீட்டை வழங்குகிறது, இது கோப்பு -> எடுத்துக்காட்டுகள் -> FreeRTOS இல் கீழே காட்டப்பட்டுள்ளது.

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

சுற்று வரைபடம்

Arduino இல் FreeRTOS ஐப் பயன்படுத்தி ஒளிரும் எல்.ஈ.டி பணியை உருவாக்குவதற்கான சுற்று வரைபடம் கீழே:

Arduino FreeRTOS எடுத்துக்காட்டு- Arduino IDE இல் FreeRTOS பணிகளை உருவாக்குதல்

FreeRTOS திட்டத்தை எழுத ஒரு அடிப்படை கட்டமைப்பைப் பார்ப்போம்.

1. முதலில், Arduino FreeRTOS தலைப்பு கோப்பை இவ்வாறு சேர்க்கவும்

#சேர்க்கிறது

2. மரணதண்டனைக்காக நீங்கள் எழுதும் அனைத்து செயல்பாடுகளின் செயல்பாட்டு முன்மாதிரியையும் கொடுங்கள்

வெற்றிட பணி 1 (வெற்றிடத்தை * pvParameters); வெற்றிட பணி 2 (வெற்றிடத்தை * pvParameters); .. ….

3. இப்போது, வெற்றிட அமைவு () செயல்பாட்டில், பணிகளை உருவாக்கி பணி அட்டவணையைத் தொடங்கவும்.

பணியை உருவாக்க, xTaskCreate () API சில அளவுருக்கள் / வாதங்களுடன் அமைவு செயல்பாட்டில் அழைக்கப்படுகிறது.

xTaskCreate (TaskFunction_t pvTaskCode, const char * const pcName, uint16_t usStackDepth, void * pvParameters, UBaseType_t uxPriority, TaskHandle_t * pxCreatedTask);

எந்தவொரு பணியையும் உருவாக்கும் போது 6 வாதங்கள் நிறைவேற்றப்பட வேண்டும். இந்த வாதங்கள் என்ன என்று பார்ப்போம்

  1. pvTaskCode: இது வெறுமனே செயல்பாட்டை சுட்டிக்காட்டும் பணியாகும் (இதன் விளைவாக, செயல்பாட்டின் பெயர்).
  2. pcName: பணிக்கான விளக்கமான பெயர். இதை FreeRTOS பயன்படுத்தாது. பிழைத்திருத்த நோக்கங்களுக்காக இது முற்றிலும் சேர்க்கப்பட்டுள்ளது.
  3. usStackDepth: ஒவ்வொரு பணிக்கும் அதன் சொந்த தனித்துவமான அடுக்கு உள்ளது, இது பணி உருவாக்கப்படும் போது பணிக்கு கர்னலால் ஒதுக்கப்படுகிறது. மதிப்பு அடுக்குகளின் எண்ணிக்கையை குறிப்பிடுகிறது, பைட்டுகளின் எண்ணிக்கையை அல்ல. எடுத்துக்காட்டாக, அடுக்கு 32-பிட்கள் அகலமாகவும், usStackDepth 100 ஆகவும் அனுப்பப்பட்டால், ரேமில் 400 பைட்டுகள் ஸ்டேக் இடம் (100 * 4 பைட்டுகள்) ஒதுக்கப்படும். Arduino Uno க்கு 2Kbytes ரேம் மட்டுமே இருப்பதால் இதை புத்திசாலித்தனமாகப் பயன்படுத்தவும்.
  4. pvParameters: பணி உள்ளீட்டு அளவுரு (NULL ஆக இருக்கலாம்).
  5. uxPriority: பணியின் முன்னுரிமை (0 மிகக் குறைந்த முன்னுரிமை).
  6. pxCreatedTask: உருவாக்கப்படும் பணிக்கு ஒரு கைப்பிடியை அனுப்ப இது பயன்படுத்தப்படலாம். இந்த கைப்பிடி பின்னர் API அழைப்புகளில் பணியைக் குறிக்கப் பயன்படுத்தலாம், எடுத்துக்காட்டாக, பணி முன்னுரிமையை மாற்றலாம் அல்லது பணியை நீக்கலாம் (NULL ஆக இருக்கலாம்).

பணி உருவாக்கத்தின் எடுத்துக்காட்டு

xTaskCreate (task1, "task1", ​​128, NULL, 1, NULL); xTaskCreate (task2, "task2", 128, NULL, 2, NULL);

இங்கே, Task2 க்கு அதிக முன்னுரிமை உள்ளது, எனவே முதலில் இயங்குகிறது.

4. பணியை உருவாக்கிய பிறகு, vTaskStartScheduler () ஐப் பயன்படுத்தி ஒரு வெற்றிட அமைப்பில் திட்டமிடலைத் தொடங்கவும் ; API.

5. எந்தவொரு பணியையும் கைமுறையாகவும் எண்ணற்றதாகவும் இயக்க விரும்பாததால், வெற்றிட வளைய () செயல்பாடு காலியாகவே இருக்கும். ஏனெனில் பணி செயல்படுத்தல் இப்போது திட்டமிடுபவரால் கையாளப்படுகிறது.

6. இப்போது, ​​நாங்கள் பணி செயல்பாடுகளை செயல்படுத்த வேண்டும் மற்றும் இந்த செயல்பாடுகளுக்குள் நீங்கள் இயக்க விரும்பும் தர்க்கத்தை எழுத வேண்டும். செயல்பாட்டு பெயர் xTaskCreate () API இன் முதல் வாதத்திற்கு சமமாக இருக்க வேண்டும்.

void task1 (void * pvParameters) { போது (1) { .. ..// உங்கள் தர்க்கம் } }

7. இயங்கும் பணியை நிறுத்த பெரும்பாலான குறியீட்டிற்கு தாமத செயல்பாடு தேவைப்படுகிறது, ஆனால் RTOS இல் இது CPU ஐ நிறுத்துவதால் தாமதம் () செயல்பாட்டைப் பயன்படுத்த பரிந்துரைக்கப்படவில்லை, எனவே RTOS மேலும் செயல்படுவதை நிறுத்துகிறது. எனவே ஒரு குறிப்பிட்ட நேரத்திற்கு பணியைத் தடுக்க FreeRTOS க்கு கர்னல் API உள்ளது.

vTaskDelay (const TickType_t xTicksToDelay);

இந்த API ஐ தாமத நோக்கங்களுக்காகப் பயன்படுத்தலாம். இந்த ஏபிஐ குறிப்பிட்ட எண்ணிக்கையிலான உண்ணிக்கு ஒரு பணியை தாமதப்படுத்துகிறது. பணி தடைசெய்யப்பட்ட உண்மையான நேரம் டிக் வீதத்தைப் பொறுத்தது. டிக் வீதத்திலிருந்து நிகழ்நேரத்தைக் கணக்கிட நிலையான போர்ட் TICK_PERIOD_MS ஐப் பயன்படுத்தலாம்.

இதன் பொருள் நீங்கள் 200 மீ தாமதத்தை விரும்பினால், இந்த வரியை எழுதுங்கள்

vTaskDelay (200 / portTICK_PERIOD_MS);

எனவே இந்த டுடோரியலுக்காக, மூன்று பணிகளைச் செயல்படுத்த இந்த FreeRTOS API களைப் பயன்படுத்துவோம்.

பயன்படுத்த வேண்டிய API கள்:

  1. xTaskCreate ();
  2. vTaskStartScheduler ();
  3. vTaskDelay ();

இந்த டுடோரியலுக்காக உருவாக்க வேண்டிய பணி:

  1. 200 எம்எஸ் அதிர்வெண் கொண்ட டிஜிட்டல் பின் 8 இல் எல்இடி ஒளிரும்
  2. 300 எம்எஸ் அதிர்வெண் கொண்ட டிஜிட்டல் பின் 7 இல் எல்இடி ஒளிரும்
  3. சீரியல் மானிட்டரில் 500 எம்எஸ் அதிர்வெண் கொண்ட எண்களை அச்சிடுக.

Arduino IDE இல் FreeRTOS பணி அமலாக்கம்

1. மேலே உள்ள அடிப்படை கட்டமைப்பு விளக்கத்திலிருந்து, Arduino FreeRTOS தலைப்பு கோப்பைச் சேர்க்கவும். பின்னர் செயல்பாட்டு முன்மாதிரிகளை உருவாக்கவும். எங்களுக்கு மூன்று பணிகள் இருப்பதால், மூன்று செயல்பாடுகளைச் செய்யுங்கள், அது முன்மாதிரிகள்.

# வெற்றிட டாஸ்க்ளிங்க் 1 (வெற்றிடத்தை * பிவிபராமீட்டர்கள்) சேர்க்கவும்; வெற்றிட TaskBlink2 (வெற்றிடத்தை * pvParameters); பணிக்குழு (வெற்றிடத்தை * pvParameters);

2. வெற்றிட அமைவு () செயல்பாட்டில், சீரியல் தகவல்தொடர்புகளை வினாடிக்கு 9600 பிட்களில் துவக்கி, xTaskCreate () API ஐப் பயன்படுத்தி மூன்று பணிகளையும் உருவாக்கவும். ஆரம்பத்தில், அனைத்து பணிகளின் முன்னுரிமைகளையும் '1' ஆக உருவாக்கி, திட்டமிடலைத் தொடங்கவும்.

void setup () { Serial.begin (9600); xTaskCreate (TaskBlink1, "Task1", ​​128, NULL, 1, NULL); xTaskCreate (TaskBlink2, "Task2", 128, NULL, 1, NULL); xTaskCreate (பணி முத்திரை, "பணி 3", 128, NULL, 1, NULL); vTaskStartScheduler (); }

3. இப்போது, பணி 1 எல்இடி ஒளிரும் கீழே காட்டப்பட்டுள்ளபடி மூன்று செயல்பாடுகளையும் செயல்படுத்தவும்.

வெற்றிட TaskBlink1 (வெற்றிடத்தை * pvParameters) { pinMode (8, OUTPUT); (1) { டிஜிட்டல்ரைட் (8, உயர்); vTaskDelay (200 / portTICK_PERIOD_MS); டிஜிட்டல்ரைட் (8, குறைந்த); vTaskDelay (200 / portTICK_PERIOD_MS); } }

இதேபோல், TaskBlink2 செயல்பாட்டை செயல்படுத்தவும். பணி 3 செயல்பாடு என எழுதப்படும்

பணிக்குழு (வெற்றிடத்தை * pvParameters) { int counter = 0; (1) { எதிர் ++; Serial.println (எதிர்); vTaskDelay (500 / portTICK_PERIOD_MS); } }

அவ்வளவுதான். Arduino Uno க்கான FreeRTOS Arduino திட்டத்தை வெற்றிகரமாக முடித்துள்ளோம். இந்த டுடோரியலின் முடிவில் ஒரு வீடியோவுடன் முழு குறியீட்டையும் நீங்கள் காணலாம்.

இறுதியாக, டிஜிட்டல் பின் 7 மற்றும் 8 இல் இரண்டு எல்.ஈ.டிகளை இணைத்து, உங்கள் ஆர்டுயினோ போர்டில் குறியீட்டைப் பதிவேற்றி சீரியல் மானிட்டரைத் திறக்கவும். கீழே காட்டப்பட்டுள்ளபடி பணி பெயருடன் 500 மீட்டருக்கு ஒரு முறை ஒரு கவுண்டர் இயங்குவதை நீங்கள் காண்பீர்கள்.

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

இப்போது, ​​அனலாக் ரீட் மற்றும் டிஜிட்டல் ரீட் பணிகள் உருவாக்கப்படும் முதல் இரண்டு எடுத்துக்காட்டுக் குறியீடுகளை நீங்கள் புரிந்து கொள்ளலாம். இந்த வழியில், நீங்கள் Arduino Uno மற்றும் FreeRTOS API களைப் பயன்படுத்தி மேலும் முன்கூட்டியே திட்டங்களை உருவாக்கலாம்.

பதிக்கப்பட்ட

ஆசிரியர் தேர்வு

மொபிடி மியூசிக் சேவையகத்தைப் பயன்படுத்தி ராஸ்பெர்ரி பையில் ஸ்பாட்ஃபை எவ்வாறு இயக்குவது

அல்ட்ரா-ஸ்மால் டி.சி.

Arduino ஸ்மார்ட் அலாரம் கடிகாரம்

ஒருங்கிணைந்த கேன் எஃப்.டி கட்டுப்படுத்தி மற்றும் டிரான்ஸ்ஸீவர் கொண்ட கணினி அடிப்படை சிப் (எஸ்.பி.சி)

லினக்ஸ் விநியோகத்துடன் Stm32mp1 mpus அயோட் பயன்பாடுகளின் வளர்ச்சியை வேகப்படுத்துகிறது

வயர்லெஸ் மல்டி