ខ្ញុំស្នើជម្រើសឧបករណ៍ដែលចាប់ផ្ដើមកុំព្យូទ័រឡើងវិញដោយស្វ័យប្រវត្តិនៅពេលវាបង្កក។

វាត្រូវបានផ្អែកលើបន្ទះ Arduino ដ៏ល្បីល្បាញជាមួយនឹងចំនួនអប្បបរមានៃខាងក្រៅ សមាសធាតុអេឡិចត្រូនិច. យើងភ្ជាប់ត្រង់ស៊ីស្ទ័រទៅនឹងក្តារយោងទៅតាមរូបភាពខាងក្រោម។ យើងភ្ជាប់ឧបករណ៍ប្រមូលត្រង់ស៊ីស្ទ័រជំនួសឱ្យប៊ូតុង "កំណត់ឡើងវិញ" របស់កុំព្យូទ័រ motherboardទៅ pin ដែលមិនត្រូវបានភ្ជាប់ទៅ GND ។

នេះជាដ្យាក្រាមទាំងមូល៖

ឧបករណ៍មានមុខងារដូចខាងក្រោមៈ ស្គ្រីបមួយត្រូវបានបើកនៅលើកុំព្យូទ័រ ដែលបញ្ជូនទិន្នន័យតាមកាលកំណត់ទៅកាន់ច្រកកុំព្យូទ័រ។ Arduino ភ្ជាប់ទៅ USB និងស្តាប់ច្រកនេះ។ ប្រសិនបើមិនមានទិន្នន័យក្នុងរយៈពេល 30 វិនាទី Arduino បើកត្រង់ស៊ីស្ទ័រដែលភ្ជាប់ Reset ទៅដី ដោយហេតុនេះការក្លែងធ្វើដោយចុចប៊ូតុងកំណត់ឡើងវិញ។
បន្ទាប់ពីការកំណត់ឡើងវិញ Arduino ផ្អាករយៈពេល 2 នាទី រង់ចាំកម្មវិធីទាំងអស់ដំណើរការ ហើយបន្ទាប់មកចាប់ផ្តើមស្តាប់ច្រកម្តងទៀត។

ស្គ្រីបនិងអ្នករុករកត្រូវតែបន្ថែមទៅការចាប់ផ្តើម ហើយ BIOS ត្រូវតែកំណត់ទៅ ការបើកដោយស្វ័យប្រវត្តិកុំព្យូទ័រ។

ការផលិតឧបករណ៍តម្រូវឱ្យមានជំនាញតិចតួចក្នុងការធ្វើការជាមួយដែក soldering និងសរសេរកម្មវិធី Arduino ។

អ្នកក៏អាចប្រើត្រង់ស៊ីស្ទ័រ H channel ជាមួយ លក្ខណៈស្រដៀងគ្នា. ប៉ុន្តែត្រូវប្រាកដថា pinout ត្រូវគ្នា។ ឧទាហរណ៍ ខ្ញុំបានប្រើ 9013 មានការតភ្ជាប់បញ្ច្រាស

ខ្ញុំបានទិញគ្រឿងបន្លាស់សម្រាប់ដំឡើងនៅលើ Aliexpress៖

ខ្សែសម្រាប់ ការដំឡើងក្តារបន្ទះ http://ali.pub/22k78b

Arduino UNO (ពិតជាសម) http://ali.pub/22k7dd

គំនូរព្រាង Arduino

int LedPin = 13;
int ResetPin = 12;
int val = 0;
int រាប់ = 0;
ការ​កំណត់​ទុក​ជា​មោឃៈ ()
{
Serial.begin(9600);
pinMode(LedPin, OUTPUT);

// ចាប់ផ្តើមផ្អាក 2 នាទី។
ការពន្យាពេល (120000);
}

ចន្លោះប្រហោង ()
{
រាប់ ++;

ប្រសិនបើ (Serial.available() > 0)
{
val = Serial.read();
ប្រសិនបើ (val == 'H')
{
digitalWrite(LedPin, LOW);
digitalWrite(ResetPin, LOW);
រាប់ = 0;
}
ផ្សេងទៀត។
(រាប់ ++;
}
}

ការពន្យាពេល (1000);

ប្រសិនបើ (រាប់ > 10)
{
digitalWrite(LedPin, HIGH);
digitalWrite(ResetPin, HIGH);
}
}

ស្គ្រីបបញ្ជូនទិន្នន័យទៅច្រក៖

(Get-Date).ToString('dd.MM.yyyy HH:mm') | ឯកសារក្រៅ c:\Users\miner\Desktop\reboot.txt -append

while($TRUE)(
ចាប់ផ្តើម-គេង-s ៣
$port=new-Object System.IO.Ports.SerialPort COM3,9600,None,8,one
$port.open()
$port.WriteLine("H")
$port.Close()
}

ភ្លាមៗបន្ទាប់ពីការបើកដំណើរការស្គ្រីបសរសេរទៅឯកសារ reboot.txt កាលបរិច្ឆេទបច្ចុប្បន្ននិងពេលវេលា។ ពីឯកសារនេះ អ្នកអាចវិនិច្ឆ័យចំនួន និងពេលវេលានៃការចាប់ផ្តើមឡើងវិញ។ ផ្លូវឯកសារ និងលេខច្រកត្រូវតែត្រូវបានកែសម្រួលដោយយោងទៅតាមទិន្នន័យប្រព័ន្ធរបស់អ្នក។ លេខកូដត្រូវបានសរសេរក្នុង notepad ធម្មតា ហើយរក្សាទុកជាមួយផ្នែកបន្ថែម *ps1។

ដោយសារតែ វ គោលការណ៍វីនដូសុវត្ថិភាព ការប្រតិបត្តិស្គ្រីបត្រូវបានបិទ ចុចពីរដងហើយពី autoload យើងធ្វើឱ្យមានការក្លែងបន្លំជាមួយត្រចៀករបស់យើងហើយចាប់ផ្តើមសែលពីឯកសាររាងកាយជាមួយនឹងមាតិកាដូចខាងក្រោម។

Watchdog គឺជាឧបករណ៍ដែលត្រូវបានរចនាឡើងដើម្បីស្វែងរក និងដោះស្រាយបញ្ហាផ្នែករឹង។ ជាធម្មតា វាត្រូវបានធ្វើដោយប្រើកម្មវិធីកំណត់ម៉ោង ដែលចាប់ផ្តើមឡើងវិញជាទៀងទាត់ ដើម្បីទប់ស្កាត់ការបញ្ជូនសញ្ញាចាប់ផ្ដើមឡើងវិញ។

