แแแแแกแแแแแแ แงแแแแ แแแแแฎแแแแก "แฌแแ แแแแแแ แแ แแแแแแแ แจแแ แแแแแแ" แแแแงแแคแแแแแ Habr-แแ! แแฆแแแแแแแแ แกแขแแขแแ แแฅแแแแ TTP223 แฉแแแแ แกแแแกแแ แฃแแ แแแแแแ แแแแแแก แจแแกแแฎแแ |
แ แแแแ แช แงแแแแ แฌแแแ แแ แแแฅแขแ, แแกแแช Arduino แแ แแแฅแขแแ, แแ แแแ แแแ แแแฌแแ แแแแ Arduino IDE-แจแ. แแแฌแงแแแแแแแแก แแ แแแ แแแฃแแ แแแแแ แแแ แแคแฃแซแแแแ Mysensors แแ แแขแแแแแก |
(แแแแแแแก, แแแกแแช แกแฌแแแแ แกแฃแ แก -
แกแแแกแแ แฃแแ แแแแแแ แแแแแ แแแคแ แจแแแฅแแแ Deeptrace แแ แแแ แแแแจแ, แจแแแแแแแ แฌแแ แแแแแแก แแแแแแแแกแฌแแแแแแ แแแแแ แฃแแ แแแฃแแแแแแก แขแแฅแแแแแแแแก (LUT) แแแแแแแก แแแแแงแแแแแแ. แแแคแ แจแแแฃแจแแแแแฃแแแ 60x60 แแ แแแแแแจแ (แกแขแแแแแ แขแฃแแ แแแแแก แแแแแแก แแฅแแก แแแแแแ 80x80 แแ). แฌแ แ แแแแแแญแแ แแฃแ แแแแแก Antenna-แก แแแแ แแแแแ แแ แแแแแแขแแแแก Bosch-แแก แฃแแแแ "Len" แแแ แแแแขแ แแ (แแแฅแกแแแแแฃแ แ แกแแแซแแแแ แ) แแ แแฎแ แแ แคแแแแแก แแแแแแแญแแแแแแ แแแคแแแ 1.5 แแ, 35 ฮผm (แแแแ แแก แแ แแ แกแแแแแแก แจแแแแฎแแแแแจแ).
แแ แแแแ แแแ แแแแฎแแ แชแแแแแ แ แแแแแก แฅแแแ แแแแก แฎแกแแแ แแ, แ แแแแแแช แแแ แ แแแแแแแแแฃแแ แแงแ 1.5 แฉแแแก แแแแแ 250 แแ แแแแ แฌแงแแแแ. แแ แแชแแกแก 15 แฌแฃแแ แแแกแญแแ แแ.
แกแแแฃแ แฆแ แฎแแ แแแแแแก แแแแฃแ แฆแแ แแ แแแขแแ แแแก แแแแญแแ แแก แแแแแแ แแแ แจแแกแ แฃแแแ DREMEL 3000 แแแแ แแฃแ แฆแแ, แ แแแแแแช แแแแแแขแแแแแฃแแแ DREMEL 220 แกแแแฃแ แฆแ แกแแแแแแแ. แจแฃแแแแแฃแ แ แแแแแแแกแแแแก แฎแแ แแแแแ แแแแฃแ แฆแฃแแ แแงแ 0,4แแ แแฃแ แฆแแ, แแแขแแ แแแก แแแแญแแ แแกแแแแก แฎแแ แแแแแ 1,1แแ แแฃแ แฆแแ. . แแแคแแก แกแแแฆแแ แแแแก แแแกแฌแแ แแ แแแ แแแ แแแแฎแแ แชแแแแแ แแแแแ แแแแ แแฃแ แฆแแ DREMEL 540 แแแแแแแขแแ (แกแแญแ แแแ แฌแ แ d=32.0mm). แแแกแฎแแแ แ แแกแแแ แแขแแ แจแ แฎแแแแแแ.
แแแคแฅแฃแแ แแแคแแก แแแแแแกแแ แแแแ แฎแแแแแแ แแแ แแแก แจแแแแแแแแแก แแแแแงแแแแแแ แฌแงแแแฎแกแแแ แจแ (1 แฉแแแก แแแแแ แแ แแกแขแแแแแแแฃแแ แแแแแแแแแแ 300 แแ แฌแงแแแแ).
แจแแแฃแฆแแแแก แแ แแชแแกแก แแแแฎแแแแแแ แแ แแ แกแแแแ แแแกแญแแ แแ, แแ แแแก แฃแแแขแแกแ แแแฌแแแ แแแฎแแ แฏแฃแแ แแงแ แแแแแฃแแแก (แแแแแแกแแ แแแแฃแแ, 0.4 แแ แแแแแแขแ แแก) แจแแแฃแฆแแแแแ, แคแแแแแแก แแแแแกแแกแแแแแแแแก แฎแแ แแแแแจแ.
แแแคแ แแแ แแชแฎแแแ แแงแ FLUX OFF แแแ แแแแแฃแ แ แแแแฌแแแแแแ.
แแแฌแงแแแแแแแแก แแแ แแฃแกแแก แแแแแแแ แแแแฎแแ แชแแแแแ แกแแแแแแแแแแแแแแแแ แแแแแแฃแขแแ แแก แแแฎแแแ แแแแ แแแแแแแแก แ แแแแฅแขแแ แจแ. แแแ แแฃแกแแก แแแแแแ 78,5 แแ X 78,5 แแ X 12 แแ.
แแแ แแฃแกแแก แแ แแแขแแ แแแก แแแแงแแคแแแแแแก แกแแคแแ แแก แแแกแ แฃแแแแฃแแ แแแแแแ แจแแแแฎแฃแแ แแงแ STL แคแแ แแแขแจแ, แจแแแแแ แกแแญแแ แ แแแฎแแ แแ แแแแแแแแแก แแแแแแแแแ SLA แแ แแแขแแ แแ แแแกแแแแญแแแ (แกแแงแ แแแแแแแก แแแแแขแแแ, แแ แแแแขแแชแแ). แแ แแขแแแแ แฌแแ แแแแจแแ แแชแแ แ แแ แแแแแแ, แ แแแแแ แกแแงแแคแแชแฎแแแ แแแ SLA แแ แแแขแแ แแแแก แแแญแแแแก แแ แแแแ แแชแแ แแ. แแแฌแงแแแแแแแแก แแแ แแฃแกแแก แแแแแแ แแแญแแแแก แแ แแกแแแ แจแแแแ แแแแ แงแแแแแแ แแแขแแแแแฃแ แแแแแแแ แแแแแจแ แแ แฏแแแแแแ แแแญแแแแก แแแแแก แแแแแแจแ. แแแแแแแก 45 แแ แแแฃแกแแ แแแงแแแแแแกแแก แแกแแแ แแแแแแแชแ แฃแแแฃแแ แจแแแแแ แแแแแแฆแ, แกแแงแ แแแแแก แฌแแแ แกแฎแแฃแแแก แแแแแแแก แฌแแแแก แฃแแ แแแ. แแแแแฌแงแแ แแแแแแแก แแแ แขแแแแแฃแ แแ แแแแแญแแแ, แกแแงแ แแแแแก แแแแแแแแ แแ แ-แแ แ แฌแแแ แแฎแแ แแก, แฌแแแแกแฌแแ แจแแแแแฎแแแแฃแแ แแงแ แจแแแแแแแ แแแแฃแจแแแแแแก แคแแฅแขแแ. แกแฎแแฃแแแก แแแแแญแแแแก 5 แกแแแแ แแแกแญแแ แแ 50 แแแแ แแแ แคแแแแก แแแงแแแแแแ. แจแแแแแแ, แแแแฃแจแแแแแ แแแแฎแแ แชแแแแแ แซแแแแแ แฌแแ แแแแแ แชแแแแแแแ แฅแแแจแแก แฅแแฆแแแแแก แแแแแงแแแแแแ (แแแแแ แก แแ แแแแฌแแ , แ แแแแแ แแ แแแชแ :)). แแแขแแ แแแก แกแแคแแ แแก แแแแแญแแแแก 40 แฌแฃแแ แแแกแญแแ แแ.
แจแฃแจแแก แแแแแแแแ Aliexpress-แแกแแแ แแงแแแแแ แฃแแแ แฌแแแแแแแ แแแแกแขแแแกแแก แฉแแ แฉแแแ, แฉแแ แฉแแก แแแแฆแแแแก แแ แแแแแแ แแ แงแแคแแแ. แแ แแแแแแฆแ แจแฃแจแแก แแแแแแ แฉแแแฃแแแแ แแแ แคแแแแ แฌแแแแกแฌแแ แแแฎแฃแ แแแแก แจแแแแแ.
LED แแแแแแแแแก แแแคแฃแแแ แ แแแแแแแแแฃแแแ แแ แแฎแ แแแ แแแแขแแ แแแ แแแแก แฌแแแแแแแ 3M 9088-200. แคแแฃแแ แแกแชแแแขแฃแ แ แแแแแแแแแกแแแแก แ แแแแแแแแ แแแกแแแ แแงแ แแ แฉแแแแแแก แแแแแแแแ, แฉแแแฃแ แ แฌแแแแแแแ แแแแขแ แแ แฌแแแแแแแ แฅแแฆแแแแ, แ แแแแแแช แแแญแ แแแ แแงแ แคแแ แแ แจแแแ แแแแแแแแ Luminofor-แแกแแแ. แแ แฉแแแแแ แแแแแแแ แจแแแ แแฌแแ แแแแแแแก แกแแกแแ แแแแแแ; แฉแแแ แแ แซแแแแแแแก แแแฎแแแแแ, แแก แแแแแแแแ แฃแคแ แ แแแจแแแจแ แแ แฃแคแ แ แแ แซแแแ. 3M 9088-200 แแ แแฎแ แแแ แแแแขแแ แแแแแแแ แแงแ แแแแแแ แแแฃแแ แคแแฃแแ แแกแชแแแขแฃแ แ แแแแแแแขแแ แฅแแฆแแแแแก แแแแแ แแขแ.
แแแแ แแแแแแ แแ แแแแแแ แแแแแแก แกแฎแแฃแแแ แแ แแฎแ แแแ แแแแขแแก แแแแแงแแแแแแ 3M VHB 4910 แแแ แแแแก แฌแแแแแ.
แกแแคแแ แ แแแแแแ แแ แฎแ แแฎแแแ M 1,4 X 5 แแ.
แแแฌแงแแแแแแแแก แฆแแ แแแฃแแแแ แแงแ 890 แ แฃแแแ.
แจแแแแแ แแแแแแ แแ แแแ แแแแก แแแฌแแแ. แแงแ แแแ แแแแฃแแ แแ แแแแแแแแ. แแแแแแแก, แ แแ TTP223 แกแแแกแแ แฃแแ แฉแแแแแ แแจแแแแแแ แแ แแฃแจแแแแก แกแขแแแแแแแแแฃแแ 3.3V แแแแแก แฌแงแแ แแกแแแ แแ แแ แช แแกแ แแแ แแแ, แ แแแแกแแช แแแแแแแแ แแแ แแแแแ แแแ แแแ แแแชแแแแ แแแขแแ แแแแแ. แแแฌแงแแแแแแแแก แฉแแ แแแแกแแก แแแแฅแขแ แแแแแแ แแแแแแ แแแแฎแแแแแแ 2.5 แ, แแแฃแก แแแแแขแแแแ โแแแแแจแแแกโ แจแแแแแ Mysensors-แแก แแ แแแแแขแแชแแแก แแแแฃแจแแแแแแกแแก, TTP223 แแแแ แแกแฅแแแแ (แแแแแแแแ แแแแกแแแแแแ) แแแแแแฌแแแ MK-แแก แจแแคแแ แฎแแแ, แ แแแแแ แแก แแฅแขแแฃแ แ แขแ แแแแ แแ แแงแ.
แจแแแชแแแแ แแแแ แแกแฅแแแแก แแแแฅแขแ แแแแแแ แแแแแแก แฌแ แ (แแแแฅแขแ แแแแแ แแแแก แแแแแฏแแแแขแ TTP223 gpio MK-แแ), แแแแฌแแแแแ แแแแแขแแแแแ แแแแแฌแแแ แแ แฃแคแ แ แแแฆแแแ แฌแแแแแฆแแแแแแแแก แแฅแแแ แ แแแแกแขแแ แแแ แจแแแชแแแแ rgb led แฎแแแแแแ (แ แแแแแแช แแแแแก แขแแแแแ แกแแแกแแ แแก แแแคแแก แแแแ แ แแฎแแ แแก). แแแ แแกแแแ แแแแแแขแ แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก: แกแแแซแแแแ แแก แแแแฅแขแแฃแ แแแ แขแแแแแแแแก แแแแ แแกแฅแแแแกแแแแก Mysensors-แแก แฉแแ แฉแแก แแแฌแงแแแแก แแ แแ แแแแแขแแชแแแก แแแแฃแจแแแแแแก แจแแแแแ. แแแแ แแแแแ TTP223 แฉแแแแก แแแขแแแแขแฃแ แ แแแแแแ แแชแแแก แจแแคแแ แฎแแแ แแแแฅแขแ แแแแแ แแแแก แแแแแงแแแแแแกแแก. แงแแแแ แแ แชแแแแแแแแ แแแแแแแแ แแฆแแแคแฎแแ แ แแก แแ แแแแแแ.
แแ แแแ แแแแก แแแแแก แแแฎแแแแแ แแแ แฉแแแ แแแแชแแแ แแกแแแแแแแก แซแแ แแแแ แกแขแ แฃแฅแขแฃแ แแก Mysensors-แจแ.void before()
{
// ะะพะฟะพะปะฝะธัะตะปัะฝะฐั ััะฝะบัะธั, ะตัะปะธ ััะฐะฒะฝะธะฒะฐัั ัะพ ััะฐะฝะดะฐััะฝะพะน ััััะบัััะพะน ะัะดัะธะฝะพ ัะบะตััะตะน, ัะพ before() ััะพ ะฟะพะดะพะฑะธะต setup(), ะพััะฐะฑะพัะบะฐ ะฟัะพะธัั
ะพะดะธั ะดะพ ะธะฝะธัะธะฐะปะธะทะฐัะธะธ ััะฐะฝัะฟะพััะฝะพะณะพ ััะพะฒะฝั Mysensors, ัะตะบะพะผะตะฝะดัะตััั ะฝะฐะฟัะธะผะตั ะดะปั ะธะฝะธัะธะฐะปะธะทะฐัะธะธ ััััะพะนััะฒ SPI
}
void setup()
{
}
void presentation()
{
//ะขัั ะฟัะพะธัั
ะพะดะธั ะฟัะตะทะตะฝัะฐัะธั ะฝะพะดั ะธ ะตะต ัะตะฝัะพัะพะฒ ะฝะฐ ะบะพะฝััะพะปะตัะต ัะตัะตะท ะผะฐัััััะธะทะฐัะพั
sendSketchInfo("Name of my sensor node", "1.0"); // ะฟัะตะทะตะฝัะฐัะธั ะฝะฐะทะฒะฐะฝะธั ะฝะพะดั, ะฒะตััะธะธ ะะ
present(CHILD_ID, S_WHATEVER, "Description"); // ะฟัะตะทะตะฝัะฐัะธั ัะตะฝัะพัะพะฒ ะฝะพะดั, ะพะฟะธัะฐะฝะธั ัะตะฝัะพัะพะฒ
}
void loop()
{
}
แจแแฎแแแแ แแแแแ แแแแก แแ แแแ แแแแก แขแแกแขแแก แแแแ:test_sens.ino
/**
ะขะะกะขะะะซะ ะกะะะขะง ะกะะะกะะ ะะะะ ะะซะะะฎะงะะขะะะฏ ะก ะะ ะะ ะซะะะะะฏะะ ะะ NRF_LPCOMP
*/
bool button_flag;
bool sens_flag;
bool send_flag;
bool detection;
bool nosleep;
byte timer;
unsigned long SLEEP_TIME = 21600000; //6 hours
unsigned long oldmillis;
unsigned long newmillis;
unsigned long interrupt_time;
unsigned long SLEEP_TIME_W;
uint16_t currentBatteryPercent;
uint16_t batteryVoltage = 0;
uint16_t battery_vcc_min = 2400;
uint16_t battery_vcc_max = 3000;
#define MY_RADIO_NRF5_ESB
//#define MY_PASSIVE_NODE
#define MY_NODE_ID 30
#define MY_PARENT_NODE_ID 0
#define MY_PARENT_NODE_IS_STATIC
#define MY_TRANSPORT_UPLINK_CHECK_DISABLED
#define IRT_PIN 3 //(PORT0, gpio 5)
#include <MySensors.h>
// see https://www.mysensors.org/download/serial_api_20
#define SENS_CHILD_ID 0
#define CHILD_ID_VOLT 254
MyMessage sensMsg(SENS_CHILD_ID, V_VAR1);
//MyMessage voltMsg(CHILD_ID_VOLT, V_VOLTAGE);
void preHwInit() {
sleep(2000);
pinMode(RED_LED, OUTPUT);
digitalWrite(RED_LED, HIGH);
pinMode(GREEN_LED, OUTPUT);
digitalWrite(GREEN_LED, HIGH);
pinMode(BLUE_LED, OUTPUT);
digitalWrite(BLUE_LED, HIGH);
pinMode(MODE_PIN, INPUT);
pinMode(SENS_PIN, INPUT);
}
void before()
{
NRF_POWER->DCDCEN = 1;
NRF_UART0->ENABLE = 0;
sleep(1000);
digitalWrite(BLUE_LED, LOW);
sleep(150);
digitalWrite(BLUE_LED, HIGH);
}
void presentation() {
sendSketchInfo("EFEKTA Sens 1CH Sensor", "1.1");
present(SENS_CHILD_ID, S_CUSTOM, "SWITCH STATUS");
//present(CHILD_ID_VOLT, S_MULTIMETER, "Battery");
}
void setup() {
digitalWrite(BLUE_LED, LOW);
sleep(100);
digitalWrite(BLUE_LED, HIGH);
sleep(200);
digitalWrite(BLUE_LED, LOW);
sleep(100);
digitalWrite(BLUE_LED, HIGH);
lpComp();
detection = false;
SLEEP_TIME_W = SLEEP_TIME;
pinMode(31, OUTPUT);
digitalWrite(31, HIGH);
/*
while (timer < 10) {
timer++;
digitalWrite(GREEN_LED, LOW);
wait(5);
digitalWrite(GREEN_LED, HIGH);
wait(500);
}
timer = 0;
*/
sleep(7000);
while (timer < 3) {
timer++;
digitalWrite(GREEN_LED, LOW);
sleep(15);
digitalWrite(GREEN_LED, HIGH);
sleep(85);
}
timer = 0;
sleep(1000);
}
void loop() {
if (detection) {
if (digitalRead(MODE_PIN) == 1 && button_flag == 0 && digitalRead(SENS_PIN) == 0) {
//back side button detection
button_flag = 1;
nosleep = 1;
}
if (digitalRead(MODE_PIN) == 1 && button_flag == 1 && digitalRead(SENS_PIN) == 0) {
digitalWrite(RED_LED, LOW);
wait(10);
digitalWrite(RED_LED, HIGH);
wait(50);
}
if (digitalRead(MODE_PIN) == 0 && button_flag == 1 && digitalRead(SENS_PIN) == 0) {
nosleep = 0;
button_flag = 0;
digitalWrite(RED_LED, HIGH);
lpComp_reset();
}
if (digitalRead(SENS_PIN) == 1 && sens_flag == 0 && digitalRead(MODE_PIN) == 0) {
//sens detection
sens_flag = 1;
nosleep = 1;
newmillis = millis();
interrupt_time = newmillis - oldmillis;
SLEEP_TIME_W = SLEEP_TIME_W - interrupt_time;
if (send(sensMsg.set(detection))) {
send_flag = 1;
}
}
if (digitalRead(SENS_PIN) == 1 && sens_flag == 1 && digitalRead(MODE_PIN) == 0) {
if (send_flag == 1) {
while (timer < 10) {
timer++;
digitalWrite(GREEN_LED, LOW);
wait(20);
digitalWrite(GREEN_LED, HIGH);
wait(30);
}
timer = 0;
} else {
while (timer < 10) {
timer++;
digitalWrite(RED_LED, LOW);
wait(20);
digitalWrite(RED_LED, HIGH);
wait(30);
}
timer = 0;
}
}
if (digitalRead(SENS_PIN) == 0 && sens_flag == 1 && digitalRead(MODE_PIN) == 0) {
sens_flag = 0;
nosleep = 0;
send_flag = 0;
digitalWrite(GREEN_LED, HIGH);
sleep(500);
lpComp_reset();
}
if (SLEEP_TIME_W < 60000) {
SLEEP_TIME_W = SLEEP_TIME;
sendBatteryStatus();
}
}
else {
//if (detection == -1) {
SLEEP_TIME_W = SLEEP_TIME;
sendBatteryStatus();
}
if (nosleep == 0) {
oldmillis = millis();
sleep(SLEEP_TIME_W);
}
}
void sendBatteryStatus() {
wait(20);
batteryVoltage = hwCPUVoltage();
wait(2);
if (batteryVoltage > battery_vcc_max) {
currentBatteryPercent = 100;
}
else if (batteryVoltage < battery_vcc_min) {
currentBatteryPercent = 0;
} else {
currentBatteryPercent = (100 * (batteryVoltage - battery_vcc_min)) / (battery_vcc_max - battery_vcc_min);
}
sendBatteryLevel(currentBatteryPercent, 1);
wait(2000, C_INTERNAL, I_BATTERY_LEVEL);
//send(powerMsg.set(batteryVoltage), 1);
//wait(2000, 1, V_VAR1);
}
void lpComp() {
NRF_LPCOMP->PSEL = IRT_PIN;
NRF_LPCOMP->ANADETECT = 1;
NRF_LPCOMP->INTENSET = B0100;
NRF_LPCOMP->ENABLE = 1;
NRF_LPCOMP->TASKS_START = 1;
NVIC_SetPriority(LPCOMP_IRQn, 15);
NVIC_ClearPendingIRQ(LPCOMP_IRQn);
NVIC_EnableIRQ(LPCOMP_IRQn);
}
void s_lpComp() {
if ((NRF_LPCOMP->ENABLE) && (NRF_LPCOMP->EVENTS_READY)) {
NRF_LPCOMP->INTENCLR = B0100;
}
}
void r_lpComp() {
NRF_LPCOMP->INTENSET = B0100;
}
#if __CORTEX_M == 0x04
#define NRF5_RESET_EVENT(event)
event = 0;
(void)event
#else
#define NRF5_RESET_EVENT(event) event = 0
#endif
extern "C" {
void LPCOMP_IRQHandler(void) {
detection = true;
NRF5_RESET_EVENT(NRF_LPCOMP->EVENTS_UP);
NRF_LPCOMP->EVENTS_UP = 0;
MY_HW_RTC->CC[0] = (MY_HW_RTC->COUNTER + 2);
}
}
void lpComp_reset () {
s_lpComp();
detection = false;
NRF_LPCOMP->EVENTS_UP = 0;
r_lpComp();
}
MyBoardNRF5.cpp
#ifdef MYBOARDNRF5
#include <variant.h>
/*
* Pins descriptions. Attributes are ignored by arduino-nrf5 variant.
* Definition taken from Arduino Primo Core with ordered ports
*/
const PinDescription g_APinDescription[]=
{
{ NOT_A_PORT, 0, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // LFCLK
{ NOT_A_PORT, 1, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // LFCLK
{ PORT0, 2, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), ADC_A0, PWM4, NOT_ON_TIMER},
{ PORT0, 3, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), ADC_A1, PWM5, NOT_ON_TIMER},
{ PORT0, 4, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), ADC_A2, PWM6, NOT_ON_TIMER},
{ PORT0, 5, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), ADC_A3, PWM7, NOT_ON_TIMER},
{ PORT0, 6, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // INT3
{ PORT0, 7, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // INT4
{ PORT0, 8, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), No_ADC_Channel, PWM10, NOT_ON_TIMER}, //USER_LED
{ PORT0, 9, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // NFC1
{ PORT0, 10, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // NFC2
{ PORT0, 11, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // TX
{ PORT0, 12, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // RX
{ PORT0, 13, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // SDA
{ PORT0, 14, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // SCL
{ PORT0, 15, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // SDA1
{ PORT0, 16, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // SCL1
{ PORT0, 17, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // TP4
{ PORT0, 18, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // TP5
{ PORT0, 19, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // INT2
{ PORT0, 20, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // INT1
{ PORT0, 21, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // INT1
{ PORT0, 22, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), No_ADC_Channel, PWM9, NOT_ON_TIMER},
{ PORT0, 23, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), No_ADC_Channel, PWM8, NOT_ON_TIMER},
{ PORT0, 24, PIO_DIGITAL, PIN_ATTR_DIGITAL, No_ADC_Channel, NOT_ON_PWM, NOT_ON_TIMER}, // INT
{ PORT0, 25, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), No_ADC_Channel, PWM11, NOT_ON_TIMER}, //RED_LED
{ PORT0, 26, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), No_ADC_Channel, PWM11, NOT_ON_TIMER}, //GREEN_LED
{ PORT0, 27, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), No_ADC_Channel, PWM11, NOT_ON_TIMER}, //BLUE_LED
{ PORT0, 28, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), ADC_A4, PWM3, NOT_ON_TIMER},
{ PORT0, 29, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), ADC_A5, PWM2, NOT_ON_TIMER},
{ PORT0, 30, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), ADC_A6, PWM1, NOT_ON_TIMER},
{ PORT0, 31, PIO_DIGITAL, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM), ADC_A7, PWM0, NOT_ON_TIMER}
};
// Don't remove this line
#include <compat_pin_mapping.h>
#endif
MyBoardNRF5.h
#ifndef _MYBOARDNRF5_H_
#define _MYBOARDNRF5_H_
#ifdef __cplusplus
extern "C"
{
#endif // __cplusplus
// Number of pins defined in PinDescription array
#define PINS_COUNT (32u)
#define NUM_DIGITAL_PINS (32u)
#define NUM_ANALOG_INPUTS (8u)
#define NUM_ANALOG_OUTPUTS (8u)
/*
* LEDs
*
* This is optional
*
* With My Sensors, you can use
* hwPinMode() instead of pinMode()
* hwPinMode() allows to use advanced modes like OUTPUT_H0H1 to drive LEDs.
* https://github.com/mysensors/MySensors/blob/development/drivers/NRF5/nrf5_wiring_constants.h
*
*/
#define PIN_LED1 (16)
#define PIN_LED2 (15)
#define PIN_LED3 (17)
#define RED_LED (PIN_LED1)
#define GREEN_LED (PIN_LED2)
#define BLUE_LED (PIN_LED3)
#define INTERRUPT_PIN (5)
#define MODE_PIN (25)
#define SENS_PIN (27)
/*
* Analog ports
*
* If you change g_APinDescription, replace PIN_AIN0 with
* port numbers mapped by the g_APinDescription Array.
* You can add PIN_AIN0 to the g_APinDescription Array if
* you want provide analog ports MCU independed, you can add
* PIN_AIN0..PIN_AIN7 to your custom g_APinDescription Array
* defined in MyBoardNRF5.cpp
*/
static const uint8_t A0 = ADC_A0;
static const uint8_t A1 = ADC_A1;
static const uint8_t A2 = ADC_A2;
static const uint8_t A3 = ADC_A3;
static const uint8_t A4 = ADC_A4;
static const uint8_t A5 = ADC_A5;
static const uint8_t A6 = ADC_A6;
static const uint8_t A7 = ADC_A7;
/*
* Serial interfaces
*
* RX and TX are required.
* If you have no serial port, use unused pins
* CTS and RTS are optional.
*/
#define PIN_SERIAL_RX (11)
#define PIN_SERIAL_TX (12)
#ifdef __cplusplus
}
#endif
#endif
แแแแแแ แแแแแก แแฅแแก แกแแแกแแ แฃแแ แฆแแแแแ แแ แขแแฅแขแแก แฆแแแแแ แแแฌแงแแแแแแแแก แฃแแแแ แแฎแแ แแก. แแก แขแแฅแขแแแแ แฆแแแแแ แแแแแงแแแแแฃแแ แแฅแแแแ แกแแ แแแกแแก แ แแแแแแแแกแแแแก, แกแแฐแแแ แ แแแแแแจแแ แแแแก แ แแแแแแกแแแแก แแ แแแฌแงแแแแแแแแก แแแแแขแแแ แแแแกแแแแก. แฆแแแแแก แแฅแแก แ แแแแแก แกแแฌแแแแแฆแแแแแ แคแฃแแฅแชแแ. แขแแแแแแแแก แกแแแกแแ แแก แฎแแแ แแ แกแแแแแก แฆแแแแแแก แฎแแแ แแแแแแจแแ แแแฃแแแ Schottky แแแแแแแแก แกแแจแฃแแแแแแ แแ แฃแแแแจแแ แแแแ แแแแแแแฃแ แแแแก p0.05, แแกแแแ แขแแแแแแแแก แกแแแกแแ แแแแ แแ แกแแแแแก แฆแแแแแแแแ แแ แแก แฎแแแแแ MK แฅแแแซแแกแแแแแแ p0.25 แแ p0.27. .0.05 แแแแแแแ แแแแแแแก แฌแแกแแแแแฎแแ p0.05 pXNUMX-แแ แจแแฌแงแแแขแแก แแแแฅแขแแฃแ แแแแก แจแแแแแ. PXNUMX แแแแแ แแแแฅแขแแฃแ แแแฃแแแ แจแแฌแงแแแขแ แจแแแแ แแแแก (NRF_LPCOMP) แแแจแแแแแแ EVENTS_UP. แแแแฆแ แจแแแแแแแแ แแ แแแแแแแก แแแแแกแแญแ แแแแ
แแแแแแ แแแแแ แแแแแแขแ Mysensors แฅแกแแแก, แ แแแแแกแแช แแแ แแแแก แญแแแแแแ แกแแฎแแแก แแแแขแ แแแแ แ Majordomo (
PHP แแแแ แกแขแแขแฃแกแแก แแแแแฎแแแแแก แแแแแแแ แแแแแแ แแแแแแก แแแกแแแแขแแแแแ
if (getGlobal("MysensorsButton01.status")==1) {
if (getGlobal('MysensorsRelay04.status') == 0) {
setGlobal('MysensorsRelay04.status', '1');
} else if (getGlobal('MysensorsRelay04.status') == 1) {
setGlobal('MysensorsRelay04.status', '0');
}
}
แจแแแแแ แแฎแแแแ แแแแแแจแ
แแแแแแแแแแแ, แแแ แแแแขแ แแแแแแแ แแแแแซแแแแ แแแแแก แแแแแแงแแแแแ, แแแแ แแ แแก แแ แแ แแก แแแแแแจแแ แแแฃแแ TTP223 แขแแแแแแแแก แแแแ แแกแฅแแแแก แแฃแจแแแแแกแแแ; แแแขแ แกแฃแ แแแแแ แแแ แแ แแ แแ แแแแแ แแแแแ แแแแแแแแแกแแแ แฆแแแแแแแแก แแแญแแ แแกแแก แแแขแแ แแแก แแแแแ แแแ แแแแแก แแแแแแแแแแแจแ.
แแแ แแแแ
แแ แแแฅแขแ Github -
แ แฃแกแฃแแแแแแแแ
แ แแแแแแแแ แคแแขแ
แฌแงแแ แ: www.habr.com