แแ แ แแฆแแก แแแแแฉแแแ แแแแฃแ แ แแแแ แแแขแแแ
แแ แแแฅแขแก แแฃแฌแแแ Nanonyam (Nanonyam) แแ แแแแแช แแ แแแแแคแแฅแ แ (5 แฌแฃแแ แแแแฎแแขแ).
แแแแแแแก, แแแแช แคแแฅแ แแแก Arduino-แแ, แจแแแแแซแแแ แแแฅแแแ, แ แแ Nanonyam แแ แแก แแแ แขแฃแแแฃแ แ Arduino แคแแ แ Windows-แแก แกแแแแ แแแแแ.
แกแฎแแ แกแแขแงแแแแแ แ แแ แแแฅแแแ, Nanonyam แแ แแก แแแ แขแฃแแแฃแ แ แแแแฅแแแ, แ แแแแแแช แแงแแแแแก firmware-แก AVR แแแแ แแแแแขแ แแแแ แแกแแแแก (แ แแแแแแแแแแฃแแแ ATMEGA2560), แ แแแแ แช แแแแขแแแแแ. แแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแก แจแแแแแ แแ แแก AVR แแแ แแแแก แกแแแฃแแแขแแ แ, แแแแ แแ แแแ แแคแแ แแฃแแ แแแฌแงแแแแแแแแแแก แแแชแแแแ, แ แแแแแแแช แแแแแแแแแฃแแแ SRAM แแแกแแแแ แแแแแ 0x0060-แแแ 0x01FF-แแแ, แแ แแก แกแแแชแแแแฃแ แ แแแขแแ แคแแแกแ แแแ แขแฃแแแฃแ แ แคแฃแแฅแชแแแแแกแแแแก (แแแ แจแแ แแก Windows API แคแฃแแฅแชแแแแ). แแ แแฅ แซแแแแแ แแแแจแแแแแแแแแแ แแแฃแงแแแแแแแแ แแแแกแแแแแก: Nanonyam-แแก แแแแก แแ แฃแแแ แฐแฅแแแแแก แฌแแแแแ แแแแแแแแฃแ แแแฎแกแแแ แแแแก แแแแแแแแแจแ, แ แแแ แจแแแแฎแแแแแ แแ แแแแแแซแแฎแแก, แแแแแแแแแ, แคแแแแแแแก แฌแแจแแแก แคแฃแแฅแชแแ แแ แแแกแแแก แคแแ แแแขแแ แแแ. แแแแแ แฉแแแ SRAM แแแฎแกแแแ แแแแก แแแแแแแแแ 0x0200-แแแ 0xFFFF-แแแ (แแก แฃแคแ แ แแแขแแ, แแแแ แ แ แแแแฃแ แแแแ แแแแแขแ แแแแ แจแ) แฎแแแแแกแแฌแแแแแแ แแแแฎแแแ แแแแแกแแแแก แแแแแกแแแแ แ แแแแแแ. แแแฃแงแแแแแแแแ แแฆแแแแจแแแ, แ แแ แแ แกแแแแแก แกแแแชแแแแฃแ แ แแแชแแ แ แแแแฃแ แ แแแแ แแแแแขแ แแแแ แแก (แแ แกแฎแแ แแ แฅแแขแแฅแขแฃแ แแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก) แจแแแแฎแแแแแ แแแจแแแแแกแแแ: "แกแแจแแจแ" แคแฃแแฅแชแแแแแก แแแแฅแขแแฃแ แแแแแแ, แแฅแแแ แฃแแแ แแแแแแซแแฎแแ แกแแแชแแแแฃแ แ แกแแฎแแคแแแ แแแ แขแฃแแแฃแ แ แคแฃแแฅแชแแ. แแกแแแ แแ แแก แกแฎแแ แฃแกแแคแ แแฎแแแแแก แแแฎแแกแแแแแแแแแ.
Nanonyam-แแกแแแแก แแ แแแ แแแแแแก แจแแกแแฅแแแแแแ, แแฅแแแ แฃแแแ แแแแแแงแแแแ แกแแแชแแแแฃแ แ แแแแแแแแแแแแ, แ แแแแแแแช แแฎแแ แชแแแแแแแ แแแแแแแ แแ แกแแแฃแ แงแแแแ แแแ แขแฃแแแฃแ แคแฃแแฅแชแแแก. แฉแแแแขแแแ แแแ Nanonyam แแแ แขแฃแแแฃแ แ แแแแฅแแแ แแ แแแแแแแแแแแแ แแแกแแแแก
Nanonyam แฃแคแแกแแ แกแแฎแแแกแ แแ แแแแแ แชแแฃแแ แแแแแงแแแแแแกแแแแก. Nanonyam แแ แแแ แแแ แแแฌแแแแแฃแแแ "แ แแแแ แช แแ แแก" แกแแคแฃแซแแแแแ. แฌแงแแ แแก แแแแ แแ แแ แแก แแแฌแแแแแฃแแ.
แแ แแแ แแแ แแแแแแแ แขแแกแขแแ แแแแก แคแแแแจแแ. แแแแฎแแ แชแแแแแ 200-แแแ แแแ แขแฃแแแฃแ แ แคแฃแแฅแชแแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แจแแฅแแแแ แแแ แขแแแ แแ แแแ แแแแแ Windows-แแกแแแแก.
แชแฎแแแแ, แแกแแ แแแ แขแฃแแแฃแ แแแแฅแแแแจแ แ แแแแ แ แแฃแแแก แจแแฅแแแ แแ แแแฃแจแแแแแก, แ แแแแแ แแแแแก แแแฎแกแแแ แแแ แแฎแแแแ 256 แแ-แแ. แแแแแชแแแแแ แจแแแซแแแแ แแแแฎแแแแแแก แชแแแแแฃแ แคแแแแแแจแ, แแ แแคแแแฃแแ แแแฌแแแแก แแฃแคแแ แ แแแแแ แแแแแ แแแ แแแแ. แงแแแแ แคแฃแแฅแชแแ แแแแแ แขแแแแแฃแแแ แแ แแแแแขแแ แแแฃแแแ 8-แแแขแแแแ แแ แฅแแขแแฅแขแฃแ แแกแแแแก.
แ แ แจแแแแซแแแแ แแแแแแแแ แแแแแแแแแจแ? แ แแแแแแแแ แแ แแแแแแ แแแแแแแแแแ.
แแ แแแ แแแแก แแแแแแแแก แจแแแฃแจแแแแแ
แแ แแฎแแ แแแแญแแ แแ แแแแแแแฅแกแฃแ แ แแแแแฃแก แจแแแฃแจแแแแแ 128x64 แฌแแ แขแแแแแแ แแ แแคแแแฃแแ แฉแแแแแแแกแแแแก. แแ แแแแแแแแแ แแ แแแแแแแ แแฃแแแแแแ แฉแแขแแแ แแแ firmware แ แแแแฃแ แแแแ แแแแแขแ แแแแ แจแ, แ แแแ แแแแแฎแ, แ แแแแ แแแแแแงแฃแ แแแ แแแฅแกแแแแแ. แแกแ แแแแแแแ แแแแแแแแแแก แแแแ. แฅแแแแแ แแแงแแแแแแ แกแฃแ แแแ แแแแฉแแแแแแก แกแฃแ แแแก แแแแแ แแแแแฃแก แแ แ-แแ แแ แแแแแแแขแแก แ แแแแฃแ แ OLED แแแ แแแแแแ. แแฎแแ แแ แจแแแแซแแแ แแแกแ แแแจแแแแแแ แแฃแจแแแแ แ แแแแฃแ แ แแแฌแงแแแแแแแแก แแแ แแจแ.
Nanonyam (แแแก แกแแแแแแ แแแแแจแ) แแแ แแ แแแกแขแ แฃแแแแขแแ แแแแ แแแแแขแ แแแแ แแแแกแแแแก แแ แแแ แแแแก แแแแแแแแก แแแกแแแฃแจแแแแแแแ, แ แแแแแ แแ แกแแแแแก แแ แแคแแแแกแแแ แแฃแจแแแแแก แคแฃแแฅแชแแแแ (แจแแแแซแแแแ แแแแฎแแแแแ แแแกแแแแแแแก แแ แแแแแแแขแแ แแแแก แกแแแฃแแแชแแ), แคแแแแแแแแ (แจแแแแซแแแแ แแแแแแแแ แแฃแ แแแแแแ, แฌแแแแแแฎแแ แขแแกแขแแก แแแแแชแแแแแ), แแแแแแแขแฃแ แ (แจแแแแซแแแแ แแ แแแ แแฃแแแ แฌแแแแแแฎแแ 10 แฆแแแแแ), COM แแแ แขแแแแ (แแฅ แแ แแก แชแแแแ แแฃแแฅแขแ).
แกแฌแ แแคแ แแ แแแ แแแแแแก แจแแฅแแแ
แแแแแแแแแ, แแฅแแแ แฃแแแ แกแฌแ แแคแแ แแแแแฃแจแแแแ 100500 แขแแฅแกแขแฃแ แ แคแแแแ. แแแแแแฃแแ แแแแแแแ แฃแแแ แแแแฎแกแแแก, แแแแแ แจแแชแแแแแก แ แแแแ แแแ แขแแแ แแแแแ แแแแแก แแแฎแแแแแ, แจแแแแฎแแ แแ แแแฎแฃแ แแ. แแฃ แแแแแแแก แแกแขแแขแ แฎแแ , แแแจแแ แแแแแชแแ, แงแแแแแคแแ แ แแแฅแแก. แแแแ แแ แแฃ แแฅแแแ แฎแแ แ แแแแแแ แแแฃแแ แแ แแฃแแแ (แแ แแแแ แ แแแแแแแแ), แแแจแแ Nanonyam แแแแแฎแแแ แแแแ แแ แแ แแแแแแแก แแแแแแ แแแแจแ. แแก แแ แแก แฉแแแ แแแแ แ แแแแแแ Nanonyam-แจแ: แแแแแแแขแ แแแแ แ แกแแกแแ แแแแแ แคแฃแแฅแชแแ, แ แแแแ แแชแแ แขแแฅแกแขแแก แแแแฃแจแแแแแ, แกแแ แแแจแแขแแแแก แแแแแฆแแแ แแ แแแแแแจแแแแก แแแ แขแงแแแก แกแแแฃแแแชแแ แกแแกแขแแแแจแ (แกแฎแแแแ แจแแ แแก, แฃแแแ แแ แกแแแแแก), แแกแแแ แ แแแแ แช แแ แแแแแ แกแฎแแ แคแฃแแฅแชแแ แ แฃแขแแแฃแแ แแแแชแแแแแแก แแแแแกแแญแ แแแแ. .
แแแแ แแขแฃแ แแก แขแแกแขแแ แแแ COM แแแ แขแแก แกแแจแฃแแแแแแ
Nanonyam แจแแแซแแแแ แแแแฅแแแแแก แ แแแแ แช แขแแ แแแแแแ, แ แแแแแแช แแฃแจแแแแก แแฅแแแแ แแแแแ แแแแแก แแแฎแแแแแ. แแฅแแแ แจแแแแซแแแแ แแแฎแแแแ แแแขแแ แ แแแแแฃ แแแฌแงแแแแแแแแก แแแกแแแแแขแ แแแแแแแ แแ แแแ แขแแแแ แแแฆแแแฃแแ แแแแแชแแแแแแก แฉแแแแแแแก แแแแแแ. แแฅแแแ แจแแแแซแแแแ แจแแแแแฎแแ แแ แฌแแแแแแฎแแ แแแแแชแแแแแ แคแแแแแแแแแ แแแแแแแแกแแแแก. แแแกแแฎแแ แฎแแแแแ แฎแแแกแแฌแงแ แขแแฅแแแแแก แแแ แขแแแ แแแแแ แแแแกแ แแ แแแแแแ แแชแแแกแแแแก, แแกแแแ แแแ แขแแแ แแแ แขแฃแแแฃแ แ แแแกแขแ แฃแแแแขแแก แแแ แแแแก แแแแแแแแแก แจแแกแแฅแแแแแแ. แกแขแฃแแแแขแแแแกแแแแก แแ แแฎแแแแแแ แแ แแแชแแแแ แแแแกแแแแก แแก แแ แแแฅแขแ แจแแแซแแแแ แซแแแแแ แกแแกแแ แแแแแ แแงแแก.
แแ แแแ แแแแ แแแแก แขแ แแแแแแ
แแฃแแชแ, แ แแแแ แช แแแแแ Arduino แแ แแแฅแขแแก แจแแแแฎแแแแแจแ, Nanonyam-แแก แแแแแแ แ แกแแ แแแแแแแ แแแแแแแ แแแแก แคแฃแแฅแชแแแแแก, แแแขแแ แคแแแกแแก แแ แฉแแแขแแแ แแแแแแก แแแแแ แขแแแแแแจแ. แแแแขแแ, แแก แแ แแแฅแขแ แกแแแแขแแ แแกแ แฃแแแ แแงแแก แแแแฌแงแแแ แแ แแแ แแแแกแขแแแแกแแแแก แแ แแแแแแแก, แแแแช แแแแงแแคแแแแ แแ แแฃแแแแก แแแแแ. แกแฎแแแแ แจแแ แแก, แแ แแแแแแ แฏแแ แแแแแ แแ แแแฅแแก แจแแกแฌแแแแแแ แแ แแฃแแแ แแแขแแแฃแ แแ, แ แแแแแ แงแแแแแแแแก แแแงแแแแแแ WinAVR แแ AVR Studio, แแแแ แแ แแแแแฌแงแ แแกแแแแแแ แแ. แแแแขแแ, แฅแแแแแ แแแงแแแแแแ แแแแแแแแแก แแ แแแ แแแ แชแแขแ แแ แแกแฌแแ แ แแฅแแแแ, แแแแ แแ แกแแแแแแ แแฃแจแ.
แแแแแ แฏแแแ แฐแแแ !
แแ แแ แแแแชแแแ Nanonyam-แแก แแแแแแ แ แแแฎแแกแแแแแแแแก แแ แแแฌแแ แแ แแแ แขแแแ แแ แแแ แแแ. แฉแแแ แแแแฌแแ แ Arduino-แจแ, แแแแ แแ แแ แ แฉแแแฃแแแแ แแแแ, แแ แแแแ แแกแ, แ แแแแ แช แแฎแแ แจแแแแซแแแ (แฃแแแ แแแฅแแ, แ แแ แฏแแ แแแ แแแ แแ แแแแแแแ แแแแ แแก แแแ แแแ). แฏแแ แจแแฅแแแแแ แแฎแแแ แแกแแแแ แแ แแแ แฉแแแ Mega2560 แแแคแ.
แจแแแแแฎแแ แแกแแแแ แคแแแแจแ แแ แแแแแแแแ แแ แจแแแแแแ
#include <stdio.h>
#include "NanonyamnN_System_lib.c"
#include "NanonyamnN_Keyboard_lib.c"
#include "NanonyamnN_File_lib.c"
#include "NanonyamnN_Math_lib.c"
#include "NanonyamnN_Text_lib.c"
#include "NanonyamnN_Graphics_lib.c"
#include "NanonyamnN_RS232_lib.c"
แแแแแ แฃแคแ แ แกแฌแแ แ แแฅแแแแ แกแแแชแแแแฃแ แ แแแแฃแแแก โNanonyam for Arduinoโ-แก แแแงแแแแแ, แ แแแแแแช แจแแแซแแแแ แแแแแกแขแแแแ แแแก แแแ แแแแแ Arduino-แแแ. แ แแแแ แช แแ แแแแแ แแแแ, แแแจแแแแ แแแแแแแแแ, แแแแ แแ แฏแแ แฏแแ แแแแ แแฎแแแแ แแแ แขแฃแแแฃแ แแแแฅแแแแกแแแ แแฃแจแแแแแก แแ แกแก แแแฉแแแแแ. แฉแแแ แแฌแแ แ แจแแแแแ แแแแก:
//ะกัะฐะทั ะฟะพัะปะต ะทะฐะฟััะบะฐ ัะธััะตะผ ัะตะบัั ะฒ ะพะบะฝะต
void setup() {
sys_Nanonyam();//ะะพะดัะฒะตัะถะดะฐะตะผ ะบะพะด ะฒะธัััะฐะปัะฝะพะน ะผะฐัะธะฝั
g_SetScreenSize(400,200);//ะะฐะดะฐัะผ ัะฐะทะผะตั ะดะธัะฟะปะตั 400ั
200 ัะพัะตะบ
sys_WindowSetText("Example");//ะะฐะณะพะปะพะฒะพะบ ะพะบะฝะฐ
g_ConfigExternalFont(0,60,1,0,0,0,"Arial");//ะะฐะดะฐัะผ ััะธัั Windows ะฒ ััะตะนะบะต ััะธััะพะฒ 0
g_SetExternalFont(0);//ะัะฑะธัะฐะตะผ ััะตะนะบั ััะธััะพะฒ 0 ะดะปั ัะธัะพะฒะฐะฝะธั ัะตะบััะฐ
g_SetBackRGB(0,0,255);//ะฆะฒะตั ัะพะฝะฐ ัะธะฝะธะน
g_SetTextRGB(255,255,0);//ะฆะฒะตั ัะตะบััะฐ ะถัะปััะน
g_ClearAll();//ะัะธัะฐะตะผ ัะบัะฐะฝ (ะทะฐะปะธะฒะบะฐ ัะฒะตัะพะผ ัะพะฝะฐ)
g_DrawTextCenterX(0,400,70,"Hello, Habr!");//ะ ะธััะตะผ ะฝะฐะดะฟะธัั
g_Update();//ะัะฒะพะดะธะผ ะณัะฐัะธัะตัะบะธะน ะฑััะตั ะฝะฐ ัะบัะฐะฝ
}
//ะัะพััะพ ะถะดัะผ ะทะฐะบัััะธั ะฟัะพะณัะฐะผะผั
void loop() {
sys_Delay(100);//ะะฐะดะตัะถะบะฐ ะธ ัะฐะทะณััะทะบะฐ ะฟัะพัะตััะพัะฐ
}
แแกแแแแ แแ แแ แแแ แแแแ
แฉแแแ แแแญแแ แ แฆแแแแแก "แจแแแแฌแแแแ" แแ แแ แฃแแแ แแงแแก แจแแชแแแแแแ.
แแฎแแ แแฅแแแ แฃแแแ แแแแฆแแ แแแแแ แฃแแ แคแแแแ (firmware). แแแ แฉแแแ แแแแแฃ "แฉแแแแฎแแขแ>>แแ แแแแแ แคแแแแแก แแฅแกแแแ แขแ (CTRL+ALT+S)".
แแก แแแแแแแแ แแแก แแ HEX แคแแแแก แแกแแแแแก แกแแฅแแฆแแแแแจแ. แฉแแแ แแแฆแแแ แแฎแแแแ แคแแแแก แแ แแคแแฅแกแแก แแแ แแจแ "with_bootloader.mega".
Nanonyam แแแ แขแฃแแแฃแ แแแแฅแแแแจแ HEX แคแแแแแก แแแแแแแแแก แ แแแแแแแแ แแแ แแ แกแแแแแก, แงแแแแ แแแแแแแ แแฆแฌแแ แแแแ
แแแแแแแแฃแ แแ, แจแแแแซแแแแ แจแแฅแแแแ แแ แแแ แแแแแ แกแฎแแ แแแ แแแแจแ, แ แแแแ แแชแแ AVR Studio แแ WinAVR.
แกแฌแแ แแ แแฅ แแแแแแแ แแแ แแแแแแแแแแแ แแแชแแแแแก. แแแแแแ แ แแแ แ แแแแแแ แฃแแแ แแงแแก.
แแแแแแแ แงแแแแแก แงแฃแ แแแฆแแแแกแแแแก แแ แแแ แแ แแ แแแ แแแแ แแแแกแแแแก!
แฌแงแแ แ: www.habr.com