ម៉ាស៊ីនមេគោលដៅនៅលើ Gentoo ត្រូវបានប្រើប្រាស់ដោយខ្ញុំជាចម្បងសម្រាប់ការពិសោធន៍ ប៉ុន្តែវាដំណើរការសេវាកម្មមួយចំនួនដែលប្រសិនបើអាចធ្វើទៅបាន គួរតែមានដោយគ្មានការរំខាន។ ជាអកុសល ផលវិបាកនៃការពិសោធន៍មួយចំនួននាំឱ្យខឺណែលភ័យស្លន់ស្លោ 100% បន្ទុកស៊ីភីយូនិងបញ្ហាផ្សេងទៀតនៅពេលមិនសមរម្យបំផុត។ ដូច្នេះ​គំនិត​នៃ​ការ​បន្ថែម​ឧបករណ៍​ឃ្លាំ​មើល​បាន​ទាមទារ​ឱ្យ​មាន​ការ​យក​ចិត្ត​ទុក​ដាក់​ជា​យូរ​មក​ហើយ​នៅ​ទី​បំផុត​បាន​ក្លាយ​​​ទៅ​ជា​ឧបករណ៍​នេះ​។

បន្ទាប់ពីពិនិត្យមើលយ៉ាងដិតដល់នូវអ្វីដែលមាន និងវាយតម្លៃពេលវេលាដែលអាចប្រើបាន។ ជម្រើសដ៏ល្អបំផុតបានក្លាយជាអ្នកឃ្លាំមើលប្រមូលផ្តុំ ផ្អែកលើ Arduinoណាណូ។ បញ្ជីនៃតម្រូវការបានលេចឡើងប្រហែលដូចគ្នា:

1. ការចាប់ផ្តើម និងបញ្ឈប់ដេមិន ដើម្បីធ្វើការជាមួយកម្មវិធីកំណត់ម៉ោង, មធ្យោបាយស្តង់ដារប្រព័ន្ធប្រតិបត្តិការ (OpenRC) ។
2. ឧបករណ៍នេះមានឧបករណ៍ឃ្លាំមើលផ្ទាល់ខ្លួន ATmega មានវា អ្នកត្រូវប្រើវា។
3. កំណត់ហេតុព្រឹត្តិការណ៍នៅលើឧបករណ៍ដើម្បីកត់ត្រាការចាប់ផ្តើមឡើងវិញ និងកម្មវិធីកំណត់ម៉ោង។
4. ធ្វើសមកាលកម្មពេលវេលាឧបករណ៍ជាមួយម៉ាស៊ីនដើម្បីកត់ត្រាពេលវេលាត្រឹមត្រូវនៅក្នុងកំណត់ហេតុ។
5. ការទទួល និងបង្ហាញស្ថានភាពឧបករណ៍ និងធាតុកំណត់ហេតុរបស់វា។
6. ការសម្អាតកំណត់ហេតុ និងកំណត់ឧបករណ៍ឡើងវិញទៅស្ថានភាពដើមរបស់វា។

ផ្នែករឹង

ចាប់ផ្ដើម Arduino ដែលមិនចង់បាន

មានជម្រើសជាច្រើនសម្រាប់ការដោះស្រាយបញ្ហា ប៉ុន្តែមានតែមួយប៉ុណ្ណោះបានដំណើរការ - អ្នកត្រូវដំឡើងអេឡិចត្រូលីត 10µF (C1 ក្នុងដ្យាក្រាមខាងក្រោម) រវាងទំនាក់ទំនង RST និង GND ។ ជាអកុសល នេះក៏រារាំងគំនូរព្រាងពីការទាញយកទៅឧបករណ៍ផងដែរ។

ជាលទ្ធផល ដ្យាក្រាមបានប្រែក្លាយដូចខាងក្រោម៖

គូរដោយប្រើ KiCad

ការពន្យល់សម្រាប់ដ្យាក្រាម

• R1- រេស៊ីស្តង់កំណត់បច្ចុប្បន្ន គណនាតាមលក្ខណៈបច្ចេកទេសសម្រាប់អុបតូកូបល័រ PC817: (5V - 1.2V / 0.02A) = 190Ω តម្លៃស្តង់ដារជិតបំផុតគឺ 180Ω។
• U2- optocoupler សម្រាប់ភាពឯកោ galvanic នៃ Arduino និង PC ។ អ្នកអាចទទួលបានតាមរយៈត្រង់ស៊ីស្ទ័រ ដោយសារដីជារឿងធម្មតា (តាមរយៈឧបករណ៍ភ្ជាប់ USB) ប៉ុន្តែវាមិនប្រសើរជាង។
• JP1- jumper ត្រូវតែបិទនៅក្នុងទីតាំងធ្វើការ។ ដើម្បីទាញយកគំនូរព្រាងទៅឧបករណ៍ វាត្រូវតែដោះសោ។
• គ១- capacitor រារាំងឧបករណ៍ពីការចាប់ផ្ដើមឡើងវិញក្នុងការឆ្លើយតបទៅនឹងសញ្ញា DTR ។
• MB_RST, MB_GND- RESET សកម្មនៅពេលដែលកម្រិតសញ្ញាទាប ដូច្នេះអ្នកត្រូវកាត់ RST ទៅដី (GND)។ optocoupler ប្រើត្រង់ស៊ីស្ទ័រ ដូច្នេះវាមានសារៈសំខាន់ណាស់ក្នុងការថែរក្សាបន្ទាត់រាងប៉ូល។
• BTN_RST, BTN_GND- ប៊ូតុងនៅលើរាងកាយជាធម្មតានេះ។ កុងតាក់មេកានិចដូច្នេះប៉ូលមិនសំខាន់ទេ ប៉ុន្តែមានករណីលើកលែង។

Boot-loop (ការចាប់ផ្តើមឡើងវិញជារង្វង់) នៅពេលធ្វើការជាមួយ WDT

ទេ។ ការស្វែងរកយូរបានរកឃើញថាកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធនៃក្លូន Arduino ភាគច្រើនមិនគាំទ្រ WDT ទេ។ ជាសំណាងល្អ បញ្ហានេះត្រូវបានដោះស្រាយនៅក្នុងកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធជំនួស Optiboot ។

ដើម្បីបញ្ចេញកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធ អ្នកត្រូវការអ្នកសរសេរកម្មវិធីដែលអាចដំណើរការដោយប្រើពិធីការ SPI វាក៏គួរឱ្យចង់បានដែរដែល Arduino IDE ស្គាល់ឧបករណ៍នេះដោយមើលឃើញ។ IN ក្នុងករណីនេះ Arduino មួយផ្សេងទៀតនឹងល្អ។

ប្រសិនបើអ្នកយក Arduino UNOក្នុងនាមជាអ្នកសរសេរកម្មវិធី ហើយក្រោយមកទៀត នៅពេលនេះកំណែ Arduino IDE v1.6.5 បន្ទាប់មកក្បួនដោះស្រាយនឹងមានដូចខាងក្រោម៖

