chore(i18n): sync translations with latest source changes (chunk 3/3, 25 changes)

pull/577/head
localizeflow[bot] 5 months ago
parent 81aaaeffae
commit 07a743f587

@ -0,0 +1,81 @@
# អត្ថបទ​ទៅ​សំឡេង - ឧបករណ៍ IoT ខាងវីឌ្យូ
ក្នុង​ផ្នែក​នេះ​នៃមេរៀន អ្នក​នឹង​សរសេរកូដ​ដំណើរការ​បម្លែង​អត្ថបទ​ទៅ​សំឡេង ដោយ​ប្រើ​សេវាកម្ម​សំឡេង។
## បម្លែង​អត្ថបទ​ទៅ​សំឡេង
SDK សេវាកម្ម​សំឡេង​ដែល​អ្នក​បាន​ប្រើ​ក្នុង​មេរៀន​មុន​ដើម្បី​បម្លែង​សំឡេង​ទៅអត្ថបទ អាច​ប្រើ​ដើម្បី​បម្លែង​អត្ថបទ​ត្រឡប់វិញ​ទៅ​សំឡេង។ នៅពេល​ស្នើសុំ​សំឡេង អ្នក​ត្រូវ​ផ្តល់​អង្គធាតុ​សំឡេង​ដើម្បី​ប្រើ ព្រោះ​សំឡេង​អាច​ត្រូវបាន​បង្កើត​ដោយប្រើ​អង្គធាតុ​សំឡេង​ផ្សេងៗ​ជា​ច្រើន​។
រៀងរាល់​ភាសា​គាំទ្រ​អង្គធាតុ​សំឡេង​ផ្សេងៗ ហើយ​អ្នក​អាច​ទទួលបាន​បញ្ជី​អង្គធាតុ​សំឡេង​ដែល​គាំទ្រ​សម្រាប់ភាសារ​នីមួយៗ​ពី SDK សេវាកម្ម​សំឡេង។
### ភារកិច្ច - បម្លែង​អត្ថបទ​ទៅ​សំឡេង
1. បើក​គម្រោង `smart-timer` នៅ​ក្នុង VS Code ហើយប្រាកដថាបរិយាកាសយន្ត_virtual បាន​ផ្ទុក​នៅ​ក្នុង​ទ терминال។
1. អនុញ្ញាត​ឲ្យ​អ្នកអញ្ញាតាំន `SpeechSynthesizer` ពី​បណ្ដុំ​ម៉ូឌុល `azure.cognitiveservices.speech` ដោយ​បូក​បញ្ចូល​វា​ក្នុង​ការ​នាំ​ចូល​ដែល​មាន​រួច​ហើយ៖
```python
from azure.cognitiveservices.speech import SpeechConfig, SpeechRecognizer, SpeechSynthesizer
```
1. ខាង​លើ​មុខងារ `say` សូម​បង្កើត​ការកំណត់​សំឡេង​សម្រាប់​ប្រើ​ជាមួយ speech synthesizer៖
```python
speech_config = SpeechConfig(subscription=speech_api_key,
region=location)
speech_config.speech_synthesis_language = language
speech_synthesizer = SpeechSynthesizer(speech_config=speech_config)
```
នេះ​ប្រើកន្លែង API key, ទីតាំង និងភាសា​ដដែល​ដែល​បាន​ប្រើ​ដោយ recognizer ។
1. ខាង​ក្រោម​នេះ បន្ថែម​កូដ​ខាង​ក្រោម​ដើម្បី​ទទួល​អង្គធាតុ​សំឡេង​មួយ ហើយ​កំណត់​វា​លើ​ការកំណត់​សំឡេង៖
```python
voices = speech_synthesizer.get_voices_async().get().voices
first_voice = next(x for x in voices if x.locale.lower() == language.lower())
speech_config.speech_synthesis_voice_name = first_voice.short_name
```
វា​យក​បញ្ជី​អង្គធាតុ​សំឡេង​ទាំងអស់​ដែលអាចប្រើបាន ហើយ​រក​អង្គធាតុ​សំឡេង​ដំបូង​ដែល​ផ្គូផ្គង​ជាមួយ​ភាសា​ដែល​កំពុង​ប្រើ។
> 💁 អ្នក​អាច​ទាញ​យក​បញ្ជី​ពេញលេញ​នៃ​អង្គធាតុ​សំឡេង​ដែល​គាំទ្រ​បាន​ពី [ឯកសារ Language and voice support documentation on Microsoft Docs](https://docs.microsoft.com/azure/cognitive-services/speech-service/language-support?WT.mc_id=academic-17441-jabenn#text-to-speech)។ ប្រសិនបើ​ចង់​ប្រើ​អង្គធាតុ​សំឡេង​ពិសេស​មួយ អ្នក​អាច​ដក​រាល់​មុខងារ​នេះចេញ ហើយ​កំណត់​អង្គធាតុ​សំឡេង​ដោយ​ដៃ​ដោយ​ប្រើ​ឈ្មោះ​សំឡេង​ពីឯកសារ​នេះ។ ឧទាហរណ៍៖
>
> ```python
> speech_config.speech_synthesis_voice_name = 'hi-IN-SwaraNeural'
> ```
1. បន្ទាប់​មក​វាយបញ្ជូល​មាតិកា​នៃ​មុខងារ `say` ដើម្បី​បង្កើត SSML សម្រាប់​តបតទៅ៖
```python
ssml = f'<speak version=\'1.0\' xml:lang=\'{language}\'>'
ssml += f'<voice xml:lang=\'{language}\' name=\'{first_voice.short_name}\'>'
ssml += text
ssml += '</voice>'
ssml += '</speak>'
```
1. ខាង​ក្រោម​នេះ ពង្រឹង​ការទទួល​សំឡេង​ឲ្យ​ឈប់ ពោល​សំឡេង SSML ទើប​ចាប់ផ្ដើម​ការ​ទទួល​សំឡេង​ម្ដង​ទៀត៖
```python
recognizer.stop_continuous_recognition()
speech_synthesizer.speak_ssml(ssml)
recognizer.start_continuous_recognition()
```
ការទទួល​សំឡេង​ត្រូវ​បាន​ឈប់នៅពេល​ដែល​អត្ថបទ​ត្រូវ​បកប្ដូរ​ទៅ​សំឡេង ដើម្បី​ឱ្យ​ការប្រកាស​ថា​ឧបករណ៍​កំណត់​ពេល​វេលា​បាន​ចាប់ផ្ដើម មិន​ត្រូវ​បាន​គេ​ឮ​ឃើញ សំឡេង​ដែល​ផ្ញើ​ទៅ LUIS ហើយ​អាច​ត្រូវ​បាន​បកស្រាយ​ថា​គឺជា​សំណើ​ឱ្យ​កំណត់​ឧបករណ៍​ពេល​វេលា​ថ្មី។
> 💁 អ្នក​អាច​សាកល្បង​នេះ​ដោយ​ការ​សរសេរ​ជាកំណត់ ឬ ការដក​បន្ទាត់​ដែល​ឈប់ និង​ចាប់ផ្ដើម​ការ​ទទួល​សំឡេង​ម្ដងទៀត។ កំណត់​ឧបករណ៍​ពេល​វេលា​មួយ ហើយ​អ្នក​អាច​សង្កេត​ឃើញ​ការ​ប្រកាស​កំណត់​ឧបករណ៍​ពេល​វេលា​ថ្មី ដែល​នាំ​រួច​ទៅ​ការ​ប្រកាស​ថ្មី​នាំឲ្យ​មាន​ការកំណត់​ឧបករណ៍​ពេល​វេលា​ថ្មី ហើយបន្ត​តទៅបន្ត​មក​ជានិច្ច!
1. ដំណើរការ​កម្មវិធី ហើយ​ប្រាកដ​ថា​មុខងារ app កំពុង​ដំណើរការ​ផងដែរ។ កំណត់​ឧបករណ៍​ពេល​វេលា​មួយ​ចំនួន ហើយ​អ្នក​នឹង​ស្តាប់​ការ​ទទួល​សំឡេង​ថា​ការកំណត់​ឧបករណ៍​ពេល​វេលា​របស់​អ្នក​ត្រូវ​បាន​ដំណើរការ រួច​ក៏​មាន​ការ​ទទួល​សំឡេង​ម្តង​ទៀត​ពេល​ឧបករណ៍​ពេល​វេលា​ដំណើរការសម្រេច។
> 💁 អ្នក​អាច​រកឃើញ​កូដ​នេះ​នៅក្នុងថត [code-spoken-response/virtual-iot-device](../../../../../6-consumer/lessons/3-spoken-feedback/code-spoken-response/virtual-iot-device)។
😀 កម្មវិធី​កំណត់​ពេល​វេលា​របស់​អ្នក​បាន​ជោគជ័យ!
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារនេះត្រូវបានប្រែសម្រួលដោយប្រព័ន្ធបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ បើទោះបីយើងខិតខំប្រឹងប្រែងក្នុងការជាក់លាក់ ក៏សូមយកចិត្តទុកដាក់ថា ការបកប្រែដោយស្វ័យប្រវត្តិនេះអាចមានកំហុសឬច្រឡំ។ ឯកសារដើមក្នុងភាសាទីតាំងរបស់វាគួរត្រូវបានចាត់ទុកជាវិទ្យាសាស្ត្រដែលមានអានុភាព។ សម្រាប់ព័ត៌មានមានសារៈសំខាន់ ការប្រែសម្រួលដោយអ្នកជំនាញមនុស្សគឺផ្តល់អនុសាសន៍។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសត្រូវណាមួយដែលកើតមានពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,294 @@
# កំណត់ម៉ោងតុល្យ - Wio Terminal
នៅក្នុងផ្នែកនេះនៃមេរៀន អ្នកនឹងហៅកូដមិនមានម៉ាស៊ីនម៉ាស៊ីនរបស់អ្នកដើម្បីយល់អំពីសំឡេង និងកំណត់ម៉ោងតុល្យលើ Wio Terminal របស់អ្នកដោយផ្អែកលើលទ្ធផល។
## កំនត់ម៉ោងតុល្យ
អត្ថបទដែលត្រូវត្រឡប់មកពីការហៅសំឡេងទៅអត្ថបទត្រូវត្រូវផ្ញើទៅកូដមិនមានម៉ាស៊ីនម៉ាស៊ីនរបស់អ្នកសម្រាប់ដំណើរការ LUIS ដើម្បីទទួលបានចំនួនវិនាទីសម្រាប់ម៉ោងតុល្យ។ ចំនួនវិនាទីនេះអាចប្រើសម្រាប់កំណត់ម៉ោងតុល្យ។
Microcontrollers មិនមានការគាំទ្រដើម្បីមានព័ត៍មានច្រើននៃ​​ threads ក្នុង Arduino ដោយដើមទេ ដូច្នេះគ្មានថ្នាក់ម៉ោងតុល្យស្តង់ដារដូចដែលអ្នកអាចជួបនៅពេលបង្កើតកម្មវិធីនៅ Python ឬភាសាដទៃទៀតដែលមានកម្រិតខ្ពស់។ ជំនួសចំណុចនេះ អ្នកអាចប្រើបណ្ណាល័យម៉ោងតុល្យដែលធ្វើការដោយវាស់ពេលដែលបានកន្លងផុតក្នុងមុខងារ `loop` ហើយហៅមុខងារមានពេលវេលាបញ្ចប់។
### កិច្ចការជូន - ផ្ញើអត្ថបទទៅមុខងារមិនមានម៉ាស៊ីនម៉ាស៊ីន
1. បើកគម្រោង `smart-timer` ក្នុង VS Code ប្រសិនបើវាមិនទាន់បើក។
1. បើកឯកសារ header `config.h` ហើយបន្ថែម URL សម្រាប់កម្មវិធីមុខងាររបស់អ្នក៖
```cpp
const char *TEXT_TO_TIMER_FUNCTION_URL = "<URL>";
```
ជំនួស `<URL>` ជាមួយ URL របស់កម្មវិធីមុខងារដែលអ្នកបានទទួលនៅជំហានចុងក្រោយនៃមេរៀនចុងក្រោយ ដែលបញ្ជាក់ទៅកាន់អាសយដ្ឋាន IP របស់ម៉ាស៊ីនក្នុងតំបន់ដែលកំពុងរត់មុខងារនោះ។
1. បង្កើតឯកសារថ្មីមួយក្នុងថត `src` មានឈ្មោះ `language_understanding.h`។ នេះនឹងត្រូវបានប្រើសម្រាប់កំណត់ថ្នាក់មួយដើម្បីផ្ញើសំឡេងដែលត្រូវបានស្គាល់ទៅកម្មវិធីមុខងារ រួចបម្លែងទៅវិនាទីដោយការប្រើប្រាស់ LUIS។
1. បន្ថែមខាងក្រោមនេះនៅលើសំពាធនៃឯកសារនេះ៖
```cpp
#pragma once
#include <Arduino.h>
#include <ArduinoJson.h>
#include <HTTPClient.h>
#include <WiFiClient.h>
#include "config.h"
```
នេះរួមបញ្ចូលឯកសារមេដឹកនាំមួយចំនួនដែលត្រូវការ។
1. កំណត់ថ្នាក់មួយដែលមានឈ្មោះ `LanguageUnderstanding` ហើយប្រកាសមេរៀនម៉ាស៊ីនមួយរបស់ថ្នាក់នេះ៖
```cpp
class LanguageUnderstanding
{
public:
private:
};
LanguageUnderstanding languageUnderstanding;
```
1. ដើម្បីហៅមុខងាររបស់អ្នក អ្នកត្រូវចាត់ថ្នាក់ WiFi client។ បន្ថែមខាងក្រោមទំហំ `private` នៃថ្នាក់៖
```cpp
WiFiClient _client;
```
1. នៅក្នុងផ្នែក `public` ប្រកាសមុខងារ​មួយដែលមានឈ្មោះ `GetTimerDuration` ដើម្បីហៅមុខងារនេះ៖
```cpp
int GetTimerDuration(String text)
{
}
```
1. នៅក្នុងមុខងារ `GetTimerDuration` បន្ថែមកូដខាងក្រោមដើម្បីបង្កើត JSON ដែលត្រូវផ្ញើទៅមុខងារ៖
```cpp
DynamicJsonDocument doc(1024);
doc["text"] = text;
String body;
serializeJson(doc, body);
```
នេះបម្លែងអត្ថបទដែលផ្ញើទៅមុខងារ `GetTimerDuration` ទៅជា JSON ដូចខាងក្រោម៖
```json
{
"text" : "<text>"
}
```
ដែល `<text>` គឺជាអត្ថបទដែលផ្ញើទៅមុខងារ។
1. ខាងក្រោមនេះ បន្ថែមកូដខាងក្រោមដើម្បីអនុវត្តការហៅកូនហ្វុងខ្នាត់មុខងារ៖
```cpp
HTTPClient httpClient;
httpClient.begin(_client, TEXT_TO_TIMER_FUNCTION_URL);
int httpResponseCode = httpClient.POST(body);
```
នេះបង្កើតការស្នើសុំ POST ទៅមុខងារ ដោយផ្ញើ JSON body ហើយទទួលស្តាតកូដតបសំរាប់។
1. បន្ថែមកូដខាងក្រោមនេះនៅក្រោម៖
```cpp
int seconds = 0;
if (httpResponseCode == 200)
{
String result = httpClient.getString();
Serial.println(result);
DynamicJsonDocument doc(1024);
deserializeJson(doc, result.c_str());
JsonObject obj = doc.as<JsonObject>();
seconds = obj["seconds"].as<int>();
}
else
{
Serial.print("Failed to understand text - error ");
Serial.println(httpResponseCode);
}
```
កូដនេះពិនិត្យស្ថានភាពតប។ ប្រសិនបើវាជា 200 (ជោគជ័យ) នោះចំនួនវិនាទីសម្រាប់ម៉ោងតុល្យត្រូវបានទាញពីខ្លឹមសារតបស្រាប់។ បើមិនដូច្នោះទេ កំហុសត្រូវបានបញ្ជូនទៅម៉ូនីទ័រតាម Serial ហើយចំនួនវិនាទីត្រូវបានកំណត់ជា 0។
1. បន្ថែមកូដខាងក្រោមនៅចុងមុខងារ​នេះដើម្បីបិទការតភ្ជាប់ HTTP ហើយបង្វិលតម្លៃចំនួនវិនាទី៖
```cpp
httpClient.end();
return seconds;
```
1. នៅឯកសារ `main.cpp` បញ្ចូល header ថ្មីនេះ៖
```cpp
#include "speech_to_text.h"
```
1. នៅចុងមុខងារ `processAudio` ហៅមុខងារ `GetTimerDuration` ដើម្បីទទួលបានរយៈពេលម៉ោងតុល្យ៖
```cpp
int total_seconds = languageUnderstanding.GetTimerDuration(text);
```
នេះបម្លែងអត្ថបទពីការហៅទៅថ្នាក់ `SpeechToText` ទៅជាចំនួនវិនាទីសម្រាប់ម៉ោងតុល្យ។
### កិច្ចការជូន - កំណត់ម៉ោងតុល្យ
ចំនួនវិនាទីអាចប្រើសម្រាប់កំណត់ម៉ោងតុល្យ។
1. បន្ថែមការគាំទ្របណ្ណាល័យខាងក្រោមទៅឯកសារ `platformio.ini` ដើម្បីបញ្ចូលបណ្ណាល័យសម្រាប់កំណត់ម៉ោងតុល្យ៖
```ini
contrem/arduino-timer @ 2.3.0
```
1. បន្ថែមបញ្ជាដើម្បីរួមបញ្ចូលបណ្ណាល័យនេះក្នុងឯកសារ `main.cpp`
```cpp
#include <arduino-timer.h>
```
1. ខាងលើមុខងារ `processAudio` បញ្ចូលកូដខាងក្រោម៖
```cpp
auto timer = timer_create_default();
```
កូដនេះបានប្រកាសម៉ោងតុល្យមួយដែលមានឈ្មោះ `timer`
1. ខាងក្រោមនេះ បន្ថែមកូដខាងក្រោម៖
```cpp
void say(String text)
{
Serial.print("Saying ");
Serial.println(text);
}
```
មុខងារ `say` នេះនឹងបម្លែងអត្ថបទទៅសំឡេងនៅពេលក្រោយ ប៉ុន្តែក្នុងពេលនេះ វានឹងសរសេរអត្ថបទដែលបានផ្ញើទៅម៉ូនីទ័រតាម Serial។
1. ខាងក្រោមមុខងារ `say`, បន្ថែមកូដខាងក្រោម៖
```cpp
bool timerExpired(void *announcement)
{
say((char *)announcement);
return false;
}
```
នេះជាមុខងារត្រឡប់ហៅរវល់នេះដែលនឹងត្រូវហៅពេលម៉ោងតុល្យផុតកំណត់។ វាត្រូវបានផ្ញើសារ​ដែលត្រូវនិយាយពេលម៉ោងតុល្យផុតកំណត់។ ម៉ោងតុល្យអាចធ្វើម្តងទៀត ហើយអាចគ្រប់គ្រងដោយតម្លៃត្រឡប់មុខងារនេះ - វាត្រឡប់ `false` ដើម្បីប្រាប់ម៉ោងតុល្យមិនត្រូវរត់ម្ដងទៀត។
1. បន្ថែមកូដខាងក្រោមនៅចុងមុខងារ `processAudio`
```cpp
if (total_seconds == 0)
{
return;
}
int minutes = total_seconds / 60;
int seconds = total_seconds % 60;
```
កូដនេះពិនិត្យចំនួនវិនាទីសរុប បើវាជា 0 វានឹងត្រលប់ពីមុខងារដើម្បីមិនកំណត់ម៉ោងតុល្យ។ បន្ទាប់មកវាបម្លែងចំនួនវិនាទីសរុបទៅជាទីនាទី និងវិនាទី។
1. ខាងក្រោមកូដនេះ បន្ថែមកូដដូចខាងក្រោមដើម្បីបង្កើតសារ​និយាយពេលម៉ោងតុល្យចាប់ផ្តើម៖
```cpp
String begin_message;
if (minutes > 0)
{
begin_message += minutes;
begin_message += " minute ";
}
if (seconds > 0)
{
begin_message += seconds;
begin_message += " second ";
}
begin_message += "timer started.";
```
1. ខាងក្រោមនេះ បន្ថែមកូដស្រដៀងគ្នាដើម្បីបង្កើតសារនិយាយពេលម៉ោងតុល្យផុតកំណត់៖
```cpp
String end_message("Times up on your ");
if (minutes > 0)
{
end_message += minutes;
end_message += " minute ";
}
if (seconds > 0)
{
end_message += seconds;
end_message += " second ";
}
end_message += "timer.";
```
1. បន្ទាប់ពីនេះ និយាយសារ​ចាប់ផ្តើមម៉ោងតុល្យ៖
```cpp
say(begin_message);
```
1. នៅចុងមុខងារនេះ ចាប់ផ្តើមម៉ោងតុល្យ៖
```cpp
timer.in(total_seconds * 1000, timerExpired, (void *)(end_message.c_str()));
```
នេះបង្ហួតម៉ោងតុល្យ។ ម៉ោងតុល្យត្រូវបានកំណត់ជាមิล្លីវិនាទី ដូច្នេះចំនួនវិនាទីសរុបត្រូវគុណ 1,000 ដើម្បីបម្លែងទៅមิล្លីវិនាទី។ មុខងារ `timerExpired` ត្រូវបានផ្ញើជា callback ហើយ `end_message` ត្រូវបានផ្ញើជាប៉ារ៉ាម៉ែត្រដើម្បីផ្ញើទៅ callback។ Callback នេះគ្រាន់តែទទួលតែអាគុយម៉ង់ `void *` ដូច្នេះខ្សែអក្សរត្រូវបានបម្លែងតាមតម្រូវការ។
1. ចុងក្រោយ ម៉ោងតុល្យត្រូវតែ *tick* ហើយវាត្រូវបានអនុវត្តនៅក្នុងមុខងារ `loop`។ បន្ថែមកូដខាងក្រោមនៅចុងមុខងារ `loop`
```cpp
timer.tick();
```
1. សាងសង់កូដនេះ អាប់ឡូដទៅ Wio Terminal របស់អ្នក និងសាកល្បងតាមម៉ូនីទ័រតាម Serial។ នៅពេលឃើញ `Ready` នៅម៉ូនីទ័រតាម Serial ចុចប៊ូតុង C (នៅជាន់ខាងឆ្វេង បិតជិតស៊្វេចបើកបុង) ហើយនិយាយ។ សំឡេង ៤ វិនាទីនឹងត្រូវបានចាប់យក បម្លែងទៅអត្ថបទ ហើយផ្ញើទៅកម្មវិធីមុខងាររបស់អ្នក ហើយម៉ោងតុល្យនឹងត្រូវរៀបចំ។ សូមប្រាកដថាកម្មវិធីមុខងាររបស់អ្នកកំពុងរត់ក្នុងតំបន់។
អ្នកនឹងឃើញពេលម៉ោងតុល្យចាប់ផ្តើម និងពេលវាចប់។
```output
--- Available filters and text transformations: colorize, debug, default, direct, hexlify, log2file, nocontrol, printable, send_on_enter, time
--- More details at http://bit.ly/pio-monitor-filters
--- Miniterm on /dev/cu.usbmodem1101 9600,8,N,1 ---
--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
Connecting to WiFi..
Connected!
Got access token.
Ready.
Starting recording...
Finished recording
Sending speech...
Speech sent!
{"RecognitionStatus":"Success","DisplayText":"Set a 2 minute and 27 second timer.","Offset":4700000,"Duration":35300000}
Set a 2 minute and 27 second timer.
{"seconds": 147}
2 minute 27 second timer started.
Times up on your 2 minute 27 second timer.
```
> 💁 អ្នកអាចស្វែងរកកូដនេះនៅក្នុងថត [code-timer/wio-terminal](../../../../../6-consumer/lessons/3-spoken-feedback/code-timer/wio-terminal) ។
😀 កម្មវិធីម៉ោងតុល្យរបស់អ្នកបានជោគជ័យ!
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ទោះយើងខ្ញុំមានការខិតខំសម្រាប់ភាពត្រឹមត្រូវ​ សូមជ្រាបថា ការបកប្រែដោយដំណើរការស្វ័យប្រវត្តិប៉ុន្មានអាចមានកំហុស ឬ ភាពមិនត្រឹមត្រូវខ្លះៗ។ ឯកសារដើមជាភាសាដើមគួរត្រូវបានគិតថាជាទិន្នន័យផ្លូវការដោយសុពលភាព។ សម្រាប់ព័ត៌មានសំខាន់ៗ ការបកប្រែដោយមនុស្សជំនាញត្រូវបានណែនាំ។ យើងខ្ញុំមិនទទួលភារកិច្ចចំពោះការយល់ច្រឡំ ឬ ការបកប្រែខុសពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,528 @@
# អត្ថបទទៅសំឡេង - Wio Terminal
នៅផ្នែកនេះនៃមេរៀន អ្នកនឹងបម្លែងអត្ថបទទៅសំឡេង ដើម្បីផ្តល់ព័ត៌មានត្រឡប់ជាពាក្យនិយាយ។
## អត្ថបទទៅសំឡេង
SDK សេវាសំឡេងដែលអ្នកបានប្រើនៅមេរៀនមុន ដើម្បីបម្លែងសំឡេងទៅអត្ថបទ អាចប្រើបានដើម្បីបម្លែងអត្ថបទទៅសំឡេងវិញ។
## ទទួលបានបញ្ជីសំឡេង
នៅពេលស្នើសុំសំឡេង អ្នកត្រូវផ្តល់សំឡេងដែលត្រូវប្រើ ដោយសំឡេងអាចត្រូវបង្កើតដោយប្រើសំឡេងផ្សេងៗគ្នាជាច្រើន។ ភាសាក្នុងមួយក្នុងសមស្សម៍គាំទ្រសំឡេងផ្សេងៗនានា ហើយអ្នកអាចទទួលបានបញ្ជីសំឡេងដែលគាំទ្រសម្រាប់ភាសាទាំងនោះពី SDK សេវាសំឡេង។ ការដាក់បញ្ចូលរបស់មីក្រូកុងតូឡឺរ មានកំណត់នៅទីនេះ - ការ អូសបញ្ជីសំឡេងដែលគាំទ្រដោយសេវាអត្ថបទទៅសំឡេងគឺជា​ឯកសារ JSON ដែលមានទំហំលើស ៧៧KB ដែលធំពេកសម្រាប់ Wio Terminal ដំណើរការ។ នៅពេលសរសេរ បញ្ជីពេញរួមមានសំឡេង ២១៥ នាក់ មួយៗត្រូវបានកំណត់ដោយឯកសារ JSON ដូចខាងក្រោម៖
```json
{
"Name": "Microsoft Server Speech Text to Speech Voice (en-US, AriaNeural)",
"DisplayName": "Aria",
"LocalName": "Aria",
"ShortName": "en-US-AriaNeural",
"Gender": "Female",
"Locale": "en-US",
"StyleList": [
"chat",
"customerservice",
"narration-professional",
"newscast-casual",
"newscast-formal",
"cheerful",
"empathetic"
],
"SampleRateHertz": "24000",
"VoiceType": "Neural",
"Status": "GA"
}
```
JSON នេះសម្រាប់សំឡេង **Aria** ដែលមានរចនាប័ទ្មសំឡេងច្រើន។ អ្វីដែលត្រូវការនៅពេលបម្លែងអត្ថបទទៅសំឡេងគឺហៅជា shortname, `en-US-AriaNeural`
ជំនួសការទាញយកនិងដកលេខចេញពីបញ្ជីនេះទាំងមូលនៅលើមីក្រូកុងតូឡឺរ របស់អ្នក អ្នកត្រូវតែសរសេរកូដ serverless បន្ថែម មួយកូដ ដើម្បីទាញបញ្ជីសំឡេងសម្រាប់ភាសាដែលអ្នកប្រើ ហើយហៅវាពី Wio Terminal របស់អ្នក។ កូដរបស់អ្នកអាចបញ្ជ្រើសសំឡេងដែលសមរម្យពីបញ្ជី ដូចជាសំឡេងដំបូងដែលវាចាប់បាន។
### កិច្ចការ - បង្កើតក័ណកម្មមិនមានម៉ាស៊ីនមេដើម្បីទទួលបញ្ជីសំឡេង
1. បើកគម្រោង `smart-timer-trigger` របស់អ្នកក្នុង VS Code ហើយបើក terminal ដើម្បីប្រាកដថាវបើកបរិយាកាសវីរិយៈ។ ប្រសិនបើគ្មាន សូមបិទហើយបើក terminal ថ្មីឡើងវិញ។
1. បើកឯកសារ `local.settings.json` ហើយបន្ថែមការកំណត់ៈសម្រាប់ speech API សោនិងទីតាំង៖
```json
"SPEECH_KEY": "<key>",
"SPEECH_LOCATION": "<location>"
```
ជំនួស `<key>` ជាមួយសោ API សម្រាប់ធនធានសេវាសំឡេងរបស់អ្នក។ ជំនួស `<location>` ជាមួយទីតាំងដែលអ្នកបានប្រើពេលបង្កើតធនធានសេវាសំឡេង។
1. បន្ថែមសោHTTP trigger ថ្មីមួយឈ្មោះ `get-voices` សម្រាប់កម្មវិធីនេះ ដោយប្រើពាក្យបញ្ជាខាងក្រោមពីក្នុង terminal VS Code នៅកំណត់តិបថėមគម្រោង functions app ដែលជារាងកំណត់ផ្សេងៗ៖
```sh
func new --name get-voices --template "HTTP trigger"
```
នេះនឹងបង្កើត HTTP trigger មួយឈ្មោះ `get-voices`
1. ជំនួសមាតិកានៃឯកសារ `__init__.py` នៅក្នុងថត `get-voices` ជាមួយ​ស្នាដៃខាងក្រោម៖
```python
import json
import os
import requests
import azure.functions as func
def main(req: func.HttpRequest) -> func.HttpResponse:
location = os.environ['SPEECH_LOCATION']
speech_key = os.environ['SPEECH_KEY']
req_body = req.get_json()
language = req_body['language']
url = f'https://{location}.tts.speech.microsoft.com/cognitiveservices/voices/list'
headers = {
'Ocp-Apim-Subscription-Key': speech_key
}
response = requests.get(url, headers=headers)
voices_json = json.loads(response.text)
voices = filter(lambda x: x['Locale'].lower() == language.lower(), voices_json)
voices = map(lambda x: x['ShortName'], voices)
return func.HttpResponse(json.dumps(list(voices)), status_code=200)
```
កូដនេះធ្វើសំណើ HTTP ទៅផ្លូវចូលបង្ហាញសំឡេង។ បញ្ជីសំឡេងនេះជាប្លក់ JSON ធំសម្រាប់សំឡេងសម្រាប់ភាសាទាំងអស់ ដូច្នេះសំឡេងសម្រាប់ភាសាដែលបានផ្ញើក្នុងខ្លឹមសារស្នើសុំត្រូវបានតម្រៀបចេញ ហើយបន្ទាប់មក shortname ត្រូវបានដកចេញ ហើយត្រឡប់មកជាបញ្ជី JSON។ shortname គឺជាតំលៃដែលចាំបាច់ក្នុងការបម្លែងអត្ថបទទៅសំឡេង ដូច្នេះត្រឹមតែតំលៃនេះត្រូវបានត្រឡប់តែប៉ុណ្ណោះ។
> 💁 អ្នកអាចផ្លាស់ប្ដូរតម្រងទៅតាមតម្រូវការ ដើម្បីជ្រើសរើសតែសំឡេងដែលអ្នកចង់បាន។
នេះកាត់បន្ថយទំហំទិន្នន័យពី ៧៧KB (នៅពេលសរសេរ) ទៅឯកសារ JSON ដែលតូចជាងនេះយ៉ាងខ្លាំង។ ឧទាហរណ៍ សំឡេងសម្រាប់ US គឺមានទំហំ ៤០៨ បៃ។
1. ដំណើរការកម្មវិធី function app របស់អ្នកនៅក្នុងកន្លែង។ បន្ទាប់មក អ្នកអាចហៅវា ដោយប្រើឧបករណ៍ដូចជា curl ដូចជាវិធីសាស្រ្តដែលអ្នកបានសាកល្បង `text-to-timer` HTTP trigger។ ប្រាកដថាអ្នកផ្ញើភាសារបស់អ្នកជាគ្រឿងខាង JSON៖
```json
{
"language":"<language>"
}
```
ជំនួស `<language>` ជាមួយភាសារបស់អ្នក ដូចជា `en-GB``zh-CN`
> 💁 អ្នកអាចស្វែងរកកូដនេះនៅក្នុងថត [code-spoken-response/functions](../../../../../6-consumer/lessons/3-spoken-feedback/code-spoken-response/functions)។
### កិច្ចការ - ទាញយកសំឡេងពី Wio Terminal របស់អ្នក
1. បើកគម្រោង `smart-timer` ក្នុង VS Code ប្រសិនបើវាមិនទាន់បើកជាមួយទេ។
1. បើកឯកសារ header `config.h` ហើយបន្ថែម URL សម្រាប់កម្មវិធី function app របស់អ្នក៖
```cpp
const char *GET_VOICES_FUNCTION_URL = "<URL>";
```
ជំនួស `<URL>` ជាមួយ URL សម្រាប់ `get-voices` HTTP trigger នៅលើកម្មវិធី function app របស់អ្នក។ នេះគឺដូចដែលមានតម្លៃសម្រាប់ `TEXT_TO_TIMER_FUNCTION_URL` ប៉ុន្តែជាមួយឈ្មោះ function ជា `get-voices` ជំនួស `text-to-timer`
1. បង្កើតឯកសារថ្មីក្នុងថត `src` ឈ្មោះ `text_to_speech.h`។ វានឹងត្រូវប្រើសម្រាប់កំណត់ក្លាសផ្លាស់ប្តូរពីអត្ថបទទៅសំឡេង។
1. បន្ថែមការបញ្ចូលដូចខាងក្រោមនៅលើបន្ទាត់ថ្មី `text_to_speech.h` ថ្មី៖
```cpp
#pragma once
#include <Arduino.h>
#include <ArduinoJson.h>
#include <HTTPClient.h>
#include <Seeed_FS.h>
#include <SD/Seeed_SD.h>
#include <WiFiClient.h>
#include <WiFiClientSecure.h>
#include "config.h"
#include "speech_to_text.h"
```
1. បន្ថែមកូដខាងក្រោមនេះដើម្បីប្រកាសក្លាស `TextToSpeech` រួមជាមួយវត្ថុមួយដែលអាចប្រើបាននៅក្នុងកម្មវិធីភាគច្រើន៖
```cpp
class TextToSpeech
{
public:
private:
};
TextToSpeech textToSpeech;
```
1. ដើម្បីហៅកម្មវិធី functions app របស់អ្នក អ្នកត្រូវប្រកាស WiFi client។ បន្ថែមកូដខាងក្រោមទៅផ្នែក `private` របស់ក្លាស៖
```cpp
WiFiClient _client;
```
1. នៅផ្នែក `private` បន្ថែមវាលមួយសម្រាប់សំឡេងដែលបានជ្រើសរើស៖
```cpp
String _voice;
```
1. ទៅផ្នែក `public` បន្ថែមមុខងារ `init` មួយដែលនឹងទទួលសំឡេងដំបូង៖
```cpp
void init()
{
}
```
1. ដើម្បីទទួលបានសំឡេង មួយឯកសារ JSON ត្រូវបានផ្ញើទៅកម្មវិធី function app ជាមួយភាសា។ បន្ថែមកូដខាងក្រោមទៅមុខងារ `init` ដើម្បីបង្កើតឯកសារ JSON នេះ៖
```cpp
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;
String body;
serializeJson(doc, body);
```
1. បន្ទាប់បង្កើត `HTTPClient` ហើយប្រើវាហៅ function app ដើម្បីទទួលសំឡេងដោយបញ្ជូនឯកសារ JSON ៖
```cpp
HTTPClient httpClient;
httpClient.begin(_client, GET_VOICES_FUNCTION_URL);
int httpResponseCode = httpClient.POST(body);
```
1. ខាងក្រោមនេះ បន្ថែមកូដត្រួតពិនិត្យលេខកូដចំលើយ ប្រសិនបើវាគឺ ២០០ (ជោគជ័យ) ដកបញ្ជីសំឡេង ហើយយកសំឡេងដំបូងក្នុងបញ្ជី៖
```cpp
if (httpResponseCode == 200)
{
String result = httpClient.getString();
Serial.println(result);
DynamicJsonDocument doc(1024);
deserializeJson(doc, result.c_str());
JsonArray obj = doc.as<JsonArray>();
_voice = obj[0].as<String>();
Serial.print("Using voice ");
Serial.println(_voice);
}
else
{
Serial.print("Failed to get voices - error ");
Serial.println(httpResponseCode);
}
```
1. បន្ទាប់មក បញ្ចប់ការតភ្ជាប់ HTTP client៖
```cpp
httpClient.end();
```
1. បើកឯកសារ `main.cpp` ហើយបន្ថែមការបញ្ចូលខាងក្រោមនៅចំណុចខ្ពស់ដើម្បីបញ្ចូលឯកសារ header ថ្មីនេះ៖
```cpp
#include "text_to_speech.h"
```
1. នៅមុខងារ `setup` ក្រោមការហៅ `speechToText.init();` បន្ថែមខាងក្រោមដើម្បីធ្វើការចាប់ផ្តើមក្លាស `TextToSpeech`
```cpp
textToSpeech.init();
```
1. សង់កូដនេះ ផ្ទុកវាទៅកាន់ Wio Terminal របស់អ្នក ហើយសាកល្បងតាមរយៈផ្ទាំងម៉ូនីទ័រ serial។ ប្រាកដថាកម្មវិធី function app របស់អ្នកកំពុងដំណើរការ។
អ្នកនឹងឃើញបញ្ជីសំឡេងដែលអាចប្រើប្រាស់បានត្រឡប់មកពី function app រួមជាមួយសំឡេងដែលបានជ្រើសរើស។
```output
--- Available filters and text transformations: colorize, debug, default, direct, hexlify, log2file, nocontrol, printable, send_on_enter, time
--- More details at http://bit.ly/pio-monitor-filters
--- Miniterm on /dev/cu.usbmodem1101 9600,8,N,1 ---
--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
Connecting to WiFi..
Connected!
Got access token.
["en-US-JennyNeural", "en-US-JennyMultilingualNeural", "en-US-GuyNeural", "en-US-AriaNeural", "en-US-AmberNeural", "en-US-AnaNeural", "en-US-AshleyNeural", "en-US-BrandonNeural", "en-US-ChristopherNeural", "en-US-CoraNeural", "en-US-ElizabethNeural", "en-US-EricNeural", "en-US-JacobNeural", "en-US-MichelleNeural", "en-US-MonicaNeural", "en-US-AriaRUS", "en-US-BenjaminRUS", "en-US-GuyRUS", "en-US-ZiraRUS"]
Using voice en-US-JennyNeural
Ready.
```
## បម្លែងអត្ថបទទៅសំឡេង
ពេលដែលអ្នកមានសំឡេងដែលចង់ប្រើ វាអាចប្រើសម្រាប់បម្លែងអត្ថបទទៅសំឡេង។ កំណត់ចំណុចវាំងននជាមួយសំឡេងក៏មាននៅពេលបម្លែងសំឡេងទៅអត្ថបទដែរ ដូច្នេះអ្នកត្រូវតែរាយការណ៍សំឡេងទៅកាត SD ដើម្បីអាចចាក់សំឡេងតាម ReSpeaker។
> 💁 នៅមេរៀនមុនក្នុងគម្រោងនេះ អ្នកបានប្រើ flash memory ដើម្បីផ្ទុកសំឡេងដែលបានចាប់ពីមីក្រូហ្វូន។ មេរៀននេះប្រើកាត SD ព្រោះវាសមរម្យជាងសម្រាប់ចាក់សំឡេងដោយប្រើបណ្ណាល័យសំឡេង Seeed។
មានកំណត់បន្ថែមមួយទៀតដែលត្រូវគិតទុក ដូចជា ទិន្នន័យសំឡេងដែលមានពីសេវាសំឡេង និងទ្រង់ទ្រាយដែល Wio Terminal គាំទ្រ។ ខុសពីកុំព្យូទ័រពេញលេញ បណ្ណាល័យសំឡេងសម្រាប់មីក្រូកុងតូឡឺរអាចមានកំណត់ខ្លាំងខាងទ្រង់ទ្រាយសំឡេង។ ឧទាហរណ៍ បណ្ណាល័យ Seeed Arduino Audio ដែលអាចចាក់សំឡេងតាម ReSpeaker គឺគាំទ្រសំឡេង Sample rate 44.1KHz តែប៉ុណ្ណោះ។ សេវាសំឡេង Azure អាចផ្តល់សំឡេងក្នុងទ្រង់ទ្រាយមួយចំនួន ប៉ុន្តែមិនមានទ្រង់ទ្រាយ 44.1KHz ទេ វាផ្តល់តែ 8KHz, 16KHz, 24KHz និង 48KHz។ នេះមានន័យថាសំឡេងត្រូវបាន sample rate សារភាពទៅ 44.1KHz ដែលត្រូវការធនធានលើស Wio Terminal មាន ជាពិសេសផ្នែកអង្គចងចាំ។
ពេលត្រូវកែប្រែទិន្នន័យដូចនេះ ជាជាងប្រើ Wio Terminal ដោយផ្ទាល់ គឺល្អប្រសើរជាងក្នុងការប្រើកូដ serverless។ Wio Terminal អាចហៅក័ណកម្មមិនមានម៉ាស៊ីនមេមួយ ដោយផ្ញើអត្ថបទដែលត្រូវបម្លែង ហើយក័ណកម្មនេះអាចហៅសេវាសំឡេងដើម្បីបម្លែងអត្ថបទទៅសំឡេង និងអាច sample rate ជាថ្មីទៅ 44.1KHz។ បន្ទាប់មក វាអាចត្រឡប់សំឡេងនោះក្នុងទ្រង់ទ្រាយដែល Wio Terminal នឹងផ្ទុកនៅលើកាត SD ហើយចាក់តាម ReSpeaker។
### កិច្ចការ - បង្កើតក័ណកម្មមិនមានម៉ាស៊ីនមេដើម្បីបម្លែងអត្ថបទទៅសំឡេង
1. បើកគម្រោង `smart-timer-trigger` របស់អ្នកក្នុង VS Code ហើយបើក terminal ដើម្បីប្រាកដថាបរិយាកាសវីរិយៈត្រូវបានបើក។ ប្រសិនបើគ្មាន សូមបិទហើយបើក terminal ថ្មីឡើងវិញ។
1. បន្ថែម HTTP trigger ថ្មីមួយឈ្មោះ `text-to-speech` សម្រាប់កម្មវិធីនេះ ដោយប្រើពាក្យបញ្ជាខាងក្រោមពីក្នុង terminal VS Code នៅកំណត់តិបថėមគម្រោង functions app៖
```sh
func new --name text-to-speech --template "HTTP trigger"
```
នេះនឹងបង្កើត HTTP trigger ឈ្មោះ `text-to-speech`
1. package Pip នៃ [librosa](https://librosa.org) មានមុខងារសម្រាប់ធ្វើការបម្រុងសំឡេង sample rate ដូច្នេះបន្ថែមវាទៅឯកសារ `requirements.txt`
```sh
librosa
```
បន្ទាប់បន្ថែមរួច តំឡើង package Pip ដោយប្រើពាក្យបញ្ជាខាងក្រោមពីក្នុង terminal VS Code៖
```sh
pip install -r requirements.txt
```
> ⚠️ ប្រសិនបើអ្នកប្រើ Linux រួមទាំង Raspberry Pi OS អ្នកអាចត្រូវតំឡើង `libsndfile` ដោយប្រើពាក្យបញ្ជាខាងក្រោម៖
>
> ```sh
> sudo apt update
> sudo apt install libsndfile1-dev
> ```
1. ដើម្បីបម្លែងអត្ថបទទៅសំឡេង អ្នកមិនអាចប្រើកូនសោ API speech ទៅដោយផ្ទាល់ទេ ត្រូវស្នើសុំ token ចូល ប្រើកូនសោ API ដើម្បីផ្ទៀងផ្ទាត់សំណើសុំ token។ បើកឯកសារ `__init__.py` នៅក្នុងថត `text-to-speech` ហើយជំនួសកូដទាំងអស់ក្នុងឯកសារនេះជាមួយកូដខាងក្រោម៖
```python
import io
import os
import requests
import librosa
import soundfile as sf
import azure.functions as func
location = os.environ['SPEECH_LOCATION']
speech_key = os.environ['SPEECH_KEY']
def get_access_token():
headers = {
'Ocp-Apim-Subscription-Key': speech_key
}
token_endpoint = f'https://{location}.api.cognitive.microsoft.com/sts/v1.0/issuetoken'
response = requests.post(token_endpoint, headers=headers)
return str(response.text)
```
នេះកំណត់អថេរតំបន់ និងសោសំឡេង ដែលនឹងត្រូវអានពីការកំណត់។ បន្ទាប់មកកំណត់មុខងារ `get_access_token` ដែលនឹងទាញយក access token សម្រាប់សេវាសំឡេង។
1. ខាងក្រោមកូដនេះ បន្ថែម៖
```python
playback_format = 'riff-48khz-16bit-mono-pcm'
def main(req: func.HttpRequest) -> func.HttpResponse:
req_body = req.get_json()
language = req_body['language']
voice = req_body['voice']
text = req_body['text']
url = f'https://{location}.tts.speech.microsoft.com/cognitiveservices/v1'
headers = {
'Authorization': 'Bearer ' + get_access_token(),
'Content-Type': 'application/ssml+xml',
'X-Microsoft-OutputFormat': playback_format
}
ssml = f'<speak version=\'1.0\' xml:lang=\'{language}\'>'
ssml += f'<voice xml:lang=\'{language}\' name=\'{voice}\'>'
ssml += text
ssml += '</voice>'
ssml += '</speak>'
response = requests.post(url, headers=headers, data=ssml.encode('utf-8'))
raw_audio, sample_rate = librosa.load(io.BytesIO(response.content), sr=48000)
resampled = librosa.resample(raw_audio, sample_rate, 44100)
output_buffer = io.BytesIO()
sf.write(output_buffer, resampled, 44100, 'PCM_16', format='wav')
output_buffer.seek(0)
return func.HttpResponse(output_buffer.read(), status_code=200)
```
នេះកំណត់ HTTP trigger ដែលបម្លែងអត្ថបទទៅសំឡេង។ វាដកអត្ថបទដែលត្រូវបម្លែង ភាសា និងសំឡេងពីខ្លឹមសារបញ្ជូន JSON ទៅសំណើ ហើយកសាង SSML ដើម្បីស្នើសុំសំឡេង បន្ទាប់ហៅ REST API ដោយផ្ទៀងផ្ទាត់ការចូលប្រើគ្រប់គ្រាន់។ ការហៅ REST API នេះត្រឡប់តម្លៃសំឡេងដែល encode ជា 16-bit, 48KHz mono WAV ដែលកំណត់ដោយតម្លៃ `playback_format` ដែលបញ្ជូនទៅ REST API call។
វាត្រូវបានធ្វើ sample rate ជាថ្មីដោយ `librosa` ពី sample rate 48KHz ទៅ 44.1KHz បន្ទាប់សំឡេងត្រូវបានរក្សាទុកទៅក្នុងបណ្ដាលីង binary buffer ហើយត្រូវបានត្រឡប់ត្រឡប់ពី function។
1. ដំណើរការកម្មវិធី function app របស់អ្នកនៅក្នុងកន្លែង ឬបង្ហោះវាទៅពពក។ បន្ទាប់មក អ្នកអាចហៅវា ដោយប្រើ ឧបករណ៍ដូចជាគឺ curl ដូចដែលបានសាកល្បង `text-to-timer` HTTP trigger។ ប្រាកដថាអ្នកផ្ញើភាសា សំឡេង និងអត្ថបទ ជាគ្រឿង JSON body៖
```json
{
"language": "<language>",
"voice": "<voice>",
"text": "<text>"
}
```
ជំនួស `<language>` ជាមួយភាសារបស់អ្នក ដូចជា `en-GB``zh-CN`។ ជំនួស `<voice>` ជាមួយសំឡេងដែលអ្នកចង់ប្រើ។ ជំនួស `<text>` ជាមួយអត្ថបទដែលអ្នកចង់បម្លែងទៅសំឡេង។ អ្នកអាចរក្សាទុកលទ្ធផលទៅឯកសារ ហើយចាក់វាជាមួយកម្មវិធីចាក់សំឡេងណាមួយដែលអាចចាក់ឯកសារ WAV បាន។
ឧទាហរណ៍ ដើម្បីបម្លែង "Hello" ទៅសំឡេងជាភាសា អង់គ្លេស US ជាមួយសំឡេង Jenny Neural ដែល function app កំពុងដំណើរការអោយនៅក្នុងកន្លែង អ្នកអាចប្រើពាក្យបញ្ជា curl ខាងក្រោម៖
```sh
curl -X GET 'http://localhost:7071/api/text-to-speech' \
-H 'Content-Type: application/json' \
-o hello.wav \
-d '{
"language":"en-US",
"voice": "en-US-JennyNeural",
"text": "Hello"
}'
```
នេះនឹងរក្សាសំឡេងទៅឯកសារ `hello.wav` នៅក្នុងថតបច្ចុប្បន្ន។
> 💁 អ្នកអាចស្វែងរកកូដនេះនៅក្នុងថត [code-spoken-response/functions](../../../../../6-consumer/lessons/3-spoken-feedback/code-spoken-response/functions)។
### កិច្ចការ - ទាញយកសំឡេងពី Wio Terminal របស់អ្នក
1. បើកគម្រោង `smart-timer` ក្នុង VS Code ប្រសិនបើវាមិនទាន់បើកប្រើទេ។
1. បើកឯកសារ header `config.h` ហើយបន្ថែម URL សម្រាប់កម្មវិធី function app របស់អ្នក៖
```cpp
const char *TEXT_TO_SPEECH_FUNCTION_URL = "<URL>";
```
ជំនួស `<URL>` ជាមួយ URL សម្រាប់ `text-to-speech` HTTP trigger នៅលើកម្មវិធី function app របស់អ្នក។ នេះគឺដូចដែលមានតម្លៃសម្រាប់ `TEXT_TO_TIMER_FUNCTION_URL` ប៉ុន្តែជាមួយឈ្មោះ function ជា `text-to-speech` ជំនួស `text-to-timer`
1. បើកឯកសារ header `text_to_speech.h` ហើយបន្ថែមមុខងារខាងក្រោមទៅផ្នែក `public` របស់ក្លាស `TextToSpeech`
```cpp
void convertTextToSpeech(String text)
{
}
```
1. ទៅមុខងារ `convertTextToSpeech` បន្ថែមកូដខាងក្រោមដើម្បីបង្កើត JSON សម្រាប់ផ្ញើទៅ function app៖
```cpp
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;
doc["voice"] = _voice;
doc["text"] = text;
String body;
serializeJson(doc, body);
```
នេះសរសេរភាសា សំឡេង និងអត្ថបទទៅឯកសារ JSON បន្ទាប់ serialize វាទៅជាស្ទ្រង់។
1. ខាងក្រោមនេះ បន្ថែមកូដហៅ function app៖
```cpp
HTTPClient httpClient;
httpClient.begin(_client, TEXT_TO_SPEECH_FUNCTION_URL);
int httpResponseCode = httpClient.POST(body);
```
នេះបង្កើត HTTPClient បន្ទាប់ធ្វើសំណើ POST ដោយប្រើ JSON ទៅ http trigger text to speech ។
1. ប្រសិនបើការហៅនេះជោគជ័យ ទិន្នន័យ binary ចុងក្រោយដែលបានត្រឡប់ពី function app អាចត្រូវបានផ្សព្វផ្សាយទៅឯកសារមួយនៅលើកាត SD។ បន្ថែមកូដខាងក្រោមសម្រាប់ធ្វើដូច្នេះ៖
```cpp
if (httpResponseCode == 200)
{
File wav_file = SD.open("SPEECH.WAV", FILE_WRITE);
httpClient.writeToStream(&wav_file);
wav_file.close();
}
else
{
Serial.print("Failed to get speech - error ");
Serial.println(httpResponseCode);
}
```
កូដនេះពិនិត្យសំណើចំលើយ ប្រសិនបើវាជា ២០០ (ជោគជ័យ) ទិន្នន័យ binary នឹងត្រូវផ្សព្វផ្សាយទៅឯកសារ `SPEECH.WAV` នៅក្នុងថតស្ដាំឬ root នៃកាត SD។
1. នៅចុងបញ្ចប់មុខងារនេះ បិទការតភ្ជាប់ HTTP៖
```cpp
httpClient.end();
```
1. អត្ថបទដែលត្រូវនិយាយឥឡូវនេះអាចត្រូវបានបម្លែងទៅសំឡេង។ នៅក្នុងឯកសារ `main.cpp` បន្ថែមបន្ទាត់ខាងក្រោមនៅចុងមុខងារ `say` ដើម្បីបម្លែងអត្ថបទឲ្យទៅជា សំឡេង៖
```cpp
textToSpeech.convertTextToSpeech(text);
```
### កិច្ចការ - ចាក់សំឡេងពី Wio Terminal របស់អ្នក
**មកឆាប់ៗนี้**
## ការដាក់ពាក្យកម្មវិធី functions របស់អ្នកទៅកាន់ពពក
ហេតុផលសម្រាប់ការរត់កម្មវិធី functions នៅក្នុងមូលដ្ឋានគឺដោយសារបណ្ណាល័យ `librosa` Pip នៅលើ linux មានការពឹងផ្អែកលើបណ្ណាល័យមួយដែលមិនត្រូវបានដំឡើងដោយលំនាំដើម ហើយត្រូវការត្រូវបានដំឡើងមុនពេលកម្មវិធី function អាចរត់បាន។ កម្មវិធី function គឺជាបណ្តាញមិនមានម៉ាស៊ីនបម្រើ - មិនមានម៉ាស៊ីនបម្រើដែលអ្នកអាចគ្រប់គ្រងដោយខ្លួនឯងទេ ដូច្នេះមិនមានវិធីណាដើម្បីដំឡើងបណ្ណាល័យនេះជាមុនទេ។
វិធីធ្វើនេះគឺជាការដាក់ពាក្យកម្មវិធី functions របស់អ្នកតាមរយៈធុង Docker មួយ។ ធុងនេះត្រូវបានដាក់បង្ហោះដោយពពករាល់ពេលវាត្រូវការបើកឱ្យមានឯកត្តិកម្មថ្មីមួយសម្រាប់កម្មវិធី function របស់អ្នក (ដូចជា ពេលដែលការទាមទារលើសធនធានដែលមានស្រាប់ ឬបើកម្មវិធី function មិនបានប្រើប្រាស់រយៈពេលខ្លះហើយត្រូវបានបិទ)។
អ្នកអាចស្វែងរកការណែនាំដើម្បីដំឡើងកម្មវិធី function និងដាក់បង្ហោះតាមរយៈ Docker នៅក្នុង [ការបង្កើត function លើ Linux ប្រើ ធុងផ្ទាល់ខ្លួន ដោយឯកសារ Microsoft Docs](https://docs.microsoft.com/azure/azure-functions/functions-create-function-linux-custom-image?WT.mc_id=academic-17441-jabenn&tabs=bash%2Cazurecli&pivots=programming-language-python)។
ពេលនេះបន្ទាប់ពីបានដាក់បង្ហោះហើយ អ្នកអាចផ្ទេរកូដ Wio Terminal របស់អ្នកដើម្បីចូលដំណើរការមុខងារនេះ៖
1. បន្ថែមវិញ្ញាបនបត្រ Azure Functions ទៅកាន់ `config.h`:
```cpp
const char *FUNCTIONS_CERTIFICATE =
"-----BEGIN CERTIFICATE-----\r\n"
"MIIFWjCCBEKgAwIBAgIQDxSWXyAgaZlP1ceseIlB4jANBgkqhkiG9w0BAQsFADBa\r\n"
"MQswCQYDVQQGEwJJRTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJl\r\n"
"clRydXN0MSIwIAYDVQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTIw\r\n"
"MDcyMTIzMDAwMFoXDTI0MTAwODA3MDAwMFowTzELMAkGA1UEBhMCVVMxHjAcBgNV\r\n"
"BAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEgMB4GA1UEAxMXTWljcm9zb2Z0IFJT\r\n"
"QSBUTFMgQ0EgMDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCqYnfP\r\n"
"mmOyBoTzkDb0mfMUUavqlQo7Rgb9EUEf/lsGWMk4bgj8T0RIzTqk970eouKVuL5R\r\n"
"IMW/snBjXXgMQ8ApzWRJCZbar879BV8rKpHoAW4uGJssnNABf2n17j9TiFy6BWy+\r\n"
"IhVnFILyLNK+W2M3zK9gheiWa2uACKhuvgCca5Vw/OQYErEdG7LBEzFnMzTmJcli\r\n"
"W1iCdXby/vI/OxbfqkKD4zJtm45DJvC9Dh+hpzqvLMiK5uo/+aXSJY+SqhoIEpz+\r\n"
"rErHw+uAlKuHFtEjSeeku8eR3+Z5ND9BSqc6JtLqb0bjOHPm5dSRrgt4nnil75bj\r\n"
"c9j3lWXpBb9PXP9Sp/nPCK+nTQmZwHGjUnqlO9ebAVQD47ZisFonnDAmjrZNVqEX\r\n"
"F3p7laEHrFMxttYuD81BdOzxAbL9Rb/8MeFGQjE2Qx65qgVfhH+RsYuuD9dUw/3w\r\n"
"ZAhq05yO6nk07AM9c+AbNtRoEcdZcLCHfMDcbkXKNs5DJncCqXAN6LhXVERCw/us\r\n"
"G2MmCMLSIx9/kwt8bwhUmitOXc6fpT7SmFvRAtvxg84wUkg4Y/Gx++0j0z6StSeN\r\n"
"0EJz150jaHG6WV4HUqaWTb98Tm90IgXAU4AW2GBOlzFPiU5IY9jt+eXC2Q6yC/Zp\r\n"
"TL1LAcnL3Qa/OgLrHN0wiw1KFGD51WRPQ0Sh7QIDAQABo4IBJTCCASEwHQYDVR0O\r\n"
"BBYEFLV2DDARzseSQk1Mx1wsyKkM6AtkMB8GA1UdIwQYMBaAFOWdWTCCR1jMrPoI\r\n"
"VDaGezq1BE3wMA4GA1UdDwEB/wQEAwIBhjAdBgNVHSUEFjAUBggrBgEFBQcDAQYI\r\n"
"KwYBBQUHAwIwEgYDVR0TAQH/BAgwBgEB/wIBADA0BggrBgEFBQcBAQQoMCYwJAYI\r\n"
"KwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTA6BgNVHR8EMzAxMC+g\r\n"
"LaArhilodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vT21uaXJvb3QyMDI1LmNybDAq\r\n"
"BgNVHSAEIzAhMAgGBmeBDAECATAIBgZngQwBAgIwCwYJKwYBBAGCNyoBMA0GCSqG\r\n"
"SIb3DQEBCwUAA4IBAQCfK76SZ1vae4qt6P+dTQUO7bYNFUHR5hXcA2D59CJWnEj5\r\n"
"na7aKzyowKvQupW4yMH9fGNxtsh6iJswRqOOfZYC4/giBO/gNsBvwr8uDW7t1nYo\r\n"
"DYGHPpvnpxCM2mYfQFHq576/TmeYu1RZY29C4w8xYBlkAA8mDJfRhMCmehk7cN5F\r\n"
"JtyWRj2cZj/hOoI45TYDBChXpOlLZKIYiG1giY16vhCRi6zmPzEwv+tk156N6cGS\r\n"
"Vm44jTQ/rs1sa0JSYjzUaYngoFdZC4OfxnIkQvUIA4TOFmPzNPEFdjcZsgbeEz4T\r\n"
"cGHTBPK4R28F44qIMCtHRV55VMX53ev6P3hRddJb\r\n"
"-----END CERTIFICATE-----\r\n";
```
1. ផ្លាស់ប្តូរជម្រើសទាំងអស់ `<WiFiClient.h>` ទៅជា `<WiFiClientSecure.h>`
1. ផ្លាស់ប្តូរផ្នែកទាំងអស់ `WiFiClient` ទៅជា `WiFiClientSecure`
1. នៅក្នុងថ្នាក់រាល់ថ្នាក់ដែលមានផ្នែក `WiFiClientSecure` បន្ថែម constructor មួយ ហើយកំណត់វិញ្ញាបនបត្រនៅក្នុង constructor នោះ៖
```cpp
_client.setCACert(FUNCTIONS_CERTIFICATE);
```
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ នៅពេលដែលយើងខិតខំរកភាពត្រឹមត្រូវ សូមយកចិត្តទុកដាក់ថាការបកប្រែដោយស្វ័យប្រវត្តិក្នុងករណីមួយចំនួនអាចមានកំហុស ឬការខុសពីការពិត។ ឯកសារដើមនៅក្នុងភាសាមេគួរត្រូវបានយកជាអនុសាសន៍សំខាន់។ សម្រាប់ព័ត៌មានសំខាន់ៗ គួរត្រូវបានបកប្រែដោយមនុស្សដែលមានជំនាញ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសណាមួយដែលកើតមានពីការប្រើប្រាស់ការបកប្រែនេះ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,181 @@
# គាំទ្រភាសាច្រើន
![A sketchnote overview of this lesson](../../../../../translated_images/km/lesson-24.4246968ed058510a.webp)
> Sketchnote by [Nitya Narasimhan](https://github.com/nitya). សូមចុចលើរូបភាពសម្រាប់មើលរូបភាពដែលធំជាងនេះ។
វីដេអូនេះបានផ្តល់ការណែនាំសម្រាប់សេវាកម្មសម្លេង Azure ដែលគ្របដណ្តប់ពីសម្លេងទៅអត្ថបទ និងអត្ថបទទៅសម្លេង ពីមេរៀនមុនៗ ព្រមទាំងការបកប្រែសម្លេង ក៏ដូចជាបទពិសោធន៍ដែលបានគ្របដណ្តប់ក្នុងមេរៀននេះ៖
[![Recognizing speech with a few lines of Python from Microsoft Build 2020](https://img.youtube.com/vi/h6xbpMPSGEA/0.jpg)](https://www.youtube.com/watch?v=h6xbpMPSGEA)
> 🎥 សូមចុចលើរូបភាពខាងលើដើម្បីមើលវីដេអូ
## ប្រលងមុនមេរៀន
[ប្រលងមុនមេរៀន](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/47)
## ការណែនាំ
ក្នុង ៣ មេរៀនចុងក្រោយ អ្នកបានរៀនពីការបម្លែងសម្លេងទៅអត្ថបទ ការយល់ដឹងភាសា និងការបម្លែងអត្ថបទទៅសម្លេង ដែលទាំងអស់នេះគឺគាំទ្រដោយ AI។ ផ្នែកមួយទៀតនៃការទំនាក់ទំនងរវាងមនុស្សដែល AI អាចជួយបាន គឺការបកប្រែភាសា - បម្លែងពីភាសាមួយទៅភាសាផ្សេងទៀត ដូចជាពីភាសាអង់គ្លេសទៅភាសាបារាំង។
ក្នុងមេរៀននេះ អ្នកនឹងរៀនពីការប្រើ AI ដើម្បីបកប្រែអត្ថបទ អនុញ្ញាតឱ្យម៉ោងចាប់អារម្មណ៍ឆ្លាតវៃរបស់អ្នកអាចអន្តរកម្មជាមួយអ្នកប្រើជាភាសាច្រើន។
ក្នុងមេរៀននេះ យើងនឹងគ្របដណ្តប់៖
* [បកប្រែអត្ថបទ](#បកប្រែអត្ថបទ)
* [សេវាកម្មបកប្រែ](#សេវាកម្មបកប្រែ)
* [បង្កើតធនធានតំណាងបកប្រែ](#បង្កើតធនធានតំណាងបកប្រែ)
* [គាំទ្រភាសាច្រើននៅក្នុងកម្មវិធីជាមួយការបកប្រែ](#គាំទ្រភាសាច្រើននៅក្នុងកម្មវិធីជាមួយការបកប្រែ)
* [បកប្រែអត្ថបទដោយប្រើសេវាកម្ម AI](#បកប្រែអត្ថបទដោយប្រើសេវាកម្ម-ai)
> 🗑 នេះជាមេរៀនចុងក្រោយក្នុងគម្រោងនេះ ដូច្នេះបន្ទាប់ពីបញ្ចប់មេរៀននេះ និងភារកិច្ច សូមកុំភ្លេចសំអាតសេវាកម្មពពករបស់អ្នក។ អ្នកនឹងត្រូវការសេវាកម្មទាំងនេះដើម្បីបញ្ចប់ភារកិច្ច ដូច្នេះសូមប្រាកដថាបញ្ចប់វាមុនមុនគេ។
>
> សូមយោងទៅ [មគ្គុទេសក៍សំអាតគម្រោងរបស់អ្នក](../../../clean-up.md) ប្រសិនបើត្រូវការជំនួយសម្រាប់វិធីសាស្រ្តធ្វើការនេះ។
## បកប្រែអត្ថបទ
បកប្រែអត្ថបទគឺជាបញ្ហាស្វ័យប្រវត្តិគណិតវិទ្យាដែលបានស្រាវជ្រាវជាង ៧០ ឆ្នាំ មិនទាន់បានដោះស្រាយពេញលេញទេ ហើយឥឡូវនេះដោយសារវិច្ចាសាស្រ្ត AI និងថាមពលកុំព្យូទ័រដែលបានឆ្ពោះទៅមុខ គឺកំពុងជិតដោះស្រាយបានស្រួលដូចជាជនបកប្រែមនុស្សម្នាក់។
> 💁 ប្រភពដើមអាចតាមដានទៅត្រឡប់ក្រោយបន្ថែមទៀត ទៅកាន់ [Al-Kindi](https://wikipedia.org/wiki/Al-Kindi) ជាតិគ្រិក ៩ មួយដែលជាគ្រូបកប្រែអារ៉ាប់ដែលបានអភិវឌ្ឍបច្ចេកទេសសម្រាប់បកប្រែភាសា
### បកប្រែដោយម៉ាស៊ីន
ការ​បកប្រែអត្ថបទបានចាប់ផ្តើមជាបច្ចេកវិទ្យាមួយដែលហៅថាបកប្រែដោយម៉ាស៊ីន (Machine Translation - MT) ដែលអាចបកប្រែក្នុងរវាងគូភាសាផ្សេងៗ។ MT ប្រារព្ធការងារដោយប្ដូរពាក្យនៅក្នុងភាសាមួយជាមួយភាសាផ្សេង មួយផ្សំជាមួយបច្ចេកទេសសម្រាប់ជ្រើសរើសរបៀបបកប្រែត្រឹមត្រូវសម្រាប់វាក្យសព្ទ ឬផ្នែកនៃប្រយោគនៅពេលដែលការបកប្រែតាមពាក្យគ្រប់តែម្តងមិនមានន័យ។
> 🎓 នៅពេលអ្នកបកប្រែគាំទ្រការបកប្រែរវាងភាសាមួយទៅភាសាផ្សេង សូមហៅមួយក្រុមនៃភាសាទាំងនេះថា *គូភាសា*។ ឧបករណ៍ផ្សេងៗគ្នាគាំទ្រគូភាសាផ្សេងៗគ្នា ហើយគួរតែចាប់ផ្តើមមិនជាប់ពេញលេញទេ។ ឧទាហរណ៍ មួយកម្មវិធីបកប្រែអាចគាំទ្រឧទាហរណ៍ពីភាសាអង់គ្លេសទៅប៉ិនអេស្ប៉ាញ និងពីប៉ិនអេស្ប៉ាញទៅអ៊ីតាលីប៉ុន្តែមិនគាំទ្រពីអង់គ្លេសទៅអ៊ីតាលីឡើយ។
ឧទាហរណ៍ បកប្រែ “Hello world” ពីភាសាអង់គ្លេសទៅភាសាបារាំង អាចធ្វើបានដោយការប្ដូរពាក្យ “Bonjour” ជំនួស “Hello”, និង “le monde” ជំនួស “world”, ដូច្នេះនាំឱ្យបានការបកប្រែត្រឹមត្រូវគឺ "Bonjour le monde"។
ការប្ដូរពាក្យមិនដំណើរការពេលភាសាផ្សេងៗប្រើរបៀបផ្សេងៗគ្នា ក្នុងការបង្ហាញន័យដូចគ្នា។ ឧទាហរណ៍ ប្រយោគអង់គ្លេស “My name is Jim” បកប្រែជាភាសាបារាំងអាចមើលថាជា “Je m'appelle Jim”—ពាក្យ "Je" មានន័យថា "ខ្ញុំ", "m'" គឺជាការតភ្ជាប់ជាមួយកិរិយាស័ព្ទ "appelle" មានន័យថា "ហៅ" ហើយ "Jim" គឺជាឈ្មោះមិនត្រូវបានបកប្រែ។ លំដាប់ពាក្យក៏មានបញ្ហា ផ្ទុយពីអង់គ្លេស ដែលមានលំដាប់ពាក្យផ្សេងៗ។
> 💁 ពាក្យខ្លះមិនដែលត្រូវបានបកប្រែទេ - ឈ្មោះរបស់ខ្ញុំគឺជំ Jim មិនថាប្រើភាសាអ្វីទេ សម្រាប់ភាសាដែលប្រើអក្សរផ្សេង ឬអក្សរផ្សេង សម្រាប់សំនាញសំឡេងផ្សេង គឺអាចធ្វើ *ការប្រែអក្សរ* ដែលជាបច្ចេកទេសជ្រើសរើសអក្សរឬតួអក្សរដែលផ្តល់សំឡេងស្រដៀងនឹងពាក្យដែលបានផ្តល់។
លិខិតសម្ភាសន៍ ក៏ជាបញ្ហារបស់ការបកប្រែ។ សំណុំប្រយោគសម្ភាសន៍មានន័យស្រដៀង តែទំនោរ និង ការបម្រាមពាក្យបន្តិច។ ឧទាហរណ៍ ក្នុងភាសាអង់គ្លេស ប្រយោគសម្ភាស "I've got ants in my pants" មិនមានន័យលិតដូចជា “មានមនោគមិន ដែលក្នុងខោ” ប៉ុន្តែជាសញ្ញាត្រាថាអ្នកមានអារម្មណ៍អតិផរណា។ បើបកប្រែទៅភាសាអាល្លឺម៉ង់ វានឹងធ្វើឲ្យអ្នកស្តាប់ច្រឡំ ក្រោយពីវាមានន័យថា “ខ្ញុំមានផ្កាឈូកនៅខាងក្រោម”។
> 💁 តំបន់ផ្សេងៗផ្តល់ន័យខុសៗគ្នា។ មានអា‌្រោប​ប​ណ្តោះ​អាសន្ន​ចំពោះ​ប្រយោគ​សម្ភាស "ants in your pants", ក្នុងភាសាអង់គ្លេសអាមេរិក "pants" មានន័យជាគ្រឿងអាវក្រៅខោ ប៉ុន្តិនៅភាសាអង់គ្លេសបរទេស "pants" មានន័យជាខោក្នុង។
✅ ប្រសិនបើអ្នកនិយាយភាសាដាច់ចំនួន ចូរគិតពីប្រយោគមួយចំនួនដែលមិនអាចបកប្រែដោយផ្ទាល់បាន។
ប្រព័ន្ធបកប្រែដោយម៉ាស៊ីនពឹងផ្អែកលើមូលដ្ឋានទិន្នន័យធំទូលាយនៃច្បាប់កំណត់វិធីបកប្រែមួយចំនួន និងវិធីសាស្រ្តស្ថិតិដើម្បីជ្រើសរើសការបកប្រែត្រឹមត្រូវពីជម្រើសដែលមាន។ វិធីសាស្រ្តស្ថិតិទាំងនេះប្រើទិន្នន័យធំដែលបានបកប្រែក្នុងភាសាច្រើនដោយមនុស្ស ដើម្បីជ្រើសរើសបកប្រែដែលមានសក្ដានុពលខ្ពស់បំផុត ដែលហៅថា *ស្ថិតិសាស្ត្របកប្រែដោយម៉ាស៊ីន*។ ជាច្រើននៃប្រព័ន្ធទាំងនេះប្រើតំណាងកណ្តាលភាសា បើគេបកប្រែពីភាសាមួយទៅតំណាងកណ្តាល បន្ទាប់មកពីតំណាងកណ្តាលទៅភាសាផ្សេងទៀត។ ដូច្នេះ ការបន្ថែមភាសាបន្ថែម ចាំបាច់តែបកប្រែទៅ និងពីរវាងភាសា និងតំណាងកណ្តាល ប៉ុន្តែមិនចាំបាច់បកប្រែទៅ និងពីគោលភាសាផ្សេងទៀតទាំងអស់ទេ។
### បកប្រែដោយបណ្តាញសរសៃប្រសាទ
បកប្រែដោយបណ្តាញសរសៃប្រសាទប្រើថាមពល AI ដើម្បីបកប្រែ ជាទូទៅបកប្រែប្រយោគទាំងមូលដោយប្រើម៉ូដែលមួយ។ ម៉ូដែលទាំងនេះត្រូវបានហ្វឹកហាត់លើកន្លែងទិន្នន័យធំនៅក្រោមការបកប្រែក្នុងសួនដូចជា បណ្ដាញអ៊ីនធឺណិត សៀវភៅ និងឯកសារសហប្រជាជាតិសមាគម។
ម៉ូដែលបកប្រែដោយបណ្តាញសរសៃប្រសាទសូម្បីតែល្មមជាងម៉ូដែលបកប្រែដោយម៉ាស៊ីន ដោយមិនត្រូវការ មូលដ្ឋានទិន្នន័យធំនៃវាក្យសព្ទ និងលិខិតសម្ភាសន៍។ សេវាកម្ម AI សម័យថ្មីដែលផ្តល់ការបកប្រែ ជាញឹកញាប់លាយបញ្ចូលបច្ចេកទេសច្រើន ដូចជាការបកប្រែដោយម៉ាស៊ីនយោងទៅស្ថិតិ និងការបកប្រែដោយបណ្តាញសរសៃប្រសាទ។
មិនមានការបកប្រែ ១៖១ សម្រាប់គូភាសាណាមួយទេ។ ម៉ូដែលបកប្រែផ្សេងៗគ្នានឹងបង្ហាញលទ្ធផលខុសគ្នាបន្តិចបន្តួច ដោយផ្អែកលើទិន្នន័យដែលបានហ្វឹកហាត់ម៉ូដែល។ ការបកប្រែមិនតែងតែលំដាប់ជាគន្លងស្មើគ្នាទេ - នោះគឺ បើអ្នកបកប្រែប្រយោគពីភាសាមួយទៅផ្សេងទៀត ហើយបន្ទាប់មកបកប្រែវាចូលវិញទៅភាសដើម អ្នកអាចមើលឃើញប្រយោគខុសបន្តិចជាលទ្ធផល។
✅ សាកល្បងអ្នកបកប្រែអនឡាញផ្សេងៗ ដូចជា [Bing Translate](https://www.bing.com/translator), [Google Translate](https://translate.google.com), ឬកម្មវិធីបកប្រែរបស់ Apple។ ប្រៀបធៀបការបកប្រែភាសារបស់ប្រយោគខ្លះៗ។ ក៏សាកល្បងបកប្រែក្នុងភាសាមួយ បន្ទាប់មកបកប្រែវិញក្នុងភាសាផ្សេង។
## សេវាកម្មបកប្រែ
មានសេវាកម្ម AI ច្រើនដែលអាចប្រើបានពីកម្មវិធីរបស់អ្នកសម្រាប់បកប្រែសម្លេង និងអត្ថបទ។
### សេវាកម្មសម្លេង Cognitive services Speech service
![The speech service logo](../../../../../translated_images/km/azure-speech-logo.a1f08c4befb0159f.webp)
សេវាកម្មសម្លេងដែលអ្នកបានប្រើចាប់ពីមេរៀនកន្លងមក មានសមត្ថភាពបកប្រែសម្រាប់ការទទួលសម្លេង។ ពេលអ្នកស្គាល់សម្លេង អ្នកអាចស្នើរសុំទទួលអត្ថបទសម្លេងក្នុងភាសាដដែលបាន ប៉ុន្តែស្របនឹងមានភាសាផ្សេងទៀត។
> 💁 អ្នកអាចប្រើតែពី SDK សម្លេងប៉ុណ្ណោះ ខណៈដែល REST API មិនមានការបកប្រែបញ្ចូលក្នុង។
### សេវាកម្មបកប្រែ Cognitive services Translator service
![The translator service logo](../../../../../translated_images/km/azure-translator-logo.c6ed3a4a433edfd2.webp)
សេវាកម្ម Translator គឺជាសេវាកម្មពិសេសសម្រាប់ការបកប្រែ ដែលអាចបកប្រែអត្ថបទពីភាសាមួយទៅភាសាជាច្រើន។ មិនត្រឹមតែបកប្រែទេ វាក៏គាំទ្រមុខងារបន្ថែមជាច្រើន រួមមានការលាក់ពាក្យមិនសមរម្យ។ វាព្រមទាំងអនុញ្ញាតឲ្យអ្នកផ្តល់ការបកប្រែភាសាពិសេសសម្រាប់ពាក្យ ឬប្រយោគជាក់លាក់ ដើម្បីប្រើជាមួយពាក្យដែលអ្នកមិនចង់បកប្រែ ឬមានការបកប្រែមួយដែលស្គាល់ថាថ្មី។
ឧទាហរណ៍ ពេលបកប្រែប្រយោគ "I have a Raspberry Pi", ដែលចង់បង្ហាញពីកុំព្យូទ័រផ្ទាល់ខ្លួនមួយ ចូលទៅភាសាបារាំង អ្នកអាចរក្សា "Raspberry Pi" ដូចដើម និងមិនបកប្រែវានេះទៅជា "pi aux framboises" ក្ដៅជាទីបំផុត។
## បង្កើតធនធានតំណាងបកប្រែ
សម្រាប់មេរៀននេះ អ្នកនឹងត្រូវការ Translator resource។ អ្នកនឹងប្រើ REST API សម្រាប់បកប្រែអត្ថបទ។
### ភារកិច្ច - បង្កើតធនធាន Translator
1. ពី Terminal ឬ Command prompt របស់អ្នក អនុវត្តបន្ទាត់ពាក្យបញ្ជាខាងក្រោមសម្រាប់បង្កើត Translator resource ក្នុងក្រុមធនធាន `smart-timer` របស់អ្នក។
```sh
az cognitiveservices account create --name smart-timer-translator \
--resource-group smart-timer \
--kind TextTranslation \
--sku F0 \
--yes \
--location <location>
```
ប្តូរ `<location>` ជាមួយទីតាំងដែលអ្នកប្រើនៅពេលបង្កើត Resource Group។
1. ទទួលសោសម្រាប់សេវាកម្ម Translator៖
```sh
az cognitiveservices account keys list --name smart-timer-translator \
--resource-group smart-timer \
--output table
```
ចម្លងមួយក្នុងចំណោមសោ។
## គាំទ្រភាសាច្រើននៅក្នុងកម្មវិធីជាមួយការបកប្រែ
ក្នុងពិភពអតិបរមា កម្មវិធីរបស់អ្នកគឺគួរតែយល់ភាសាថ្មីៗជាច្រើន ប្រហែលពីការស្តាប់សម្លេង ដល់ការយល់ដឹងភាសា រហូតដល់ការឆ្លើយតបជាសម្លេង។ វាជាកិច្ចការច្រើន ហើយដូច្នេះសេវាកម្មបកប្រែអាចជួយឱ្យពេលវេលាចេញផ្សាយកម្មវិធីរបស់អ្នករហ័សឡើង។
![A smart timer architecture translating Japanese to English, processing in English then translating back to Japanese](../../../../../translated_images/km/translated-smart-timer.08ac20057fdc5c37.webp)
សូមកន្សោមថាអ្នកកំពុងបង្កើតម៉ោងចាប់អារម្មណ៍ឆ្លាតវៃមួយប្រើភាសាអង់គ្លេសទាំងមូល ពីការយល់សម្លេងទៅអត្ថបទ រត់ដំណើរការយល់ដឹងភាសា និងបង្កើតការឆ្លើយតបជាភាសាអង់គ្លេស ហើយឆ្លើយតបទៅដោយសម្លេងភាសាអង់គ្លេស។ ប្រសិនបើអ្នកចង់គាំទ្ររហូតទៅភាសាជប៉ុន អ្នកអាចចាប់ផ្តើមពីការបកប្រែសម្លេងជប៉ុនទៅអត្ថបទអង់គ្លេស រួចរក្សាជំហានស្នូលនៅក្នុងកម្មវិធីដូចគ្នា ហើយបកប្រែអត្ថបទការឆ្លើយតបទៅជាជប៉ុនមុននិយាយការឆ្លើយ។ វានឹងអនុញ្ញាតឲ្យអ្នកបន្ថែមគាំទ្រភាសាជប៉ុនបានយ៉ាងមានប្រសិទ្ធភាព ហើយអ្នកអាចពង្រីកមុខងារពេញលេញជាភាសាជប៉ុននៅពេលក្រោយ។
> 💁 ខុសគ្នានៃការគ្រប់គ្រងលើការពឹងផ្អែកលើការបកប្រែដោយម៉ាស៊ីន គឺភាសា និងវប្បធម៌ផ្សេងៗមានរបៀបនិយាយមិនដូចគ្នា ដូច្នេះការបកប្រែអាចមិនផ្គូផ្គងនឹងអារម្មណ៍ដែលអ្នករង់ចាំ។
បកប្រែដោយម៉ាស៊ីន ក៏បើកឱកាសសម្រាប់កម្មវិធី និងឧបករណ៍ដែលអាចបកប្រែមាតិកាដែលអ្នកប្រើបង្កើតក៏ដូចជាពេលវាលើក។ សាច់រឿងវិទ្យាសាស្ត្រដ៏ប្រចាំជាលក្ខខណ្ឌ បង្ហាញពីឧបករណ៍បកប្រែសកល ដែលអាចបកប្រែពីភាសាផ្សេងដែលមិនមែនមនុស្សទៅភាសាអង់គ្លេសជាធម្មតា។ ឧបករណ៍ទាំងនេះគឺនៅកន្លែងពិតជាងហើយ ប្រសិនបើហាមឃាត់ផ្នែកមិនមែនមនុស្ស។ មានកម្មវិធី និងឧបករណ៍ដែលផ្តល់ការបកប្រែដាច់ខាតជាពេលវេលាពិតជាក់ស្ដែងសម្រាប់សម្លេង និងអត្ថបទ ដែលប្រើការលាយបញ្ចូលនៃសេវាកម្មសម្លេង និងបកប្រែ។
ឧទាហរណ៍មួយ គឺកម្មវិធីទូរស័ព្ទចល័ត [Microsoft Translator](https://www.microsoft.com/translator/apps/?WT.mc_id=academic-17441-jabenn) ដែលបង្ហាញក្នុងវីដេអូនេះ៖
[![Microsoft Translator live feature in action](https://img.youtube.com/vi/16yAGeP2FuM/0.jpg)](https://www.youtube.com/watch?v=16yAGeP2FuM)
> 🎥 សូមចុចលើរូបភាពខាងលើដើម្បីមើលវីដេអូ
សូមនឹកឃើញថាមានឧបករណ៍ដូចនេះដែលអ្នកអាចប្រើបាន ជាពិសេសពេលធ្វើដំណើរយ៉ាងហោចណាស់ ជាមួយមនុស្សដែលភាសារបស់ពួកគេលោកអ្នកមិនស្គាល់ផង។ ការមានឧបករណ៍បកប្រែដាច់ខាតនៅអាកាសយានដ្ឋាន ឬមន្ទីរពេទ្យ នឹងផ្តល់នូវការកែលម្អការចូលដំណើរការចាំបាច់យ៉ាងខ្លាំង។
✅ ស្រាវជ្រាវមួយចំនួន៖ តើមានឧបករណ៍ IoT សម្រាប់បកប្រែដែលមានលក់ពាណិជ្ជកម្មទេ? តើមានមុខងារបកប្រែដែលអាចបញ្ជូលក្នុងឧបករណ៍ឆ្លាតទេ?
> 👽 ទោះបីជាមានឧបករណ៍បកប្រែសកលមួយដែលអាចអោយយើងនិយាយជាមួយបរទេសបានក៏ដោយ ក្តី [Microsoft translator គាំទ្រភាសា Klingon](https://www.microsoft.com/translator/blog/2013/05/14/announcing-klingon-for-bing-translator/?WT.mc_id=academic-17441-jabenn)។ Qapla!
## បកប្រែអត្ថបទដោយប្រើសេវាកម្ម AI
អ្នកអាចប្រើសេវាកម្ម AI ដើម្បីបន្ថែមសមត្ថភាពបកប្រែនេះទៅម៉ោងចាប់អារម្មណ៍ឆ្លាតវៃរបស់អ្នក។
### ភារកិច្ច - បកប្រែអត្ថបទដោយប្រើសេវាកម្ម AI
ធ្វើតាមមគ្គុទេសក៍ដែលពាក់ព័ន្ធ ដើម្បីបម្លែងអត្ថបទនៅលើឧបករណ៍ IoT របស់អ្នក៖
* [Arduino - Wio Terminal](wio-terminal-translate-speech.md)
* [Single-board computer - Raspberry Pi](pi-translate-speech.md)
* [Single-board computer - Virtual device](virtual-device-translate-speech.md)
---
## 🚀 បញ្ហាដែលត្រូវធ្វើ
តើយ៉ាងដូចម្តេចការបកប្រែដោយម៉ាស៊ីនអាចផ្តល់អត្ថប្រយោជន៍ដល់កម្មវិធី IoT ផ្សេងទៀតក្រៅពីឧបករណ៍ឆ្លាត? ចូរគិតពីវិធីផ្សេងៗដែលការបកប្រែអាចជួយបាន មិនត្រឹមតែពាក្យនិយាយ និងអត្ថបទផងដែរ។
## ប្រលងបន្ទាប់មេរៀន
[ប្រលងបន្ទាប់មេរៀន](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/48)
## ពិនិត្យឡើងវិញ និងសិក្សាឯករាជ្យ
* អានបន្ថែមអំពីបកប្រែម៉ាស៊ីន នៅលើ​ទំព័របកប្រែម៉ាស៊ីនក្នុង [វិគីភីឌា](https://wikipedia.org/wiki/Machine_translation)
* អានបន្ថែមអំពីបកប្រែម៉ាស៊ីនសរសៃប្រសាទ នៅលើ​ទំព័របកប្រែម៉ាស៊ីនសរសៃប្រសាទក្នុង [វិគីភីឌា](https://wikipedia.org/wiki/Neural_machine_translation)
* ពិនិត្យមើលបញ្ជីភាសាគាំទ្រសម្រាប់សេវាកម្មសម្លេង Microsoft នៅក្នុង [ឯកសារគាំទ្រភាសា និងសម្លេងសម្រាប់សេវាកម្មសម្លេងលើ Microsoft Docs](https://docs.microsoft.com/azure/cognitive-services/speech-service/language-support?WT.mc_id=academic-17441-jabenn)
## ភារកិច្ច
[បង្កើតកម្មវិធីបកប្រែសកល](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator) ។ ខណៈពេលដែលយើងខំប្រឹងប្រែងចំពោះភាពត្រឹមត្រូវ សូមយល់ថាការបកប្រែដោយស្វ័យប្រវត្តិ​អាចមានកំហុសឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមនៅក្នុងភាសាទើបមានគុណតម្លៃជាឯកសារយោងដ៍សំខាន់។ សម្រាប់ព័ត៌មានសំខាន់ ការបកប្រែដោយមនុស្សជំនាញគួរតែត្រូវបានប្រើ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែវាយប្រហារណាមួយដែលកើតឡើងពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,24 @@
# សាងសង់កម្មវិធីបកប្រែសកល
## សេចក្តីណែនាំ
កម្មវិធីបកប្រែសកលគឺជាឧបករណ៍មួយដែលអាចបកប្រែភាសាច្រើនបាន អនុញ្ញាតឲ្យមនុស្សដែលនិយាយភាសាផ្សេងៗអាចទំនាក់ទំនងគ្នាបាន។ អ្នកត្រូវប្រើសម្លឹងសិក្សាដែលបានរៀនក្នុងមេរៀនចុងក្រោយៗ ដើម្បីសាងសង់កម្មវិធីបកប្រែសកលមួយដោយប្រើឧបករណ៍ IoT ចំនួន ២។
> ប្រសិនបើអ្នកមិនមានឧបករណ៍ ២ គ្រឿង នោះសូមអនុវត្តជំហាននៅក្នុងមេរៀនមុនៗដើម្បីបង្កើតឧបករណ៍ IoT ជាការស្រមៃមួយ ជាឧបករណ៍ IoT មួយ។
អ្នកគួរតែបញ្ជាក់ឧបករណ៍មួយសម្រាប់ភាសាមួយ ហើយឧបករណ៍មួយសម្រាប់ភាសាផ្សេងទៀត។ ឧបករណ៍នីមួយៗគួរទទួលសំឡេង នាំសំឡេងទៅជាអក្សរ បញ្ជូនទៅឧបករណ៍មួយទៀតតាមរយៈ IoT Hub និងកម្មវិធី Functions បន្ទាប់មកបកប្រែ ហើយចាក់បញ្ចាំងសំឡេងដែលបានបកប្រែ។
> 💁 របៀប: នៅពេលផ្ញើសំឡេងពីឧបករណ៍មួយទៅឧបករណ៍មួយទៀត សូមផ្ញើភាសាដែលសំឡេងនោះស្ថិតនៅផង ដើម្បីសម្រួលការបកប្រែ។ អ្នកអាចអោយឧបករណ៍នីមួយៗចុះឈ្មោះតាមរយៈ IoT Hub និងកម្មវិធី Functions កាន់តែច្បាស់ជាមុន ដោយផ្ញើភាសាដែលគេគាំទ្រដើម្បីរក្សាទុកនៅក្នុង Azure Storage។ បន្ទាប់មក អ្នកអាចប្រើកម្មវិធី Functions ដើម្បីធ្វើការបកប្រែ ដោយផ្ញើអក្សរដែលបានបកប្រែនៅឧបករណ៍ IoT។
## តារាងវាយតម្លៃ
| វិធានការ | ល្អឧបមា | គ្រប់គ្រាន់ | ត្រូវការកែលម្អ |
| -------- | --------- | -------- | ----------------- |
| បង្កើតកម្មវិធីបកប្រែសកល | អាចសាងសង់កម្មវិធីបកប្រែសកល ដែលបានបម្លែងសំឡេងដែលឧបករណ៍មួយចាប់យកទៅជាសំឡេងដែលឧបករណ៍មួយផ្សេង ចាក់បញ្ចាំងជាភាសាផ្សេង | អាចធ្វើឲ្យមុខងារមួយចំនួនដំណើរការ បានដូចជា ចាប់យកសំឡេង ឬបកប្រែ តែក៏មិនអាចបង្កើតដំណោះស្រាយចប់បាន | មិនអាចសាងសង់ផ្នែកណាមួយនៃកម្មវិធីបកប្រែសកលដំណើរការ |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការ​ប្រកាស​ផ្តាច់មុខ**៖
ឯកសារ​នេះ​ត្រូវ​បាន​បម្រើ​ប្រែសម្រួល​ដោយ​ការ​បម្រើ​ប្រែសម្រួល AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ក្នុង​ពេល​ដែល​ពួកយើង​ព្យាយាម​សំរេច​សុវត្ថិភាព ខ្ជិលខ្ជាយ​ភាព​ត្រឹមត្រូវ ខ្ញុំសូម​ឲ្យ​ដឹង​ថា​ការ​បម្រើ​ប្រែសម្រួល​ដោយ​ស្វ័យប្រវត្តិ​អាច​មាន​កំហុស​ឬ​ការមិនត្រឹមត្រូវ។ ឯកសារ​ដើម​ក្នុង​ភាសា​ដើម​ជា​ប្រភព​ផ្លូវការ​ត្រូវ​បាន​ពិចារណា​ជា​មុន។ សម្រាប់​ព័ត៌មាន​សំខាន់ ការ​បម្រើ​ប្រែសម្រួល​ដោយ​មនុស្ស​អាជីព​ត្រូវ​បាន​ផ្តល់អនុ​សាសន៍។ ពួក​យើង​មិនទទួល​ខុសត្រូវ​ចំពោះ​ការ​ខុស​ឆ្គង​ឬ​ការ​យល់​ខុស​ដែល​កើត​មាន​ពី​ការ​ប្រើប្រាស់​ការ​បម្រើ​ប្រែសម្រួល​នេះ​នោះទេ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,157 @@
# បកប្រែសុន្ទរកថា - Raspberry Pi
នៅផ្នែកនេះនៃមេរៀន អ្នកនឹងសរសេរកូដដើម្បីបកប្រែអត្ថបទដោយប្រើសេវាកម្ម translator។
## បម្លែងអត្ថបទទៅសុន្ទរកថា ដោយប្រើសេវាកម្ម translator
សេវាកម្មសុន្ទរកថា REST API មិនគាំទ្រការបកប្រែផ្ទាល់ទេ ជំនួសវិញ អ្នកអាចប្រើសេវាកម្ម Translator ដើម្បីបកប្រែអត្ថបទដែលផលិតដោយសេវាកម្ម speech to text និងអត្ថបទនៃការឆ្លើយតបជាសុន្ទរកថា។ សេវាកម្មនេះមាន REST API ដែលអ្នកអាចប្រើដើម្បីបកប្រែអត្ថបទ។
### ការងារ - ប្រើធនធាន translator ដើម្បីបកប្រែអត្ថបទ
1. ម៉ាស៊ីនថ្មម៉ាតរបស់អ្នកនឹងបានកំណត់ភាសា 2 ភាសា - ភាសារបស់ម៉ាស៊ីនបម្រើដែលបានប្រើសម្រាប់បណ្តុះបណ្តាល LUIS (ភាសាដូចគ្នាក៏ត្រូវបានប្រើសម្រាប់បង្កើតសារ ដើម្បីនិយាយជាមួយអ្នកប្រើ), និងភាសាដែលអ្នកប្រើនិយាយ។ បច្ចុប្បន្នភាពអថេរ `language` ឲ្យជា ភាសាដែលនឹងត្រូវនិយាយដោយអ្នកប្រើ ហើយបន្ថែមអថេរថ្មីមួយឈ្មោះ `server_language` សម្រាប់ភាសាដែលបានប្រើបណ្តុះបណ្តាល LUIS៖
```python
language = '<user language>'
server_language = '<server language>'
```
ផ្លាស់ប្តូរ `<user language>` ជាមួយឈ្មោះតំបន់សម្រាប់ភាសាដែលអ្នកនឹងនិយាយ ប្រដាប់ដូចជា `fr-FR` សម្រាប់ភាសាបារាំង ឬ `zn-HK` សម្រាប់ភាសាកង់តូនីស៍។
ផ្លាស់ប្តូរ `<server language>` ជាមួយឈ្មោះតំបន់សម្រាប់ភាសាដែលបានប្រើបណ្តុះបណ្តាល LUIS។
អ្នកអាចស្វែងរកបញ្ជីភាសាដែលគាំទ្រ និងឈ្មោះតំបន់របស់ពួកវា នៅក្នុង [Language and voice support documentation on Microsoft docs](https://docs.microsoft.com/azure/cognitive-services/speech-service/language-support?WT.mc_id=academic-17441-jabenn#speech-to-text)។
> 💁 ប្រសិនបើអ្នកមិននិយាយភាសាច្រើន អ្នកអាចប្រើសេវាកម្មដូចជា [Bing Translate](https://www.bing.com/translator) ឬ [Google Translate](https://translate.google.com) ដើម្បីបកប្រែពីភាសារបស់អ្នកទៅភាសាដែលអ្នកចូលចិត្ត។ សេវាកម្មទាំងនេះអាចចាក់សម្លេងនៃអត្ថបទដែលបានបកប្រែផងដែរ។
>
> ឧទាហរណ៍ ប្រសិនបើអ្នកបណ្តុះបណ្តាល LUIS ជាភាសាអង់គ្លេស ប៉ុន្តាចង់ប្រើភាសាបារាំងជាភាសាអ្នកប្រើ អ្នកអាចបកប្រែប្រយោគ "set a 2 minute and 27 second timer" ពីភាសាអង់គ្លេស ទៅភាសាបារាំងដោយប្រើ Bing Translate ហើយបន្ទាប់មកប្រើប៊ូតុង **Listen translation** ដើម្បីនិយាយការបកប្រែទៅកាន់ម្ជុលម៉ាស៊ីនភ្លើងរបស់អ្នក។
>
> ![ប៊ូតុង listen translation នៅលើ Bing translate](../../../../../translated_images/km/bing-translate.348aa796d6efe2a9.webp)
1. បន្ថែមកូនសោ API របស់ translator ខាងក្រោម `speech_api_key`
```python
translator_api_key = '<key>'
```
ផ្លាស់ប្តូរ `<key>` ជាមួយកូនសោ API សម្រាប់ធនធានសេវាកម្ម translator របស់អ្នក។
1. មុខមាត់នៃ `say` function កំណត់មុខងារ `translate_text` ដែលនឹងបកប្រែអត្ថបទពីភាសាម៉ាស៊ីនបម្រើទៅភាសាអ្នកប្រើ៖
```python
def translate_text(text, from_language, to_language):
```
ភាសា from និង to ត្រូវបានផ្ដល់ទៅមុខងារនេះ - កម្មវិធីរបស់អ្នកត្រូវបម្លែងពីភាសាអ្នកប្រើទៅភាសាម៉ាស៊ីនបម្រើពេលស្គាល់សុន្ទរកថា ហើយពីភាសាម៉ាស៊ីនបម្រើទៅភាសាអ្នកប្រើពេលផ្តល់មតិយោបល់ជាសុន្ទរកថា។
1. ក្នុងមុខងារនេះ កំណត់ URL និង headers សម្រាប់ការហៅ REST API៖
```python
url = f'https://api.cognitive.microsofttranslator.com/translate?api-version=3.0'
headers = {
'Ocp-Apim-Subscription-Key': translator_api_key,
'Ocp-Apim-Subscription-Region': location,
'Content-type': 'application/json'
}
```
URL សម្រាប់ API នេះមិនផ្ដោតតំបន់ជាក់លាក់ ទេ តាមពិតតំបន់ត្រូវផ្ដល់ជា header។ កូនសោ API ត្រូវបានប្រើដោយផ្ទាល់ ដូច្នេះខុសពីសេវាកម្មសុន្ទរកថា គ្មានការទាមទារបាន access token ពី token issuer API ទេ។
1. ខាងក្រោមនេះ កំណត់សំណុំបែបបទនិងខ្លឹមសារសម្រាប់ការហៅ៖
```python
params = {
'from': from_language,
'to': to_language
}
body = [{
'text' : text
}]
```
`params` កំណត់ប៉ារ៉ាម៉ែត្រដែលផ្ដល់ទៅការហៅ API ពីភាសា from ទៅភាសា to។ ការហៅនេះនឹងបកប្រែអត្ថបទនៅភាសា `from` ទៅភាសា `to`
`body` មានអត្ថបទដែលត្រូវបកប្រែ។ នេះជាអារ៉េ មូលហេតុជាច្រើននៃអត្ថបទអាចត្រូវបានបកប្រែក្នុងការហៅដូចគ្នា។
1. រៀបចំការហៅ REST API ហើយទទួលការឆ្លើយតប៖
```python
response = requests.post(url, headers=headers, params=params, json=body)
```
ការឆ្លើយតបដែលត្រូវបានត្រឡប់មកវិញគឺជាអារ៉េ JSON មានធាតុមួយដែលមានការបកប្រែ។ ធាតុនេះមានអារ៉េសម្រាប់ការបកប្រែនៃធាតុទាំងអស់ដែលបានផ្ដល់នៅក្នុង body ។
```json
[
{
"translations": [
{
"text": "Set a 2 minute 27 second timer.",
"to": "en"
}
]
}
]
```
1. ត្រឡប់តម្លៃ `test` ពីការបកប្រែដំបូងពីធាតុដំបូងនៅក្នុងអារ៉េ៖
```python
return response.json()[0]['translations'][0]['text']
```
1. បច្ចុប្បន្នភាពលំនាំ `while True` ដើម្បីបកប្រែអត្ថបទពីការហៅ `convert_speech_to_text` ពីភាសាអ្នកប្រើទៅភាសាម៉ាស៊ីនបម្រើ៖
```python
if len(text) > 0:
print('Original:', text)
text = translate_text(text, language, server_language)
print('Translated:', text)
message = Message(json.dumps({ 'speech': text }))
device_client.send_message(message)
```
កូដនេះក៏បង្ហាញអត្ថបទដើម និងអត្ថបទបានបកប្រែទៅកាន់ console ផងដែរ។
1. បច្ចុប្បន្នភាពមុខងារ `say` ដើម្បីបកប្រែអត្ថបទដែលនឹងនិយាយ ពីភាសាម៉ាស៊ីនបម្រើទៅភាសាអ្នកប្រើ៖
```python
def say(text):
print('Original:', text)
text = translate_text(text, server_language, language)
print('Translated:', text)
speech = get_speech(text)
play_speech(speech)
```
កូដនេះក៏បង្ហាញអត្ថបទដើម និងអត្ថបទបានបកប្រែទៅកាន់ console ផងដែរ។
1. ប្រតិបត្តិការកូដរបស់អ្នក។ ប្រាកដថាកម្មវិធី function app របស់អ្នកកំពុងដំណើរការ ហើយស្នើសុំម៉ោងថ្មក្នុងភាសាអ្នកប្រើ ដោយនិយាយភាសានោះដោយខ្លួនឯង ឬប្រើកម្មវិធីបកប្រែ។
```output
pi@raspberrypi:~/smart-timer $ python3 app.py
Connecting
Connected
Using voice fr-FR-DeniseNeural
Original: Définir une minuterie de 2 minutes et 27 secondes.
Translated: Set a timer of 2 minutes and 27 seconds.
Original: 2 minute 27 second timer started.
Translated: 2 minute 27 seconde minute a commencé.
Original: Times up on your 2 minute 27 second timer.
Translated: Chronométrant votre minuterie de 2 minutes 27 secondes.
```
> 💁 ដោយសារប្លែកៗនៃរបៀបនិយាយក្នុងភាសាផ្សេងៗ អ្នកអាចទទួលបានការបកប្រែដែលខុសពីឧទាហរណ៍ដែលអ្នកផ្តល់ទៅ LUIS។ ប្រសិនបើមានករណីនេះ សូមបន្ថែមឧទាហរណ៍បន្ថែមទៅ LUIS បណ្ដុះបណ្ដាលឡើងវិញ ហើយបោះពុម្ពផ្សាយម៉ូដែលឡើងវិញ។
> 💁 អ្នកអាចរកឃើញកូដនេះនៅក្នុងថត [code/pi](../../../../../6-consumer/lessons/4-multiple-language-support/code/pi)។
😀 កម្មវិធីម៉ោងថ្មភាសាច្រើនរបស់អ្នកបានជោគជ័យ!
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**:
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ទោះយើងខិតខំប្រឹងប្រែងឱ្យមានភាពត្រឹមត្រូវ ប៉ុន្តែសូមយល់ព្រមថាការបកប្រែម៉ាស៊ីនអាចមានកំហុស ឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមនៅក្នុងភាសាទូទៅគួរត្រូវបានគិតថា ជាវិទ្យាស្ថានឯកសារដែលត្រឹមត្រូវ។ សម្រាប់ព័ត៌មានសំខាន់ៗ ការបកប្រែដោយអ្នកជំនាញមនុស្សត្រូវបានផ្ដល់អនុសាសន៍។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសចេញពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,197 @@
# បកប្រែសំឡេង - ឧបករណ៍ IoT វើឌួល
នៅផ្នែកនេះនៃមេរៀន អ្នកនឹងសរសេរកូដ ដើម្បីបកប្រែសំឡេងពេលបម្លែងទៅជាអក្សរដោយប្រើសេវាសំឡេង បន្ទាប់មកបកប្រែអក្សរដោយប្រើសេវាដែលមានឈ្មោះថា Translator មុននឹងបង្កើតចម្លើយដែលផ្តល់ជាសំឡេង។
## ប្រើសេវាសំឡេងដើម្បីបកប្រែសំឡេង
សេវាសំឡេងអាចទទួលបានសំឡេង ហើយមិនត្រឹមតែបម្លែងទៅជាអក្សរដែរនៅក្នុងភាសាដូចគ្នាប៉ុណ្ណោះ ទេក៏អាចបកប្រែផលបញ្ចេញទៅជาทាសាផ្សេងទៀតបានផងដែរ។
### ភារកិច្ច - ប្រើសេវាសំឡេងដើម្បីបកប្រែសំឡេង
1. បើកគម្រោង `smart-timer` នៅក្នុង VS Code ហើយប្រាកដថាបរិវេណវើឌួលត្រូវបានផ្ទុកក្នុងរបារថែមីនាល់។
1. បន្ថែមបញ្ជាចូល (import) ខាងក្រោមដែលមានរួចហើយ៖
```python
from azure.cognitiveservices import speech
from azure.cognitiveservices.speech.translation import SpeechTranslationConfig, TranslationRecognizer
import requests
```
នេះនាំចូលថ្នាក់ដែលប្រើសម្រាប់បកប្រែសំឡេង និងបណ្ណាល័យ `requests` ដែលនឹងប្រើសម្រាប់ហៅទៅសេវាកម្ម Translator នៅពេលបន្តនៅក្នុងមេរៀននេះ។
1. ម៉ាស៊ីនម៉ោងឆ្លាតនឹងមានភាសា 2 កំណត់ - ភាសារបស់ម៉ាស៊ីនមេដែលបានប្រើសម្រាប់បណ្តុះបណ្តាល LUIS (ភាសាដូចគ្នានេះត្រូវបានប្រើដើម្បីកសាងសារ​សម្រាប់និយាយទៅអ្នកប្រើ) ហើយភាសាដែលអ្នកប្រើនិយាយ។ បញ្ចូលអថេរ `language` ដើម្បីកំណត់ភាសាដែលនឹងត្រូវនិយាយដោយអ្នកប្រើ ហើយបន្ថែមអថេរថ្មីមួយឈ្មោះ `server_language` សម្រាប់ភាសាដែលប្រើបណ្តុះបណ្តាល LUIS៖
```python
language = '<user language>'
server_language = '<server language>'
```
ជំនួស `<user language>` ជាមួយឈ្មោះភាសារបស់ភាសាដែលអ្នកនឹងនិយាយ នៅឧទាហរណ៍ `fr-FR` សម្រាប់ភាសាបារាំង ឬ `zn-HK` សម្រាប់ភាសាកាន់តូនីស៍។
ជំនួស `<server language>` ជាមួយឈ្មោះភាសារបស់ភាសាដែលបានប្រើបណ្តុះបណ្តាល LUIS។
អ្នកអាចស្វែងរកបញ្ជីនៃភាសាដែលគាំទ្រ និងឈ្មោះភាសានៅក្នុងឯកសារគាំទ្រភាសា និងសំឡេងលើMicrosoft docs [Language and voice support documentation on Microsoft docs](https://docs.microsoft.com/azure/cognitive-services/speech-service/language-support?WT.mc_id=academic-17441-jabenn#speech-to-text)។
> 💁 ប្រសិនបើអ្នកមិននិយាយភាសាច្រើន អ្នកអាចប្រើសេវាដូចជា [Bing Translate](https://www.bing.com/translator) ឬ [Google Translate](https://translate.google.com) ដើម្បីបកប្រែពីភាសាដែលអ្នកចូលចិត្តទៅភាសាដែលអ្នកចង់បាន។ សេវាកម្មទាំងនេះអាចបញ្ចេញសំឡេងនៃអត្ថបទដែលបានបកប្រែ។ សូមយល់ថា ពេលប្រើស្គាល់សំឡេង អ្នកស្គាល់សំឡេងអាចមិនចាប់យកសំឡេងបញ្ចេញពីឧបករណ៍របស់អ្នកបានទាំងស្រុង។ ដូច្នេះ អ្នកអាចត្រូវការប្រើឧបករណ៍បន្ថែមក្រៅពីសំឡេងបញ្ចេញ។
> ឧទាហរណ៍ ប្រសិនបើអ្នកបណ្តុះបណ្តាល LUIS ជាភាសាអង់គ្លេស ប៉ុន្តាចង់ប្រើភាសាបារាំងជាភាសារបស់អ្នកប្រើ អ្នកអាចបកប្រែអត្ថបទដូចជា "set a 2 minute and 27 second timer" ពីភាសាអង់គ្លេសទៅភាសាបារាំង តាមរយៈ Bing Translate ហើយប្រើប៊ូតុង **Listen translation** ដើម្បីនិយាយសំឡេងចូលទៅក្នុងម៉ាញ៉េក្រូហ្វូនរបស់អ្នក។
> ![ប៊ូតុងស្ដាប់ការបកប្រែលើ Bing translate](../../../../../translated_images/km/bing-translate.348aa796d6efe2a9.webp)
1. ជំនួសសេចក្ដីប្រកាស `recognizer_config` និង `recognizer` ជាមួយខាងក្រោម៖
```python
translation_config = SpeechTranslationConfig(subscription=speech_api_key,
region=location,
speech_recognition_language=language,
target_languages=(language, server_language))
recognizer = TranslationRecognizer(translation_config=translation_config)
```
នេះបង្កើតបរិបទបកប្រែដើម្បីស្គាល់សំឡេងនៅក្នុងភាសាអ្នកប្រើ និងបង្កើតការបកប្រែជាភាសាអ្នកប្រើ និងភាសាម៉ាស៊ីនមេ។ បន្ទាប់មកប្រើបរិបទនេះ ដើម្បីបង្កើតម្ចាស់ស្គាល់សំឡេងបកប្រែ - ម្ចាស់ស្គាល់សំឡេងដែលអាចបកប្រែផលបញ្ចេញពីការស្គាល់សំឡេងទៅភាសាច្រើន។
> 💁 ភាសាដើមត្រូវបានកំណត់ក្នុង `target_languages` ដូច្នេះអ្នកមិនបានទទួលការបកប្រែអ្វីទេ។
1. ប្រែប្រួលមុខងារ `recognized` ដោយជំនួសមាតិកាទាំងមូលនៃមុខងារជាមួយខាងក្រោម៖
```python
if args.result.reason == speech.ResultReason.TranslatedSpeech:
language_match = next(l for l in args.result.translations if server_language.lower().startswith(l.lower()))
text = args.result.translations[language_match]
if (len(text) > 0):
print(f'Translated text: {text}')
message = Message(json.dumps({ 'speech': text }))
device_client.send_message(message)
```
កូដនេះពិនិត្យមើលថា ព្រឹត្តិការណ៍ recognized ត្រូវបានបញ្ចេញ ពីព្រោះសំឡេងត្រូវបានបកប្រែ (ព្រឹត្តិការណ៍នេះអាចបញ្ចេញនៅពេលផ្សេងៗ ដូចជា ពេលសម្ដីត្រូវបានស្គាល់ ប៉ុន្តែមិនត្រូវបានបកប្រែ)។ ប្រសិនបើសំឡេងត្រូវបានបកប្រែ វានឹងស្វែងរកការបកប្រែក្នុង `args.result.translations` ដែលសម្រូវនឹងភាសាម៉ាស៊ីនមេ។
ភាសាក្នុង `args.result.translations` ត្រូវបានកំណត់តាមផ្នែកភាសានៃការកំណត់ប្រភេទ ភាគរយមិនគិតតាមសរុបនៃការកំណត់ប្រភេទទេ។ ឧទាហរណ៍ ប្រសិនបើអ្នកស្នើសុំការបកប្រែទៅ `fr-FR` សម្រាប់ភាសាបារាំង វានឹងមានធាតុសម្រាប់ `fr` មិនមែន `fr-FR` ទេ។
អត្ថបទដែលបានបកប្រែក្រោយមកត្រូវបានផ្ញើទៅ IoT Hub។
1. ចាប់ផ្តើមកូដនេះ ដើម្បីសាកល្បងការបកប្រែ។ ប្រាកដថា function app របស់អ្នកកំពុងដំណើរការ ហើយស្នើសុំម៉ោងតាមភាសាអ្នកប្រើ ដោយនិយាយភាសានោះផ្ទាល់ ឬប្រើកម្មវិធីបកប្រែ។
```output
(.venv) ➜ smart-timer python app.py
Connecting
Connected
Translated text: Set a timer of 2 minutes and 27 seconds.
```
## បកប្រែអត្ថបទដោយប្រើសេវាកម្ម Translator
សេវាសំឡេងមិនគាំទ្រការបកប្រែអត្ថបទវិលត្រឡប់ទៅជាសំឡេងវិញទេ ជំនួសវាអ្នកអាចប្រើសេវា Translator ដើម្បីបកប្រែអត្ថបទ។ សេវានេះមាន REST API ដែលអ្នកអាចប្រើសម្រាប់បកប្រែអត្ថបទ។
### ភារកិច្ច - ប្រើធនធាន translator ដើម្បីបកប្រែអត្ថបទ
1. បន្ថែម key API translator នៅខាងក្រោម `speech_api_key`:
```python
translator_api_key = '<key>'
```
ជំនួស `<key>` ជាមួយ key API សម្រាប់ធនធានសេវាអូសិច Translator របស់អ្នក។
1. ខាងលើមុខងារ `say` សរសេរមុខងារ `translate_text` ដែលនឹងបកប្រែអត្ថបទពីភាសាម៉ាស៊ីនមេទៅភាសាអ្នកប្រើ៖
```python
def translate_text(text):
```
1. នៅក្នុងមុខងារនេះ កំណត់ URL និង headers សម្រាប់ហៅ REST API៖
```python
url = f'https://api.cognitive.microsofttranslator.com/translate?api-version=3.0'
headers = {
'Ocp-Apim-Subscription-Key': translator_api_key,
'Ocp-Apim-Subscription-Region': location,
'Content-type': 'application/json'
}
```
URL សម្រាប់ API នេះមិនខ្ចីជតិសម្រាប់ទីកន្លែងណាមួយទេ ទេ ត្រូវបញ្ជាក់ទីកន្លែងជាក្បាលសំណើ។ API key ត្រូវបានប្រើដោយផ្ទាល់ ដូច្នេះ មិនចាំបាច់ទទួលបាន access token ពី token issuer API ដូចសេវាសំឡេង ។
1. ខាងក្រោមនេះកំណត់ parameters និង body សម្រាប់ពាក់ព័ន្ធ៖
```python
params = {
'from': server_language,
'to': language
}
body = [{
'text' : text
}]
```
`params` កំណត់ប៉ារ៉ាម៉ែត្រ សម្រាប់ផ្ញើទៅ API ហៅពីភាសា និងទៅភាសា ។ ការហៅនេះនឹងបកប្រែអត្ថបទពីភាសា `from` ទៅភាសា `to`
`body` មានអត្ថបទដែលត្រូវបកប្រែ។ វាជាអារេ ខណៈកំណត់អត្ថបទច្រើនអាចបកប្រែបានក្នុងការហៅមួយនេះ។
1. ហៅ REST API ហើយទទួលបានចម្លើយ៖
```python
response = requests.post(url, headers=headers, params=params, json=body)
```
ចម្លើយដែលត្រូវបានត្រឡប់មកវិញ គឺជា JSON array ដែលមានធាតុមួយដែលមានការបកប្រែ។ ធាតុនេះមានអារេសម្រាប់ការបកប្រែសម្រាប់ធាតុទាំងអស់ដែលបានផ្ញើក្នុង body។
```json
[
{
"translations": [
{
"text": "Chronométrant votre minuterie de 2 minutes 27 secondes.",
"to": "fr"
}
]
}
]
```
1. ត្រឡប់មកលទ្ធផល `test` ពីការបកប្រែដំបូងក្នុងធាតុដំបូងនៃអារេ៖
```python
return response.json()[0]['translations'][0]['text']
```
1. បន្ទាប់មុខងារ `say` ដើម្បីបកប្រែអត្ថបទនឹងនិយាយ មុនពេលផលិត SSML៖
```python
print('Original:', text)
text = translate_text(text)
print('Translated:', text)
```
កូដនេះ ក៏បោះពុម្ពនូវអត្ថបទដើម និងអត្ថបទបកប្រែទៅកាន់ console ផងដែរ។
1. ដំណើរការកូដរបស់អ្នក។ ប្រាកដថា function app របស់អ្នកកំពុងដំណើរការ ហើយស្នើសុំម៉ោងនៅភាសាអ្នកប្រើ ដោយនិយាយភាសានោះផ្ទាល់ ឬប្រើកម្មវិធីបកប្រែ។
```output
(.venv) ➜ smart-timer python app.py
Connecting
Connected
Translated text: Set a timer of 2 minutes and 27 seconds.
Original: 2 minute 27 second timer started.
Translated: 2 minute 27 seconde minute a commencé.
Original: Times up on your 2 minute 27 second timer.
Translated: Chronométrant votre minuterie de 2 minutes 27 secondes.
```
> 💁 ដូចជា វិធីនិយាយរបស់មនុស្សនៅភាសាផ្សេងៗគ្នាខុសគ្នា អ្នកប្រហែលជានឹងបានការបកប្រែខុសប្លែកពីឧទាហរណ៍ដែលអ្នកផ្តល់ឲ្យ LUIS។ ប្រសិនបើបែបនេះ សូមបន្ថែមឧទាហរណ៍មួយចំនួនទៀតទៅ LUIS បណ្តុះបណ្តាលឡើងវិញ ហើយចេញផ្សាយម៉ូឌែលម្តងទៀត។
> 💁 អ្នកអាចស្វែងរកកូដនេះនៅក្នុងថត [code/virtual-iot-device](../../../../../6-consumer/lessons/4-multiple-language-support/code/virtual-iot-device)។
😀 កម្មវិធីម៉ោងច្រើនភាសារបស់អ្នកបានជោគជ័យ!
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**:
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលយើងខំប្រឹងសម្រាប់ការពិតប្រាកដ សូមយល់ដឹងថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុស ឬចំណុចដែលមិនត្រឹមត្រូវ។ ឯកសារដើមជាភាសាដើម គួរត្រូវបានរាប់បញ្ចូលជាផ្នែកដ៏សំខាន់ជាមូលដ្ឋាន។ សម្រាប់ព័ត៌មានសំខាន់ៗ សូមផ្ដល់អាទិភាពការបកប្រែដោយមនុស្សជំនាញវិជ្ជាជីវៈ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,277 @@
# បកប្រែសូភាសា - Wio Terminal
ក្នុងផ្នែកនេះនៃមេរៀន អ្នកនឹងសរសេរកូដដើម្បីបកប្រែអត្ថបទដោយប្រើសេវាកម្មអ្នកបកប្រែ។
## បំលែងអត្ថបទទៅជាសូរ្យដោយប្រើសេវាកម្មអ្នកបកប្រែ
សេវាកម្មសូរ្យ REST API មិនគាំទ្រការបកប្រែដោយផ្ទាល់ទេ ទោះយ៉ាងណា អ្នកអាចប្រើសេវាកម្មអ្នកបកប្រែ ដើម្បីបកប្រែអត្ថបទដែលបានបង្កើតដោយសេវាកម្មសូរ្យទៅអត្ថបទ និងអត្ថបទនៃការឆ្លើយតបទៅជាសូរ្យ។ សេវាកម្មនេះមាន REST API ដែលអ្នកអាចប្រើដើម្បីបកប្រែអត្ថបទ ប៉ុន្តែដើម្បីឲ្យងាយស្រួលក្នុងការប្រើ នេះនឹងត្រូវបានរុំជុំក្នុងវីធីគ្រាប់ HTTP ផ្សេងទៀតនៅក្នុងកម្មវិធី function របស់អ្នក។
### ភារកិច្ច - បង្កើត function ដែលមិនមានម៉ាស៊ីនបម្រើសម្រាប់បកប្រែអត្ថបទ
1. បើកគម្រោង `smart-timer-trigger` របស់អ្នកនៅក្នុង VS Code ហើយបើក terminal ដើម្បីធានាថាបរិយាកាសសំណុំបែបបទបានដំណើរការ។ ប្រសិនបើមិនដំណើរការ សូមបិទ ហើយបង្កើត terminal ថ្មីម្តងទៀត។
1. បើកក្រុមហ៊ុន `local.settings.json` ហើយបន្ថែមការកំណត់សម្រាប់កូនសោ API និងទីតាំងសម្រាប់សេវាកម្មអ្នកបកប្រែ៖
```json
"TRANSLATOR_KEY": "<key>",
"TRANSLATOR_LOCATION": "<location>"
```
ជំនួស `<key>` ជាមួយកូនសោ API សម្រាប់ធនធានសេវាកម្មអ្នកបកប្រែរបស់អ្នក។ ជំនួស `<location>` ជាមួយទីតាំងដែលអ្នកប្រើពេលបង្កើតធនធានសេវាកម្មអ្នកបកប្រែ។
1. បន្ថែម HTTP trigger ថ្មីឈ្មោះ `translate-text` ទៅកម្មវិធីនេះដោយប្រើពាក្យបញ្ជាតាមដំណាក់កាលក្នុង terminal VS Code នៅថត root របស់គម្រោង function app៖
```sh
func new --name translate-text --template "HTTP trigger"
```
វានឹងបង្កើត HTTP trigger ឈ្មោះ `translate-text`
1. ជំនួសមាតិកានៃឯកសារ `__init__.py` នៅក្នុងថត `translate-text` ជាមួយអ្វីដូចខាងក្រោម៖
```python
import logging
import os
import requests
import azure.functions as func
location = os.environ['TRANSLATOR_LOCATION']
translator_key = os.environ['TRANSLATOR_KEY']
def main(req: func.HttpRequest) -> func.HttpResponse:
req_body = req.get_json()
from_language = req_body['from_language']
to_language = req_body['to_language']
text = req_body['text']
logging.info(f'Translating {text} from {from_language} to {to_language}')
url = f'https://api.cognitive.microsofttranslator.com/translate?api-version=3.0'
headers = {
'Ocp-Apim-Subscription-Key': translator_key,
'Ocp-Apim-Subscription-Region': location,
'Content-type': 'application/json'
}
params = {
'from': from_language,
'to': to_language
}
body = [{
'text' : text
}]
response = requests.post(url, headers=headers, params=params, json=body)
return func.HttpResponse(response.json()[0]['translations'][0]['text'])
```
កូដនេះដកអត្ថបទ និងភាសាពីសំណើ HTTP។ បន្ទាប់មកវាចេញសំណើទៅកាន់ REST API នៃអ្នកបកប្រែ ដោយផ្ញើភាសាជាពារព័ន្ធសម្រាប់ URL និងអត្ថបទដែលត្រូវបកប្រែជារូបភាពសម្រាប់ body។ ហើយចុងក្រោយ បកប្រែត្រូវបានត្រឡប់មកវិញ។
1. ដំណើរការកម្មវិធី function app របស់អ្នកក្នុងបរិយាកាសក្នុងមូលដ្ឋាន។ បន្ទាប់មក អ្នកអាចហៅវាតាមរបៀបប្រើឧបករណ៍ដូចជា curl ដូច្នេះអ្នកបានសាកល្បង HTTP trigger `text-to-timer` របស់អ្នក។ សូមប្រាកដថាបញ្ជូនអត្ថបទដែលត្រូវបកប្រែ និងភាសាជាលំហូរជា JSON body៖
```json
{
"text": "Définir une minuterie de 30 secondes",
"from_language": "fr-FR",
"to_language": "en-US"
}
```
ឧទាហរណ៍នេះបកប្រែ *Définir une minuterie de 30 secondes* ពីភាសាបារាំងទៅភាសាអង់គ្លេសអាមេរិក។ វានឹងត្រឡប់បាន *Set a 30-second timer*
> 💁 អ្នកអាចរកឃើញកូដនេះនៅក្នុងថត [code/functions](../../../../../6-consumer/lessons/4-multiple-language-support/code/functions)។
### ភារកិច្ច - ប្រើ function អ្នកបកប្រែដើម្បីបកប្រែអត្ថបទ
1. បើកគម្រោង `smart-timer` ក្នុង VS Code ប្រសិនបើវាមិនត្រូវបានបើករួចទេ។
1. ម៉ោងរាប់អ៊ីវ៉ែនឌង់របស់អ្នកនឹងមានភាសា 2 ភាសាត្រូវបានកំណត់ - ភាសានៃម៉ាស៊ីនបម្រើដែលបានប្រើសម្រាប់បណ្តុះបណ្តាល LUIS (ភាសាដដែលក៏បានប្រើសម្រាប់បង្កើតសារដែលនឹងនិយាយទៅឲ្យអ្នកប្រើ) និងភាសាដែលអ្នកប្រើនិយាយ។ អាប់ដេតថេរ `LANGUAGE` នៅក្នុងឯកសារ header `config.h` ដើម្បីជា ភាសាដែលនឹងនិយាយដោយអ្នកប្រើ ហើយបន្ថែមថេរ ថ្មីមួយរបស់ឈ្មោះ `SERVER_LANGUAGE` សម្រាប់ភាសាដែលប្រើសម្រាប់បណ្តុះបណ្តាល LUIS៖
```cpp
const char *LANGUAGE = "<user language>";
const char *SERVER_LANGUAGE = "<server language>";
```
ជំនួស `<user language>` ជាជាឈ្មោះ locale សម្រាប់ភាសាដែលអ្នកនឹងនិយាយ ឧទាហរណ៍ `fr-FR` សម្រាប់ភាសាបារាំង ឬ `zn-HK` សម្រាប់ភាសាកាន់តូន៉េស។
ជំនួស `<server language>` ជាឈ្មោះ locale សម្រាប់ភាសាដែលបានប្រើសម្រាប់បណ្តុះបណ្តាល LUIS។
អ្នកអាចរកបញ្ជីភាសាដែលគាំទ្រនិងឈ្មោះ locale របស់ពួកវានៅក្នុង [ឯកសារគាំទ្រភាសា និងសូរ្យនៅលើឯកសារ Microsoft docs](https://docs.microsoft.com/azure/cognitive-services/speech-service/language-support?WT.mc_id=academic-17441-jabenn#speech-to-text)។
> 💁 ប្រសិនបើអ្នកមិននិយាយភាសាច្រើន អ្នកអាចប្រើសេវាកម្មដូចជា [Bing Translate](https://www.bing.com/translator) ឬ [Google Translate](https://translate.google.com) ដើម្បីបកប្រែពីភាសាដែលអ្នកចូលចិត្តទៅភាសាដែលអ្នកចង់បាន។ សេវាកម្មទាំងនេះអាចលេងសម្លេងសំឡេងអត្ថបទដែលបានបកប្រែ។
> ឧទាហរណ៍ ប្រសិនបើអ្នកបណ្តុះបណ្តាល LUIS ជាភាសាអង់គ្លេស ប៉ុន្តាចង់ប្រើភាសាបារាំងជាភាសាអ្នកប្រើ អ្នកអាចបកប្រែប្រយោគដូចជា "set a 2 minute and 27 second timer" ពីភាសាអង់គ្លេស ទៅភាសាបារាំង ដោយប្រើ Bing Translate បន្ទាប់មកប្រើប៊ូតុង **Listen translation** ដើម្បីនិយាយការបកប្រែតាមមីក្រូហ្វូនរបស់អ្នក។
> ![ប៊ូតុងនិយាយការបកប្រែលើ Bing translate](../../../../../translated_images/km/bing-translate.348aa796d6efe2a9.webp)
1. បន្ថែមកូនសោ API នៃអ្នកបកប្រែ និងទីតាំងខាងក្រោម `SPEECH_LOCATION`
```cpp
const char *TRANSLATOR_API_KEY = "<KEY>";
const char *TRANSLATOR_LOCATION = "<LOCATION>";
```
ជំនួស `<KEY>` ជាមួយកូនសោ API ផ្នែកធនធានសេវាកម្មអ្នកបកប្រែរបស់អ្នក។ ជំនួស `<LOCATION>` ជាមួយទីតាំងដែលអ្នកប្រើពេលបង្កើតធនធានសេវាកម្មអ្នកបកប្រែ។
1. បន្ថែម URL នៃអ្នកបកប្រែ trigger ខាងក្រោម `VOICE_URL`
```cpp
const char *TRANSLATE_FUNCTION_URL = "<URL>";
```
ជំនួស `<URL>` ជា URL សម្រាប់ HTTP trigger `translate-text` លើកម្មវិធី function app របស់អ្នក។ វានឹងដូចនឹងតម្លៃសម្រាប់ `TEXT_TO_TIMER_FUNCTION_URL` ប៉ុន្តែម្នាក់ឯងមានឈ្មោះ function ជា `translate-text` មិនមែន `text-to-timer` ទេ។
1. បន្ថែមឯកសារថ្មីមួយទៅថត `src` ឈ្មោះ `text_translator.h`
1. ឯកសារ header ថ្មីនេះ `text_translator.h` នឹងមានថ្នាក់សម្រាប់បកប្រែអត្ថបទ។ បន្ថែមអ្វីខាងក្រោមទៅឯកសារនេះដើម្បីប្រកាសថ្នាក់នេះ៖
```cpp
#pragma once
#include <Arduino.h>
#include <ArduinoJson.h>
#include <HTTPClient.h>
#include <WiFiClient.h>
#include "config.h"
class TextTranslator
{
public:
private:
WiFiClient _client;
};
TextTranslator textTranslator;
```
នេះប្រកាសថ្នាក់ `TextTranslator` ជាមួយនឹងឧទាហរណ៍មួយនៃថ្នាក់នេះ។ ថ្នាក់មានព_field_តែមួយសម្រាប់ client WiFi។
1. នៅផ្នែក `public` នៃថ្នាក់នេះ បន្ថែមវិធីសាស្ត្រមួយសម្រាប់បកប្រែអត្ថបទ៖
```cpp
String translateText(String text, String from_language, String to_language)
{
}
```
វិធីសាស្ត្រនេះទទួលភាសាដែលត្រូវបកប្រែពី និងភាសាដែលត្រូវបកប្រែទៅ។ នៅពេលដំណើរការសូរ្យ សូរ្យនឹងត្រូវបកប្រែពីភាសាអ្នកប្រើទៅភាសាម៉ាស៊ីនបម្រើ LUIS ហើយនៅពេលផ្តល់ចម្លើយ វានឹងបកប្រែពីភាសា LUIS ម៉ាស៊ីនបម្រើ ទៅភាសា អ្នកប្រើ។
1. ក្នុងវិធីសាស្ត្រនេះ បន្ថែមកូដដើម្បីបង្កើត JSON body ដែលមានអត្ថបទដែលត្រូវបកប្រែ និងភាសា៖
```cpp
DynamicJsonDocument doc(1024);
doc["text"] = text;
doc["from_language"] = from_language;
doc["to_language"] = to_language;
String body;
serializeJson(doc, body);
Serial.print("Translating ");
Serial.print(text);
Serial.print(" from ");
Serial.print(from_language);
Serial.print(" to ");
Serial.print(to_language);
```
1. ខាងក្រោមនេះ បន្ថែមកូដដើម្បីផ្ញើ body ទៅកម្មវិធី function app ដែលមិនមានម៉ាស៊ីនបម្រើ៖
```cpp
HTTPClient httpClient;
httpClient.begin(_client, TRANSLATE_FUNCTION_URL);
int httpResponseCode = httpClient.POST(body);
```
1. បន្ទាប់មក បន្ថែមកូដដើម្បីទទួលបានការឆ្លើយតប៖
```cpp
String translated_text = "";
if (httpResponseCode == 200)
{
translated_text = httpClient.getString();
Serial.print("Translated: ");
Serial.println(translated_text);
}
else
{
Serial.print("Failed to translate text - error ");
Serial.println(httpResponseCode);
}
```
1. ចុងក្រោយ បន្ថែមកូដដើម្បីបិទការតភ្ជាប់ និងត្រឡប់អត្ថបទដែលបានបកប្រែ៖
```cpp
httpClient.end();
return translated_text;
```
### ភារកិច្ច - បកប្រែសូរ្យដែលត្រូវបានទទួលស្គាល់ និងចម្លើយ
1. បើកឯកសារ `main.cpp`
1. បន្ថែមបញ្ជា include នៅខាងលើឯកសារ សម្រាប់ឯកសារ header នៃថ្នាក់ `TextTranslator`
```cpp
#include "text_translator.h"
```
1. អត្ថបទដែលនិយាយពេលម៉ោងធ្វើការកំណត់ ឬផុតកំណត់ត្រូវបានបកប្រែ។ ដើម្បីធ្វើបាន នេះ បន្ថែមអត្ថបទដូចខាងក្រោមជាថ្មីជួរដាក់ជួរដំបូងរបស់មុខងារ `say`
```cpp
text = textTranslator.translateText(text, LANGUAGE, SERVER_LANGUAGE);
```
វានឹងបកប្រែអត្ថបទទៅភាសាអ្នកប្រើ។
1. ក្នុងមុខងារ `processAudio` អត្ថបទត្រូវបានទាញយកពីសម្លេងដែលបានចាប់យកជាមួយកាល `String text = speechToText.convertSpeechToText();`។ បន្ទាប់ពីការហៅនេះ បកប្រែអត្ថបទ៖
```cpp
String text = speechToText.convertSpeechToText();
text = textTranslator.translateText(text, LANGUAGE, SERVER_LANGUAGE);
```
វានឹងបកប្រែអត្ថបទពីភាសាអ្នកប្រើទៅភាសាដែលប្រើនៅលើម៉ាស៊ីនបម្រើ។
1. បង្កើតកូដនេះ​, បញ្ចូនវាទៅ Wio Terminal របស់អ្នក ហើយសាកល្បងវាតាមរយៈម៉ូនីទ័រ serial។ បន្ទាប់ពីអ្នកឃើញ `Ready` នៅក្នុងម៉ូនីទ័រ serial សូមចុចប៊ូតុង C (ប៊ូតុងនៅខាងឆ្វេងសំរាប់ជិតប៊ូតុងថាមពល) ហើយនិយាយ។ សូមប្រាកដថាកម្មវិធី function app របស់អ្នកកំពុងដំណើរការ ហើយស្នើសុំម៉ោងរាប់ជាភាសាអ្នកប្រើ ម្តងទៀត អាចនិយាយភាសានេះដោយខ្លួនឯង ឬប្រើកម្មវិធីបកប្រែ។
```output
Connecting to WiFi..
Connected!
Got access token.
Ready.
Starting recording...
Finished recording
Sending speech...
Speech sent!
{"RecognitionStatus":"Success","DisplayText":"Définir une minuterie de 2 minutes 27 secondes.","Offset":9600000,"Duration":40400000}
Translating Définir une minuterie de 2 minutes 27 secondes. from fr-FR to en-US
Translated: Set a timer of 2 minutes 27 seconds.
Set a timer of 2 minutes 27 seconds.
{"seconds": 147}
Translating 2 minute 27 second timer started. from en-US to fr-FR
Translated: 2 minute 27 seconde minute a commencé.
2 minute 27 seconde minute a commencé.
Translating Times up on your 2 minute 27 second timer. from en-US to fr-FR
Translated: Chronométrant votre minuterie de 2 minutes 27 secondes.
Chronométrant votre minuterie de 2 minutes 27 secondes.
```
> 💁 អ្នកអាចរកឃើញកូដនេះនៅក្នុងថត [code/wio-terminal](../../../../../6-consumer/lessons/4-multiple-language-support/code/wio-terminal)។
😀 ប្រ​កា​ស​លទ្ធិ​កម្ម​កម្មវិធីម៉ោងរាប់ភាសាច្រើន​របស់​អ្នកបាន​ជោគជ័យ!
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបញ្ចាក់**៖
ឯកសារនេះត្រូវបានបម្លែងភាសាដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលដែលយើងខិតខំធ្វើឱ្យបានត្រឹមត្រូវ សូមប្រយ័ត្នថាការបកប្រែដោយស្វ័យប្រវត្តិនេះអាចមានកំហុសឬមិនត្រឹមត្រូវខ្លះ។ ឯកសារដើមក្នុងភាសាតំណើរការមានតម្លៃជារបស់ដើមដែលអាចជាការយោងដ៏ត្រឹមត្រូវ។ សម្រាប់ព័ត៌មានសំខាន់សូមណែនាំឱ្យបកប្រែដោយអ្នកជំនាញមនុស្សជាផ្លូវការជំនួយ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសៗនាដែលកើតមានពីការប្រើប្រាស់ការបកប្រែនេះនោះទេ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,16 @@
# ច្បាប់អនុលោមការបើកប្រភពរបស់ Microsoft
គម្រោងនេះបានអនុម័ត [ច្បាប់អនុលោមការបើកប្រភពរបស់ Microsoft](https://opensource.microsoft.com/codeofconduct/)។
ធនធាន៖
- [ច្បាប់អនុលោមការបើកប្រភពរបស់ Microsoft](https://opensource.microsoft.com/codeofconduct/)
- [សំណួរញែកៗ អំពីច្បាប់អនុលោមការបើកប្រភពរបស់ Microsoft](https://opensource.microsoft.com/codeofconduct/faq/)
- ទំនាក់ទំនង [opencode@microsoft.com](mailto:opencode@microsoft.com) សម្រាប់សំណួរឬបញ្ហា
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការព្រមាន**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈដែលយើងខិតខំប្រឹងប្រែងដើម្បីភាពត្រឹមត្រូវ សូមយល់ដឹងថាការបកប្រែដោយស្វ័យប្រវត្តិនេះអាចមានកំហុស ឬមិនត្រឹមត្រូវខ្លះៗ។ ឯកសារដើមនៅក្នុងភាសាមូលដ្ឋានត្រូវបានគេយកឱ្យជា ប្រភពអនុញ្ញាត ។ សម្រាប់ព័ត៌មានសំខាន់ ដាក់អនុសាសន៍ឲ្យប្រើការបកប្រែដោយមនុស្សជំនាញវិជ្ជាជីវៈ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសពីការប្រើប្រាស់ការបកប្រែនេះដែរ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,18 @@
# ចូលរួម
គម្រោងនេះស្វាគមន៍ការចូលរួម និងការផ្តល់យោបល់។ ការចូលរួមភាគច្រើនតម្រូវឲ្យអ្នកយល់ព្រមចំពោះ សន្ធិសញ្ញាប័ណ្ណអ្នកចូលរួម (CLA) ដែលប្រកាសថាអ្នកមានសិទ្ធិ និងពិតជាផ្តល់សិទ្ធិឲ្យយើងប្រើប្រាស់ការចូលរួមរបស់អ្នក។ សម្រាប់ព័ត៌មានលម្អិត សូមចូលទៅកាន់ https://cla.microsoft.com។
> สำคัญ: នៅពេលបម្លែងអត្ថបទនៅក្នុងរ៉េប៉ូនេះ សូមប្រាកដថាអ្នកមិនប្រើការបម្លែងដោយម៉ាស៊ីនទេ។ យើងនឹងពិនិត្យការបំលែងតាមរយៈសហគមន៍ ដូច្នេះសូមចូលរួមគ្រាន់តែសម្រាប់ភាសាដែលអ្នកមានជំនាញប៉ុណ្ណោះ។
ពេលអ្នកដាក់សំណើ pull request មួយ CLA-bot នឹងកំណត់ដោយស្វ័យប្រវត្តិយថាអ្នកត្រូវការផ្ដល់ CLA ដែរឬទេ ហើយតុបតែង PR ដូចគ្នា (ឧ. ស្លាក, សំណេីចំលែក)។ គ្រាន់តែអនុវត្តបណ្តា ព៍ធការដែលបូតផ្ដល់ឲ្យ។ អ្នកត្រូវតែធ្វើបែបនេះតែម្តងតែមួយសម្រាប់គ្រប់រ៉េប៉ូដែលប្រើ CLA របស់យើង។
គម្រោងនេះបានទទួលយក [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/)។
សម្រាប់ព័ត៌មានបន្ថែម សូមអាន [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
ឬទាក់ទង [opencode@microsoft.com](mailto:opencode@microsoft.com) សម្រាប់សំណួរឬមតិយោបល់បន្ថែម។
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ** ៖
ឯកសារនេះត្រូវបានបម្លែងភាសាដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ទោះបីយើងខិតខំដើម្បីបានភាពត្រឹមត្រូវ ក៏សូមយកចិត្តទុកដាក់ថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុស ឬភាពមិនត្រឹមត្រូវមួយចំនួន។ ឯកសារដើមដែលមានភាសា​ដើម​គួរត្រូវបានគេចាត់ទុកជាក្រមសីលធម៌សំខាន់។ សម្រាប់ព័ត៌មានចាំបាច់ ការបកប្រែដោយមនុស្សជំនាញត្រូវបានផ្តល់អាណិត។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំឬការបកប្រែខុសដែលកើតឡើងពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,222 @@
[![អាជ្ញាប័ណ្ណ GitHub](https://img.shields.io/github/license/microsoft/IoT-For-Beginners.svg)](https://github.com/microsoft/IoT-For-Beginners/blob/master/LICENSE)
[![អ្នកចូលរួម GitHub](https://img.shields.io/github/contributors/microsoft/IoT-For-Beginners.svg)](https://GitHub.com/microsoft/IoT-For-Beginners/graphs/contributors/)
[![បញ្ហា GitHub](https://img.shields.io/github/issues/microsoft/IoT-For-Beginners.svg)](https://GitHub.com/microsoft/IoT-For-Beginners/issues/)
[![សំណើ Pull Requests GitHub](https://img.shields.io/github/issues-pr/microsoft/IoT-For-Beginners.svg)](https://GitHub.com/microsoft/IoT-For-Beginners/pulls/)
[![ស្វាគមន៍ PRs](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
[![អ្នកគាំទ្រ GitHub](https://img.shields.io/github/watchers/microsoft/IoT-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/IoT-For-Beginners/watchers/)
[![សាខា GitHub](https://img.shields.io/github/forks/microsoft/IoT-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/IoT-For-Beginners/network/)
[![ផ្កាយ GitHub](https://img.shields.io/github/stars/microsoft/IoT-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/IoT-For-Beginners/stargazers/)
### ចូលរួមសហគមន៍ Azure AI Foundry
បើអ្នកមានបញ្ហា ឬសំណួរណាមួយអំពីការបង្កើតកម្មវិធី AI។ ចូលរួមជាមួយអ្នករៀន និងអ្នកអភិវឌ្ឍមានបទពិសោធន៍ ក្នុងការពិភាក្សាអំពី MCP។ វាជាសហគមន៍ដ៏គាំទ្រដែលសំណួរត្រូវបានស្វាគមន៍ ហើយចំណេះដឹងត្រូវបានចែករំលែកដោយសេរី។
[![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG)
បើអ្នកមានមតិផ្ទាល់។ ឬកំហុសពេលកំពុងបង្កើត សូមចូលទៅកាន់៖
[![Discussion Forum Microsoft Foundry Developer](https://img.shields.io/badge/GitHub-Microsoft_Foundry_Developer_Forum-blue?style=for-the-badge&logo=github&color=000000&logoColor=fff)](https://aka.ms/foundry/forum)
អនុវត្តជំហានទាំងនេះដើម្បីចាប់ផ្តើមប្រើធនធានទាំងនេះ៖
1. **រុះរៀប Repository**៖ ចុច [![សាខា GitHub](https://img.shields.io/github/forks/microsoft/IoT-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/IoT-For-Beginners/fork)
2. **ចម្លង Repository**៖ `git clone https://github.com/microsoft/IoT-For-Beginners.git`
3. [**ចូលរួម Microsot Foundry Discord ហើយជួបអ្នកជំនាញ និងអ្នកអភិវឌ្ឍទាំងអស់**](https://discord.com/invite/ByRwuEEgH4)
### 🌐 ការគាំទ្រជាភាសាច្រើន
#### គាំទ្រដោយ GitHub Action (ស្វ័យប្រវត្តិ & លើសទៀងទាត់)
<!-- CO-OP TRANSLATOR LANGUAGES TABLE START -->
[អារ៉ាប់](../ar/README.md) | [បង់្គោលី](../bn/README.md) | [ប៊ុលហ្គារី](../bg/README.md) | [ភាសាប៊ឺម៉ា (មียนម៉ា)](../my/README.md) | [ចិន (សាមញ្ញ)](../zh-CN/README.md) | [ចិន (បែបប្រពៃណីហុងកុង)](../zh-HK/README.md) | [ចិន (បែបប្រពៃណីម៉ាកាវ)](../zh-MO/README.md) | [ចិន (បែបប្រពៃណីតៃវ៉ាន់)](../zh-TW/README.md) | [ខ្រូអាត](../hr/README.md) | [ឆែក](../cs/README.md) | [ដាណីស](../da/README.md) | [ហុល្លង់](../nl/README.md) | [អេស្ទូនីយ៉ា](../et/README.md) | [ហ្វាំងឡង់](../fi/README.md) | [បារាំង](../fr/README.md) | [អាល្លឺម៉ង់](../de/README.md) | [ក្រិច](../el/README.md) | [ហីប្រ៊ូ](../he/README.md) | [ឥណ្ឌា](../hi/README.md) | [ហ៊ុនហ្គារី](../hu/README.md) | [ឥណ្ឌូណេស៊ី](../id/README.md) | [អ៊ីតាលី](../it/README.md) | [ជប៉ុន](../ja/README.md) | [កណាដា](../kn/README.md) | [ខ្មែរ](./README.md) | [កូរ៉េ](../ko/README.md) | [លីថុយអានី](../lt/README.md) | [ម៉ាឡេ](../ms/README.md) | [ម៉ាឡាលៃឡាំ](../ml/README.md) | [ម៉ារ៉ាធ៊ី](../mr/README.md) | [នេប៉ាល់](../ne/README.md) | [ភីជាំង នៃនីហ្សេរីយ៉ា](../pcm/README.md) | [ណ័រវេ](../no/README.md) | [ភាសាផែរ(ហ្វាស៊ី)](../fa/README.md) | [ប៉ូឡូញ](../pl/README.md) | [ព័រទុយហ្គាល់ (ប្រេស៊ីល)](../pt-BR/README.md) | [ព័រទុយហ្គាល់ (ប៉ះតុហ្គាល់)](../pt-PT/README.md) | [ភាសាផ៊ុនជាប (កូម៊ូហ្គី)](../pa/README.md) | [រ៉ូម៉ានី](../ro/README.md) | [រុស្ស៊ី](../ru/README.md) | [ស៊ែប៊ី (ស៊ីរីលីក)](../sr/README.md) | [ស្ពៃក](../sk/README.md) | [ស្ពឺឡូវេនី](../sl/README.md) | [ស្ប៉ាញ](../es/README.md) | [ស្វាហ៊ីលី](../sw/README.md) | [ស៊ុយអែត](../sv/README.md) | [តាហ្គាឡុក (ហិលីពីន)](../tl/README.md) | [តាមីល](../ta/README.md) | [ទេលារូគូ](../te/README.md) | [ថៃ](../th/README.md) | [តួគី](../tr/README.md) | [អ៊ុយក្រែន](../uk/README.md) | [ឥណ្ឌូរ](../ur/README.md) | [វៀតណាម](../vi/README.md)
> **ចូលចិត្តចម្លងក្នុងតំបន់បណ្ដាញមែនទេ?**
>
> កម្មវិធីនេះមានការប្រែច្រើនជាភាសា 50+ ដែលបង្កើនទំហំទាញយកយ៉ាងមានសារៈសំខាន់។ ដើម្បីចម្លងដោយគ្មានការប្រែភាសា អ្នកអាចប្រើ sparse checkout:
>
> **Bash / macOS / Linux:**
> ```bash
> git clone --filter=blob:none --sparse https://github.com/microsoft/IoT-For-Beginners.git
> cd IoT-For-Beginners
> git sparse-checkout set --no-cone '/*' '!translations' '!translated_images'
> ```
>
> **CMD (Windows):**
> ```cmd
> git clone --filter=blob:none --sparse https://github.com/microsoft/IoT-For-Beginners.git
> cd IoT-For-Beginners
> git sparse-checkout set --no-cone "/*" "!translations" "!translated_images"
> ```
>
> វានឹងផ្តល់អ្វីគ្រប់យ៉ាងដែលអ្នកត្រូវការដើម្បីបញ្ចប់វគ្គសិក្សាដោយមានការទាញយកយ៉ាងលឿនជាងមុន។
<!-- CO-OP TRANSLATOR LANGUAGES TABLE END -->
# IoT សម្រាប់អ្នកចាប់ផ្តើម - មុខវិជ្ជា
អ្នកគាំទ្របង្ហោះពពក Azure នៅ Microsoft មានកិត្តិយសផ្តល់មុខវិជ្ជា 12 សប្ដាហ៍ 24 មេរៀន ដែលជាអំពីមូលដ្ឋាន IoT ។ មេរៀននីមួយៗមានសំណួរប្រឡងមុននិងក្រោយមេរៀន សេចក្ដីណែនាំដោយសរសេរដើម្បីបញ្ចប់មេរៀន ដំណោះស្រាយ កិច្ចការនិងច្រើនទៀត។ វិធីសាស្រ្តសិក្សាធ្វើតាមគម្រោងរបស់យើងអនុញ្ញាតឱ្យអ្នករៀនពេលកំពុងបង្កើត មុខងារដែលបានបញ្ជាក់ជាប្រសិទ្ធភាពសម្រាប់ជំនាញថ្មីៗ "នៅជាប់"។
គម្រោងទាំងនេះគ្របដណ្តប់ដំណើរការនៃអាហារពីស្រែទៅតុ។ វារួមបញ្ចូលស្រែ ការដឹកជញ្ជូន ផលិតរោងចក្រ រាយឡើងលក់ និងអ្នកប្រើប្រាស់ - ទាំងអស់នេះជាពហុឧស្សាហកម្មដែលពេញនិយមសម្រាប់ឧបករណ៍ IoT។
![ផែនទីផ្លូវសម្រាប់វគ្គសិក្សាបង្ហាញពី 24 មេរៀនគ្របដណ្ដាប់បណ្តាញរួមមានដំណើរណែនាំ ស្រែ ដឹកជញ្ជូន ការកែច្នៃ ការលក់រាយ និងការចម្អិន](../../translated_images/km/Roadmap.bb1dec285dda0eda.webp)
> រូបរាងដោយ [Nitya Narasimhan](https://github.com/nitya)។ ចុចរូបភាពដើម្បីមើលទំហំធំជាង។
**សូមអរគុណយ៉ាងប្រាកដចិត្តទៅកាន់អ្នកនិពន្ធរបស់យើង [Jen Fox](https://github.com/jenfoxbot), [Jen Looper](https://github.com/jlooper), [Jim Bennett](https://github.com/jimbobbennett) និងសិល្បករូបរាង [Nitya Narasimhan](https://github.com/nitya)។**
**សូមអរគុណដល់ក្រុមអ្នករៀន [Microsoft Learn Student Ambassadors](https://studentambassadors.microsoft.com?WT.mc_id=academic-17441-jabenn) ដែលបានពិនិត្យ និងបកប្រែមុខវិជ្ជានេះ - [Aditya Garg](https://github.com/AdityaGarg00), [Anurag Sharma](https://github.com/Anurag-0-1-A), [Arpita Das](https://github.com/Arpiiitaaa), [Aryan Jain](https://www.linkedin.com/in/aryan-jain-47a4a1145/), [Bhavesh Suneja](https://github.com/EliteWarrior315), [Faith Hunja](https://faithhunja.github.io/), [Lateefah Bello](https://www.linkedin.com/in/lateefah-bello/), [Manvi Jha](https://github.com/Severus-Matthew), [Mireille Tan](https://www.linkedin.com/in/mireille-tan-a4834819a/), [Mohammad Iftekher (Iftu) Ebne Jalal](https://github.com/Iftu119), [Mohammad Zulfikar](https://github.com/mohzulfikar), [Priyanshu Srivastav](https://www.linkedin.com/in/priyanshu-srivastav-b067241ba), [Thanmai Gowducheruvu](https://github.com/innovation-platform), និង [Zina Kamel](https://www.linkedin.com/in/zina-kamel/))។**
ជួបក្រុមការងាររបស់យើង!
[![វីដេអូផ្សព្វផ្សាយ](../../images/IOT.gif)](https://youtu.be/-wippUJRi5k)
**Gif ដោយ** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
> 🎥 ចុចរូបភាពខាងលើដើម្បីមើលវីដេអូអំពីគម្រោង!
> **គ្រូបង្គោល** យើងបាន [រួមបញ្ចូលការផ្តល់អនុសាសន៍](for-teachers.md) អំពីវិធីប្រើប្រាស់មុខវិជ្ជានេះ។ បើអ្នកចង់បង្កើតមេរៀនផ្ទាល់ខ្លួន យើងក៏បានរួមបញ្ចូល​ [ទម្រង់មេរៀន](lesson-template/README.md) ផងដែរ។
> **[សិស្ស](https://aka.ms/student-page)** ដើម្បីប្រើប្រាស់មុខវិជ្ជានេះដោយខ្លួនឯង សូមរុះរៀបឃ្លាំងទាំងមូល ហើយបញ្ចប់លំហាត់ដោយខ្លួនឯង ចាប់ផ្តើមការប្រឡងមុនវគ្គសិក្សា បន្ទាប់មកអានវគ្គសិក្សា និងបញ្ចប់សកម្មភាពផ្សេងទៀត។ ព្យាយាមបង្កើតគម្រោងដោយយល់ដឹងពីមេរៀន ជាងការចម្លងកូដដំណោះស្រាយ ទោះបីជាកូដនោះមាននៅក្នុងថត /solutions ក្នុងមេរៀនផ្អែកលើគម្រោងនីមួយៗ។ គំនិតមួយផ្សេងទៀត គឺបង្កើតក្រុមសិក្សាជាមួយមិត្តភក្តិ ហើយរៀនជាក្រុម។ សម្រាប់ការសិក្សាបន្ថែម យើងផ្តល់អនុសាសន៍ [Microsoft Learn](https://docs.microsoft.com/users/jimbobbennett/collections/ke2ehd351jopwr?WT.mc_id=academic-17441-jabenn)។
សម្រាប់មើលវីដេអូសង្ខេបពីវគ្គសិក្សានេះ សូមពិនិត្យមើលវីដេអូនេះ៖
[![វីដេអូផ្សព្វផ្សាយ](https://img.youtube.com/vi/bccEMm8gRuc/0.jpg)](https://youtube.com/watch?v=bccEMm8gRuc "វីដេអូផ្សព្វផ្សាយ")
> 🎥 ចុចរូបភាពខាងលើដើម្បីមើលវីដេអូអំពីគម្រោង!
## វិធីសាស្រ្តសិក្សា
យើងបានជ្រើសរើសគោលការណ៍ពីរនៅពេលបង្កើតមុខវិជ្ជានេះ៖ ដោយធានាថាវាប្រកបដោយគម្រោង និងរួមបញ្ចូលការប្រឡងជាញឹកញាប់។ នៅចុងបញ្ចប់នៃស៊េរីនេះ សិស្សនឹងបានបង្កើតប្រព័ន្ធត្រួតពិនិត្យរុក្ខជាតិ និងទឹក រថយន្តតាមដាន រោងចក្រច្នៃប្រឌិតដើម្បីតាមដាន និងពិនិត្យអាហារ និងម៉ាស៊ីនវាស់ពេលចម្អិនដោយកំណត់សំឡេងបាន ហើយបានរៀនមូលដ្ឋានអំពីអ៊ីនធឺណិតនៃវត្ថុ រួមមានវិធីសរសេរកូដឧបករណ៍ ភ្ជាប់ទៅពពក វិភាគទិន្នន័យ និងរត់ AI នៅលើមុំ។
ដោយធានាថាតម្រូវការបង្ហាញពីគម្រោង វិធីសាស្រ្តនេះធ្វើឲ្យមានការចូលរួមសម្រាប់សិស្ស និងការចងចាំគំនិតនឹងកាន់តែប្រសើរ។
បន្ថែមពីនេះ ការប្រឡងមិនធ្ងន់ធ្ងរមុនថ្នាក់ជួយបង្កើតការចាក់បញ្ចូលចិត្តច្បាស់លាស់សម្រាប់សិស្សក្នុងការរៀនមុខវិជ្ជា មួយទៀតការប្រឡងបន្ទាប់ពីថ្នាក់ធានាថានឹងមានការចងចាំបន្ថែម។ មុខវិជ្ជានេះត្រូវបានរចនាឡើងសម្រាប់ភាពបត់បែន និងភាពរីករាយ ហើយអាចអនុវត្តបានទាំងមូលឬផ្នែកតែមួយ។ គម្រោងចាប់ផ្តើមតូចហើយកាន់តែស្មុគស្មាញចុងបញ្ចប់រយៈពេល 12 សប្ដាហ៍។
គម្រោងនីមួយៗផ្អែកលើឧបករណ៍ពិភពលោកពិតដែលមានស្រាប់សម្រាប់សិស្ស និងអ្នកចំណូលចិត្ត។ គម្រោងនីមួយៗមើលទៅថ្នាក់គម្រោងជាក់លាក់ ផ្តល់ចំណេះដឹងមូលដ្ឋានពាក់ព័ន្ធ។ ដើម្បីជាអ្នកអភិវឌ្ឍជោគជ័យ វាជួយឲ្យយល់ដឹងអំពីវិស័យដែលអ្នកកំពុងដោះស្រាយបញ្ហា ការផ្តល់ចំណេះដឹងមូលដ្ឋាននេះអនុញ្ញាតឲ្យសិស្សគិតអំពីដំណោះស្រាយ IoT និងការរៀនរបស់ពួកគេក្នុងបរិបទនៃបញ្ហាពិភពរូបប្រាំដែលពួកគេអាចត្រូវបានស្នើឲ្យដោះស្រាយជាអ្នកអភិវឌ្ឍ IoT។ សិស្សរៀនពី "ហេតុអ្វី" នៃការដោះស្រាយដែលពួកគេចង់បង្កើត និងទទួលបានការយល់ដឹងអំពីអ្នកប្រើប្រាស់ចុងក្រោយ។
## គ្រឿងចក្រ
យើងមានជម្រើសសម្ភារៈ IoT ពីរ សម្រាប់ប្រើប្រាស់ក្នុងគម្រោង ដោយអាស្រ័យលើចំណូលចិត្តផ្ទាល់ខ្លួន, ចំណេះដឹងភាសាកម្មវិធី ឬចំណូលចិត្ត, គោលដៅរៀន និងភាពអាចប្រើបាន។ យើងក៏បានផ្តល់ជូនកំណែ 'សម្ភារៈវីរុស' សម្រាប់អ្នកដែលមិនអាចប្រើសម្ភារៈបាន ឬចង់រៀនបន្ថែមមុនពេលបញ្ចប់កិច្ចស្នើសុំទិញ។ អ្នកអាចអានបន្ថែម និងស្វែងរក 'បញ្ជីទៅហាង' នៅលើ[ទំព័រសម្ភារៈ](./hardware.md) រួមមានតំណភ្ជាប់ទិញឈុតបញ្ចប់ពីមិត្តភក្តិរបស់យើងនៅ Seeed Studio។
> 💁 សូមស្វែងរក[កូដអាកប្បកិរិយា](CODE_OF_CONDUCT.md), [ការចូលរួម](CONTRIBUTING.md), និង[ការបកប្រែ](TRANSLATIONS.md)ណែនាំ។ យើងសូមស្វាគមន៍មតិយោបល់ដ៏សាងសង់របស់អ្នក!
>
> 🔧 មានបញ្ហា? សូមពិនិត្យមើល[មគ្គុទេសក៍ដោះស្រាយ](TROUBLESHOOTING.md) សម្រាប់ដំណោះស្រាយបញ្ហាទូទៅ។
## មេរៀននីមួយៗរួមមាន៖
- សេចក្ដីសង្ខេបគំនូរ
- វីដេអូបន្ថែមតាមចំណង់
- កម្រងសំនួរកម្រិតកំសាន្តមុនមេរៀន
- មេរៀនសរសេរ
- សម្រាប់មេរៀនផ្អែកលើគម្រោង, សៀវភៅណែនាំជំហ៊ានៗសម្រាប់កែលម្អគម្រោង
- ភាសារពិនិត្យចំណេះដឹង
- បញ្ហាប្រឈម
- អានបន្ថែម
- ការចាត់តាំង
- [សំណួរបន្ទាប់មេរៀន](https://ff-quizzes.netlify.app/en/)
> **កំណត់ចំណាំអំពីសំណួរ**: សំណួរទាំងអស់ត្រូវបានរៀបចំក្នុងថត quiz-app សម្រាប់សំណួរចំនួន ៤៨ នៃម្នាក់នីមួយៗមានបីសំណួរ។ វាត្រូវបានភ្ជាប់ពីក្នុងមេរៀន ប៉ុន្តែកម្មវិធីសំណួរអាចដំណើរការជ្រុងឬផ្ដល់ទៅ Azure; អនុវត្តតាមការណែនាំនៅក្នុងថត `quiz-app`។ វាកំពុងត្រូវបានបកប្រែទៅភាសាផ្សេងៗយ៉ាងលាបស្តើង។
## មេរៀន
| | ឈ្មោះគម្រោង | គំនិតបានបង្រៀន | គោលបំណងសិក្សា | មេរៀនភ្ជាប់ |
| :---: | :------------------------------------: | :---------------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------: |
| 01 | [ការចាប់ផ្តើម](./1-getting-started/README.md) | ការណែនាំអំពី IoT | រៀនពីគ្រឹះនៃ IoT និងប្លុកសំណុំគ្រឹះក្នុងដំណោះស្រាយ IoT ដូចជាសង្គ្រោះ និងសេវាកម្មពពក ខណៈដែលអ្នកកំពុងដាក់ឧបករណ៍ IoT ដំបូងរបស់អ្នក | [ការណែនាំអំពី IoT](./1-getting-started/lessons/1-introduction-to-iot/README.md) |
| 02 | [ការចាប់ផ្តើម](./1-getting-started/README.md) | ជំរុញជ្រៅចូលទៅក្នុង IoT | រៀនបន្ថែមអំពីគ្រឿងផ្សំក្នុងប្រព័ន្ធ IoT, ព្រមទាំងកុងត្រូលកររួម និងកុំព្យូទ័រចុចតែមួយ | [ជំរុញជ្រៅចូលក្នុង IoT](./1-getting-started/lessons/2-deeper-dive/README.md) |
| 03 | [ការចាប់ផ្តើម](./1-getting-started/README.md) | អន្តរកម្មជាមួយពិភពផ្លូវការជាមួយសាំងសឺរ និងព្រួញកម្មវិធី | រៀនអំពីសង្កេតករដើម្បីប្រមូលទិន្នន័យពីពិភពផ្លូវការនិងកម្មវិធីដើម្បីផ្ញើមតិយោបល់ ខណៈដែលអ្នកកំពុងបង្កើតភ្លើងផ្ទះ | [អន្តរកម្មពិភពផ្លូវការជាមួយសាំងសឺរ និងកម្មវិធី](./1-getting-started/lessons/3-sensors-and-actuators/README.md) |
| 04 | [ការចាប់ផ្តើម](./1-getting-started/README.md) | ភ្ជាប់ឧបករណ៍របស់អ្នកទៅអ៊ីនធឺណិត | រៀនអំពីការភ្ជាប់ឧបករណ៍ IoT ទៅអ៊ីនធឺណិតសម្រាប់ផ្ញើនិងទទួលសារដោយភ្ជាប់ភ្លើងផ្ទះរបស់អ្នកទៅ MQTT broker | [ភ្ជាប់ឧបករណ៍របស់អ្នកទៅអ៊ីនធឺណិត](./1-getting-started/lessons/4-connect-internet/README.md) |
| 05 | [កសិកម្ម](./2-farm/README.md) | កំណត់ការលូតលាស់រុក្ខជាតិ | រៀនរបៀបប៉ាន់ស្មានការលូតលាស់រុក្ខជាតិតាមទិន្នន័យសីតុណ្ហភាពដែលបានចាប់យកដោយឧបករណ៍ IoT | [កំណត់ការលូតលាស់រុក្ខជាតិ](./2-farm/lessons/1-predict-plant-growth/README.md) |
| 06 | [កសិកម្ម](./2-farm/README.md) | រកឃើញសំណើមដី | រៀនរបៀបរកឃើញសំណើមដី និងកំណត់តុល្យមាត្រការសំណើមដី | [រកឃើញសំណើមដី](./2-farm/lessons/2-detect-soil-moisture/README.md) |
| 07 | [កសិកម្ម](./2-farm/README.md) | សំរបសំរួលការដែល tubig ត្រូវដាំរុក្ខជាតិ | រៀនរបៀបស្វ័យប្រវត្តិកម្ម និងកំណត់ពេលវេលាដោយប្រើ relay និង MQTT | [ស្វ័យប្រវត្តិកម្មការដាំរុក្ខជាតិ](./2-farm/lessons/3-automated-plant-watering/README.md) |
| 08 | [កសិកម្ម](./2-farm/README.md) | ផ្ទេររុក្ខជាតិរបស់អ្នកទៅពពក | រៀនអំពីពពក និងសេវាកម្ម IoT ដែលមាននៅលើពពក និងរបៀបភ្ជាប់រុក្ខជាតិរបស់អ្នកទៅសេវាកម្មទាំងនេះ ផ្ទុយពីប្រើ MQTT broker សាធារណៈ | [ផ្ទេររុក្ខជាតិរបស់អ្នកទៅពពក](./2-farm/lessons/4-migrate-your-plant-to-the-cloud/README.md) |
| 09 | [កសិកម្ម](./2-farm/README.md) | ផ្ទេរតុល្យភាពកម្មវិធីរបស់អ្នកទៅពពក | រៀនអំពីរបៀបសរសេរតុល្យភាពកម្មវិធីនៅពពក ដែលឆ្លើយតបទៅនឹងសារជាច្រើនរបស់ IoT | [ផ្ទេរតុល្យភាពកម្មវិធីទៅពពក](./2-farm/lessons/5-migrate-application-to-the-cloud/README.md) |
| 10 | [កសិកម្ម](./2-farm/README.md) | ការការពាររុក្ខជាតិរបស់អ្នក | រៀនអំពីសុវត្ថិភាពជាមួយ IoT និងរបៀបបញ្ជាក់ពីសុវត្ថិភាពរបស់រុក្ខជាតិរបស់អ្នកដោយប្រើកូនសោ និងវិញ្ញាបនបត្រ | [ការការពាររុក្ខជាតិរបស់អ្នក](./2-farm/lessons/6-keep-your-plant-secure/README.md) |
| 11 | [ការដឹកជញ្ជូន](./3-transport/README.md) | តាមដានទីតាំង | រៀនអំពីការតាមដានទីតាំង GPS សម្រាប់ឧបករណ៍ IoT | [តាមដានទីតាំង](./3-transport/lessons/1-location-tracking/README.md) |
| 12 | [ការដឹកជញ្ជូន](./3-transport/README.md) | រក្សាទុកទិន្នន័យទីតាំង | រៀនវិធីរក្សាទុកទិន្នន័យ IoT សម្រាប់មើលឃើញឬវិភាគគួរសម | [រក្សាទុកទិន្នន័យទីតាំង](./3-transport/lessons/2-store-location-data/README.md) |
| 13 | [ការដឹកជញ្ជូន](./3-transport/README.md) | តំណាងទិន្នន័យទីតាំង | រៀនអំពីការតំណាងទិន្នន័យទីតាំងលើផែនទី និងរបៀបដែលផែនទីបង្ហាញពិភព 3D จริง នៅលើ ២វិមាត្រ | [តំណាងទិន្នន័យទីតាំង](./3-transport/lessons/3-visualize-location-data/README.md) |
| 14 | [ការដឹកជញ្ជូន](./3-transport/README.md) | បដិសណ្ឋារក្ស | រៀនអំពីបដិសណ្ឋារក្ស និងរបៀបប្រើវាសម្រាប់ដាក់សញ្ញាពេលយានយន្តនៅខ្សែផ្គត់ផ្គង់មកកាន់គោលដៅរបស់វា | [បដិសណ្ឋារក្ស](./3-transport/lessons/4-geofences/README.md) |
| 15 | [ការផលិត](./4-manufacturing/README.md) | បណ្តុះបណ្តាលឧបករណ៍រកគុណភាពផ្លែឈើ | រៀនអំពីការបណ្តុះបណ្តាលម៉ាស៊ីនចំណាត់ថ្នាក់រូបភាពនៅពពក ដើម្បីរកគុណភាពផ្លែឈើ | [បណ្តុះបណ្តាលឧបករណ៍រកគុណភាពផ្លែឈើ](./4-manufacturing/lessons/1-train-fruit-detector/README.md) |
| 16 | [ការផលិត](./4-manufacturing/README.md) | ពិនិត្យគុណភាពផ្លែឈើពីឧបករណ៍ IoT | រៀនអំពីការប្រើឧបករណ៍រកគុណភាពផ្លែឈើរបស់អ្នកពីឧបករណ៍ IoT | [ពិនិត្យគុណភាពផ្លែឈើពីឧបករណ៍ IoT](./4-manufacturing/lessons/2-check-fruit-from-device/README.md) |
| 17 | [ការផលិត](./4-manufacturing/README.md) | ប្រតិបត្ដិការឧបករណ៍រកគុណភាពផ្លែឈើនៅចុងក្រោយ | រៀនអំពីការប្រតិបត្ដិការឧបករណ៍រកគុណភាពផ្លែឈើនៅចុង IoT device | [ប្រតិបត្ដិការឧបករណ៍រកគុណភាពផ្លែឈើនៅចុងក្រោយ](./4-manufacturing/lessons/3-run-fruit-detector-edge/README.md) |
| 18 | [ការផលិត](./4-manufacturing/README.md) | ចាប់ផ្តើមរកគុណភាពផ្លែឈើពីសង់ស័រមួយ | រៀនអំពីការចាប់ផ្តើមរកគុណភាពផ្លែឈើពីសង់ស័រ | [ចាប់ផ្តើមរកគុណភាពផ្លែឈើពីសង់ស័រ](./4-manufacturing/lessons/4-trigger-fruit-detector/README.md) |
| 19 | [លក់រាយ](./5-retail/README.md) | បណ្តុះបណ្តាលឧបករណ៍រកស្តុក | រៀនរបៀបប្រើកម្រិតវត្ថុ ដើម្បីបណ្តុះឧបករណ៍រកស្តុកសម្រាប់រាប់ស្តុកនៅហាង | [បណ្តុះបណ្តាលឧបករណ៍រកស្តុក](./5-retail/lessons/1-train-stock-detector/README.md) |
| 20 | [លក់រាយ](./5-retail/README.md) | ពិនិត្យស្តុកពីឧបករណ៍ IoT | រៀនរបៀបពិនិត្យស្តុកពីឧបករណ៍ IoT ដោយប្រើម៉ូដែលកំណត់វត្ថុ | [ពិនិត្យស្តុកពីឧបករណ៍ IoT](./5-retail/lessons/2-check-stock-device/README.md) |
| 21 | [ប្រើប្រាស់](./6-consumer/README.md) | ការទទួលស្គាល់សំលេងជាមួយឧបករណ៍ IoT | រៀនរបៀបទទួលស្គាល់សំលេងពីឧបករណ៍ IoT ដើម្បីបង្កើតម៉ោងវេលាឆ្លាត | [ទទួលស្គាល់សំលេងជាមួយឧបករណ៍ IoT](./6-consumer/lessons/1-speech-recognition/README.md) |
| 22 | [ប្រើប្រាស់](./6-consumer/README.md) | យល់ដឹងភាសា | រៀនអំពីរបៀបយល់ដឹងប្រយោគដែលបាននិយាយទៅឧបករណ៍ IoT | [យល់ដឹងភាសា](./6-consumer/lessons/2-language-understanding/README.md) |
| 23 | [ប្រើប្រាស់](./6-consumer/README.md) | កំណត់ម៉ោងហើយផ្តល់មតិថ្លែងមាត់ | រៀនរបៀបកំណត់ម៉ោងនៅលើឧបករណ៍ IoT និងផ្តល់មតិយោបល់ថ្លែងមាត់ពេលម៉ោងបានកំណត់ និងពេលម៉ោងបញ្ចប់ | [កំណត់ម៉ោងហើយផ្តល់មតិថ្លែងមាត់](./6-consumer/lessons/3-spoken-feedback/README.md) |
| 24 | [ប្រើប្រាស់](./6-consumer/README.md) | គាំទ្រភាសាច្រើន | រៀនរបៀបគាំទ្រភាសាជាច្រើន អាំងរួមទាំងភាសាដែលនិយាយទំព័ក និងការឆ្លើយតបទៅពីម៉ោងវេលាឆ្លាត | [គាំទ្រភាសាច្រើន](./6-consumer/lessons/4-multiple-language-support/README.md) |
## ការចូលដំណើរការដោយមិនចាំបាច់ភ្ជាប់អ៊ិនធឺណិត
អ្នកអាចដំណើរការឯកសារនេះដោយមិនចាំបាច់ភ្ជាប់អ៊ិនធឺណិត ដោយប្រើ [Docsify](https://docsify.js.org/#/). ចម្លងផ្ទុកចេញ repo នេះ, [ដំឡើង Docsify](https://docsify.js.org/#/quickstart) លើម៉ាស៊ីនផ្ទាល់ខ្លួន រួចចូលទៅក្នុងថតគ្រឹះនៃ repo នេះ ហើយវាយ `docsify serve`។ វែបសាយនឹងត្រូវបម្រើលើច្រក 3000 នៅលើ localhost របស់អ្នក: `localhost:3000`
## ការស្នើសុំបញ្ចប់សំណួរ
សូមអរគុណសហគមន៍ដែលបានផ្ដល់ជាសំណួរផ្ទាល់ខ្លួនដែលតេស្តចំណេះដឹងរបស់អ្នកលើមេរៀននីមួយៗ។ អ្នកអាចសាកល្បងចំណេះដឹងនៅ[ទីនេះ](https://ff-quizzes.netlify.app/en/)
### PDF
អ្នកអាចបង្កើតឯកសារ PDF នៃខ្លឹមសារនេះសម្រាប់ការចូលដំណើរការដោយមិនចាំបាច់ភ្ជាប់អ៊ិនធឺណិត ប្រសិនបើត្រូវការ។ ដើម្បីធ្វើបែបនេះ សូមប្រាកដថាអ្នកមាន [npm ដំឡើងរួច](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) ហើយរត់ពាក្យបញ្ជាកូដខាងក្រោមនៅក្នុងថតគ្រឹះនៃ repo នេះ៖
```sh
npm i
npm run convert
```
### ឯកសារស្លាយ
មានឯកសារស្លាយសម្រាប់មេរៀនខ្លះៗនៅក្នុងថត [slides](../../slides)។
## មេរៀនផ្សេងទៀត
ក្រុមរបស់យើងបង្កើតមេរៀនផ្សេងទៀតផង! សូមពិនិត្យមើល៖
<!-- CO-OP TRANSLATOR OTHER COURSES START -->
### LangChain
[![LangChain4j សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/LangChain4j%20for%20Beginners-22C55E?style=for-the-badge&&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchain4j-for-beginners)
[![LangChain.js សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/LangChain.js%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[![LangChain សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/LangChain%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
---
### Azure / Edge / MCP / Agents
[![AZD សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/AZD%20for%20Beginners-0078D4?style=for-the-badge&labelColor=E5E7EB&color=0078D4)](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Edge AI សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/Edge%20AI%20for%20Beginners-00B8E4?style=for-the-badge&labelColor=E5E7EB&color=00B8E4)](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![MCP សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/MCP%20for%20Beginners-009688?style=for-the-badge&labelColor=E5E7EB&color=009688)](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[![AI Agents សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/AI%20Agents%20for%20Beginners-00C49A?style=for-the-badge&labelColor=E5E7EB&color=00C49A)](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
---
### សំណួរ Generative AI
[![Generative AI សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/Generative%20AI%20for%20Beginners-8B5CF6?style=for-the-badge&labelColor=E5E7EB&color=8B5CF6)](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Generative AI (.NET)](https://img.shields.io/badge/Generative%20AI%20(.NET)-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
[![Generative AI (Java)](https://img.shields.io/badge/Generative%20AI%20(Java)-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
[![Generative AI (JavaScript)](https://img.shields.io/badge/Generative%20AI%20(JavaScript)-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst)
---
### ការសិក្សាគ្រឹះ
[![ML សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/ML%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=22C55E)](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst)
[![វិទ្យាសាស្ត្រទិន្នន័យសម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/Data%20Science%20for%20Beginners-84CC16?style=for-the-badge&labelColor=E5E7EB&color=84CC16)](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst)
[![AI សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/AI%20for%20Beginners-A3E635?style=for-the-badge&labelColor=E5E7EB&color=A3E635)](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst)
[![សុវត្ថិភាពសារពើពន្ធសម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/Cybersecurity%20for%20Beginners-F97316?style=for-the-badge&labelColor=E5E7EB&color=F97316)](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung)
[![ការអភិវឌ្ឍវេបសាយសម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/Web%20Dev%20for%20Beginners-EC4899?style=for-the-badge&labelColor=E5E7EB&color=EC4899)](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst)
[![IoT សម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/IoT%20for%20Beginners-14B8A6?style=for-the-badge&labelColor=E5E7EB&color=14B8A6)](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst)
[![XR ការអភិវឌ្ឍសម្រាប់អ្នកចាប់ផ្តើម](https://img.shields.io/badge/XR%20Development%20for%20Beginners-38BDF8?style=for-the-badge&labelColor=E5E7EB&color=38BDF8)](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst)
---
### សំណួរ Copilot
[![Copilot សម្រាប់កម្មវិធីគូរូបភាព AI](https://img.shields.io/badge/Copilot%20for%20AI%20Paired%20Programming-FACC15?style=for-the-badge&labelColor=E5E7EB&color=FACC15)](https://aka.ms/GitHubCopilotAI?WT.mc_id=academic-105485-koreyst)
[![Copilot សម្រាប់ C#/.NET](https://img.shields.io/badge/Copilot%20for%20C%23/.NET-FBBF24?style=for-the-badge&labelColor=E5E7EB&color=FBBF24)](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers?WT.mc_id=academic-105485-koreyst)
[![Copilot សម្រាប់ការផ្សងព្រេង](https://img.shields.io/badge/Copilot%20Adventure-FDE68A?style=for-the-badge&labelColor=E5E7EB&color=FDE68A)](https://github.com/microsoft/CopilotAdventures?WT.mc_id=academic-105485-koreyst)
<!-- CO-OP TRANSLATOR OTHER COURSES END -->
## ការបរិច្ឆេទរូបភាព
អ្នកអាចរកឃើញការបរិច្ឆេទទាំងអស់សម្រាប់រូបភាពដែលបានប្រើនៅក្នុងមេរៀននេះនៅកន្លែងដាក់ក្នុង [Attributions](./attributions.md)។
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការព្រមាន**៖
ឯកសារនេះបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ទោះបីយើងខំប្រឹងសំរាប់ភាពត្រឹមត្រូវ ក៏ជូនដំណឹងថាការបកប្រែដោយស្វ័យប្រវត្តិក្នុងខ្លះអាចមានកំហុស ឬភាពមិនត្រឹមត្រូវបាន។ ឯកសារដើមនៅក្នុងភាសាទទួលបានគួរត្រូវបានគេស្គាល់ថាជាមូលដ្ឋានមានសារៈសំខាន់បំផុត។ សម្រាប់ព័ត៌មានសំខាន់ៗវិញ ការបកប្រែដោយអ្នកជំនាញមនុស្សគឺជាការផ្ដល់អនុសាសន៍។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសដែលកើតឡើងពីការប្រើប្រាស់ការបកប្រែនេះនោះទេ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,44 @@
# សុវត្ថិភាព
Microsoft យកចិត្តទុកដាក់ទៅលើសុវត្ថិភាពនៃផលិតផលនិងសេវាកម្មកម្មវិធីរបស់យើងយ៉ាងខ្លាំង រួមមានរោងចក្រ​កូដប្រភព​ទាំងអស់ដែលគ្រប់គ្រងតាមរយៈ អង្គការរបស់យើងលើ GitHub ដែលរួមមាន [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), និង [អង្គការរបស់យើងលើ GitHub](https://opensource.microsoft.com/)។
បើអ្នកជឿថាអ្នកបានរកឃើញចំណុចអនុលោមសុវត្ថិភាពនៅក្នុងរោងចក្រ​ដែលទទួលបានហិរញ្ញវត្ថុពី Microsoft ដែលបំពេញតាមកំណត់នៃ [Microsoft ស្ដីពីចំណុចអនុលោមសុវត្ថិភាព](https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)) សូមរាយការណ៍របស់អ្នកទៅកាន់យើងដូចបានពណ៌នានៅខាងក្រោម។
## រាយការណ៍បញ្ហាសុវត្ថិភាព
**សូមកុំរាយការណ៍ចំណុចអនុលោមសុវត្ថិភាពតាមរយៈបញ្ហាសាធារណៈលើ GitHub។**
ផ្ទុយទៅវិញ សូមរាយការណ៍ទៅកាន់មជ្ឈមណ្ឌលដំណោះស្រាយសុវត្ថិភាព Microsoft (MSRC) តាមរយៈ [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report)។
បើអ្នកចង់បញ្ជូនដោយមិនចូលប្រើប្រាស់ អ៊ីមែលមកកាន់ [secure@microsoft.com](mailto:secure@microsoft.com)។ ប្រសិនបើអាចធ្វើបាន សូម mã hóaសាររបស់អ្នកជាមួយកូនសោ PGP របស់យើង; សូមទាញយកវាពីទំព័រ [Microsoft Security Response Center PGP Key](https://www.microsoft.com/en-us/msrc/pgp-key-msrc) ។
អ្នកគួរតែទទួលបានការឆ្លើយតបក្នុងរយៈពេល 24 ម៉ោង។ ប្រសិនបើមានហេតុផលណាមួយដែលមិនទទួលបាន សូមតាមដានតាមអ៊ីមែល ដើម្បីធានាថាយើងបានទទួលសារ​ដើមរបស់អ្នក។ ព័ត៌មានបន្ថែមអាចអានបាននៅ [microsoft.com/msrc](https://www.microsoft.com/msrc)។
សូមដាក់បញ្ចូលព័ត៌មានដែលបានស្នើរខាងក្រោម (ប៉ុន្មានដែលអ្នកអាចផ្តល់បាន) ដើម្បីជួយយើងយល់ដឹងលម្អិតពីលក្ខណៈនិងវិសាលភាពនៃបញ្ហាអាចកើតមាន៖
* ប្រភេទបញ្ហា (ឧ. ល្បឿនករណីអតិផរណា, ចាក់បញ្ចូល SQL, បញ្ហា scripting លើគេហទំព័រជាច្រើន បញ្ហា cross-site scripting, ល)
* ផ្លូវពេញលេញនៃឯកសារប្រភពដែលទាក់ទងនឹងការបង្ហាញបញ្ហា
* ទីតាំងកូដប្រភពដែលគំរូ (ចំណុចដាក់ស្លាក / សាខា / ការប្តេជ្ញា ឬ URL ត្រង់)
* ការកំណត់ពិសេសណាមួយដែលត្រូវការដើម្បីបង្កើតបញ្ហា
* ជំហាន​ដំណើរការ​ឈរ​ពន្លឺសម្រាប់បង្កើតបញ្ហា
* កូដបង្ហាញឬកូដកាប់ប្រាក់ (ប្រសិនបើអាច)
* ផលប៉ះពាល់នៃបញ្ហា រួមទាំងរបៀបដែលអ្នកប្រលោមលោកអាចប្រើប្រាស់បញ្ហានេះ
ព័ត៌មាននេះនឹងជួយយើងក្នុងការបែងចែក អាទិភាពបានយ៉ាងរហ័ស។
បើអ្នកកំពុងរាយការណ៍សម្រាប់រង្វាន់ bug bounty មានរបាយការណ៍លម្អិតជាងនេះអាចជួយឱ្យទទួលបានរង្វាន់បន្ថែមបញ្ចូល។ សូមចូលទៅកាន់ទំព័រ [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) របស់យើងសម្រាប់ពត៌មានលម្អិតអំពីកម្មវិធីចូលរួមរបស់យើង។
## ភាសាដែលចូលចិត្ត
យើងចូលចិត្តឲ្យការទំនាក់ទំនងទាំងអស់ជាភាសាអង់គ្លេស។
## سياست
Microsoft អនុវត្តតាមគោលការណ៍ [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd)។
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបំពាន**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ក្នុងនាមជាក្រុមយើងខ្ញុំខិតខំយ៉ាងត្រឺមត្រូវ ប៉ុន្តែសូមយល់ព្រមថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុស ឬការយល់ខុសបាន។ ឯកសារដើមក្នុងភាសាតំណក់គួរត្រូវបានពិចារណាជាផ្លូវការជាកួនទីប្រឹក្សា។ សម្រាប់ព័ត៌មានសំខាន់ៗការបកប្រែដោយមនុស្សជំនាញជាប្រយោជន៍។ យើងខ្ញុំមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការយល់ខុសណាមួយដែលកើតមានចេញពីការប្រើប្រាស់ការបកប្រែនេះទេ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,18 @@
# គាំទ្រ
## របៀបដាក់បញ្ហានិងទទួលបានជំនួយ
គម្រោងនេះប្រើ GitHub Issues ដើម្បីតាមដានកម្រិតកំហុសនិងការស្នើសុំមុខងារ។ សូមស្វែងរកបញ្ហាមុនសិនមុនដាក់បញ្ហាថ្មីដើម្បីជៀសវាងការចម្លង។ សម្រាប់បញ្ហាថ្មីៗ សូមដាក់កំហុសឬស្នើសុំមុខងាររបស់អ្នកជា Issue ថ្មី។
សម្រាប់ជំនួយនិងសំណួរអំពីការប្រើគម្រោងនេះ សូមទំនាក់ទំនងមកយើងតាមការដាក់បញ្ហានៅក្នុង repo នេះ។
## គោលនយោបាយគាំទ្ររបស់ Microsoft
ការគាំទ្រសម្រាប់ **គម្រោង ឬ ផលិតផល** នេះត្រូវបានកំណត់ទុកតែធនធានដែលបានរៀបរាប់ខាងលើ។
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការព្រមាន**:
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលយើងខំប្រឹងប្រែងសម្រាប់កម្រិតត្រឹមត្រូវ ខ្ញុំសូមជូនដំណឹងថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុស ឬការមិនត្រឹមត្រូវ។ ឯកសារដើមនៅភាសាមូលដ្ឋានគួរត្រូវបានគិតថាជាផ្នែកផ្លូវការពិតប្រាកដ។ សម្រាប់ព័ត៌មានសំខាន់ៗ សូមណែនាំឱ្យប្រើការបកប្រែដោយអ្នកជំនាញមនុស្ស។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសទាំងអស់ដែលកើតមានពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,752 @@
# មេរៀនដោះស្រាយបញ្ហា
មេរៀននេះជួយអ្នកដោះស្រាយបញ្ហាទូទៅពេលធ្វើការជាមួយសៀវភៅបង្រៀន IoT សម្រាប់អ្នកថ្មី។ បញ្ហាត្រូវបានរៀបចំតាមប្រភេទសម្រាប់ងាយស្រួលក្នុងការស្វែងរក។
## បញ្ជីមាតិកា
- [បញ្ហាការដំឡើង](#បញ្ហាការដំឡើង)
- [ការដំឡើង Python](#ការដំឡើង-python)
- [VS Code និងផ្នែកបន្ថែម](#vs-code-និងផ្នែកបន្ថែម)
- [PlatformIO (Wio Terminal)](#platformio-wio-terminal)
- [បណ្ណាល័យ Grove](#បណ្ណាល័យ-grove)
- [បញ្ហាឧបករណ៍ផ្ទាល់ខ្លួន](#បញ្ហាឧបករណ៍ផ្ទាល់ខ្លួន)
- [Raspberry Pi](#raspberry-pi)
- [Wio Terminal](#wio-terminal)
- [ឧបករណ៍ពាក់ព័ន្ធវីរុច (CounterFit)](#ឧបករណ៍ពាក់ព័ន្ធវីរុច-counterfit)
- [បញ្ហាការតភ្ជាប់](#បញ្ហាការតភ្ជាប់)
- [ការតភ្ជាប់ WiFi](#ការតភ្ជាប់-wifi)
- [សេវាកម្ម Cloud](#សេវាកម្ម-cloud)
- [MQTT](#mqtt)
- [បញ្ហាសენს័រ និងឧបករណ៍ដំណើរការ](#បញ្ហាជាមួយ-ឧបករណ៍ស៊ិនស័រ-និងឧបករណ៍ចល័ត)
- [សենս័រ Grove](#ស៊ិនស័រ-grove)
- [កាមេរ៉ា](#កាមេរា)
- [មីក្រូហ្វូន និងស្ពីកเกอร์](#មីក្រូហ្វូន-និង-ស្បែកហ្វូន)
- [បរិបទអភិវឌ្ឍន៍](#បញ្ហាបរិបទអភិវឌ្ឍន៍)
- [VS Code](#vs-code)
- [បរិបទមេឌីយ៉ាង Python](#បរិបទ-python-virtual-environments)
- [ភាពពាក់ព័ន្ធ](#ផ្នែក-dependencies)
- [បញ្ហាការសម្តែង](#បញ្ហាប្រតិបត្តិការ)
- [សារកំហុសទូទៅ](#សារ​កំហុសទូទៅ)
- [ផ способовជំនួយ](#ដំណោះស្រាយ-codeblock18)
---
## បញ្ហាការដំឡើង
### ការដំឡើង Python
#### បញ្ហា៖ កំណែ Python ចាស់ពេក
**កំហុស៖** `ត្រូវការពី Python 3.6 ឡើងទៅ`
**ដំណោះស្រាយ៖**
1. ទាញយក Python 3 ចុងក្រោយពី [python.org](https://www.python.org/downloads/)
2. ការ​ដំឡើង​លើ Windows សូម​ជ្រើស "បន្ថែម Python ទៅ PATH"
3. សំណូមពរ​ការ​ដំឡើង៖
```bash
python3 --version
```
#### បញ្ហា៖ មាន​កំណែ Python ច្រើនបង្កការ​ច្របូកច្របល់
**រោគសញ្ញា៖** ប្រើ​កំណែ Python មិនត្រឹមត្រូវ​ ផ្នែកបណ្ណាល័យដំឡើងលើទីតាំងខុស
**ដំណោះស្រាយ៖**
- **Windows:** ប្រើ `py -3` ជំនួស `python` ដើម្បីហៅ Python 3 យ៉ាងច្បាស់
- **macOS/Linux:** ប្រើ `python3` ជំនួស `python`
- តែងតែបង្កើត ហើយប្រើបរិបទមេឌីយ៉ាង (virtual environments) សម្រាប់គម្រោង
#### បញ្ហា៖ មិនរកឃើញបញ្ជា pip
**កំហុស៖** `'pip' មិនត្រូវបានគេរំពឹងទុកជាបញ្ជាក្នុងម៉ាស៊ីន'
**ដំណោះស្រាយ៖**
1. សាកល្បងប្រើ `pip3` ជំនួស `pip`
2. ឬប្រើ `python -m pip``python3 -m pip`
3. ប្រាកដថា Python ត្រូវបានបន្ថែមចូល PATH (ដំឡើងPythonឡើងវិញ ហើយជ្រើសជម្រើសនេះ)
### VS Code និងផ្នែកបន្ថែម
#### បញ្ហា៖ ផ្នែកបន្ថែម Pylance មិនដំណើរការ
**រោគសញ្ញា៖** គ្មាន IntelliSense, ការសម្រេចកូដ ឬការត្រួតពិនិត្យប្រភេទ
**ដំណោះស្រាយ៖**
1. បើក Command Palette នៅ VS Code (`Ctrl+Shift+P` ឬ `Cmd+Shift+P`)
2. រត់ "Python: Select Interpreter"
3. កំរើស Python interpreter ត្រឹមត្រូវ (បរិបទមេឌីយ៉ាងប្រសិនបើប្រើ)
4. Reload ប្រព័ន្ធ
#### បញ្ហា៖ VS Code មិនចាប់ផ្តើមបរិបទមេឌីយ៉ាង
**រោគសញ្ញា៖** ជ្រើស Python interpreter មិនត្រឹមត្រូវ
**ដំណោះស្រាយ៖**
1. ប្រាកដថាបង្កើតនិងបើកបរិបទមេឌីយ៉ាងនៅក្នុង terminal
2. បើក Command Palette ហើយរត់ "Python: Select Interpreter"
3. ជ្រើស interpreter ពីថត `.venv`
4. ពិនិត្យ status bar (ខាងក្រោមឆ្វេង) បង្ហាញកំណែ Python ត្រឹមត្រូវ
### PlatformIO (Wio Terminal)
#### បញ្ហា៖ ការដំឡើង PlatformIO មិនបានជោគជ័យ
**កំហុស៖** កំហុសផ្សេងៗពេលដំឡើង PlatformIO
**ដំណោះស្រាយ៖**
1. ប្រាកដថា VS Code ទាន់សម័យ
2. ដំឡើង​ផ្នែកបន្ថែម C/C++ ជាមុន
3. ចាប់ផ្តើម VS Code ជាថ្មីបន្ទាប់ជាដំឡើង PlatformIO
4. ពិនិត្យការតភ្ជាប់អ៊ីនធឺណិត (PlatformIO ទាញយកឯកសារធំ)
#### បញ្ហា៖ ប៊ូលដ័រ PlatformIO មិនចាប់បាន
**រោគសញ្ញា៖** មិនអាចផ្ទុកកូដទៅ Wio Terminal
**ដំណោះស្រាយ៖**
1. សាកល្បងខ្សែ USB ផ្សេង (ខ្សែខ្លះគឺសម្រាប់សាកថ្មតែប៉ុណ្ណោះ)
2. ពិនិត្យ​ Device Manager (Windows) ឬ `ls /dev/tty*` (macOS/Linux)
3. ដំឡើង ឬអាប់ដេតដ្រាយវែរ USB
4. សាកល្បងច្រក USB ផ្សេង
5. រអិលប៊ូតុងភ្លើងលើ Wio Terminal ឆាប់ៗពីរដង ដើម្បីចូលម៉ូដ bootloader
#### បញ្ហា៖ កំហុសបញ្ចូលកូដក្នុង PlatformIO
**កំហុស៖** `fatal error: Arduino.h: No such file or directory`
**ដំណោះស្រាយ៖**
1. លុបថត `.pio` ក្នុងគម្រោង
2. រត់ "PlatformIO: Rebuild" ពី Command Palette
3. ប្រាកដថា `platformio.ini` មានការកំណត់ប៊ូលដ័រត្រឹមត្រូវ៖
```ini
[env:seeed_wio_terminal]
platform = atmelsam
board = seeed_wio_terminal
framework = arduino
```
### បណ្ណាល័យ Grove
#### បញ្ហា៖ ការនាំចូលបណ្ណាល័យ Grove បរាជ័យលើ Raspberry Pi
**កំហុស៖** `ModuleNotFoundError: No module named 'grove'`
**ដំណោះស្រាយ៖**
1. ដំឡើងបណ្ណាល័យ Grove ថ្មី៖
```bash
cd ~
git clone https://github.com/Seeed-Studio/grove.py
cd grove.py
sudo pip3 install .
```
2. ប្រសិនបើប្រើបរិបទមេឌីយ៉ាង អ្នកប្រហែលត្រូវតែដំឡើងជាសកល ឬចម្លងបណ្ណាល័យ
3. ប្រាកដថា I2C បានបើក: `sudo raspi-config nonint do_i2c 0`
#### បញ្ហា៖ Grove sensor មិនចាប់បាន
**កំហុស៖** `IOError: [Errno 121] Remote I/O error`
**ដំណោះស្រាយ៖**
1. ពិនិត្យការតភ្ជាប់ផ្លូវហត្ថ (ប្រាកដថា ខ្សែ Grove បានដាក់ត្រឹមត្រូវ)
2. ប្រាកដថាសេនស័រត្រូវបានភ្ជាប់ទៅច្រកត្រឹមត្រូវ (analog, digital, I2C, UART)
3. រត់ `i2cdetect -y 1` ដើម្បីមើលថាឧបករណ៍បង្ហាញលើ I2C bus មានទេ
4. សាកល្បងខ្សែ Grove ផ្សេង
5. ប្រាកដថា Grove Base Hat ត្រូវបានដាក់លើពិសោធន៍ Raspberry Pi GPIO បានត្រឹមត្រូវ
---
## បញ្ហាឧបករណ៍ផ្ទាល់ខ្លួន
### Raspberry Pi
#### បញ្ហា៖ Raspberry Pi មិនចាប់ផ្តើម
**រោគសញ្ញា៖** គ្មានការបង្ហាញទេ មិនមាន LED ធ្វើការ ឬអេក្រង់ពណ៌ខៀវ
**ដំណោះស្រាយ៖**
1. **ពិនិត្យថាមវន្ត៖** ប្រើថាមវន្ត USB-C 5V 3A ផ្លូវការសម្រាប់ Pi 4
2. **បញ្ហាគាត SD៖**
- កែទ្រង់គាត SD និងដំឡើងឡើងវិញរបៀបប្រើ Raspberry Pi OS
- សាកល្បងគាត SD ផ្សេង (ប្រើម៉ាកណែនាំ)
- ប្រាកដថាគាត SD ត្រូវបានដាក់សរសេរត្រឹមត្រូវ
3. **ពិនិត្យការតភ្ជាប់ HDMI:** សាកល្បងច្រក HDMI ទាំងពីរលើ Pi 4 ប្រើ HDMI ជិតថាមវន្ត
#### បញ្ហា៖ មិនអាច SSH ទៅ Raspberry Pi
**រោគសញ្ញា៖** មិនអាចភ្ជាប់បាន ឬកាលពេលកំណត់លើកលែង
**ដំណោះស្រាយ៖**
1. បើក SSH៖
- ពេលបង្ហាប់គាត SD ប្រើ Raspberry Pi Imager កំណត់ SSH នៅជម្រើសឈានមុខ
- ឬបង្កើតឯកសារគ្មានផ្នែកបន្ថែមឈ្មោះ `ssh` នៅក្នុងផ្នែក boot
2. ស្វែងរកអាសយដ្ឋាន IP របស់ Pi:
- ពិនិត្យឧបករណ៍ភ្ជាប់សង្គមរបស់អ្នក
- ប្រើ `ping raspberrypi.local` (ប្រសិនបើ mDNS ប្រតិបត្តិការ)
- ប្រើឧបករណ៍ស្តាប់បណ្ដាញដូចជា `nmap` ឬ Angry IP Scanner
3. ពិនិត្យបណ្តាញ៖
- ប្រាកដថា Pi នៅលើបណ្តាញដូចជាគណនីអ្នក
- សាកល្បងភ្ជាប់ ethernet ជំនួស WiFi
4. ប្រាកដឈ្មោះនិងពាក្យសម្ងាត់ (លំនាំដើម៖ ឈ្មោះ `pi`, ពាក្យសម្ងាត់ `raspberry`)
#### បញ្ហា៖ Grove Base Hat មិនត្រូវបានស្គាល់
**រោគសញ្ញា៖** សេនស័រមិនដំណើរការ កំហុស I2C
**ដំណោះស្រាយ៖**
1. ប្រាកដថា Base Hat បានដាក់លើពិសោធន៍ GPIOទាំងអស់យ៉ាងត្រឹមត្រូវ
2. ពិនិត្យថា ពិនភាគុំ់ខូចលើ Pi ឬ Base Hat
3. បើក I2C interface៖
```bash
sudo raspi-config nonint do_i2c 0
sudo reboot
```
4. ពិនិត្យថា I2C ធ្វើការ៖ `i2cdetect -y 1`
#### បញ្ហា៖ Raspberry Pi ធ្វើការយឺត
**រោគសញ្ញា៖** UI យឺត ផ្ទារាចលនា យឺត
**ដំណោះស្រាយ៖**
1. ពិនិត្យល្បឿនគាត SD (ប្រើ Class 10 ឬលើស ស៊េរី SSD តាម USB)
2. សម្អាតកន្លែងរក្សាទុក៖ ប្រើ `df -h` ដើម្បីពិនិត្យ លុបឯកសារមិនចាំបាច់
3. បន្ថយ GPU memory នៅក្នុង `raspi-config` ប្រសិនបើមិនប្រើកាមេរ៉ា/អេក្រង់យ៉ាងខ្លាំង
4. បិទកម្មវិធីដែលមិនចាំបាច់
5. ពិចារណាឡើងកំលាំងទៅ Pi 4 ក្នុងករណីប្រើ Pi 3 ឬចាស់ជាងនេះ
### Wio Terminal
#### បញ្ហា៖ អេក្រង់ Wio Terminal ស្ពឺ
**រោគសញ្ញា៖** គ្មានបង្ហាញផ្សេងទេបន្ទាប់ពីផ្ទុកកូដ
**ដំណោះស្រាយ៖**
1. ពិនិត្យថាកូដចាប់ផ្តើមអេក្រង់ (បណ្ណាល័យ TFT_eSPI)
2. អាប់ដេត firmware Wio Terminal ពី [Seeed Wiki](https://wiki.seeedstudio.com/Wio-Terminal-Getting-Started/)
3. បន្ថែមកូដចាប់ផ្តើមអេក្រង់:
```cpp
#include <TFT_eSPI.h>
TFT_eSPI tft;
tft.begin();
tft.fillScreen(TFT_BLACK);
```
4. សាកល្បងផ្ទុកគំរូពី PlatformIO ដើម្បីសាកល្បង​ឧបករណ៍
#### បញ្ហា៖ WiFi មិនដំណើរការ​លើ Wio Terminal
**រោគសញ្ញា៖** មិនអាចភ្ជាប់ WiFi កំហុសបណ្តាញ
**ដំណោះស្រាយ៖**
1. **អាប់ដេត firmware WiFi:** អនុវត្តតាម [លទ្ធផល WiFi Wio Terminal](https://wiki.seeedstudio.com/Wio-Terminal-Network-Overview/)
2. **ពិនិត្យលក្ខណៈសញ្ញា WiFi:** ធ្វើការផ្ទៀងផ្ទាត់ SSID និងពាក្យសម្ងាត់ត្រឹមត្រូវ
3. **ថួរក WiFi:** Wio Terminal គាំទ្រត្រឹម 2.4GHz WiFi ប៉ុណ្ណោះ (មិនគាំទ្រ 5GHz)
4. **កម្លាំងសញ្ញា:** ក្រោយពីខ្សែ WiFi ទៅកាន់ម៉ាស៊ីនបម្រើ
5. **ការកំណត់ម៉ាស៊ីនបម្រើ:** បណ្តាញសហគ្រាស ឬ WPA-Enterprise ច្រើនប្រហែលមិនដំណើរការ
#### បញ្ហា៖ Wio Terminal មិនត្រូវបានស្គាល់ពីកុំព្យូទ័រ
**រោគសញ្ញា៖** ឧបករណ៍ USB មិនត្រូវបានរកឃើញ
**ដំណោះស្រាយ៖**
1. **សាកល្បងខ្សែ USB ផ្សេង:** ប្រើខ្សែទិន្នន័យ មិនមែនខ្សែសាកថ្មប៉ុណ្ណោះ
2. **ចូលម៉ូដ bootloader:** រអិលប៊ូតុងភ្លើងចុះពីលើពីរដងឆាប់ៗ
- LED ខៀវគួរតែបង្ហាញជារលក ឧបករណ៍បង្ហាញជា "Arduino" នៅក្នុង Device Manager
3. **ដំឡើងដ្រាយវែរ (Windows):**
- ទាញ និងដំឡើង [ដ្រាយវែរ USB Seeed](https://wiki.seeedstudio.com/Driver_for_Seeeduino/)
4. **សាកល្បងច្រក USB ផ្សេង:** មិនប្រើ USB hub ប្រើភ្ជាប់ផ្ទាល់
5. **អាប់ដេតដ្រាយវែរ USB ប្រព័ន្ធ**
#### បញ្ហា៖ សេនស័រមិនដំណើរការ​លើ Wio Terminal
**រោគសញ្ញា៖** សេនស័រ Grove មិនអានទិន្នន័យ
**ដំណោះស្រាយ៖**
1. ពិនិត្យការតភ្ជាប់ខ្សែ Grove
2. ប្រាកដថាអ្នកប្រើច្រក Grove ត្រឹមត្រូវ (ឆ្វេង ឬស្តាំ)
3. រួមបញ្ចូលបណ្ណាល័យត្រឹមត្រូវសម្រាប់សេនស័រ
4. ពិនិត្យតម្រូវការថាមពលសេនស័រ
5. សាកល្បងសេនស័រជាមួយកូដគំរូពីបណ្ណាល័យ
### ឧបករណ៍ពាក់ព័ន្ធវីរុច (CounterFit)
#### បញ្ហា៖ ពុំអាចចាប់ផ្តើមកម្មវិធី CounterFit
**កំហុស៖** កំហុស Python ផ្សេងៗពេលចាប់ផ្តើម CounterFit
**ដំណោះស្រាយ៖**
1. ប្រាកដថាបរិបទមេឌីយ៉ាងបានបើក
2. ដំឡើង ឬដំឡើងឡើងវិញ CounterFit:
```bash
pip install CounterFit
```
3. ពិនិត្យថាច្រក 5000 មិនត្រូវបានប្រើរួច:
- Windows: `netstat -ano | findstr :5000`
- macOS/Linux: `lsof -i :5000`
4. បិទដំណើរការដែលប្រើច្រក 5000 ឬប្រើច្រកផ្សេង:
```bash
counterfit --port 5001
```
#### បញ្ហា៖ មិនអាចភ្ជាប់ទៅ CounterFit ពីកូដ
**កំហុស៖** ការភ្ជាប់ត្រូវបានបដិសេធ ឬពេលកំណត់អស់
**ដំណោះស្រាយ៖**
1. ប្រាកដថា CounterFit កំពុងដំណើរការ៖ បើកកម្មវិធី浏览器ទៅ `http://127.0.0.1:5000`
2. ពិនិត្យ URL ភ្ជាប់នៅក្នុងកូដធៀបនឹងអាសយដ្ឋាន CounterFit
3. ប្រាកដថា firewall មិនរាំងខ្សែច្រក
4. សាកល្បងចាប់ផ្តើមម្តងទៀត CounterFit និងកូដរបស់អ្នក
#### បញ្ហា៖ សេនស័រមិនបង្ហាញនៅក្នុង CounterFit
**រោគសញ្ញា៖** សេនស័រដែលបានបង្កើតមិនបង្ហាញនៅក្នុង UI CounterFit
**ដំណោះស្រាយ៖**
1. បង្កើតសេនស័រនៅក្នុង UI CounterFit មុនពេលរត់កូដ
2. បង្កើតទំព័ររុញ (refresh)
3. ពិនិត្យប្រភេទសេនស័រត្រូវនឹងអ្វីដែលកូដរំពឹងទុក
4. សម្អាត cache របស់កម្មវិធី浏览器
---
## បញ្ហាការតភ្ជាប់
### ការតភ្ជាប់ WiFi
#### បញ្ហា៖ ឧបករណ៍មិនអាចភ្ជាប់ WiFi
**រោគសញ្ញា៖** ពេលភ្ជាប់អស់កំណត់ ការផ្ទៀងផ្ទាត់បរាជ័យ
**ដំណោះស្រាយ៖**
1. **ពិនិត្យ SSID និងពាក្យសម្ងាត់:** ប្រាកដថាត្រូវ
2. **ថួរក WiFi:** ឧបករណ៍ IoT ភាគច្រើនគាំទ្រត្រឹម 2.4GHz (មិនមែន 5GHz)
3. **ការកំណត់ម៉ាស៊ីនបម្រើ:**
- បិទ AP isolation ប្រសិនបើបានបើក
- ប្រើសុវត្ថិភាព WPA2-PSK (ជៀសវាង WPA3, WEP ឬបណ្តាញបើក)
- ប្រាកដថា DHCP បានបើក
4. **បណ្តាញលាក់:** ប្រសិនបើ SSID លាក់ អ្នកប្រហែលត្រូវកំណត់យ៉ាងច្បាស់
5. **កម្លាំងសញ្ញា:** ធ្វើឲ្យឧបករណ៍ជិតម៉ាស៊ីនបម្រើ
6. **ការរំខាន:** ឧបករណ៍ផ្សេង កំដៅម៉ីក្រូ វា៉លក៏អាចរំខាន
#### បញ្ហា៖ ការតភ្ជាប់ WiFi ធ្លាក់ជាប្រចាំ
**រោគសញ្ញា៖** ការតភ្ជាប់ពាក់កណ្តាល
**ដំណោះស្រាយ៖**
1. ពិនិត្យភាពចល័តម៉ាស៊ីនបម្រើ និងពិចារណាចាប់ផ្តើមម្ដងទៀត
2. អាប់ដេត firmware ឧបករណ៍
3. ប្រើ IP ស្តាទិក ជំនួស DHCP
4. បន្ថយចម្ងាយទៅម៉ាស៊ីនបម្រើ ឬបន្ថែម WiFi extender
5. ពិនិត្យការរំខានពីឧបករណ៍ផ្សេងៗ
6. ប្រាកដថាថាមពលគ្រប់គ្រាន់ (ពិសេស Raspberry Pi)
### សេវាកម្ម Cloud
#### បញ្ហា៖ មិនអាចភ្ជាប់ទៅ Azure IoT Hub
**កំហុស៖** ផ្ទៀងផ្ទាត់បរាជ័យ ការភ្ជាប់ត្រូវបានបដិសេធ
**ដំណោះស្រាយ៖**
1. **បញ្ជាក់គណនេយ្យ៖**
- ពិនិត្យខ្សែភ្ជាប់ត្រឹមត្រូវ
- ប្រាកដថាគ្មានចន្លោះ ឬបន្ទាត់ខ្ទង់លើខ្សែភ្ជាប់
2. **ពិនិត្យការចុះបញ្ជីឧបករណ៍៖** ឧបករណ៍ត្រូវបានចុះបញ្ជីនៅ IoT Hub
3. **Firewall / Proxy:** ប្រាកដថា MQTT (ច្រក 8883) ឬ HTTPS (ច្រក 443) បានកំណត់អនុញ្ញាត
4. **តំបន់ IoT Hub:** ពិនិត្យថា IoT Hub កំពុងដំណើរការ និងមិនបាននៅតំបន់ផ្សេងបង្កការពន្យារពេល
5. **ដែនកំណត់ quota:** ពិនិត្យថាតម្រូវការមិនលើសដែនកំណត់ឥតគិតថ្លៃ
6. **សាកល្បងការភ្ជាប់៖**
```bash
az iot hub device-identity show-connection-string --hub-name YourIoTHub --device-id YourDevice
```
#### បញ្ហា៖ Azure Functions មិនធ្វើការជើងផ្សាយ
**រោគសញ្ញា៖** សារ​ត្រូវបានផ្ញើ ប៉ុន្តែលំនាំមិនធ្វើ
**ដំណោះស្រាយ៖**
1. ពិនិត្យ Function App កំពុងដំណើរការ (មិនបានឈប់)
2. ប្រាកដខ្សែភ្ជាប់នៅក្នុងការកំណត់ Function App
3. ពិនិត្យកំណត់ហេតុ function នៅ Azure Portal
4. ប្រាកដ Endpoint Event Hub compatible ត្រឹមត្រូវ
5. ពិនិត្យទ្រង់ទ្រាយសារត្រូវបានផ្ញើសម្រប
6. ពិនិត្យផែនការសេវាកម្ម Function App (consumption ឬ dedicated)
### MQTT
#### បញ្ហា៖ ការភ្ជាប់ MQTT មិនបាន
**កំហុស៖** ការភ្ជាប់ត្រូវបានបដិសេធ ផ្ទៀងផ្ទាត់បរាជ័យ
**ដំណោះស្រាយៈ**
1. **អាសយដ្ឋាន Broker:** ពិនិត្យ URL/IP Broker ថាត្រឹមត្រូវ
2. **កំពង់ផែ:** ពិនិត្យលេខកំពង់ផែ (1883 សម្រាប់មិនអ៊ិនគ្រីប, 8883 សម្រាប់ TLS)
3. **ការផ្ទៀងផ្ទាត់អត្តសញ្ញាណ:** ពិនិត្យឈ្មោះអ្នកប្រើ/ពាក្យសម្ងាត់ ប្រសិនបើត្រូវការ
4. **TLS/SSL:** ប្រាកដថាសំបុត្រត្រឹមត្រូវ និងពឹងពាក់
5. **Firewall:** ពិនិត្យកំពង់ផែមិនត្រូវបានបញ្ជាលឿន
6. **សាកល្បងជាមួយ MQTT client:** ប្រើ MQTT Explorer ឬ mosquitto_pub/sub សម្រាប់សាកល្បង
#### បញ្ហា៖ សារ MQTT មិនទទួលបាន
**រោគសញ្ញាៈ** សារ បានផ្សាយ តែក៏មិនទទួលបានពីអ្នកជាវ
**ដំណោះស្រាយៈ**
1. **ឈ្មោះប្រធានបទ:** ពិនិត្យថាប្រធានបទអ្នកជាវត្រូវនឹងប្រធានបទអ្នកផ្សាយបានត្រឹមត្រូវ
2. **កម្រិត QoS:** សាកល្បង QoS 1 ឬ 2 ជំនួស 0
3. **Wildcards:** ពិនិត្យការប្រើ wildcards ប្រធានបទបានត្រឹមត្រូវ (`+` សម្រាប់កម្រិតតែមួយ, `#` សម្រាប់ច្រើនកម្រិត)
4. **សារដែលរក្សាទុក:** អ្នកផ្សាយអាចកំណត់ retain flag សម្រាប់រក្សាសារចុងក្រោយ
5. **ពេលវេលាភ្ជាប់:** ប្រាកដថាអ្នកជាវភ្ជាប់មុនពេលផ្សាយសារ
---
## បញ្ហាជាមួយ ឧបករណ៍ស៊ិនស័រ និងឧបករណ៍ចល័ត
### ស៊ិនស័រ Grove
#### បញ្ហា៖ ស៊ិនស័របង្រួមតម្លៃខុស
**រោគសញ្ញា:** ការអានជានិច្ច 0, -1 ឬតម្លៃគ្មានអត្ថន័យ
**ដំណោះស្រាយ:**
1. **ពិនិត្យការតភ្ជាប់៖** ប្រាកដថាស៊ិនស័រត្រូវបានភ្ជាប់ត្រឹមត្រូវ
2. **កំពង់ផែត្រឹមត្រូវ:** ពិនិត្យស៊ិនស័រនៅក្នុងប្រភេទកំពង់ផែត្រឹមត្រូវ៖
- ស៊ិនស័រ Analog → កំពង់ផែ Analog (A0, A2, A4)
- ស៊ិនស័រ Digital → កំពង់ផែ Digital (D5, D16, D18, ល។)
- ស៊ិនស័រ I2C → កំពង់ផែ I2C
3. **កំណត់តំរូវការតាមមនុស្សវិទ្យា:** ស៊ិនស័រមួយចំនួនត្រូវការកំណត់ស្តង់ដា (ដីស្រូបសំណើម, ពន្លឺ)
4. **បង្វិលថាមពល:** ពិភ្ជាប់ និងដោះសោស្និត្រកក្រោយ
5. **សៀវភៅច្បាប់ស៊ិនស័រ:** ពិនិត្យលក្ខណៈបច្ចេកទេស និងតម្រូវការ
#### បញ្ហា៖ ស៊ិនស័រ សំណើមដី Capacitive រៀងរាល់ពេលអានគឺសើម
**រោគសញ្ញា៖** ស៊ិនស័រអានការសំណើមខ្ពស់ទោះបីដីស្ងួត
**ដំណោះស្រាយ:**
1. **ត្រូវការកំណត់តំរូវការ៖** ស៊ិនស័រដីត្រូវតែបង្កើតស្តង់ដា៖
- អានតម្លៃក្នុងអាកាស (ស្ទះស្ងួត)
- អានតម្លៃក្នុងទឹក (ស្ទះសើម)
- បង្ហាញតម្លៃចន្លោះរវាងនេះ
2. **ពិនិត្យការការពារ​ស៊ិនស័រ:** ស៊ិនស័រសំណើមអាចបែកបាក់ ប្រសិនបើការការពារខូច
3. **ទីតាំង:** ប្រាកដថាស៊ិនស័របញ្ចូលចូលក្នុងដីពេញលេញ
#### បញ្ហា៖ ការអានសន្ទស្សន៍សីតុណ្ហភាព/សំណើមខុស
**រោគសញ្ញា៖** DHT11/DHT22 បង្ហាញសីតុណ្ហភាព ឬសំណើមខុស
**ដំណោះស្រាយ:**
1. **ទីតាំងស៊ិនស័រ:** មិនប្រើពន្លឺព្រះអាទិត្យផ្ទាល់ ប្រភពកម្តៅ ឬខ្យល់ហូរ
2. **ពេលការរំកិលកម្តៅ៖** អនុញ្ញាតឲ្យស៊ិនស័រយកពេល 2 វិនាទី បន្ទាប់ពីបើកថាមពល មុនអានទិន្នន័យ
3. **កម្រិតអាន៖** ស៊ិនស័រ DHT ត្រូវការបំបទិន្នន័យពេញលេញចន្លោះ (យ៉ាងហោចណាស់ 2 វិនាទី)
4. **ពិនិត្យសំណើមទឹកកក:** អាចមានផលប៉ះពាល់ដល់ការអាន
5. **គុណភាពស៊ិនស័រ:** DHT11 មានភាពត្រឹមត្រូវតិចជាង DHT22
### កាមេរា
#### បញ្ហា៖ កាមេរាមិនត្រូវបានរកឃើញលើ Raspberry Pi
**កំហុស:** `mmal: mmal_vc_component_create: failed to create component 'vc.ril.camera'`
**ដំណោះស្រាយ:**
1. **បើកអន្តរកម្មកាមេរា:**
```bash
sudo raspi-config
```
ចូលទៅ Interface Options → Camera → Enable
2. **ពិនិត្យខ្សែរបញ្ចូល:** ប្រាកដថាខ្សែកាមេរារត្រូវបានដាក់ត្រឹមត្រូវ
- ផ្ទាំងខៀវឈរមុខចំពោះកំពង់ USB លើ Pi Zero
- ផ្ទាំងខៀវឆ្វេងរូបមុខពីកំពង់ USB លើ Pi 4
3. **ធ្វើបច្ចុប្បន្នភាព firmware:**
```bash
sudo apt update
sudo apt full-upgrade
sudo reboot
```
4. **សាកល្បងកាមេរា:**
```bash
raspistill -o test.jpg
```
#### បញ្ហា៖ រូបភាពកាមេរាមិនបានគុណភាពល្អ
**រោគសញ្ញា៖** រូបភាពមិនច្បាស់ ធំងងឹត ឬជារូបភាពបាត់បង់ពណ៌
**ដំណោះស្រាយ:**
1. **មើលទិស:** លុបស្នាមការពារពីលើទ្រនុងកាមេរា ប្ដូរតំណកបើអាចធ្វើបាន
2. **ពន្លឺ:** ប្រាថ្នាពន្លឺគ្រប់គ្រាន់
3. **ការកំណត់កាមេរា:** ប្ដូរតំរូវការបញ្ចេញពន្លឺ ISO និង white balance ក្នុងកូដ
4. **ស្ថិរភាព:** រក្សាទុកកាមេរា ហើយប្រើ tripod ប្រសិនបើត្រូវការ
5. **កម្រិតទំហំរូបភាព:** កុំឲ្យលើសកម្រិតកម្រិតអតិបរមារបស់កាមេរា
### មីក្រូហ្វូន និង ស្បែកហ្វូន
#### បញ្ហា៖ គ្មានសំឡេងបញ្ចូល/ចេញ
**រោគសញ្ញា៖** មីក្រូហ្វូនមិនកំណត់សំឡេង ស្បែកហ្វូនមិនអាចលេង
**ដំណោះស្រាយ:**
1. **ពិនិត្យការតភ្ជាប់:** ប្រាកដថាឧបករណ៍សំឡេងភ្ជាប់ត្រឹមត្រូវ
2. **សាកល្បងឧបករណ៍៖**
- ស្បែកហ្វូន៖ `speaker-test -t wav -c 2`
- មីក្រូហ្វូន៖ `arecord -l` សម្រាប់បញ្ជី, `arecord test.wav` សម្រាប់ថត
3. **ចំណុចសំឡេង:** ពិនិត្យ និងកែតម្រូវចំណុចសំឡេង:
```bash
alsamixer
```
4. **ជ្រើសយកឧបករណ៍សំឡេងៈ** បញ្ជាក់ឧបករណ៍នៅក្នុងកូដត្រឹមត្រូវ
5. **បញ្ហាអ្នកបើកបរមុខងារ:** ដំណើរការ ALSA ឬដំឡើងឡើងវិញអ្នកបើកបរមុខងារ
#### បញ្ហា៖ ReSpeaker hat មិនដំណើរការ
**រោគសញ្ញា៖** ឧបករណ៍សំឡេងមិនត្រូវបានរកឃើញ
**ដំណោះស្រាយ:**
1. **ដំឡើងអ្នកបើកបរមុខងារ:**
```bash
git clone https://github.com/HinTak/seeed-voicecard
cd seeed-voicecard
sudo ./install.sh
sudo reboot
```
2. **ពិនិត្យការដំឡើង:** `arecord -l` គួរតែបង្ហាញ ReSpeaker
3. **ធ្វើបច្ចុប្បន្នភាព firmware:** ជួរ Pi OS ច្រើនត្រូវការកែសម្រួលអ្នកបើកបរមុខងារ
4. **ពិនិត្យការចាក់:** ប្រាកដថា hat ត្រូវបានភ្ជាប់ត្រឹមត្រូវទៅ GPIO pins
---
## បញ្ហាបរិបទអភិវឌ្ឍន៍
### VS Code
#### បញ្ហា៖ Terminal មិនបើក virtual environment បាន​ជា​ស្វ័យប្រវត្តិ
**រោគសញ្ញា៖** Terminal បើក ប៉ុន្តែមិនបើក venv
**ដំណោះស្រាយ:**
1. **កំណត់ Python interpreter:** Command Palette → "Python: Select Interpreter" → ជ្រើស venv
2. **បើក VS Code ម្តងទៀត** បន្ទាប់ពីជ្រើស interpreter
3. **ពិនិត្យការកំណត់:** ក្នុង `settings.json` បន្ថែម:
```json
"python.terminal.activateEnvironment": true
```
#### បញ្ហា៖ កូដមិនដំណើរការលើឧបករណ៍
**រោគសញ្ញា៖** កូដដំណើរការ ប៉ុន្តែមិនមានអ្វីកើតឡើងលើឧបករណ៍
**ដំណោះស្រាយ:**
1. **ប្រាកដថាកូដបានរក្សាទុក** (ពិនិត្យចុចសញ្ញាក្បាលផ្ទាំងឯកសារ)
2. **ពិនិត្យ Python ដែលដំណើរការ៖** `which python``where python`
3. **សម្រាប់ Wio Terminal:** ប្រាកដថា​កូដ​ត្រូវបានផ្ទុកឡើងតាម PlatformIO (ចុចប៊ូតុង upload)
4. **សម្រាប់ Raspberry Pi:** SSH ចូល Pi ហើយដំណើរការកូដនៅទីនោះ
5. **ពិនិត្យវីនដូវផលប៉ះពាល់** សម្រាប់កំហុស
#### បញ្ហា៖ IntelliSense មិនបង្ហាញមុខងារសៀវភៅបណ្ណាល័យ
**រោគសញ្ញា៖** គ្មានការបញ្ចូលបញ្ច្រាសសម្រាប់ម៉ូឌុលនាំចូល
**ដំណោះស្រាយ៖**
1. ប្រាកដថាបណ្ណាល័យត្រូវបានដំឡើងនៅក្នុងបរិបទបច្ចុប្បន្ន
2. ធ្វើរុញជំរុញ VS Code window
3. ពិនិត្យថា Python interpreter ត្រឹមត្រូវ
4. ដំឡើង type stubs ប្រសិនបើមាន៖ `pip install types-<library-name>`
### បរិបទ Python Virtual Environments
#### បញ្ហា៖ មិនអាចបង្កើត virtual environment បាន
**កំហុស:** `The virtual environment was not created successfully`
**ដំណោះស្រាយ:**
1. **ដំឡើងមុខងារ venv:**
- Ubuntu/Debian: `sudo apt install python3-venv`
- macOS: មកជាមួយ Python ស្រាប់
- Windows: ដំឡើងឡើងវិញ Python ជាមួយគ្រប់គ្រងគ្រឿងបន្លាស់
2. **ពិនិត្យការដំឡើង Python:** ប្រាកដថា Python ត្រូវបានដំឡើងត្រឹមត្រូវ
3. **ប្រើផ្លូវពេញ:** សាកល្បង `python3 -m venv .venv` ជាមួយការហៅ python3 ដាស់តឿន
#### បញ្ហា៖ កញ្ចប់ត្រូវបានដំឡើងច្របាក់ទីតាំង
**រោគសញ្ញា៖** កំហុសនាំចូលបន្ទាប់ពីដំឡើងកញ្ចប់
**ដំណោះស្រាយ:**
1. **ប្រាកដថា venv ត្រូវបានបើក:** Prompt បង្ហាញ `(.venv)`
2. **ពិនិត្យទីតាំង pip:** `which pip` ត្រូវបង្ហាញទៅ `.venv/bin/pip`
3. **ដំឡើងឡើងវិញនៅក្នុង venv:** បើក venv ហើយ `pip install <package>`
4. **កុំប្រើ sudo ជាមួយ pip** នៅក្នុង virtual environment
#### បញ្ហា៖ Virtual environment មិនអាចផ្ទុកបាន
**រោគសញ្ញា៖** Venv មិនដំណើរការបន្ទាប់ពីផ្លាស់ទី ឬនៅលើកុំព្យូទ័រផ្សេង
**ដំណោះស្រាយ:**
1. **កុំផ្លាស់ទី venv:** លុបចោលហើយបង្កើតឡើងវិញនៅទីតាំងថ្មី
2. **ប្រើ requirements.txt:**
```bash
pip freeze > requirements.txt
pip install -r requirements.txt
```
3. **បង្កើតឡើងវិញ venv:**
```bash
python3 -m venv .venv
source .venv/bin/activate # ឬ activate.bat នៅលើ Windows
pip install -r requirements.txt
```
### ផ្នែក Dependencies
#### បញ្ហា៖ ការដំឡើងកញ្ចប់បរាជ័យ
**កំហុស:** កំហុស pip ផ្សេងៗពេលដំឡើង
**ដំណោះស្រាយ:**
1. **ធ្វើបច្ចុប្បន្នភាព pip:**
```bash
pip install --upgrade pip
```
2. **ដំឡើងឧបករណ៍កសាង:**
- Ubuntu/Debian: `sudo apt install build-essential python3-dev`
- macOS: `xcode-select --install`
- Windows: ដំឡើង Visual Studio Build Tools
3. **ពិនិត្យការតភ្ជាប់អ៊ីនធឺណិត**
4. **សាកល្បងប្រភពកញ្ចប់ផ្សេងៗ:** `pip install --index-url https://pypi.org/simple/ <package>`
5. **ដំឡើងកំណែជាក់លាក់៖** `pip install <package>==<version>`
#### បញ្ហា៖ សំឡឹងទុកបញ្ហា Dependency Conflict
**កំហុស:** `ERROR: pip's dependency resolver does not currently take into account all the packages that are installed`
**ដំណោះស្រាយ:**
1. **ប្រើ virtual environment ថ្មីៗ** សម្រាប់រាល់គម្រោង
2. **ធ្វើបច្ចុប្បន្នភាពកញ្ចប់:** `pip install --upgrade <package>`
3. **ពិនិត្យความត្រូវតាម:** ប្រើ `pip check` សម្រាប់រកបញ្ហា
4. **ដំឡើងកំណែដែលសមរម្យ:** បញ្ជាក់ជួរជាមួយ requirements.txt
---
## បញ្ហាប្រតិបត្តិការ
### បញ្ហា៖ កូដដំណើរការយឺត
**រោគសញ្ញា៖** ពន្យាពេល, ពេលវេលា timeout, អត់ឆ្លើយតប
**ដំណោះស្រាយ:**
1. **កាត់បន្ថយកម្រិតអានស៊ិនស័រ:** កុំអានឲ្យស៊ិនស័រញឹកញាប់ពេក
2. **បង្កើតរង្វិលងារល្អ:** ជៀសវាងការរង់ចាំល្បឿនខ្ពស់, ប្រើ sleep() ឬពេលពន្យាពេល
3. **បញ្ហាអង្គចងចាំ:**
- បិទកម្មវិធីមិនចាំបាច់
- ដោះស្រាយទំហំទទេ
- តាមដានជាមួយ `top``htop` លើ Pi
4. **ល្បឿនកាត SD:** ប្រើកាត SD ឬ SSD លឿនសម្រាប់ Raspberry Pi
5. **ពន្យាពេលបណ្តាញ:** ប្រើ async សម្រាប់ការហៅបណ្តាញ
### បញ្ហា៖ កំហុសចេញពីអង្គចងចាំ
**កំហុស៖** `MemoryError` ឬ កម្មវិធីរាំងស្ទះ
**ដំណោះស្រាយ:**
1. **សម្រាប់ Raspberry Pi:**
- បិទកម្មវិធីមិនចាំបាច់
- បង្កើនទំហំ swap
- ប្រើប្រព័ន្ធប្រតិបត្តិការ​ស្រាល (Lite version)
- អាប់ដេត RAM (Pi 4 មានជម្រើស 2/4/8GB)
2. **សម្រាប់ Wio Terminal:**
- កាត់បន្ថយទំហំទុកបន្ថ័យ
- ប្រើរូបភាពតូចជាង
- បង្កើត efficiency សម្រាប់ការប្រើ string
- ពិនិត្យចេញ memory leaks (អង្គចងចាំមិនបានចេញ)
### បញ្ហា៖ បាត់បង់ទិន្នន័យ ឬ បាក់បែក
**រោគសញ្ញា៖** សារបាត់, ឯកសារបាក់បែក
**ដំណោះស្រាយ:**
1. **បញ្ហាកាត SD:**
- ប្រើកាត SD គុណភាពល្អ (ជៀសវាងកាតថោក/ចម្លង)
- បង្កើតបម្រុងទុកចម្លងជាប្រចាំ
- បិទប្រព័ន្ធត្រឹមត្រូវ (កុំចាប់ភ្លើងភ្លោះ)
2. **Buffer overflow:** កើនទំហំ buffer ក្នុងកូដ
3. **ភាពទុកចិត្ត​បណ្តាញ:** អនុវត្តលក្ខណៈ logic retry និងដោះស្រាយកំហុស
4. **គុណភាពសេវា:** ប្រើ MQTT QoS 1 ឬ 2 សម្រាប់សារសំខាន់ៗ
---
## សារ​កំហុសទូទៅ
### `ModuleNotFoundError: No module named 'X'`
**ហេតុ៖** មិនបានដំឡើង package ឬ virtual environment មិនបានបើក
**ដំណោះស្រាយ:**
```bash
pip install X
```
ប្រាកដថា virtual environment ត្រូវបានបើកជាមុនសិន។
### `Permission denied` លើ Linux/macOS
**ហេតុ៖** ត្រូវការឥណទានដំណើរការ ឬ បញ្ហាសិទ្ធិឯកសារ
**ដំណោះស្រាយ:**
- សម្រាប់ប្រតិបត្តិការរដ្ឋបាល៖ ប្រើ `sudo`
- សម្រាប់ pip៖ កុំប្រើ sudo ជាមួយ venv, បើក venv ជាមុន
- សម្រាប់ផត់ស៊េរីយ៉ាល់៖ បញ្ជូលអ្នកប្រើទៅក្រុម dialout៖ `sudo usermod -a -G dialout $USER` បន្ទាប់មកចាកចេញ/ចូលវិញ
### `OSError: [Errno 98] Address already in use`
**ហេតុ:** កំពង់ផែត្រូវបានប្រើរួចដោយដំណើរការផ្សេង
**ដំណោះស្រាយ:**
1. ស្វែងរកដំណើរការដែលប្រើកំពង់ផែ: `lsof -i :<port>``netstat -ano | findstr :<port>`
2. សម្លាប់ដំណើរការ ឬប្រើកំពង់ផែផ្សេងក្នុងកូដរបស់អ្នក
### `SSL: CERTIFICATE_VERIFY_FAILED`
**ហេតុ:** ការផ្ទៀងផ្ទាត់សំបុត្រ SSL បរាជ័យ
**ដំណោះស្រាយ:**
1. ធ្វើបច្ចុប្បន្នភាពសំបុត្រ៖ `pip install --upgrade certifi`
2. ពិនិត្យម៉ោងប្រព័ន្ធ៖ `date`
3. សម្រាប់ការអភិវឌ្ឍន៍តែប៉ុណ្ណោះ (មិនធ្វើផលិតកម្ម): បិទការផ្ទៀងផ្ទាត់ក្នុងកូដ
### `IndentationError: unexpected indent`
**ហេតុ:** បញ្ហាការតម្រូវសរសេរកូដ Python (ច្របល់ tabs និង spaces)
**ដំណោះស្រាយ:**
1. ប្រើការរចនាសរសេរជារយៈស្តង់ដារសម្រាប់ Python (4 ផ្ទះ)
2. កំណត់ editor ប្រើ spaces ជំនួស tabs
3. VS Code: កំណត់ `"editor.insertSpaces": true` និង `"editor.tabSize": 4`
### `UnicodeDecodeError``UnicodeEncodeError`
**ហេតុ:** បញ្ហាកូដអត្ថបទ
**ដំណោះស្រាយ:**
```python
# នៅពេលអានឯកសារ
with open('file.txt', 'r', encoding='utf-8') as f:
content = f.read()
# នៅពេលសរសេរឯកសារ
with open('file.txt', 'w', encoding='utf-8') as f:
f.write(content)
```
---
## ទទួលបានជំនួយ
បើអ្នកបានសាកល្បងជំហានដោះស្រាយបញ្ហាទាំងនេះហើយនៅតែមានបញ្ហា៖
### 1. ពិនិត្យធនធានដែលមានស្រាប់
- **ឯកសារណ៍៖** ពិនិត្យមើល [README](README.md) និងការណែនាំមេរៀន
- **មេរៀនឧបករណ៍៖** ពិនិត្យ [hardware.md](hardware.md) សម្រាប់ព័ត៌មានពាក់ព័ន្ធឧបករណ៍
- **Seeed Studio Wiki:** [Seeed Studio Wiki](https://wiki.seeedstudio.com/) សម្រាប់គ្រឿងញៀន Grove
### 2. ស្វែងរកបញ្ហាដូចគ្នា
- **GitHub Issues៖** ស្វែងរក [បញ្ហាដែលមានស្រាប់](https://github.com/microsoft/IoT-For-Beginners/issues)
- **Stack Overflow៖** ស្វែងរកសារកំហុស
- **វេទិកា​ឧបករណ៍៖** ពិនិត្យវេទិកា Raspberry Pi ឬ Arduino
### 3. បង្កើតបញ្ហា GitHub
បើអ្នករកមិនឃើញដំណោះស្រាយ:
1. ចូល [GitHub Issues](https://github.com/microsoft/IoT-For-Beginners/issues)
2. ចុច "New Issue"
3. ផ្ដល់ព័ត៌មាន៖
- ការពិពណ៌នាបញ្ហាឲ្យច្បាស់
- ជំហានកើតឡើង
- សារកំហុស (អត្ថបទពេញលេញ)
- កំណែឧបករណ៍/កម្មវិធី
- អ្វីដែលអ្នកបានព្យាយាម
- រូបភាពអេក្រង់ ប្រសិនបើមាន
### 4. ចូលរួមសហគមន៍
- **Discord:** [Microsoft Foundry Discord](https://discord.gg/nTYy5BXMWG)
- **Microsoft Learn:** [Microsoft Learn IoT](https://docs.microsoft.com/learn/browse/?products=azure-iot)
### 5. ផ្ដល់របាយការណ៍បញ្ហាដែលល្អ
របាយការណ៍បញ្ហាល្អរួមមាន៖
- **បរិស្ថាន៖** ប្រព័ន្ធប្រតិបត្ដិការ (OS), ជំពូក Python,​ឧបករណ៍ប្រើប្រាស់
- **ជំហានក្នុងការស្ទង់មើល៖** ជំហានពិតប្រាកដដែលបង្ករឲ្យមានបញ្ហា
- **អ្វីដែលរំពឹងទុក៖** អ្វីដែលគួរត្រូវកើតឡើង
- **អ្វីដែលកើតឡើងជាធម្មតា៖** អ្វីដែលពិតជាកើតឡើង
- **សារបញ្ហា៖** អត្ថបទកំហុសពេញលេញ មិនមែនជារូបភាពថតផ្ទាំងអេក្រង់ទេ
- **កូដ៖** ឧទាហរណ៍កូដតូចបំផុតដែលបង្កប់បញ្ហា
---
## ជំនួយក្នុងការពារជំងឺ
### អនុវត្តល្អប៉ុន្មានទូទៅ
1. **រក្សាទុកចម្លង៖** ការចម្លងទុកជាប្រចាំនៃ SD card/kod ដែលវាយតម្លៃបាន
2. **ចុះបញ្ជីការផ្លាស់ប្តូរ៖** កត់សម្គាល់អ្វីដែលដំណើរការនៅក្នុងមតិយោបល់
3. **គ្រប់គ្រងជំពូក៖** ប្រើ git ដើម្បីតាមដានការផ្លាស់ប្តូរកូដ
4. **សាកល្បងចាំបាច់៖** សាកល្បងការផ្លាស់ប្តូរតិចតួចមុនចូលបញ្ចូល
5. **អានសារកំហុស៖** ពួកវាមានពាក្យថាកំហុសដោយម៉ោង
6. **ធ្វើបច្ចុប្បន្នភាពជាប្រចាំ៖** រក្សាទុកកម្មវិធី/ផ្នែករឹងឲ្យទាន់សម័យ
7. **ប្រើធាតុជាគុណភាព៖** ជៀសវាងខ្សែថ្ម/ផ្គត់ផ្គង់ថាមពលថោក
8. **ថាមពលឈរជាប់៖** ប្រើប្រភពថាមពលសមរម្យ (ពិសេស Pi)
### ការអភិវឌ្ឍន៍កម្មវិធី
1. **ចាប់ផ្តើមពីភាពសាមញ្ញ៖** ចាប់ផ្តើមជាមួយកូដឧទាហរណ៍ដែលដំណើរការ
2. **ផ្លាស់ប្តូរតែម្ដង៖** ง่ายសម្រាប់រកអ្វីខូចខាត
3. **សាកល្បងជាប្រចាំ៖** ចាប់បញ្ហា ពេលឆាប់
4. **រក្សារឱ្យស្អាត៖** រៀបចំឯកសារ និងកូដដោយមានហេតុផល
5. **បញ្ចូលមតិយោបល់កូដ៖** អ្នកនៅថ្ងៃក្រោយនឹងស្រឡាញ់វា
---
*មេរៀនដោះស្រាយបញ្ហានេះ ត្រូវបានថែរក្សាដោយសហគមន៍។ ប្រសិនបើអ្នករកឃើញដំណោះស្រាយសម្រាប់បញ្ហាដែលមិនមាននៅទីនេះ សូមពិចារណាបានចូលរួម [contributing](CONTRIBUTING.md) ដើម្បីជួយអ្នកដទៃ!*
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការព្រមាន**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលដែលយើងខិតខំប្រឹងប្រែងសម្រាប់ភាពត្រឹមត្រូវ សូមជ្រាបថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុស ឬអក្សរបាត់បង់ខុសខាង។ ឯកសារដើមនៅភាសាផ្ទាល់ខ្លួនគួរត្រូវបានគេសង្ស័យថា ជាអ្នកផ្តល់ព័ត៌មានដ៏ទូលំទូលាយ។ សម្រាប់ព័ត៌មានដ៏សំខាន់ សូមផ្ដល់អនុសាសន៍ឱ្យប្រើការបកប្រែដោយមនុស្សដែលមានជំនាញវិជ្ជាជីវៈ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ខុស ឬការពន្យល់ខុស ដែលកើតឡើងពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,47 @@
# ការចែងអត្តសញ្ញាណរូបភាព
* กล้วยដោយ abderraouf omara ពី [Noun Project](https://thenounproject.com)
* សួតដោយ Icon Market ពី [Noun Project](https://thenounproject.com)
* សំឡេងផ្សាយដោយ RomStu ពី [Noun Project](https://thenounproject.com)
* ប៊ូតុងដោយ Dan Hetteix ពី [Noun Project](https://thenounproject.com)
* ប្រភេទ C451B ម៉ីក្រូហ្វូនកុងដឺនសឺរដោយ AKG Acoustics។ [Harumphy](https://en.wikipedia.org/wiki/User:Harumphy) នៅ [en.wikipedia](https://en.wikipedia.org/) / [Creative Commons Attribution-Share Alike 3.0 Unported](https://creativecommons.org/licenses/by-sa/3.0/deed.en)
* ប្រតិទិនដោយ Alice-vector ពី [Noun Project](https://thenounproject.com)
* សញ្ញាបត្រដោយ alimasykurm ពី [Noun Project](https://thenounproject.com)
* សៀគ្វីឌីជីថលដោយ Astatine Lab ពី [Noun Project](https://thenounproject.com)
* ពពកដោយ Debi Alpa Nugraha ពី [Noun Project](https://thenounproject.com)
* ធុងដោយ ProSymbols ពី [Noun Project](https://thenounproject.com)
* CPU ដោយ Icon Lauk ពី [Noun Project](https://thenounproject.com)
* ឌាតាបេសដោយ Icons Bazaar ពី [Noun Project](https://thenounproject.com)
* ឌៀលដោយ Jamie Dickinson ពី [Noun Project](https://thenounproject.com)
* GPS ដោយ mim studio ពី [Noun Project](https://thenounproject.com)
* ម៉ាស៊ីនកំដៅដោយ Pascal Heß ពី [Noun Project](https://thenounproject.com)
* គំនិតដោយ Pause08 ពី [Noun Project](https://thenounproject.com)
* IoT ដោយ Adrien Coquet ពី [Noun Project](https://thenounproject.com)
* LED ដោយ abderraouf omara ពី [Noun Project](https://thenounproject.com)
* ldr ដោយ Eucalyp ពី [Noun Project](https://thenounproject.com)
* បង្អក់ពន្លឺដោយ Maxim Kulikov ពី [Noun Project](https://thenounproject.com)
* ម៉ៃក្រូកុងត្រូល័រដោយ Template ពី [Noun Project](https://thenounproject.com)
* ទូរស័ព្ទដៃដោយ Alice-vector ពី [Noun Project](https://thenounproject.com)
* ម៉ូទ័រដោយ Bakunetsu Kaito ពី [Noun Project](https://thenounproject.com)
* Patti Smith កំពុងច្រៀងចំពោះម៉ីក្រូហ្វូន Shure SM58 (ប្រភេទដាយណាមិចកាតារ៉ូអ៊ីត)។ Beni Köhler / [Creative Commons Attribution-Share Alike 3.0 Unported](https://creativecommons.org/licenses/by-sa/3.0/deed.en)
* រុក្ខជាតិដោយ Alex Muravev ពី [Noun Project](https://thenounproject.com)
* កោសិការុក្ខជាតដោយ Léa Lortal ពី [Noun Project](https://thenounproject.com)
* probe ដោយ Adnen Kadri ពី [Noun Project](https://thenounproject.com)
* របាំងដោយ Atif Arshad ពី [Noun Project](https://thenounproject.com)
* Raspberry Pi 4។ Michael Henzler / [Wikimedia Commons](https://commons.wikimedia.org/wiki/Main_Page) / [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)
* ការថតឡើងវិញដោយ Aybige Speaker ពី [Noun Project](https://thenounproject.com)
* ផ្កាយផ្ទៃដីដោយ Noura Mbarki ពី [Noun Project](https://thenounproject.com)
* ឧបករណ៍ចាប់សញ្ញាឆ្លាតដោយ Andrei Yushchenko ពី [Noun Project](https://thenounproject.com)
* វិទ្យុដោយ Gregor Cresnar ពី [Noun Project](https://thenounproject.com)
* កម្លាំងបិទបើកដោយ Chattapat ពី [Noun Project](https://thenounproject.com)*
* សីតុណ្ហភាពដោយ Vectors Market ពី [Noun Project](https://thenounproject.com)
* ប៉ោម tomato ដោយ parkjisun ពី Noun Project ពី [Noun Project](https://thenounproject.com)
* កុងដូងទឹកដោយ Daria Moskvina ពី [Noun Project](https://thenounproject.com)
* អាកាសធាតុដោយ Adrien Coquet ពី [Noun Project](https://thenounproject.com)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ បើទោះបីយើងខិតខំប្រឹងប្រែងសម្រាប់ភាពត្រឹមត្រូវ ក៏ការបកប្រំដោយយន្តហោះអាចមានកំហុសឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមជាភាសាមត្តេយ្យគួរត្រូវបានគិតថាជាឯកសារផ្លូវការលើបណ្តាំ។ សម្រាប់ព័ត៌មានសំខាន់ណាស់ អ្នកគួរតែប្រើការបកប្រែដោយអ្នកជំនាញមនុស្ស។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសៗណាមួយដែលកើតឡើងពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,48 @@
# សម្អាតគម្រោងរបស់អ្នក
បន្ទាប់ពីអ្នកបញ្ចប់គម្រោងមួយៗ វាជារឿងល្អក្នុងការលុបប្រភពទិន្នន័យរបស់អ្នកក្នុងពពក។
ក្នុងមេរៀនសម្រាប់គម្រោងមួយៗ អ្នកអាចបានបង្កើតខាងក្រោមខ្លះៗ៖
* ក្រុមធនធានមួយ
* មជ្ឈមណ្ឌល IoT មួយ
* ការចុះបញ្ជីឧបករណ៍ IoT
* គណនីផ្ទុកទិន្នន័យមួយ
* អនុភាពសកម្មការ Functions App មួយ
* គណនី Azure Maps មួយ
* គម្រោងចក្ខុវិស័យប្ដូរពណ៌មួយ
* កម្មវិធី Azure Container Registry មួយ
* កម្មវិធី cognitive services មួយ
ភាគច្រើននៃធនធានទាំងនេះមិនមានថ្លៃដល់ទេ - ឬពិតជាឥតគិតថ្លៃជាប្រការ ឬអ្នកកំពុងប្រើថ្នាក់ឥតគិតថ្លៃ។ សម្រាប់សេវាកម្មដែលត្រូវការថ្នាក់បង់ប្រាក់ អ្នកនឹងប្រើវានៅកម្រិតដែលរួមបញ្ចូលនៅក្នុងការអនុញ្ញាតឥតគិតថ្លៃ ឬតែមានថ្លៃប៉ុណ្ណោះ។
ទោះបីថ្លៃតិចបែបនេះក៏ដោយ វាគួរឱ្យលុបធនធានទាំងនេះនៅពេលអ្នកបញ្ចប់។ អ្នកអាចមានតែ មជ្ឈមណ្ឌល IoT មួយដែលប្រើថ្នាក់ឥតគិតថ្លៃ ជាឧទាហរណ៍ បើអ្នកចង់បង្កើតមួយទៀត អ្នកត្រូវការ ប្រើថ្នាក់បង់ប្រាក់។
សេវាកម្មទាំងអស់របស់អ្នកត្រូវបានបង្កើតនៅក្នុងក្រុមធនធាន ហើយនេះធ្វើអោយងាយស្រួលក្នុងការគ្រប់គ្រង។ អ្នកអាចលុបក្រុមធនធាន ហើយសេវាកម្មទាំងអស់ក្នុងក្រុមនោះនឹងត្រូវបានលុបជាមួយ។
ដើម្បីលុបក្រុមធនធាន ចាប់ផ្តើមចូលបញ្ជារបញ្ជា​ខាងក្រោមនៅក្នុងទំព័របញ្ជាឬ Command Prompt របស់អ្នក៖
```sh
az group delete --name <resource-group-name>
```
ជំនួស `<resource-group-name>` ជាមួយឈ្មោះក្រុមធនធានដែលអ្នកមានចំណាប់អារម្មណ៍។
នឹងមានការបញ្ចេញការបញ្ជាក់បង្ហាញ៖
```output
Are you sure you want to perform this operation? (y/n):
```
បញ្ចូល `y` ដើម្បីបញ្ជាក់ និងលុបក្រុមធនធាន។
វានឹងចំណាយពេលបន្តិចក្នុងការលុបសេវាកម្មទាំងអស់។
> 💁 អ្នកអាចអានបន្ថែមអំពីការលុបក្រុមធនធាននៅលើ [អត្ថបទឯកសារ Azure Resource Manager resource group and resource deletion នៅលើ Microsoft Docs](https://docs.microsoft.com/azure/azure-resource-manager/management/delete-resource-group?WT.mc_id=academic-17441-jabenn&tabs=azure-cli)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**:
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ទោះបីយើងខិតខំរកភាពត្រឹមត្រូវ ក៏សូមយល់ថាការបកប្រែដោយស្វ័យប្រវត្តិក្នុងខ្លះអាចមានកំហុស ឬការមិនត្រឹមត្រូវ។ ឯកសារដើមក្នុងភាសាមូលដ្ឋានគួរត្រូវបានគេយកដូចជា ប្រភពដើមដែលមានអំណាច។ សម្រាប់ព័ត៌មានសំខាន់ៗ សូមណែនាំឱ្យបកប្រែដោយមនុស្សដែលមានជំនាញ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,44 @@
- ការណែនាំ
- [1](../1-getting-started/lessons/1-introduction-to-iot/README.md)
- [2](../1-getting-started/lessons/2-deeper-dive/README.md)
- [3](../1-getting-started/lessons/3-sensors-and-actuators/README.md)
- [4](../1-getting-started/lessons/4-connect-internet/README.md)
- កសិដ្ឋាន
- [5](../2-farm/lessons/1-predict-plant-growth/README.md)
- [6](../2-farm/lessons/2-detect-soil-moisture/README.md)
- [7](../2-farm/lessons/3-automated-plant-watering/README.md)
- [8](../2-farm/lessons/4-migrate-your-plant-to-the-cloud/README.md)
- [9](../2-farm/lessons/5-migrate-application-to-the-cloud/README.md)
- [10](../2-farm/lessons/6-keep-your-plant-secure/README.md)
- ការដឹកជញ្ជូន
- [11](../3-transport/lessons/1-location-tracking/README.md)
- [12](../3-transport/lessons/2-store-location-data/README.md)
- [13](../3-transport/lessons/3-visualize-location-data/README.md)
- [14](../3-transport/lessons/4-geofences/README.md)
- ការផលិត
- [15](../4-manufacturing/lessons/1-train-fruit-detector/README.md)
- [16](../4-manufacturing/lessons/2-check-fruit-from-device/README.md)
- [17](../4-manufacturing/lessons/3-run-fruit-detector-edge/README.md)
- [18](../4-manufacturing/lessons/4-trigger-fruit-detector/README.md)
- ការលក់រាយ
- [19](../5-retail/lessons/1-train-stock-detector/README.md)
- [20](../5-retail/lessons/2-check-stock-device/README.md)
- អ្នកប្រើប្រាស់
- [21](../6-consumer/lessons/1-speech-recognition/README.md)
- [22](../6-consumer/lessons/2-language-understanding/README.md)
- [23](../6-consumer/lessons/3-spoken-feedback/README.md)
- [24](../6-consumer/lessons/4-multiple-language-support/README.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារនេះត្រូវបានបម្លែងភាសា ដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលដែលយើងខិតខំប្រឹងប្រែងដើម្បីឲ្យបានភាពច្បាស់លាស់ សូមយល់ថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុស ឬភាពមិនត្រឹមត្រូវណាមួយ។ ឯកសារដើមក្នុងភាសាទីជាតិគួរត្រូវបានយកជាប្រភពស្បៀងដៃ និងមានអំណាច។ សម្រាប់ព័ត៌មានសំខាន់ៗ សូមណែនាំឱ្យប្រើប្រាស់ការបកប្រែដោយមនុស្សវិជ្ជាជីវៈ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសប្រក្រតីណាមួយដែលកើតឡើងពីការប្រើប្រាស់ការបកប្រែនេះទេ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,89 @@
# មគ្គុទេសក៍ការដោះស្រាយបញ្ហា Raspberry Pi
មគ្គុទេសក៍នេះផ្តល់នូវដំណោះស្រាយសម្រាប់បញ្ហាទូទៅដែលបានជួបប្រទៈក្នុងការប្រតិបត្ដិគម្រោង IoT លើឧបករណ៍ Raspberry Pi។
វាត្រូវបានរចនាសម្រាប់អ្នកចាប់ផ្ដើមដែលតាមដានមេរៀន IoT-For-Beginners ប៉ុន្តែវាក៏មានប្រយោជន៍សម្រាប់ការអភិវឌ្ឍ Pi ជាទូទៅផងដែរ។
---
## 1. កំហុសក្នុងការដំឡើង និងការទាមទារ
### ❗ `ModuleNotFoundError: No module named 'xyz'`
នេះកើតឡើងពេលម៉ូឌុល Python ត្រូវការមិនត្រូវបានដំឡើង។
**ដំណោះស្រាយ**
```bash
pip3 install <module_name>
Permission denied when running scripts
Often caused by accessing GPIO, I2C or system hardware without elevated privileges.
Quick fix:
sudo python3 script.py
Recommended fix (no sudo needed every time):
sudo usermod -aG gpio,i2c,spi $USER
sudo reboot
2. GPIO / I2C / SPI Not Working
❗ RuntimeError: No access to GPIO
Add user to GPIO group:
sudo usermod -aG gpio $USER
sudo reboot
❗ I2C / SPI devices not detected
Enable interfaces:
sudo raspi-config
→ Interface Options
→ Enable I2C / Enable SPI
Check if I2C device appears:
i2cdetect -y 1
3. Camera / Video Issues
❗ Camera not detected or fails to start
Enable camera interface:
sudo raspi-config
→ Interface Options → Camera → Enable
sudo reboot
Check if camera is visible:
vcgencmd get_camera
4. Wi-Fi / SSH / Connectivity Problems
| Problem | Fix |
| -------------------------------- | --------------------------------------------- |
| SSH connection refused | `sudo raspi-config → Interface Options → SSH` |
| Device not showing on network | Check IP using: `hostname -I` |
| Slow Wi-Fi / unstable connection | Prefer 2.4 GHz band, update OS |
| Unable to access Pi headless | Add `ssh` file to boot partition |
5. Performance Issues
Raspberry Pi running slow / laggy
Close unused applications
Reduce background services
Use Lite OS if no desktop needed
Ensure sufficient power supply (5V/3A or better)
Check CPU load:
top
htop
Storage issues:
sudo apt autoremove
sudo apt clean
df -h
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលយើងខិតខំដើម្បីរក្សា ភាពត្រឹមត្រូវ សូមព្យាយាមយកចិត្តទុកដាក់ទៅថាការបកប្រែដោយស្វ័យប្រវត្តិនេះអាចមានកំហុស ឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមក្នុងភាសាតំបន់របស់វាគួរត្រូវបានយកឲ្យជាតំណលទ្ធផលផ្លូវការជាទីបំផុត។ សម្រាប់ព័ត៌មានសំខាន់ៗ គួរតែប្រើការបកប្រែដោយមនុស្សជំនាញ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសរៀងịa រាក់ទាក់ពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,34 @@
# សម្រាប់គ្រូបង្រៀន
តើអ្នកចង់ប្រើមេរៀននេះនៅក្នុងថ្នាក់រៀនរបស់អ្នកទេ? សូមដោយក្តីសោមនស្សរីករាយ!
ការពិតហើយ អ្នកអាចប្រើវានៅនៅក្នុង GitHub ផ្ទាល់តាមរយៈការប្រើ GitHub Classroom។
ដើម្បីធ្វើដូចនេះ សូមបំបែក repo នេះ។ អ្នកនឹងត្រូវការបង្កើត repo មួយសម្រាប់មេរៀនរៀងៗគ្នា ដូច្នេះអ្នកនឹងត្រូវដកផ្ទុកថតនីមួយៗទៅក្នុង repo ផ្សេងជាចំបង។ ដូច្នេះ [GitHub Classroom](https://classroom.github.com/classrooms) អាចចាប់យកមេរៀននីមួយៗបានជា​ពិសេស។
[ការ​ណែនាំ​ពេញលេញ​ទាំងនេះ](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) នឹងផ្តល់ឱ្យអ្នកនូវគំនិតរបៀបដើម្បីធ្វើការកំណត់ថ្នាក់រៀនរបស់អ្នក។
## ម៉ូដែលរៀនដែលបានផ្តល់អនុសាសន៍
អ្នកអាចអានបន្ថែមអំពីម៉ូដែលរៀនដែលបានផ្តល់អនុសាសន៍នៅពេលបង្រៀនមេរៀននេះនៅក្នុង [មគ្គុទេសក៍ម៉ូដែលរៀនដែលបានផ្តល់អនុសាសន៍](recommended-learning-model.md) របស់យើង។
## ការប្រើ repo ដូចដែលមាន
បើអ្នកចង់ប្រើ repo នេះដូចដែលវាគឺស្ថិតនៅបច្ចុប្បន្ន ដោយមិនប្រើ GitHub Classroom នោះក៏អាចធ្វើបានផងដែរ។ អ្នកត្រូវតែទំនាក់ទំនងជាមួយសិស្សរបស់អ្នកថាមេរៀនណាដែលត្រូវធ្វើរួមគ្នា។
នៅក្នុងទ្រង់ទ្រាយអនឡាញ (Zoom, Teams, ឬផ្សេងទៀត) អ្នកអាចបង្កើតបន្ទប់បែកចេញសម្រាប់ការប្រឡងសំណួរ ហើយផ្តល់មេរៀនជាទីប្រឹក្សាផ្នែកកម្រិតខ្ពស់ដល់សិស្ស ដើម្បីជួយពួកគេចាំបាច់រៀនរួចហើយ។ បន្ទាប់មកអញ្ជើញសិស្សមកចូលរួមការប្រឡងសំណួរនិងដាក់សំណួររបស់ពួកគេជាជំងឺ ('issues') នៅពេលកំណត់។ អ្នកក៏អាចធ្វើដូចគ្នាជាមួយកិច្ចការប្រចាំផងដែរបើអ្នកចង់ឲ្យសិស្សធ្វើការងារជាក្រុមក្នុងទីលំនៅចំហ។
បើអ្នកចូលចិត្តទ្រង់ទ្រាយឯកជនច្រើនជាងនេះ សូមស្នើឲ្យសិស្សរបស់អ្នកបំបែកមេរៀននេះហើយបង្កើត repo ផ្ទាល់ខ្លួនសម្រាប់មេរៀនមួយៗនៅ GitHub កម្មវិធីផ្ទាល់ខ្លួន ហើយផ្តល់សិទ្ធិជូនអ្នក។ បន្ទាប់មកពួកគេអាចបញ្ចប់ការប្រឡងនិងកិច្ចការផ្ទាល់ខ្លួន ហើយដាក់ស្នើតាមរយៈ issues នៅ repo ថ្នាក់រៀនរបស់អ្នក។
មានវិធីជាច្រើនដើម្បីអោយវាដំណើរការល្អនៅក្នុងទ្រង់ទ្រាយថ្នាក់រៀនអនឡាញ។ សូមប្រាប់យើងថាវាដំណើរការល្អសម្រាប់អ្នកយ៉ាងដូចម្តេច!
## សូមផ្តល់មតិយោបល់របស់អ្នក!
យើងចង់ឲ្យមេរៀននេះប្រើបានល្អសម្រាប់អ្នកនិងសិស្សរបស់អ្នក។ សូមផ្តល់មតិយោបល់ [feedback](https://forms.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR2humCsRZhxNuI79cm6n0hRUQzRVVU9VVlU5UlFLWTRLWlkyQUxORTg5WS4u) មកកាន់យើងផង!
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបញ្ចាក់**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលយើងខិតខំរកភាពถูกต้อง សូមយកចិត្តទុកដាក់ថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុសឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមជាភាសាតាមដើមគួរត្រូវបានចាត់ទុកជាទិន្នន័យចម្បង។ ចំពោះព័ត៌មានសំខាន់ៗ សូមណែនាំឱ្យប្រើការបកប្រែដោយមនុស្សជំនាញ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសបញ្ហាដែលកើតឡើងពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,114 @@
# Hardware
**T** ក្នុង IoT មានន័យថា **របស់** ហើយយោងទៅលើឧបករណ៍ដែលមានការប្រាស្រ័យជាមួយពិភពលោកជុំវិញយើង។ គម្រោងនីមួយៗស្ថិតលើឧបករណ៍ពិតដែលមានស្រាប់សម្រាប់សិស្សនិងអ្នកចំណង់ចំណូលចិត្ត។ យើងមានជម្រើសពីរនៃឧបករណ៍ IoT ដើម្បីប្រើផ្អែកលើចំណង់ចំណូលចិត្តផ្ទាល់ខ្លួន, ចំណេះដឹងភាសាកម្មវិធី ឬចំណង់ចំណូលចិត្ត, គោលដៅការសិក្សា និងការ​មានស្រាប់។ យើងក៏បានផ្តល់ជូននូវជម្រើស 'ឧបករណ៍វីរុចវ៉ាល់' សម្រាប់អ្នកដែលមិនមានឧបករណ៍ ឬចង់រៀនបន្ថែមមុនពេលធ្វើការជាវផងដែរ។
> 💁 អ្នកមិនចាំបាច់ទិញឧបករណ៍ IoT ដោយខ្លួនឯងដើម្បីបញ្ចប់ការងារគោលបំណងទេ។ អ្នកអាចធ្វើការទាំងអស់ដោយប្រើឧបករណ៍ IoT វីរុចវ៉ាល់។
ជម្រើសឧបករណ៍រូបប៉ះមាន Arduino ឬ Raspberry Pi។ វេទិកាទាំងពីរមានអត្ថប្រយោជន៍និងគុណវិបត្តិផ្ទាល់ខ្លួនរបស់ខ្លួន ហើយទាំងអស់ត្រូវបានគ្របដណ្តប់ក្នុងមេរៀនដំបូងមួយ។ បើអ្នកមិនទាន់សម្រេចចិត្តលើវេទិកាឧបករណ៍ណាមួយទេ អ្នកអាចពិនិត្យមើល [មេរៀនទីពីររបស់គម្រោងដំបូង](./1-getting-started/lessons/2-deeper-dive/README.md) ដើម្បីសម្រេចចិត្តថាវិបត្តិករឧបករណ៍ណាដែលអ្នកចាប់អារម្មណ៍ក្នុងការរៀន។
ឧបករណ៍ជាក់លាក់ត្រូវបានជ្រើសរើសដើម្បីកាត់បន្ថយភាពស្មុគស្មាញនៃមេរៀននិងការងារគោលបំណង។ ទោះបីឧបករណ៍ផ្សេងទៀតអាចប្រើបាន ក៏យើងមិនអាចធានាបានថាការងារគោលបំណងទាំងអស់នឹងគាំទ្រជាលើឧបករណ៍របស់អ្នកដោយគ្មានឧបករណ៍បន្ថែមទេ។ ឧទាហរណ៍ ឧបករណ៍ Arduino ច្រើនមិនមាន WiFi ដែលចាំបាច់សម្រាប់ភ្ជាប់ទៅកាន់ពពក - Wio terminal ត្រូវបានជ្រើសរើសដោយសារវាមាន WiFi ក្នងខ្លួន។
អ្នកនឹងត្រូវការផងដែរ ឧបករណ៍មិនជាក់លាក់បច្ចេកទេសមួយចំនួន ដូចជាដី ឬរុក្ខជាតិក្នុងចានផងដែរ ផ្លែឈើ ឬបន្លែរ។
## ទិញកញ្ចប់ឧបករណ៍
![រូបស្លាក Seeed studios](../../translated_images/km/seeed-logo.74732b6b482b6e8e.webp)
Seeed Studios បានយកចិត្តទុកដាក់ផ្តល់ឧបករណ៍ទាំងអស់ជាកញ្ចប់ដែលងាយស្រួលទិញ៖
### Arduino - Wio Terminal
**[IoT សម្រាប់អ្នកចាប់ផ្តើមជាមួយ Seeed និង Microsoft - កញ្ចប់ចាប់ផ្តើម Wio Terminal](https://www.seeedstudio.com/IoT-for-beginners-with-Seeed-and-Microsoft-Wio-Terminal-Starter-Kit-p-5006.html)**
[![កញ្ចប់ឧបករណ៍ Wio Terminal](../../translated_images/km/wio-hardware-kit.4c70c48b85e4283a.webp)](https://www.seeedstudio.com/IoT-for-beginners-with-Seeed-and-Microsoft-Wio-Terminal-Starter-Kit-p-5006.html)
### Raspberry Pi
**[IoT សម្រាប់អ្នកចាប់ផ្តើមជាមួយ Seeed និង Microsoft - កញ្ចប់ចាប់ផ្តើម Raspberry Pi 4](https://www.seeedstudio.com/IoT-for-beginners-with-Seeed-and-Microsoft-Raspberry-Pi-Starter-Kit-p-5004.html)**
[![កញ្ចប់ឧបករណ៍ Raspberry Pi Terminal](../../translated_images/km/pi-hardware-kit.26dbadaedb7dd44c.webp)](https://www.seeedstudio.com/IoT-for-beginners-with-Seeed-and-Microsoft-Raspberry-Pi-Starter-Kit-p-5004.html)
## Arduino
កូដឧបករណ៍សម្រាប់ Arduino គឺនៅក្នុង C++។ ដើម្បីបញ្ចប់ការងារទាំងអស់ អ្នកនឹងត្រូវការធាតុដូចខាងក្រោម៖
### ឧបករណ៍ Arduino
* [Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html)
* *ជម្រើស* - ខ្សែ USB-C ឬអ្នកបម្រើ USB-A ទៅ USB-C។ Wio terminal មានច្រក USB-C ហើយមានខ្សែ USB-C ទៅ USB-A។ ប្រសិនបើកុំព្យូទ័រឬ Mac របស់អ្នកមានតែមួយច្រក USB-C អ្នកនឹងត្រូវការខ្សែ USB-C ឬអ្នកបម្រើ USB-A ទៅ USB-C។
### ឧបករណ៍សំខាន់ៗសម្រាប់ Arduino
ទាំងនេះជាសម្រាប់ប្រើជាមួយឧបករណ៍ Arduino Wio terminal ហើយគ្មានទាក់ទងជាមួយ Raspberry Pi។
* [ArduCam Mini 2MP Plus - OV2640](https://www.arducam.com/product/arducam-2mp-spi-camera-b0067-arduino/)
* [ReSpeaker 2-Mics Pi HAT](https://www.seeedstudio.com/ReSpeaker-2-Mics-Pi-HAT.html)
* [ខ្សែ​ជុំ ត់​ជុំ Breadboard](https://www.seeedstudio.com/Breadboard-Jumper-Wire-Pack-241mm-200mm-160mm-117m-p-234.html)
* កាសស្តាប់ត្រចៀក ឬឧបករណ៍ផ្សេងដែលមានប្រភពសំឡេង 3.5 មម ច្រក ឬនិយាមកាស JST ដូចជា:
* [រូបមួយ ហៅខាងលើជា Mono Enclosed Speaker - 2W 6 Ohm](https://www.seeedstudio.com/Mono-Enclosed-Speaker-2W-6-Ohm-p-2832.html)
* កាត microSD ទំហំ 16GB ឬតិចជាងនេះ ជាមួយឧបករណ៍ភ្ជាប់សម្រាប់ប្រើកាត SD ជាមួយកុំព្យូទ័រ ប្រសិនបើអ្នកមិនមានកាតក្នុងកុំព្យូទ័ររួចហើយ។ **សម្គាល់** - Wio Terminal គាំទ្រកាត SD ដល់ 16GB តែក៏មិនគាំទ្រច្រើនជាងនេះទេ។
## Raspberry Pi
កូដឧបករណ៍សម្រាប់ Raspberry Pi គឺនៅក្នុង Python។ ដើម្បីបញ្ចប់ការងារទាំងអស់ អ្នកនឹងត្រូវការធាតុដូចខាងក្រោម៖
### ឧបករណ៍ Raspberry Pi
* [Raspberry Pi](https://www.raspberrypi.org/products/raspberry-pi-4-model-b/)
> 💁 កំណែពី Pi 2B ក្រោមនេះឡើងគួរត្រូវបានគាំទ្រក្នុងការងារបង្រៀនទាំងនេះ។ ប្រសិនបើអ្នកចង់ដំណើរការ VS Code យោងត្រង់លើ Pi នោះ ត្រូវការម៉ាស៊ីន Pi 4 មាន RAM 2GB ឬច្រើនជាងនេះ។ ប្រសិនបើអ្នកចូលប្រើ Pi ពីចម្ងាយ Pi 2B ឬលើកលែងទៀតគឺគ្រប់គ្រាន់។
* កាត microSD (អ្នកអាចទិញកញ្ចប់ Raspberry Pi ដែលមានកាត microSD រួមជាមួយ) ជាមួយឧបករណ៍ភ្ជាប់ដើម្បីប្រើកាត SD ជាមួយកុំព្យូទ័ររបស់អ្នក បើអ្នកមិនមានកាតក្នុងនោះរួច។
* ផ្គត់ផ្គង់ថាមពល USB (អ្នកអាចទិញកញ្ចប់ Raspberry Pi 4 ដែលមានផ្គត់ផ្គង់ថាមពលរួម)។ ប្រសិនបើអ្នកប្រើ Raspberry Pi 4 អ្នកត្រូវការផ្គត់ផ្គង់ថាមពល USB-C តាមបែបឧបករណ៍ពុម្ពមុនត្រូវការផ្គត់ផ្គង់ថាមពល micro-USB។
### ឧបករណ៍សំខាន់ៗសម្រាប់ Raspberry Pi
ទាំងនេះជាសម្រាប់ប្រើជាមួយ Raspberry Pi ហើយមិនមានទាក់ទងជាមួយ Arduino ឧបករណ៍ទេ។
* [Grove Pi base hat](https://www.seeedstudio.com/Grove-Base-Hat-for-Raspberry-Pi.html)
* [Raspberry Pi កាមេរ៉ាម៉ូឌុល](https://www.raspberrypi.org/products/camera-module-v2/)
* មីក្រូហ្វូន និងរ៉ឺម៉ក:
ប្រើមួយក្នុងខាងក្រោម (ឬសមصلاحដូចគ្នា):
* មីក្រូហ្វូន USB គ្រប់ប្រភេទជាមួយរ៉ឺម៉ក USB ណាមួយ ឬរ៉ឺម៉ក់ជាមួយខ្សែច្រក 3.5 មម ឬប្រើហ៊ុមដាយអូឌីយ៉ូ HDMI ប្រសិនបើ Raspberry Pi របស់អ្នកភ្ជាប់ទៅកាន់ម៉ូនីទ័រឬទូរទស្សន៍មានរ៉ឺម៉ក
* កាស USB គ្រប់ប្រភេទដែលមានមីក្រូហ្វូនក្នុងខ្លួន
* [ReSpeaker 2-Mics Pi HAT](https://www.seeedstudio.com/ReSpeaker-2-Mics-Pi-HAT.html) ជាមួយ
* កាសស្តាប់ត្រចៀក ឬរ៉ឺម៉កផ្សេងដែលមានច្រក 3.5 មម ឬរ៉ឺម៉ក JST ដូចជា:
* [រូបមួយធ្វើឱ្យကျរួចមើល - Mono Enclosed Speaker - 2W 6 Ohm](https://www.seeedstudio.com/Mono-Enclosed-Speaker-2W-6-Ohm-p-2832.html)
* [USB Speakerphone](https://www.amazon.com/USB-Speakerphone-Conference-Business-Microphones/dp/B07Q3D7F8S/ref=sr_1_1?dchild=1&keywords=m0&qid=1614647389&sr=8-1)
* [Grove សំរាប់សំរាប់ពន្លឺ](https://www.seeedstudio.com/Grove-Light-Sensor-v1-2-LS06-S-phototransistor.html)
* [Grove ប៊ូតុង](https://www.seeedstudio.com/Grove-Button.html)
## ស៊ិនស័រនិងអាគុយឌៀត័រ
ភាគច្រើននៃស៊ិនស័រ និងអាគុយឌៀត័រដែលត្រូវការត្រូវបានប្រើទាំងពីរប្រភេទ Arduino និង Raspberry Pi ក្នុងផ្លូវសិក្សា៖
* [Grove LED](https://www.seeedstudio.com/Grove-LED-Pack-p-4364.html) x 2
* [Grove ស៊ិនស័រអាកាសធាតុ និងសំណើម](https://www.seeedstudio.com/Grove-Temperature-Humidity-Sensor-DHT11.html)
* [Grove ស៊ិនស័រឈីជីដីប្រភេទ capacitive](https://www.seeedstudio.com/Grove-Capacitive-Moisture-Sensor-Corrosion-Resistant.html)
* [Grove relay](https://www.seeedstudio.com/Grove-Relay.html)
* [Grove GPS (Air530)](https://www.seeedstudio.com/Grove-GPS-Air530-p-4584.html)
* [Grove ស៊ិនស័រប្រវែងខណៈពេលបញ្ជូនទម្ងន់](https://www.seeedstudio.com/Grove-Time-of-Flight-Distance-Sensor-VL53L0X.html)
## ឧបករណ៍ជម្រើសបន្ថែម
មេរៀនដែលទាក់ទងការស្រោចទឹកដោយស្វ័យប្រវត្តិប្រើ relay។ ជាជម្រើស អ្នកអាចភ្ជាប់ relay នេះទៅបូមទឹកដែលផ្គត់ផ្គង់ថាមពលដោយ USB ដោយប្រើឧបករណ៍បញ្ជីខាងក្រោម។
* [បូមទឹក 6V](https://www.seeedstudio.com/6V-Mini-Water-Pump-p-1945.html)
* [USB terminal](https://www.adafruit.com/product/3628)
* ថង់ស៊ីលីកូន
* ខ្សែពណ៌ក្រហម និងខ្មៅ
* ឧបករណ៍បង្កើតសោត្រង់ក្បាលតូចៗ
## ឧបករណ៍វីរុចវ៉ាល់
មុខងារនេះផ្តល់សម្ទកម្មសម្រាប់ស៊ិនស័រ និងអាគុយឌៀត័រដែលបានអនុវត្តក្នុង Python។ ផ្អែកលើភាពមានស្រាប់នៃឧបករណ៍របស់អ្នក អ្នកអាចដំណើរការនេះលើឧបករណ៍អភិវឌ្ឍន៍ធម្មតា របស់អ្នកដូចជា Mac, PC , ឬដំណើរការពី Raspberry Pi ហើយវាយកអ្នកអាចសម្តែងតែមួយហេតុថាឧបករណ៍ដែលអ្នកគ្មាន។ ឧទាហរណ៍ បើអ្នកមានកាមេរ៉ារ Raspberry Pi ប៉ុន្តែមិនមាន Grove ស៊ិនស័រ អ្នកនឹងអាចរត់កូដឧបករណ៍វីរុចវ៉ាល់នៅលើ Pi របស់អ្នក និងសម្តែង Grove ស៊ិនស័រ ប៉ុន្តែប្រើកាមេរ៉ារូបប៉ះ។
ឧបករណ៍វីរុចវ៉ាល់នេះប្រើប្រាស់គម្រោង [CounterFit](https://github.com/CounterFit-IoT/CounterFit)។
ដើម្បីបញ្ចប់មេរៀនទាំងនេះ អ្នកត្រូវតែមានមុខងារគ្មានស្រីសរីមួយ ធុងសំឡេង និងប្រភពសំឡេងដូចជា រ៉ឺម៉ក ឬកាសស្តាប់ត្រចៀក។ សំឡេងទាំងនេះអាចមានក្នុងឧបករណ៍ឬពីរបនា និងត្រូវតែបានកំណត់ឲ្យដំណើរការជាមួយប្រព័ន្ធប្រតិបត្តិការ​របស់អ្នក និងអាចប្រើបានពីកម្មវិធីទាំងអស់។
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការ​បដិសេធ**៖
ឯកសារ​នេះ​ត្រូវ​បាន​បកប្រែ​ដោយប្រើ​សេវាកម្ម​បកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេល​ដែល​យើង​ព្យាយាម​រក​សុវត្ថិភាព​នៃ​ការ​បកប្រែ សូម​យល់​ព្រម​ថា​ការ​បកប្រែ​ដោយ​ស្វ័យកែទម្រង់​អាច​មាន​កំហុស ឬ​ការខ្វះខាត​លំបាកក្នុងការបកប្រែ។ ឯកសារដើម​ជា​ភាសាទីមូល​គួរឱ្យ​ត្រូវបាន​គេ​កត់សំគាល់​ជា​មូលដ្ឋានដ៍​សម្បូរ​គុណភាព។ សម្រាប់​ព័ត៌មាន​សំខាន់ៗ សូម​ពិចារណា​ការ​បកប្រែ​ដោយ​មនុស្ស​វិជ្ជាជីវៈ។ យើង​មិន​ត្រូវ​បាន​ទទួល​ខុសត្រូវចំពោះ​ការ​យល់​ខុស ឬ​ការបកប្រែ​មិន​ត្រឹមត្រូវ​ដែល​មាន​នឹង​មកពី​ការ​ប្រើប្រាស់​ការ​បកប្រែ​នេះ​នោះទេ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,14 @@
# រូបភាព
រូបភាពនៅក្នុងថត [icons](../../../images/icons) នេះគឺមកពី [Noun Project](https://thenounproject.com) ហើយត្រូវការការទទួលស្គាល់អ្នកផ្តល់។ រូបភាពនីមួយៗបង្ហាញពីការទទួលស្គាល់ដែលត្រូវការ។ រូបភាពទាំងនេះគួរត្រូវបានប្រើសម្រាប់គំនូសតាងណាមួយដែលត្រូវការពួកវាដើម្បីរក្សាទំរង់រូបភាពឲ្យស្របតាមគ្នា។
ឯកសារ [Diagrams.sketch](../../../images/Diagrams.sketch) គឺជាឯកសារ [Sketch](https://www.sketch.com) ដែលមានគំនូសតាងទាំងអស់ដែលបានប្រើនៅក្នុងមេរៀន និងគម្រោង។ ប្រសិនបើអ្នកចូលរួមក្នុងការបកប្រែ សូមបកប្រែផងដែរដោយឯកសារនេះដោយ either ដកស្រង់និងបន្ទាន់សម័យឯកសារ ឬផ្តល់បញ្ជីពាក្យដែលអ្នកត្រូវការបកប្រែជាបញ្ហាមួយនៅលើ GitHub។
រូបភាពដែលនៅសល់ត្រូវបានប្រើនៅក្នុងមេរៀន និងគម្រោងទាំងអស់។
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**បដិសេធ**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលយើងខិតខំផ្តល់ភាពត្រឹមត្រូវ សូមយល់ព្រមថាការបកប្រែដោយស្វ័យប្រវត្តិក្នុងខ្លឹមសារអាចមានកំហុស ឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមក្នុងភាសាដើមគួរត្រូវបានគិតថាជា ប្រភពត្រឹមត្រូវ យ៉ាងពេញលេញ។ សម្រាប់ព័ត៌មានសំខាន់ៗ សូមអនុវត្តការបកប្រែដោយមនុស្សវិជ្ជាជីវៈ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំណាមួយ ឬការបកប្រែខុសចេញពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,58 @@
# [ប្រធានបទមេរៀន]
![បញ្ចូលវីដេអូនៅទីនេះ](../../../lesson-template/video-url)
## [ប្រឡងមុនបង្រៀន](../../../lesson-template/quiz-url)
[ពិពណ៌នាអំពីអ្វីដែលយើងនឹងរៀន]
### ការណែនាំ
ពិពណ៌នាអំពីអ្វីដែលនឹងត្រូវគំរូ
> សម្គាល់
### វិធីសាស្រ្តមូលដ្ឋាន
ជំហានអ្វីដែលគួរត្រូវបានគំរូមុនមេរៀននេះ?
### ការរៀបចំ
ជំហានរៀបចំដើម្បីចាប់ផ្តើមមេរៀននេះ
---
[ជំហានតាមមាតិកានៅក្នុងប្លុក]
## [ប្រធានបទ ១]
###ការងារ៖
ធ្វើការសហការគ្នាដើម្បីបង្កើនការសរសេរកូដរបស់អ្នកដោយប្រើកូដចែករំលែកសម្រាប់បង្កើតគម្រោង៖
```html
code blocks
```
✅ ការត្រួតពិនិត្យចំណេះដឹង - ប្រើពេលនេះដើម្បីពង្រីកចំណេះដឹងរបស់សិស្សជាមួយសំណួររួច
## [ប្រធានបទ ២]
## [ប្រធានបទ ៣]
🚀 ការប្រកួតប្រជែង៖ បន្ថែមការប្រកួតប្រជែងសម្រាប់សិស្សធ្វើការជាក្រុមនៅក្នុងថ្នាក់ដើម្បីពង្រីកគម្រោង
ជាជម្រើស៖ បន្ថែមរូបថតអេក្រង់នៃ UI របស់មេរៀនដែលបានបញ្ចប់ ប្រសិនបើសមរម្យ
## [ប្រឡងបន្ទាប់បាត្រ](../../../lesson-template/quiz-url)
## ការត្រួតពិនិត្យ & រៀនដោយខ្លួនឯង
**ការចាត់តាំងត្រូវបញ្ចប់ [MM/YY]**: [ឈ្មោះបេសកកម្ម](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការព្រមាន**៖
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលយើងខិតខំក្នុងការជម្រាបច្បាស់ តែសូមយល់ដឹងថាការបកប្រែដោយស្វ័យប្រវត្តិអាចមានកំហុស ឬភាពមិនត្រឺមត្រូវ។ ឯកសារដើមនៅក្នុងភាសាមាតុភាគគួរត្រូវបានពិចារណាថាជាផ្ទាំងយោងផ្លូវការបំផុត។ សម្រាប់ព័ត៌មានសំខាន់ ការបកប្រែដោយមនុស្សជំនាញត្រូវបានផ្ដល់អនុសាសន៍។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបករណ៍ខុសផ្សេងៗដែលកើតមានពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,16 @@
# [ឈ្មោះអតិថិជន]
## សេចក្ដីណែនាំ
## របៀបវាយតម្លៃ
| កត្តា | ឧទាហរណ៍ល្អ | សមរម្យ | ត្រូវការកែលម្អ |
| -------- | --------- | -------- | ----------------- |
| | | | |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារនេះត្រូវបានបម្លែងភាសាដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលយើងខំប្រឹងប្រែងសម្រាប់ភាពត្រឹមត្រូវ សូមយល់ថាការបកប្រែដោយស៊ីស្ទឹមអាចមានកំហុសឬច្របល់ខុស។ ឯកសារដើមជាភាសាដើមគួរត្រូវបានចាត់ទុកថាជាមូលដ្ឋានដ៏ទាក់ទាញ។ សម្រាប់ព័ត៌មានសំខាន់ និយាយផ្តល់ជំនួយពីមនុស្សជំនាញបកប្រែកាន់តែល្អ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការប្រែប្រួលខុសពីការប្រើប្រាស់ការបកប្រែនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,120 @@
# ការប្រលងតេស្ត
ការប្រលងតេស្តទាំងនេះ គឺជាការប្រលងតេស្តមុននិងក្រោយមេរៀនសម្រាប់មុខវិជ្ជា IoT សម្រាប់អ្នកចាប់ផ្តើម នៅ https://aka.ms/iot-beginners
## ការតំឡើងគម្រោង
```
npm install
```
### កូដកម្ម និងផ្ទុកឡើងវិញសម្រាប់ការអភិវឌ្ឍន៍
```
npm run serve
```
### កូដកម្ម និងបង្ហាប់ឲ្យតូចសម្រាប់ផលិតផល
```
npm run build
```
### ពិនិត្យកូដ និងជួសជុលឯកសារ
```
npm run lint
```
### កំណត់តំរូវការតាមតម្រូវការ
មើល [សេចក្ដីយោងកំណត់តំរូវការ](https://cli.vuejs.org/config/)។
អំណរគុណ៖ អរគុណចំពោះជំនាន់ដើមនៃកម្មវិធីប្រលងតេស្តនេះ៖ https://github.com/arpan45/simple-quiz-vue
## ការចេញផ្សាយទៅ Azure
នេះជាមដៀលជំហាន​ចាប់ពីដើមដើម្បីជួយអ្នកចាប់ផ្តើម៖
1. ផFork តារាង GitHub
ធានាថា​កូដកម្មកម្មវិធីបណ្តាញ static របស់អ្នក​នៅក្នុងឃ្លាំង GitHub របស់អ្នក។ Fork ឃ្លាំងនេះ។
2. បង្កើតកម្មវិធី Azure Static Web App
- បង្កើត និង [គណនី Azure](http://azure.microsoft.com)
- ចូល​ទៅ [ផ្ទាំង Azure portal](https://portal.azure.com)
- ចុចលើ “Create a resource” ហើយស្វែងរក “Static Web App”។
- ចុច “Create”។
3. កំណត់រចនាសម្ព័ន្ធ Static Web App
- មូលដ្ឋាន៖ ការជាវ៖ ជ្រើសរើសការជាវ Azure របស់អ្នក។
- ក្រុមធនធាន៖ បង្កើតក្រុមធនធានថ្មី ឬប្រើក្រុមដែលមានស្រាប់។
- ឈ្មោះ៖ ផ្តល់ឈ្មោះសម្រាប់កម្មវិធី static web របស់អ្នក។
- តំបន់៖ ជ្រើសរើសតំបន់ដែលនៅជិតអ្នកប្រើប្រាស់។
- #### ព័ត៌មានចេញផ្សាយ៖
- ប្រភព៖ ជ្រើសរើស “GitHub”។
- គណនី GitHub៖ អនុញ្ញាតឲ្យ Azure ចូលប្រើគណនី GitHub របស់អ្នក។
- អង្គភាព៖ ជ្រើសរើសអង្គភាព GitHub របស់អ្នក។
- ឃ្លាំងទិន្នន័យ៖ ជ្រើសរើសឃ្លាំងដែលមានកម្មវិធី static web របស់អ្នក។
- សាខា៖ ជ្រើសរើសសាខាដែលអ្នកចង់ចេញផ្សាយពីវា។
- #### ព័ត៌មានសាងសង់៖
- ការកំណត់សាងសង់៖ ជ្រើសរើសប្រព័ន្ធដែលកម្មវិធីរបស់អ្នកត្រូវបានបង្កើតជាមួយ (ឧ. React, Angular, Vue ល។)។
- ទីតាំងកម្មវិធី៖ បញ្ជាក់ថតដែលមានកូដកម្មវិធីរបស់អ្នក (ឧ. / ប្រសិនបើវាជារឿននៃគម្រោង)។
- ទីតាំង API៖ ប្រសិនបើអ្នកមាន API បញ្ជាក់ទីតាំងរបស់វា (ជាជម្រើស)។
- ទីតាំងលទ្ធផល៖ បញ្ជាក់ថតដែលមានលទ្ធផលសាងសង់ (ឧ. build ឬ dist)។
4. ពិនិត្យឡើងវិញ និងបង្កើត
ពិនិត្យការកំណត់របស់អ្នក ហើយចុច “Create”។ Azure នឹងបង្កើតធនធានទាមទារ និងបង្កើតការផលិត GitHub Actions workflow លើឃ្លាំងរបស់អ្នក។
5. GitHub Actions Workflow
Azure នឹងបង្កើតឯកសារជាប្រព័ន្ធ GitHub Actions workflow នៅក្នុងឃ្លាំងរបស់អ្នក (.github/workflows/azure-static-web-apps-<name>.yml) ដោយស្វ័យប្រវត្តិ។ Workflow នេះនឹងគ្រប់គ្រងដំណើរការសាងសង់ និងចេញផ្សាយ។
6. ត្រួតពិនិត្យការចេញផ្សាយ
ចូលទៅថេប “Actions” នៅក្នុងឃ្លាំង GitHub របស់អ្នក។
អ្នកគួរតែឃើញ workflow កំពុងរត់។ Workflow នេះនឹងសាងសង់ និងចេញផ្សាយកម្មវិធី static web របស់អ្នកទៅ Azure។
ពេល workflow បញ្ចប់ កម្មវិធីរបស់អ្នកនឹងផ្សាយបន្តផ្ទាល់លើ URL Azure ដែលបានផ្តល់។
### ឯកសារ Workflow ឧទាហរណ៍
នេះជាឧទាហរណ៍នៃឯកសារ GitHub Actions workflow រដ្ធានដែលអាចមានរាងដូចនេះ៖
name: Azure Static Web Apps CI/CD
```
on:
push:
branches:
- main
pull_request:
types: [opened, synchronize, reopened, closed]
branches:
- main
jobs:
build_and_deploy_job:
runs-on: ubuntu-latest
name: Build and Deploy Job
steps:
- uses: actions/checkout@v2
- name: Build And Deploy
id: builddeploy
uses: Azure/static-web-apps-deploy@v1
with:
azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
repo_token: ${{ secrets.GITHUB_TOKEN }}
action: "upload"
app_location: "quiz-app" #App source code path
api_location: ""API source code path optional
output_location: "dist" #Built app content directory - optional
```
### ឯកសារបន្ថែម
- [ឯកសារជាផ្លូវការ Azure Static Web Apps](https://learn.microsoft.com/azure/static-web-apps/getting-started)
- [ឯកសារជាផ្លូវការ GitHub Actions](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារនេះបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលដែលយើងខិតខំសំរាប់ភាពត្រឹមត្រូវ សូមប្រយ័ត្នក្នុងការយល់ថាការបកប្រែដោយស្វ័យប្រវត្តិនោះអាចមានកំហុស ឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមដែលសរសេរជាភាសាដើមគួរត្រូវបានគិតថាជាអត្ថប្រយោជន៍ប្ដូនាទៅ។ សម្រាប់ព័ត៌មានសំខាន់ៗ ការបកប្រែដោយមនុស្សជំនាញបានណែនាំ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែកំហុសណាមួយដែលកើតមានពីការប្រើប្រាស់ការបកប្រែនេះ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

@ -0,0 +1,48 @@
# ម៉ូដែលរៀនដែលបានណែនាំ
សម្រាប់លទ្ធផលការសិក្សាដ៏មានប្រសិទ្ធភាព, **យើងបានណែនាំវិធីសាស្រ្ត “ម៉ូដែលភ្លិច”** ដូចជាការពិសោធន៍វិទ្យាសាស្ត្រ: សិស្សនិស្សិតធ្វើគម្រោងនៅពេលរៀន, មានឱកាសចំពោះការពិភាក្សា, សំណួរ និងជំនួយគម្រោង, ហើយធ្វើដំណើរសិក្សាប្រភេទសង្ខេបជាការអានមុននៅពេលខ្លួនឯង។
## ហេតុអ្វីបានជារបៀបរៀនភ្លិច?
1. របៀបបង្រៀននេះចូលរួមការសិក្សាជាច្រើន មើល, ស្តាប់, ចំណាយដៃ, ដោះស្រាយបញ្ហា, ល។[[1]](#references)
2. ថ្នាក់រៀនភ្លិចបង្ហាញថាធ្វើឲ្យមានការផ្តោតអារម្មណ៍, ចូលរួម, មានកម្លាំងចិត្ត, ឯករាជ្យ, រក្សាទុកចំណេះដឹង និងការទំនាក់ទំនង (ពីគ្រូទៅសិស្ស និងសិស្សទៅសិស្ស)។[[2,3]](#references)
3. ជាគ្រូបង្រៀន អ្នកអាចចំណាយពេលវេលាច្រើនជាមួយសិស្សដែលមានការលំបាក ខណៈដែលអនុញ្ញាតឲ្យអ្នករៀនខ្ពស់ទទួលបានសេរីភាពក្នុងការធ្វើការបន្តថែមទៀត។[[4]](#references)
យើងក៏បានណែនាំឲ្យគ្រូបង្រៀនទទួលយកតួនាទីជា **“អ្នកជួយបង្រៀនរួមក្នង”** ដែលរៀនជាមួយ និងគាំទ្រសិស្សក្នុងពេលពួកគេធ្វើការឆ្លើយសំណួរ និងស្វែងយល់ពីចំណាប់អារម្មណ៍ និងចំណេះដឹងផ្ទាល់ខ្លួន។
គ្មាន “វិធីត្រឹមត្រូវ” នៅទីនេះទេ។ ពេលខ្លះ អ្នកប្រហែលជាមិនមានចម្លើយទាំងអស់ទេ។ សិស្សខ្លះប្រហែលជាមិនបានចប់គម្រោងទាំងអស់។ គោលបំណងរបស់អ្នកគឺជួយឲ្យសិស្សរបស់អ្នកទៅដល់វិធីដោះស្រាយបញ្ហាដេកើតឡើងដោយរំពឹងថាជាការលេងសប្បាយ, ជាការសហការណ៍ ឬការណែនាំដោយខ្លួនឯង កាន់តែច្រើនជាងដែលពួកគេចាប់អារម្មណ៍ដើម។
## គន្លឹះជួយក្នុងការជួយបង្រៀន៖
* ពិចារណាអ្វីដែលអ្នកកំពុងមើលឃើញ, សួរចម្លើយ, និងធ្វើការសង្កេត។
* ប្រើប្រាស់ប្រយោគដូចជា “ខ្ញុំមើលឃើញ…” និង “ខ្ញុំសួរថា…”
* ភ្ជាប់សិស្សដែលមានបញ្ហាជាមួយសិស្សដែលរកឃើញដំណោះស្រាយរួចរួមគ្នា។
* ចង្អុលបង្ហាញដល់ផ្នែកនិងមុខងារ ទៅកាន់សិស្សបើពួកគេចាប់អារម្មណ៍ ហើយស្នើសុំឲ្យសិស្សផ្លាស់ប្តូរពីមួយចំណុចតែម្តង និងមើលថាបានអ្វី។
* ទទួលស្គាល់ការរិះគន់ និងស្គាល់ការខិតខំតស៊ូនៃសិស្ស។
* ជៀសវាងការសង់ ឬកូដសម្រាប់សិស្ស លើកលែងតែក្រោមករណីសិស្សត្រូវការជំនួយភារកិច្ច។
## ឧទាហរណ៍ភាសាប្រាស្រ័យទាក់ទងក្នុងការជួយបង្រៀន៖
* “សូមសួរពីអ្នកផ្សេងពីរនាក់មុនពេលសួរខ្ញុំ។”
* “ចំណាយពេលបន្ថែមពីរការនាទីសម្រាប់ការព្យាយាម…”
* “យើងសាកល្បងការសម្រាកពីនេះមួយខណៈ។ ប្រហែលជាអ្នកអាចជួយសិស្សផ្សេងទៀតក្នុងការតភ្ជាប់អគ្គិសនីព្រោះអ្នកបានស្វែងរកដំណោះស្រាយរួចហើយ១។”
* “ខ្ញុំសួរថាបើសិស្សផ្សេងទៀតបានជួបបញ្ហាដូចគ្នាបើយើងមើលឲ្យបាន!”
* "អ្នកបានប្រាថ្នាថ្មីសម្រាប់ការងារនេះ ហើយរកឃើញដំណោះស្រាយ! តើខ្ញុំអាចផ្ញើអ្នកផ្សេងៗមកសុំជំនួយបានទេ?"
* “វាអស្ចារ្យណាស់ វាមិនចង់បានន័យសម្រាប់ខ្ញុំដែរ។ ប្រហែលជាយើងអាចសួរអ្នកផ្សេងម្នាក់ ឬបើអ្នកឃើញដំណោះស្រាយ សូមចែករំលែកជាមួយថ្នាក់!”
## ឯកសារយោង
[1] [An empirical study on the effectiveness of College English Reading classroom teaching in the flipped classroom paradigm (researchgate.net)](https://www.researchgate.net/publication/322264495_An_empirical_study_on_the_effectiveness_of_College_English_Reading_classroom_teaching_in_the_flipped_classroom_paradigm). Accessed 4/21/21.
[2] [Flipped Classroom adapted to the ARCS Model of Motivation and applied to a Physics Course (ejmste.com)](https://www.ejmste.com/article/flipped-classroom-adapted-to-the-arcs-model-of-motivation-and-applied-to-a-physics-course-4562). Accessed 4/21/21.
[3] [How Does Flipping Classroom Foster the STEM Education: A Case Study of the FPD Model | SpringerLink](https://link.springer.com/article/10.1007/s10758-020-09443-9). Accessed 4/21/21
[4] [An Introduction to Flipped Learning | Lesley University](https://lesley.edu/article/an-introduction-to-flipped-learning#:~:text=An%20Introduction%20to%20Flipped%20Learning.%20Flipped%20learning%20is,advancements%20in%20the%20modern%20classroom%20is%20flipped%20learning.). Accessed 4/21/21.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ការបដិសេធ**៖
ឯកសារ​នេះ​ត្រូវបាន​ប្រែសម្រួល​ដោយប្រើសេវាកម្ម​ប្រែ​សម្រួល AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ពេល​យើងព្យាយាម​ស្វែងរកភាពត្រឹមត្រូវ សូមយកចិត្តទុកដាក់ថា ការប្រែសម្រួល​ស្វ័យ​ប្រវត្តិ​អាច​មានកំហុស ឬមិនត្រឹមត្រូវ។ ឯកសារ​ដើម​នៅ​ភាសា​ធម្មជាតិ របស់វា គួរត្រូវបានចាត់ទុក​ជា ប្រភព​សុពលភាព។ សម្រាប់​ព័ត៌មាន​សំខាន់ៗ យើង​ស្នើ​ឱ្យ​ប្រើកិច្ចការប្រែសម្រួលដោយមនុស្ស​វិជ្ជាជីវៈ។ យើង​មិនមែន​ជា​អ្នក​ទទួល​បន្ទុកចំពោះការ​យល់ច្រឡំ ឬការបកប្រែ​ខុសពីការ​ប្រើប្រាស់​ការប្រែ​សម្រួលនេះឡើយ។
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
Loading…
Cancel
Save