แงแแแแแคแแ แ แแแแ แแแแฌแงแ, แ แแ แแแขแแ แแ แจแแแซแแแ แกแแแแขแแ แแกแ แแแฌแงแแแแแแแ แแแแ แแ แแแแแ แแ - Smart Response XE (
แแก แแแฌแงแแแแแแแแแ แจแแฌแงแแ แ แแแแแแแแ แฌแแแก แฌแแ แแ แแก, แ แแช แกแแแแแแแ แแงแแแแก 100-200 แแแแแ แแ, แแฎแแ แฉแแแแแ eBay-แแ 10 แแแแแ แแ แแ แแแแแแแ. แแฅ แแแแ แแขแฃแ แ แซแแแแแ แจแแกแแคแแ แแกแแ แฏแแฅแฃแ แ แแฅแกแแแ แแแแแขแแแแกแแแแก:
- 60 แแแแแแแขแฃแ แ
- แแแ แแแ 384ร136 แแแ แฉแแแแแแแแ, 2 แแแขแ แแแฅแกแแแแ - แแกแแแแกแ BC, CGA, แแแแ แแ 4 แแ แ แคแแ แ, แแ แแแแ แกแแแแจแแแจแแก แแ แแแแชแแ
- แแแแ แแแแแขแ แแแแ แ ATmega128RFA1 (128 แแ แคแแแจ แแแฎแกแแแ แแแ, 4 แแ ROM, 16 แแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ, 802.15.4 แแแแแแชแแแ)
- แแแ แ (แแแแ แแแแแขแ แแแแ แแแ แแแแแ แแแแแจแ แแ แแ แ แแแแ แแแฌแงแแแแแแแแกแแแ แแแแแ แแแแแจแ) 1 แแแแแแแขแ (128 แแแแแแแแขแ) แคแแแจ แแแฎแกแแแ แแแ SPI แแแขแแ แคแแแกแแ
- แแแแงแแคแแแแแ 4 AAA แแแแแแแขแแกแแแแก.
แแแแ แแแแแขแ แแแแ แแก แกแแฎแแแฌแแแแแแแแ แแ แแแแแ, แ แแ แแก แแแฃแแแแแก AVR แแฏแแฎแก, แ แแช แแแแก แแแจแแแแก, แ แแ แแแฌแงแแแแแแแแก Arduino-แแแ แแแแกแแแแแ แแแงแแแแแ แฃแคแ แ แขแ แแแแแแฃแ แ แแแแชแแแแ...
แแฎแแแ แแแแแแแแแ
แแแแ แแ แแแขแแ แก แฃแคแ แ แแแขแแ แแแแขแแ แแกแแแก แแแฌแงแแแแแแแแแ แแ แ แแแแแจแ, แแ แแแแ แจแแกแฌแแแแแก แจแแกแแซแแแแแแแ:
- แคแแแจ แแแฎแกแแแ แแแ แกแแ แแฃแแ SPI แแแขแแ แคแแแกแแ
- แฉแแแขแแแ แแแแแแแ AVR-แกแแแแก
- แกแขแแแแแ แขแ 802.15.4
แแแขแแ แแ แฌแแ แ แแแแฌแงแ
แแก แกแแแแแ แแกแแ Arduino-แก แฉแแแขแแแ แแแแแแก แแกแแขแแแ แแแ, แแแแ แแ แแ แ แแกแแแแ - แกแแ แแฃแแ แแแ แขแ แแ แแ แแก แแแแแแจแแ แแแฃแแ แแฅ, แแกแ แ แแ แแฅแแแ แฏแแ แแแแแ แแ แจแแแแซแแแแ แกแแฅแแแก แแแฎแกแแแก แแแ แแจแ. แแกแแแ, แแแ แแแแ แกแแ แแฃแแ แแแ แขแแก TX0 แแ RX0 แฎแแแแแ แจแแ แฌแงแแฃแแแ แแแแแแแขแฃแ แแก แแแขแ แแชแแก แแแแญแแกแงแ แแก แฎแแแแแแแ, แแแ แซแแ, แแแแแแ, แ แแแแแแแช แแฉแแแแแแแ แคแฃแแฅแชแแแก แแแแแแจแแแก แแแ แแแแก แแแแ แแแแแ. แแแแ แแ แ แ แจแแแแซแแแแ แแแแแแแแ - แแแขแแ แแ แแก แแแแ:
แแแ แแฅ แแแแขแแแ JTAG แฎแแแแแ แแ แแฎแแ แแ แแ แแก แกแแญแแ แ แแแขแแ แแแก แแแแงแแคแแแแแแก แแแฎแกแแ. แแ แแกแแแแแแแก แแขแแแ แแแแก แแแแแแ, แแ แแแ แกแแ แแฃแแ แแแ แขแ แแ แแกแ แแ แแแแแ แแแแแฅแขแแ แก แแแแแแแแจแแ แ, แฉแแแ แแแแแแช แแแแแแแขแ, แ แแแแแ แแแงแแแแแฃแแ แแแขแแ แแแแแ แคแแแแแฃแ แแ แจแแฃแซแแแแแแแ แกแฎแแแแแแ แแ แแแฌแงแแแแแแแแก แแแแแ แแแ.
แกแแแแแแ แแแแ แแ แ แแแกแญแแ แแ แจแแแฃแฆแแแแก แ แแแแแ, แกแแกแแ แแแแแ แแแแแ แแ แฌแแแแก แแแ แแฆแแแ แแฃแจแแแแแก. แแแแแแแ, แแกแแแแแแแก "แฐแแแ แแ" แแขแแแ แแแ แแแแ แแ แฃแคแ แ แแแกแแฎแแ แฎแแแแแแ, แแแแกแแแแแก แกแแกแฌแ แแคแแ แฃแแแ แแแแแแแแแ แ แแแ.
Arduino IDE แแงแแแแแก แแ แแแ แแแแก แแกแแแแแแแก แแขแแแ แแแแกแแแแก
แแ แแ แแแแแแแก แแแซแแแแแก แกแฎแแแแแกแฎแแ แแแแแแก แแชแแแแแแแก แจแแแแแ, แแแขแแ แก แจแแแแแแ แแแกแแแ แแแ แแแแแฃแแแแ. แแแฌแงแแแแแแแแก แแฅแแก 128 KB แคแแแจ แแแฎแกแแแ แแแ SPI แแแขแแ แคแแแกแแ - แฉแแแ แแแฆแแแ แแแแแชแแแแแก แกแแแแแแแแ (แแแฎแกแแแแแ, แ แแ แแแขแแ แก แฃแแแ แแฅแแก แแ แแ แแแฌแงแแแแแแแ แแแแ แแแ แแแแแฅแขแแ แแ), แแแงแแแแแ แแ แแแฎแกแแแ แแแแก แแฃแคแแ แแ แแ แแแแแแแแแ แแแแแชแแแแแก แ แแแแแแ. แแ แฎแ แกแฎแแ แแแฌแงแแแแแแแแแ. แแแแแ แฏแแแ แแแแแแแแแ.
แ แแแแ แแ แฎแแแ แแฃแจแแแแแก แแแแแก แแแฌแแ แแก แจแแแแแ, แแกแแแ แ แแแแ แช แจแ แแคแขแ, แแแแขแแแ แแแแ แแแฎแแ 4 แแแแแแแแขแแ แแ แซแแแ. แแแแขแแ, HFUSE แแแแจแแแแแแแ แฃแแแ แจแแแชแแแแแก 0xDA-แแแ 0xD8-แแแ. แแฎแแ แฉแแแขแแแ แแแแแ แจแแแซแแแแ แแงแแก 8 แแแแแแแแขแแแแ, แฎแแแ แกแแฌแงแแกแ แแแกแแแแ แแ แแ แแก 0x1E000. แแก แแแกแแฎแแแ Makefile-แจแ, แแแแ แแ แแกแแแ แฃแแแ แแงแแก แแแแแแแแกแฌแแแแแฃแแ แจแแแกแแแแกแแก
802.15.4 แแแแแแชแแแ ATmega128RFA1-แจแ แแแแแแแแ แแแแแ แจแแฅแแแแแแ แแ แแขแแแแแแก แแแแแงแแแแแแ แแฃแจแแแแแกแแแแก
แแฆแแแฉแแแ, แ แแ 15 แแ 26 แแ แฎแแแ แงแแแแแแ แแแแแแแแ แแฅแแแแแแแแ แแแ WiFi-แแก แฉแแ แแแแก, แแแขแแ แแ แแแแแแ แแแแ แ แแแ แฉแแ. แฃแแ แ แแแกแฃแฎแแกแแแแแแแแแแ: แแแแ แแแแแแแ แแ แแชแแก, แแแแแแแ แแฃแแแ แแฃ แแ แ ZigBee-แแก แแ แแแแ แแแแแ แขแแแแแ. แแฅแแแ แชแแขแ แแแขแ แแ แแแ แแแแ แแแ แแแแแแแแแ แแ แแแแแแแแ แแแแแแฎแแ แชแแแแแ?
แแแ แแแ แแแฌแงแแแแแแแแแ แแฃแชแแแแแแแแ แกแแกแ แฃแแ แแแแแแแ แแแแแก แแแแ แแขแแก แแแแแ แแแ, แ แแแแแแช แแแแแกแชแแแก แแแแแชแแแแแก STK500 แแ แแขแแแแแแ. แฃแแแขแแกแฌแแแแ, แแแแแชแแแฃแแ แแ แแแฆแแแฃแแ แจแแขแงแแแแแแแแแ แแแแแแแแ แแ, แแแแ แแ แแแแแแ แแ แแแแแแจแแ แแแฃแแแ แแแแแแ, แ แแแแแแช แแแ แ แแแแแแ แแ แฎแแ. แแแชแแแฃแแแ แแแแแแแแก แแฆแฌแแ แ
แแ แแแแแแแแก แแแแจแแแแแแแแแ แแแแแแแแแขแแ แแแแแขแแแแก แแแแแชแแแ, แ แแแแแแแช แแแแแฃแแแแแแแ แแแแแจแแฃแแแแแก แแแฌแงแแแแแแแแก แคแแแจ แแแฎแกแแแ แแแแจแ แฉแแกแแฌแแ แแ. AVR แแฏแแฎแแก แแแ แขแแแ แแแแ แแแแแขแ แแแแ แแแแกแแแแก แแแแ แแแก แแแแแ 128 แแแแขแ, ATmega128RFA1 แแ 256. แฎแแแ แคแแแจ แแแฎแกแแแ แแแแกแแแแก, แ แแแแแแช แแแแแแจแแ แแแฃแแแ SPI แแ แแขแแแแแแ, แแแแแแ. แแ แแแ แแแ แแแ แแแ แแแฌแงแแแแแแแแจแ, แแกแแแแแก แแขแแแ แแแแกแแก, แแแจแแแแ แแ แแแแแแฅแแก แแแแ แแแ, แแ แแแแ แฌแแ แก แแ แแแฎแกแแแ แแแแจแ. แ แแแแกแแช Arduino IDE แแแแฌแแแแก แฉแแแแฌแแ แแก แกแแกแฌแแ แแก, แแแแแแแแแ แแก, แ แแช แแฅ แแฌแแ แ. แแฎแแ แฉแแแ แฃแแแ แแแแแแแขแแแแ แแแฆแแแฃแแ แแแแแชแแแแแ แ แแแแ แแ แฎแแก แกแแจแฃแแแแแแ แแแแ แ แแแฌแงแแแแแแแแแ. แแแแแแ แแฃแแแ, แแแแฆแแแแแแ แแแแแชแแแแแ แแ แฃแแแ แแแแแกแแแ แกแแแแแแ แฎแจแแ แแ แฎแแแแ. STK500 แแ แแขแแแแแ แแฃแแแ แแแแ แจแแคแแ แฎแแแแแแก แแแแแ แ, แแแแ แแ แแ แแแแแแแแก แแแแแชแแแแ แแแแแ แแแแก (แฃแชแแแฃแ แแ, แแแแ แแ แแแแแ แแแฅแแ, แ แแ แจแแคแแ แฎแแแแแ แแกแแแ แแแแแแแแก แแฎแแแแก แแแแแชแแแแ แแแแแชแแแแแ). แแ แฃแแแแแแ แแแแแชแแแแก แแ แแก แแแแแแแ แแแแ แแแ แแแฃแแแแแ. ATmega128RFA1-แก แแฅแแก แแแแแแแ แแแแแ แแแแฎแแแแแก แฉแแจแแแแแฃแแ แขแแฅแแแแแก แแแแแ แแแ, แ แแแแกแแช แแ แกแแแแแก แแญแแ แแแแแชแแแแก แกแแกแฌแแ แแจแ, แแแแ แแ แแแขแแ แแ แแแแแฌแงแแแขแ แแแแแ แแแแแฎแแ แชแแแแแก แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแจแ. แแแ แจแแแแฃแจแแแ แแ แแขแแแแแ, แ แแแแแจแแช แแแชแแแแแแ แแแขแ แแแแแชแแแ แแแแแแแแแ แแ แแ แแแแแ แแฃแแแแแ, แแแแ แ แแแแ แแแ.
แแก แแ แแ แแก แกแ แฃแแงแแคแแแ, แแแแ แแ แแฃแจแแแแก. 256 แแแแขแแแแ แแแแ แแ แแแงแแคแแแแ แแแฎ แกแแแแแแขแแ, แ แแแแแแแแแ แแแแแแฃแแ แแแแแแชแแแ แฐแแแ แจแ, แ แแแแ แช แแแแแขแ. แแแแแขแก แจแแฃแซแแแ แจแแแแแฎแแก 125 แแแแขแ แแแแแชแแแแแ แแแฃแก แแ แแ แแแแขแ แกแแแ แซแแกแแแแก แแ แแ แ แแแแขแ CRC-แกแแแแก. แแกแ แ แแ, 64 แแแแขแแก แกแแแ แซแแก แคแ แแแแแแขแแแ แแแแ แแแกแ แแ แกแแแแแแขแแก แแแแ แแแแแ แแ แแแ (0-แแแ 3-แแแ) แแแแแแกแแแฃแแแ แแฅ. แแแแฆแแ แแแฌแงแแแแแแแแก แแฅแแก แชแแแแแ, แ แแแแแแช แกแแจแฃแแแแแแก แแซแแแแก แแแก แแแแแงแฃแ แ แแแแแแแก แ แแแแแแ แกแแแแแแขแ แแฅแแ แแแฆแแแฃแแ แแ แ แแแแกแแช แแแฎแแแ แฉแแแแแ, แแแแแแแแแ แแแฌแงแแแแแแแ แแฆแแแก แแแแแกแขแฃแ แแแแก, แ แแ แแแแแ แแแแ แแ แแแฆแแแฃแแแ. แแแแแกแขแฃแ แแแ แแ แแ แแก (CRC แแ แแแแแแฎแแ) - แฎแแแแฎแแ แแแแแแแแแ แแแแแ แแแแ แแ. แกแแฉแฅแแ แ แแแแแ แฃแคแ แ แแแแแ, แแแแ แ แแแแแแแก แกแแจแฃแแแแแแ แแแแแชแแแแกแแก. แแฎแแแแ:
แแแแ แแ แแแแแแแ, แกแแญแแ แ แแฅแแแแแแ แแแแแแแก แแแแแแจแแ แแแแก แแแกแแฎแแ แฎแแแแแ แแแ แแกแแแแแแแก แแขแแแ แแแแกแแแแก แแ แแแกแ แแแจแแแแแแ แแแฌแงแแแแแแแแแแแ. แแแแแแแแแ, แแแแแแแกแแ CP2102-แแ แแกแแแ แแแขแแ แคแแแกแแก แแแแแแงแแแแแก แจแแแแแ, แ แแแแ แช แคแแขแแแแ แแ แแแแฌแแแแ แแแคแแแ, แ แแแ แแแฃแซแแแก แซแแแแก Micro USB แแแแแแแก แจแแแ แแแแแกแ แแ แแแแแจแแแกแแก.
แแแก แแกแแแ แแฅแแก 3,3 แแแแขแแแแ แกแขแแแแแแแแขแแ แ (แแ แ แแแแ แแแแแแแงแแแแ แแแฌแงแแแแแแแแจแ 6 แแแแขแแแแ แแแแแแก แแแแแแ - แแฃ แแฎแแแแ แแแก แแฅแแก แแแแแ แกแขแแแแแแแแขแแ แ แแ แจแแแแซแแแแ แแแแแแขแแ แแ แ แแแแแ, แ แแ แแแขแแแแขแฃแ แแ แแแ แฉแแแ, แ แแแแแ แแแแแแแก แแแแฌแแแแก แแแฌแงแแแแแแแแก) . แกแแแแแ แจแฃแฅแแแแแฃแ แ แจแฃแฅแ แฃแแแ แแงแแก แแแฃแฎแกแแแแ แแแขแแ แคแแแกแแก แแแแแแงแแแแแก แแแคแแแแ, แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ แแกแแแ แแแแแขแแแแ แแขแแแ แแแแแ แแแขแแ แแแแก แแแแแ แแฃแจแแแแแกแแก, แแกแแแ แฎแแแก แฃแจแแแแ แแแแแแแขแฃแ แแก แแแแแแแแฎแแแก แแ แแแฃแจแแแแแแ แคแแแจ แแแฎแกแแแ แแแแกแแแ SPI แแแขแแ แคแแแกแแ.
แแแแแแก แแแฆแฌแแแ แแแแแ แฃแคแ แ แกแแแแขแแ แแกแ แแฆแแแฉแแแ, แแแแ แ แแแกแ แแแฆแฌแแแ (แแ แแ แแญแแ แแแแแ แแก แฎแฃแแ แแแ แแแขแแแฃแกแแ). แแแขแแ แแ แแแแ แ แ แแ แจแแแขแงแ AVR แฉแแแขแแแ แแแแแแแแก, SPI แคแแแจ แแแฎแกแแแ แแแแก, STK500 แแ แแขแแแแแแกแ แแ 802.15.4 แกแขแแแแแ แขแแก แจแแกแแฎแแ.
แงแแแแ แกแฎแแ แแแแ แแแแแ แแฆแฌแแ แแแ แแแแแแแแแแแก แแแ แแ แแ แแก -
แฌแงแแ แ: www.habr.com