បន្ទាប់ពីនីតិវិធីនេះ អ្នកនឹងត្រូវបង្ហោះរូបព្រាងទៅ Arduino Nano ដោយប្រើការកំណត់ដូចគ្នា - ក្តារ៖ Optiboot នៅលើ 32 pin cpus, ឧបករណ៍ដំណើរការ៖ ATmega328p, ល្បឿនស៊ីភីយូ: 16MHz ។

ការផ្សារដែក

នៅទីនេះ ដោត USBខ្ញុំត្រូវការវាព្រោះខ្ញុំមាន motherboard ខ្នាតតូច ITX ដែលមានឧបករណ៍ភ្ជាប់តែមួយប៉ុណ្ណោះក្នុងមួយគូនៃ USB2.0 ដែលចាំបាច់នៅលើបន្ទះខាងមុខ និង បន្ទះទំនាក់ទំនង USB3.0 មិនមានអ្វីត្រូវភ្ជាប់ទេ។ ប្រសិនបើអាចធ្វើបាន ឧបករណ៍បែបនេះគួរតែត្រូវបានភ្ជាប់ដោយផ្ទាល់ទៅ motherboard ដើម្បីកុំឱ្យខ្សែភ្លើងរលត់។

Soldering ជាក្បួនមិនបង្កបញ្ហាទេ ប៉ុន្តែនៅក្នុងករណីនេះ ក្តារបន្ទះត្រូវបានប្រើ ហើយវាមានលក្ខណៈពិសេសរបស់វា។

របៀបធ្វើផ្លូវដែកនៅលើក្តារបន្ទះ

ដំបូងអ្នកត្រូវដាក់គ្រាប់នៅលើរន្ធ (អ្នកមិនអាចកំដៅវាឱ្យបានយូរទេ បើមិនដូច្នេះទេសំណប៉ាហាំងនឹងលេចចេញពីផ្នែកខាងក្រោយ)។ បន្ទាប់មក solder jumpers រវាងគូនៃគ្រាប់បាល់ដែលនៅជាប់គ្នា និងបញ្ចប់បទដោយ soldering ផ្នែកដែលនៅសល់។

វាគួរតែមើលទៅដូចនេះ៖

នៅទីនេះវាហាក់ដូចជាថាទំនាក់ទំនងមួយចំនួនត្រូវបាន soldered មិនបានល្អ ប៉ុន្តែនេះគ្រាន់តែជា flux ប៉ុណ្ណោះ។ ការប្រើប្រាស់ solder នៅលើ breadboards គឺខ្ពស់ណាស់, ដូច្នេះអ្វីគ្រប់យ៉ាងដែលអាចធ្វើបានគឺមានស្នាមប្រឡាក់ជាមួយ flux ។ តាមពិតនេះគឺ ឧទាហរណ៍ដ៏ល្អរបៀបមិនទុកផលិតផលបន្ទាប់ពី soldering ។ លំហូរត្រូវតែត្រូវបានទឹកនាំទៅចេញ បើមិនដូច្នេះទេវាអាចមានបញ្ហាជាមួយនឹងការ corrosion នៃការតភ្ជាប់។ ខ្ញុំ​នឹង​សរសេរ​ចប់​ហើយ​ទៅ​លាង​វា... នេះ​ល្អ​ជាង៖

ផ្នែកកម្មវិធី

ការតភ្ជាប់អ្នកឃ្លាំមើល

ជាដំបូង អ្នកត្រូវស្វែងរកដោយមើលឃើញនូវឧបករណ៍ឃ្លាំមើលដែលបានភ្ជាប់ ជាឧទាហរណ៍ ដោយរកមើលក្នុងឯកសារកំណត់ហេតុប្រព័ន្ធ។ បន្ទាប់មកជំនួស /dev/ttyUSB0 ជាមួយ ឧបករណ៍ដែលត្រូវការសរសេរក្នុងស្ថានីយ៖

ព័ត៌មាន Udevadm -a -p "$ (ព័ត៌មាន udevadm -q ផ្លូវ -n /dev/ttyUSB0)"

លទ្ធផលឧទាហរណ៍

មើលឧបករណ៍ "/devices/pci0000:00/0000:00:14.0/usb1/1-1/1-1.4/1-1.4:1.0/ttyUSB0/tty/ttyUSB0": KERNEL=="ttyUSB0" SUBSYSTEM==" tty" ... សម្លឹងមើលឧបករណ៍មេ "/devices/pci0000:00/0000:00:14.0/usb1/1-1/1-1.4/1-1.4:1.0/ttyUSB0": KERNELS=="ttyUSB0" SUBSYSTEMS= ="usb-serial" DRIVERS=="ch341-uart" ... សម្លឹងមើលឧបករណ៍មេ "/devices/pci0000:00/0000:00:14.0/usb1/1-1/1-1.4/1-1.4:1.0 ": ... កំពុងមើលឧបករណ៍មេ "/devices/pci0000:00/0000:00:14.0/usb1/1-1/1-1.4": SUBSYSTEMS=="usb" DRIVERS=="usb" ATTRS(idVendor) =="1a86" ATTRS(idProduct)=="7523" ATTRS(product)=="USB2.0-Serial" ...

វាត្រូវតែត្រូវបានដាក់នៅក្នុង ឯកសារដាច់ដោយឡែកនៅក្នុងថត /etc/udev/rules.d ឧទាហរណ៍ 51-ttyrst-watchdog.rules និងបញ្ជា udev ដើម្បីផ្ទុកច្បាប់ឡើងវិញ៖ udevadm control --reload-rules

ចាប់ពីពេលនេះតទៅ នៅពេលភ្ជាប់ឧបករណ៍ឃ្លាំមើល តំណភ្ជាប់ /dev/ttyrst-watchdog នឹងត្រូវបានបង្កើតទៅកាន់ឧបករណ៍ដែលចង់បាន ដែលនឹងត្រូវបានប្រើបន្ថែមទៀត។

អក្សរ Bash (ttyrst-watchdog.sh)

សម្រាប់កម្មវិធីកំណត់ម៉ោងសំខាន់ ចាប់ផ្តើមរង្វិលជុំឡើងវិញ និងសម្រាប់មុខងារ បន្ទាត់ពាក្យបញ្ជាស្គ្រីបមួយត្រូវបានប្រើ។ ហេតុផលគឺថាសមាសធាតុទាំងពីរប្រើ ធនធានចែករំលែក- ឯកសារឧបករណ៍ ហើយវាត្រូវតែចូលប្រើក្នុងពេលដំណាលគ្នា។

ការ​ធ្វើ​សមកាលកម្ម​សំខាន់​មាន​ការ​រង់ចាំ​មួយ​: ខណៈ​ពេល​ដែល fuser $(DEVICE) >/dev/null 2> do true; រួចរាល់ហើយចាប់យកឧបករណ៍នៅលើ ពេលវេលាដែលត្រូវការ៖ ឆ្មា<${DEVICE}

ជាក់ស្តែង គ្រោងការណ៍បែបនេះគឺស្ថិតនៅក្រោមលក្ខខណ្ឌនៃការប្រណាំង។ អ្នកអាចដោះស្រាយវាតាមរបៀបមនុស្សពេញវ័យ (ឧទាហរណ៍ រៀបចំជួរសារ) ប៉ុន្តែក្នុងករណីនេះ វាគ្រប់គ្រាន់ក្នុងការកំណត់ពេលវេលាឱ្យត្រឹមត្រូវដើម្បីធានាដើម្បីទទួលបានលទ្ធផលក្នុងពេលវេលាដែលអាចទទួលយកបាន។ តាមពិត ស្គ្រីបទាំងមូលកំពុងដំណើរការជាមួយនឹងការអស់ពេល។

អារក្ស (រត់ក្នុងផ្ទៃខាងក្រោយ) ត្រូវបានអនុវត្តដោយប្រើកញ្ចប់ OpenRC ។ វាត្រូវបានសន្មត់ថាស្គ្រីបនេះស្ថិតនៅក្នុងឯកសារ /usr/local/bin/ttyrst-watchdog.sh ហើយស្គ្រីប OpenRC គឺនៅក្នុង /etc/init.d/ttyrst-watchdog ។

នៅពេលបញ្ឈប់ដេមិន អ្នកឃ្លាំមើលត្រូវតែបិទដំណើរការត្រឹមត្រូវ។ ដើម្បីធ្វើដូច្នេះ ឧបករណ៍ដោះស្រាយសញ្ញាដែលតម្រូវឱ្យបិទត្រូវបានដំឡើងនៅក្នុងស្គ្រីប៖ អន្ទាក់បិទដំណើរការ SIGINT SIGTERM ហើយនៅទីនេះមានបញ្ហាកើតឡើង - OpenRC មិនអាចបញ្ឈប់ដេមិនបានទេ ឬផ្ទុយទៅវិញវាអាចធ្វើបាន ប៉ុន្តែមិនញឹកញាប់ទេ។

ការពិតគឺថាពាក្យបញ្ជា kill បញ្ជូនសញ្ញាទៅស្គ្រីប ប៉ុន្តែកម្មវិធី sleep ដែលប្រើដើម្បីផ្អាក script ត្រូវបានប្រតិបត្តិក្នុងដំណើរការមួយផ្សេងទៀត ហើយមិនទទួលបានសញ្ញានោះទេ។ ជាលទ្ធផល មុខងារអសកម្មដំណើរការតែបន្ទាប់ពីដំណេកបានបញ្ចប់ ដែលចំណាយពេលយូរពេក។

ដំណោះស្រាយគឺត្រូវដំណើរការ Sleep ក្នុងផ្ទៃខាងក្រោយ ហើយរង់ចាំដំណើរការបញ្ចប់នៅក្នុងស្គ្រីប៖ គេង $(SLEEP_TIME) & wait $! # ប្រែប្រួល $! មានលេខសម្គាល់នៃដំណើរការដែលកំពុងដំណើរការចុងក្រោយ

ថេរមូលដ្ឋាន៖

WATCHDOG_ACTIVE- បាទ/ចាស ឬ ទេ រៀងគ្នា ផ្ញើសញ្ញាដើម្បីចាប់ផ្ដើមឡើងវិញ នៅពេលដែលកម្មវិធីកំណត់ម៉ោងត្រូវបានកេះ ឬអត់។
WATCHDOG_TIMER- ពេលវេលាគិតជាវិនាទីដែលកម្មវិធីកំណត់ម៉ោងត្រូវបានកំណត់។
SLEEP_TIME- ពេលវេលាគិតជាវិនាទីបន្ទាប់ពីនោះកម្មវិធីកំណត់ម៉ោងត្រូវតែចាប់ផ្តើមឡើងវិញ។ វាគួរតែតិចជាង WATCHDOG_TIMER ប៉ុន្តែមិនតូចពេក ដើម្បីកុំឱ្យបង្កើតបន្ទុកលើសនៅលើប្រព័ន្ធ និងឧបករណ៍។ ជាមួយនឹងការអស់ពេលបច្ចុប្បន្ន អប្បបរមាសមរម្យគឺប្រហែល 5 វិនាទី។
DEFAULT_LOG_LINES- ចំនួន​នៃ​ធាតុ​កំណត់​ហេតុ​ឧបករណ៍​ថ្មីៗ​បាន​ត្រឡប់​ដោយ​ពាក្យ​បញ្ជា​កំណត់​ហេតុ​តាម​លំនាំដើម។

ពាក្យបញ្ជាស្គ្រីប៖

ចាប់ផ្តើម- ចាប់ផ្តើមវដ្តនៃការចាប់ផ្តើមកម្មវិធីកំណត់ពេលវេលាសំខាន់។ អ្នកអាចបន្ថែមកូដពិនិត្យបន្ថែមទៅមុខងារ is_alive ជាឧទាហរណ៍ ពិនិត្យមើលសមត្ថភាពក្នុងការភ្ជាប់តាមរយៈ ssh ។
ស្ថានភាព- បង្ហាញស្ថានភាពឧបករណ៍។
កំណត់ឡើងវិញ- សម្អាត EEPROM (ទិន្នន័យកំណត់ហេតុ) និងចាប់ផ្ដើមឧបករណ៍ឡើងវិញ ដើម្បីស្ដារឧបករណ៍ឃ្លាំមើលទៅសភាពដើមរបស់វា។
កំណត់ហេតុ<число записей> - បង្ហាញចំនួនជាក់លាក់នៃធាតុកំណត់ហេតុថ្មីៗ។

គំនូរព្រាង Arduino (ttyrst-watchdog.ino)

គំនូរព្រាងមានឯកសារពីរ។ នេះគឺដោយសារតែការពិតដែលថា Arduino IDE មិនទទួលយករចនាសម្ព័ន្ធ (រចនាសម្ព័ន្ធ) ដែលបានប្រកាសនៅក្នុងឯកសារសំខាន់ពួកគេត្រូវតែដាក់នៅក្នុងឯកសារបឋមកថាខាងក្រៅ។ ដូចគ្នានេះផងដែរ ដើម្បីប្រកាសរចនាសម្ព័ន្ធ ពាក្យគន្លឹះ typedef គឺមិនចាំបាច់ទេ វាប្រហែលជាមានគ្រោះថ្នាក់ ... បន្ទាប់ពីពិនិត្យមើលជម្រើសស្តង់ដារ ខ្ញុំមិនបានរកឃើញវាក្យសម្ព័ន្ធសមស្របទេ។ បើមិនដូច្នេះទេ វាជាស្តង់ដារ C ++ ច្រើន ឬតិចជាង។

មុខងារ wdt_enable និង wdt_reset ដំណើរការជាមួយ watchdog ដែលបានបង្កើតឡើងនៅក្នុង microcontroller ។ បន្ទាប់ពីចាប់ផ្តើម WDT រឿងសំខាន់គឺកុំភ្លេចកំណត់វាឡើងវិញនៅក្នុងរង្វិលជុំមេនិងនៅខាងក្នុងរង្វិលជុំនៃប្រតិបត្តិការដែលដំណើរការយូរទាំងអស់។

ធាតុកំណត់ហេតុត្រូវបានសរសេរទៅអង្គចងចាំ EEPROM ដែលមិនងាយនឹងបង្កជាហេតុ ទំហំដែលអាចប្រើបានរបស់វាអាចត្រូវបានបញ្ជាក់នៅក្នុង logrecord.h ក្នុងករណីនេះវាជាលេខ 1024។ កំណត់ហេតុត្រូវបានធ្វើឡើងក្នុងទម្រង់ជារង្វង់ សញ្ញាបំបែកគឺជារចនាសម្ព័ន្ធដែលមានតម្លៃសូន្យ។ . ចំនួនអតិបរមានៃធាតុសម្រាប់ 1 KiB EEPROM គឺ 203 ។

• ការបង្រៀន

យើងនឹងនិយាយអំពីរបៀបរក្សា Arduino ឱ្យដំណើរការជានិច្ច។ យន្តការឃ្លាំមើលត្រូវបានបង្កើតឡើងនៅក្នុងឧបករណ៍បញ្ជា Atmega ប៉ុន្តែជាអកុសល មិនមែនគ្រប់កម្មវិធីចាប់ផ្ដើមប្រព័ន្ធ Arduino គ្រប់គ្រងមុខងារនេះឱ្យបានត្រឹមត្រូវនោះទេ។ ចូរយើងព្យាយាមដោះស្រាយបញ្ហានេះ។

ដូច្នេះតើអ្វីជាឧបករណ៍ឃ្លាំមើល? នៅក្នុងពាក្យសាមញ្ញ នេះគឺជាកម្មវិធីកំណត់ពេលវេលាដែលភ្ជាប់មកជាមួយសម្រាប់ពេលវេលាជាក់លាក់មួយ (រហូតដល់ 8 វិនាទីអាស្រ័យលើបន្ទះឈីប) ដែលអាចត្រូវបានចាប់ផ្តើមតាមកម្មវិធី។ ដរាបណាកម្មវិធីកំណត់ម៉ោងឈានដល់សូន្យ ឧបករណ៍បញ្ជានឹងបញ្ជូន ត្រឹមត្រូវ។សញ្ញាកំណត់ឡើងវិញ (RESET) ហើយឧបករណ៍ទាំងមូលចូលទៅក្នុង រឹងចាប់ផ្ដើមឡើងវិញ។ អ្វី​ដែល​សំខាន់​បំផុត​នោះ​គឺ​ថា​កម្មវិធី​កំណត់​ម៉ោង​នេះ​ក៏​អាច​ត្រូវ​បាន​កំណត់​ឡើង​វិញ​ទៅ​ស្ថានភាព​ដំបូង​របស់​វា​តាម​កម្មវិធី។

• ត្រឹមត្រូវ។កំណត់ឡើងវិញនូវសញ្ញា - គ្រប់គ្រាន់សម្រាប់រយៈពេលដែលឧបករណ៍បញ្ជាចាប់ផ្តើមផ្ទុកលើសទម្ងន់។ ពេលខ្លះមានការល្បួងដើម្បីភ្ជាប់លទ្ធផលឌីជីថលមួយចំនួនរបស់ Arduino ទៅនឹងការបញ្ចូល RST ហើយកំណត់វាទៅ 0 នៅពេលអ្នកត្រូវការចាប់ផ្ដើមឡើងវិញ។ នេះ​ជា​វិធីសាស្ត្រ​អាក្រក់​ក្នុង​ការ​ដោះស្រាយ​បញ្ហា​ព្រោះ​... សញ្ញាបែបនេះប្រហែលជាមិនយូរប៉ុន្មានទេ ទោះបីជាវាអាចទៅរួចដែលថាក្នុងករណីខ្លះវានឹងដំណើរការផងដែរ។
• រឹង reboot គឺជាការចាប់ផ្ដើមឡើងវិញពិតប្រាកដដែលកើតឡើងនៅពេលអ្នកចុចប៊ូតុង RESET ។ ការពិតគឺថាក៏មានគំនិតនៃការចាប់ផ្តើមឡើងវិញទន់ - នេះគឺជាការផ្លាស់ប្តូរកម្មវិធីទៅអាសយដ្ឋានទី 0 ។ ជាគោលការណ៍ នេះក៏ជារឿងមានប្រយោជន៍មួយដែរ ប៉ុន្តែដោយមានជំនួយរបស់វា វាមិនអាចទៅរួចទេក្នុងការផ្ទុកលើសទម្ងន់ឧបករណ៍បញ្ជាអ៊ីសឺរណិត ឬអេក្រង់ LCD ដែលមិនប្រក្រតី។

មុខងារឃ្លាំមើល

ឥឡូវនេះមុខងារបីខាងក្រោមមានសម្រាប់ពួកយើង៖

1. ចាប់ផ្តើមកម្មវិធីកំណត់ម៉ោងឃ្លាំមើល៖
wdt_enable(WDTO_8S); /* តម្លៃដែលអាចធ្វើបានសម្រាប់ថេរ WDTO_15MS WDTO_30MS WDTO_60MS WDTO_120MS WDTO_250MS WDTO_500MS WDTO_1S WDTO_2S WDTO_4S WDTO_8S */
កម្មវិធីកំណត់ម៉ោងនឹងរាប់យ៉ាងពិតប្រាកដដរាបណាបានបញ្ជាក់នៅក្នុងថេរ។ បន្ទាប់ពីពេលនេះ ការចាប់ផ្ដើមឡើងវិញនឹងកើតឡើង។

2. កំណត់កម្មវិធីកំណត់ម៉ោងឃ្លាំមើលឡើងវិញ៖
wdt_reset();
ខ្ញុំគិតថាវាច្បាស់ហើយថាហេតុអ្វីបានជាមុខងារនេះត្រូវការ - នៅពេលអ្នកហៅវា ឧបករណ៍បញ្ជានឹងមិនត្រូវបានកំណត់ឡើងវិញទេ។ ដរាបណាប្រព័ន្ធបង្កក ហើយមុខងារនេះឈប់ត្រូវបានហៅ ការចាប់ផ្តើមឡើងវិញនឹងកើតឡើងបន្ទាប់ពីរយៈពេលដែលបានបញ្ជាក់។

3. បិទការឃ្លាំមើល៖
wdt_disable();
បិទកម្មវិធីកំណត់ម៉ោងឃ្លាំមើល។

តាមពិតនេះអាចជាចុងបញ្ចប់នៃរឿងរបស់យើងអំពី watchdog... ប៉ុន្តែការពិតគឺថាអ្វីៗទាំងអស់នេះដំណើរការតែនៅក្នុង Arduino Uno ហើយនៅលើ Arduino Mega, Mini និង Nano វាសុទ្ធតែដំណើរការផ្ទុយគ្នាពោលគឺឧ។ មិនដំណើរការទាល់តែសោះ :)

ហេតុអ្វីបានជាអ្នកឃ្លាំមើលមិនដំណើរការលើបន្ទះ Arduino ទំនើបភាគច្រើន

ការពិតគឺថាបន្ទាប់ពីការចាប់ផ្ដើមឡើងវិញដែលបណ្តាលមកពីអ្នកឃ្លាំមើល អ្នកត្រួតពិនិត្យការចេញផ្សាយចុងក្រោយបំផុតបានទុកឱ្យអ្នកឃ្លាំមើលបើកដំណើរការ។ រយៈពេលអប្បបរមា, i.e. 15ms នេះគឺចាំបាច់ដើម្បីឱ្យកម្មវិធីនេះទទួលស្គាល់ថាការចាប់ផ្ដើមឡើងវិញពីមុនត្រូវបានធ្វើឡើងដោយអ្នកឃ្លាំមើល។ ដូច្នេះ អាទិភាពទីមួយនៃកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធ (ឬកម្មវិធីរបស់អ្នក ប្រសិនបើវាដំណើរការមុន) គឺត្រូវរក្សាទុកព័ត៌មានដែលការចាប់ផ្ដើមឡើងវិញគឺ "មិនបានរំពឹងទុក" ហើយបិទឧបករណ៍ឃ្លាំមើលភ្លាមៗ។ ប្រសិនបើវាមិនត្រូវបានធ្វើ, ប្រព័ន្ធនឹងចូលទៅក្នុង bootloop, i.e. នឹងលើសទម្ងន់ជារៀងរហូត។

ដូចដែលអ្នកដឹង Arduino មានកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធពិសេសដែលដំណើរការដំបូងបន្ទាប់ពីប្រព័ន្ធត្រូវបានចាប់ផ្ដើមឡើងវិញ។ ហើយជាអកុសល កម្មវិធីចាប់ផ្ដើមប្រព័ន្ធស្ដង់ដារមិនបានកំណត់ឧបករណ៍ឃ្លាំមើលឡើងវិញទេ! ដូច្នេះប្រព័ន្ធចូលទៅក្នុង bootloop ដ៏ឃោរឃៅ (ស្ថានភាព "ឆ្កួតដឹកនាំ" ដែល LED នៅលើ pin 13 ព្រិចភ្នែកដូចឆ្កួត) ។

វាទាំងអស់មើលទៅដូចនេះ៖

មធ្យោបាយដោះស្រាយបញ្ហា

ប្រសិនបើអ្នកក្រឡេកមើលប្រភពនៃកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធស្ដង់ដារ (ពួកវាត្រូវបានរួមបញ្ចូលនៅក្នុងការចែកចាយវេទិកា) នោះមានកូដដើម្បីបិទកម្មវិធីឃ្លាំមើល (!) ប៉ុន្តែកូដនេះគឺស្ថិតនៅក្រោមការចងក្រងតាមលក្ខខណ្ឌ ហើយជាក់ស្តែង កម្មវិធីចាប់ផ្ដើមប្រព័ន្ធស្តង់ដារត្រូវបានចងក្រងដោយគ្មានអ្នកឃ្លាំមើល។ គាំទ្រ។ យ៉ាងហោចណាស់នៅក្នុងកំណែកញ្ចប់វេទិកា 1.5.2 (ចុងក្រោយបំផុតនៅពេលសរសេរ) នេះគឺពិតជាករណីនេះ។

ដើម្បីដោះស្រាយបញ្ហា ខ្ញុំថែមទាំងបានអានទំព័របុរសនៃវេទិកាខ្លួនឯង (:) ហើយវាហាក់បីដូចជាបញ្ហានេះត្រូវបានពិពណ៌នានៅទីនោះ ហើយសូម្បីតែលេខកូដត្រូវបានផ្តល់ឱ្យដែលគួរតែធ្វើឱ្យមនុស្សគ្រប់គ្នាសប្បាយចិត្ត៖

Uint8_t mcusr_mirror __attribute__ ((ផ្នែក (.noinit"))); void get_mcusr(void) __attribute__((អាក្រាត)) __attribute__((section(.init3"))); void get_mcusr(void)( mcusr_mirror = MCUSR; MCUSR = 0; wdt_disable(); )
វាពិពណ៌នាអំពីមុខងារ get_mcusr() ដែលគួរតែត្រូវបានហៅភ្លាមៗបន្ទាប់ពីកំណត់ឡើងវិញ។ នេះត្រូវបានសម្រេចដោយម៉ាក្រូ "__attribute__((ផ្នែក(.init3")))"។ ខ្ញុំបានព្យាយាមសរសេរមុខងារនេះនៅក្នុងផ្នែកទាំងអស់ដែលអាចធ្វើទៅបាន - បាទ វាពិតជាដំណើរការមុនពេលដំណើរការ setup() function ពី sketch ប៉ុន្តែជាអកុសល យឺតជាង 15ms (អប្បបរមា watchdog constant) បន្ទាប់ពី reset...

សរុបមក មិនថាខ្ញុំរុករកអ៊ីនធឺណិតដោយរបៀបណា ដើម្បីស្វែងរកដំណោះស្រាយដ៏ងាយស្រួលចំពោះបញ្ហានោះ គ្មានអ្វីត្រូវបានរកឃើញទេ។ ខ្ញុំបានរកឃើញវិធីតែមួយគត់ដើម្បីអោយ watchdog ធ្វើការ - ដើម្បី reflash bootloader... ដែលជាអ្វីដែលយើងនឹងធ្វើឥឡូវនេះ។

កំពុងពិនិត្យមើលមុខងារឃ្លាំមើល

មុនពេលបញ្ចេញអ្វីមួយ អ្នកត្រូវពិនិត្យមើលថាតើ Arduino របស់អ្នកគាំទ្រឧបករណ៍ឃ្លាំមើលដែរឬទេ។ ដើម្បី​ធ្វើ​ដូច្នេះ ខ្ញុំ​បាន​សរសេរ​គំនូស​ព្រាង​សាកល្បង​តូច។ គ្រាន់តែបង្ហោះវា បើកម៉ូនីទ័រច្រក ហើយមើលអ្វីដែលកើតឡើង។

ការធ្វើតេស្តឃ្លាំមើល

# រួមបញ្ចូល void setup() ( wdt_disable(); // បន្ទាត់គ្មានប្រយោជន៍ដែលការប្រតិបត្តិមិនឈានដល់កំឡុងពេល bootloop Serial.begin(9600); Serial.println("Setup.."); Serial.println("រង់ចាំ 5 វិនាទី..") ពន្យាពេល(5000); // ពន្យាពេល ដើម្បីទុកពេលឱ្យឧបករណ៍ឡើងវិញ ក្នុងករណី bootloop wdt_enable (WDTO_8S); void loop())( // រាល់វិនាទីយើងព្រិចភ្នែក LED ហើយសរសេរតម្លៃរាប់ទៅ Serial if(!(millis()%1000))(timer++; Serial.println(timer); digitalWrite(13, digitalRead(13)) ==1? 0:1);

បន្ទាប់ពីចាប់ផ្តើមឡើងវិញ (ឬភ្ជាប់ម៉ូនីទ័រទៅនឹងច្រក) អំពូល LED ដែលភ្ជាប់មកជាមួយនឹងភ្លឹបភ្លែតៗ ដែលបង្ហាញថាកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធបានចាប់ផ្តើមហើយ។ បន្ទាប់មក នៅក្នុងផ្នែកដំឡើង ឧបករណ៍ឃ្លាំមើលដែលមានកម្មវិធីកំណត់ម៉ោង 8 វិនាទីត្រូវបានបើក។ បន្ទាប់ពីនេះ LED នឹងរាប់ថយក្រោយសម្រាប់យើងហើយការចាប់ផ្តើមឡើងវិញគួរតែកើតឡើង។

បន្ទាប់មកផ្នែកដែលគួរឱ្យចាប់អារម្មណ៍បំផុតចាប់ផ្តើម - ប្រសិនបើការចាប់ផ្តើមឡើងវិញបានកើតឡើងហើយអ្វីគ្រប់យ៉ាងត្រូវបានធ្វើម្តងទៀតនៅក្នុងលំដាប់ដូចគ្នានោះអ្នកមាន Arduino នៅក្នុងដៃរបស់អ្នកដែលកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធដំណើរការកម្មវិធីឃ្លាំមើលយ៉ាងត្រឹមត្រូវ។ ប្រសិនបើបន្ទាប់ពីការចាប់ផ្ដើមឡើងវិញ LED នៅលើ pin 13 ចាប់ផ្តើមភ្លឹបភ្លែតៗ នោះកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធមិនគាំទ្រការឃ្លាំមើលទេ។ សូម្បីតែប៊ូតុងកំណត់ឡើងវិញក៏មិនអាចជួយនៅទីនេះដែរ។ សម្រាប់កម្មវិធីបង្កប់ជាបន្តបន្ទាប់ អ្នកត្រូវផ្តាច់បន្ទះចេញពីការផ្គត់ផ្គង់ថាមពល ហើយបន្ទាប់ពីបើកវា អ្នកត្រូវមានពេលបញ្ចេញពន្លឺមុនពេលចាប់ផ្តើមឡើងវិញលើកដំបូង។

ខ្ញុំបានសាកល្បងប្រភេទក្តារចំនួន 4 ហើយមានតែកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធនៅក្នុង Arduino Uno ប៉ុណ្ណោះដែលដំណើរការដូចដែលវាគួរតែ៖

លទ្ធផលនៅលើម៉ូនីទ័រ

Watchdog មិនត្រូវបានគាំទ្រដោយកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធទេ៖

Watchdog ត្រូវបានគាំទ្រដោយកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធ៖

តើអ្វីជាវិធីងាយស្រួលបំផុតដើម្បីបញ្ចេញកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធថ្មី?

អ្នកអាចបញ្ចេញកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធនៅក្នុង Arduino ដោយប្រើអ្នកសរសេរកម្មវិធីដាច់ដោយឡែក ឬអ្នកអាចបង្កើតកម្មវិធីសរសេរកម្មវិធីផ្ទាល់ខ្លួនរបស់អ្នកដោយប្រើ Arduino ដូចគ្នា។ ទាំងនោះ។ ថ្លៃសេវាណាមួយ។ Arduino អាច​ត្រូវ​បាន​ប្រែ​ក្លាយ​ទៅ​ជា​អ្នក​សរសេរ​កម្មវិធី​ដោយ​ផ្ទុក​ឡើង​នូវ​គំនូរព្រាង​ពិសេស​នៅ​ទីនោះ។

នៅក្នុងអត្ថបទនេះ ខ្ញុំនឹងមិនរៀបរាប់ពីភាពស្មុគ្រស្មាញទាំងអស់នៃការបង្កើតកម្មវិធី Arduino ដែលមានមូលដ្ឋានលើ... ប្រធានបទនេះគឺពិតជា។ ខ្ញុំបានប្រើ Arduino Uno ជាអ្នកសរសេរកម្មវិធី។ ដូចដែលអ្នកបានដឹងហើយថាកម្មវិធីបង្កប់ត្រូវបានបញ្ចេញតាមរយៈឧបករណ៍ភ្ជាប់ ICSP ដាច់ដោយឡែកដែលត្រូវបានរកឃើញនៅលើក្តារស្ទើរតែទាំងអស់។ ក្នុងករណីកម្មវិធីបង្កប់ Arduino Pro Mini ដែលមិនមាន ICSP ការតភ្ជាប់ត្រូវបានធ្វើឡើងដោយផ្ទាល់ទៅម្ជុល។

ការតភ្ជាប់សម្រាប់កម្មវិធីចាប់ផ្ដើមកម្មវិធីបង្កប់

តើខ្ញុំអាចទទួលបានកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធដែលគាំទ្រអ្នកឃ្លាំមើលនៅឯណា?

ជំពូកនេះនឹកឃើញដល់ការរាំជាមួយរបាំត្រុដិ ហើយភាគច្រើនទំនងជាអ្វីៗទាំងអស់អាចត្រូវបានធ្វើឱ្យសាមញ្ញជាងនេះ ប៉ុន្តែអាឡា ខ្ញុំមិនអាចធ្វើវាតាមវិធីផ្សេងបានទេ។

វាត្រូវបានណែនាំឱ្យប្រើកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធពីកញ្ចប់ optiboot ។ ជាគោលការណ៍ កម្មវិធីចាប់ផ្ដើមប្រព័ន្ធទាំងនេះត្រូវបានរួមបញ្ចូលក្នុងការដំឡើងវេទិកា Arduino ដោយខ្លួនឯង ប៉ុន្តែវាជាការប្រសើរក្នុងការទាញយក និងដំឡើងកំណែចុងក្រោយបំផុតរបស់ optiboot ពីទីនេះ។ ការដំឡើងមានពីរជំហាន (ប្រហែលជានេះអាចត្រូវបានធ្វើខុសគ្នា)៖

1. ថតឯកសារ bootloaders\optiboot ត្រូវបានសរសេរឡើងវិញទៅ C:\Program Files (x86)\Arduino\hardware\arduino\avr\bootloaders\optiboot
2. ឯកសារ boards.txt ត្រូវបានបន្ថែមទៅឯកសារ C:\Program Files (x86)\Arduino\hardware\arduino\avr\boards.txt

ជាធម្មតា ថតដំឡើងវេទិកា Arduino របស់អ្នកអាចខុសគ្នា។

បន្ទាប់មក បរិយាកាសអភិវឌ្ឍន៍ត្រូវបានផ្ទុកឡើងវិញ ហើយនៅក្នុងម៉ឺនុយសេវាកម្ម/ក្តារ អ្នកអាចឃើញបន្ទះថ្មីត្រូវបានសម្គាល់។ ជាអកុសល នៅពេលជ្រើសរើសក្តារទាំងនេះ កំហុសក្នុងការចងក្រងចម្លែកមួយចំនួនកើតឡើង ហើយភាពចម្លែកផ្សេងទៀតលេចឡើង... ដូច្នេះយើងធ្វើឱ្យវាកាន់តែសាមញ្ញ។ បើកឯកសារ C:\Program Files (x86)\Arduino\hardware\arduino\avr\boards.txt ក្នុងកម្មវិធីនិពន្ធអត្ថបទណាមួយ ហើយប្តូរបន្ទាត់ខាងក្រោម៖

សម្រាប់ Arduino Nano៖
menu.cpu.nano.atmega328.bootloader.file=optiboot/optiboot_atmega328.hex

សម្រាប់ Arduino Mini៖
menu.cpu.mini.atmega328.bootloader.file=optiboot/optiboot_atmega328.hex

បញ្ហាបន្ទាប់គឺថា optiboot bootloader សម្រាប់ Arduino Mega board មិនមាននៅក្នុងធម្មជាតិទេព្រោះ ... មេហ្គាមានអង្គចងចាំច្រើន ហើយប្រើពិធីការផ្សេង។ ដូច្នេះ យើងប្រើកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធស្តង់ដារ ប៉ុន្តែបានកែប្រែ ដែលយើងទាញយកពីទីនេះ។ ប្តូរឈ្មោះឯកសារទៅជា stk500boot_v2_mega2560_2.hex ហើយសរសេរវាទៅថត C:\Program Files (x86)\Arduino\hardware\arduino\avr\bootloaders\stk500v2.

កុំបារម្ភថាឯកសារកម្មវិធីបង្កប់ដែលបានកែប្រែសម្រាប់ Mega គឺតូចជាងស្តង់ដារ 2 ដង - នេះហាក់ដូចជាករណីនេះ។

ដំណើរការកម្មវិធីបង្កប់

បន្ទាប់ពីការផ្លាស់ប្តូរទាំងអស់ អ្នកអាចបញ្ចេញកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធដោយជ្រើសរើសក្ដារធម្មតានៅក្នុងម៉ឺនុយក្តារ (មិនមែន !)។ ក្នុងករណីនេះ ឯកសារគោលដប់ប្រាំមួយ ដែលយើងបានបញ្ជាក់នៅក្នុងឯកសារ board.txt នឹងត្រូវបានបញ្ចេញ។
ដំណើរការកម្មវិធីបង្កប់ប្រហែលជាមិនចាប់ផ្តើមទេ ហើយកំហុសអាចលេចឡើង៖
ដើម្បីដោះស្រាយបញ្ហានេះ សូមបើកផ្ទាំងគំនូរអ្នកសរសេរកម្មវិធី ហើយនៅក្នុងផ្នែកដំឡើង សូមជ្រើសរើសល្បឿនច្រកសៀរៀលផ្សេង។
នៅពេលផ្ទុកឡើងទៅកាន់ Arduino Mega កំហុសអាចលេចឡើងដែលគួរត្រូវបានមិនអើពើ៖
avrdude៖ កំហុសក្នុងការផ្ទៀងផ្ទាត់ ភាពមិនស៊ីគ្នាដំបូងនៅបៃ 0x3e000 0x0d != 0xff avrdude: កំហុសផ្ទៀងផ្ទាត់; មាតិកាមិនស៊ីគ្នា។

ឧបាយកលចុងក្រោយ

ឧបករណ៍ផ្ទុក optiboot មានលក្ខណៈពិសេសមួយទៀត - ពួកគេបង្កើនល្បឿននៃការផ្ទុកគំនូរព្រាង ដូច្នេះនៅពេលប្រើក្តារជាមួយ optiboot អ្នកត្រូវធ្វើការផ្លាស់ប្តូរសមស្របទៅ boards.txt៖

សម្រាប់ Arduino Nano៖
menu.cpu.nano.atmega328.upload.speed=115200
សម្រាប់ Arduino Mini៖
menu.cpu.mini.atmega328.upload.speed=115200

វាជាការល្អប្រសើរជាងមុនក្នុងការចងចាំល្បឿនច្រកពីមុនផងដែរព្រោះ ... វានឹងត្រូវប្រើនៅលើក្តារដែលមានកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធស្តង់ដារ។ ប្រសិនបើការផ្លាស់ប្តូរបែបនេះមិនត្រូវបានធ្វើឡើងទេ នោះដំណើរការនៃការផ្ទុកឡើងគំនូសព្រាងនឹងបង្កើតកំហុសដូចនេះ៖
avrdude៖ stk500_getsync()៖ មិនសមកាលកម្ម៖ resp=0x00

តំណភ្ជាប់, អក្សរសិល្ប៍

កញ្ចប់ optiboot
កម្មវិធីចាប់ផ្ដើមកម្មវិធីបង្កប់
របៀបបញ្ចេញកម្មវិធីចាប់ផ្ដើមប្រព័ន្ធក្នុង Arduino Pro Mini

ស្លាក:

• អាឌូណូ
• អ្នកឃ្លាំមើល

បន្ថែមស្លាក