Простой беспроводной метеодатчик на Attiny13

#ifndef _TINYDHT_H_
#define _TINYDHT_H_

#include <avr/io.h>
#include <util/delay.h>

#ifndef TDHT_DDR_REG
#define TDHT_DDR_REG DDRB
#endif
#ifndef TDHT_PORT_REG
#define TDHT_PORT_REG PORTB
#endif
#ifndef TDHT_PIN_REG
#define TDHT_PIN_REG PINB
#endif
#ifndef TDHT_ONE_DELAY_US
#define TDHT_ONE_DELAY_US 30
#endif
#ifndef TDHT_READ_ATTEMPTS
#define TDHT_READ_ATTEMPTS 2
#endif

#define _tdhtPinLow(pin) TDHT_PORT_REG &= ~(1 << pin)
#define _tdhtPinHigh(pin) TDHT_PORT_REG |= (1 << pin)
#define _tdhtPinToOut(pin) TDHT_DDR_REG |= (1 << pin)
#define _tdhtPinToIn(pin) TDHT_DDR_REG &= ~(1 << pin)
#define _tdhtGetPinValue(pin) (TDHT_PIN_REG & (1 << pin))

static inline void _tdhtPinChangeWait(uint8_t pin, uint8_t currentState) {
  uint8_t counter = 0;
  while ((!_tdhtGetPinValue(pin)) != currentState && ++counter < 255) {
    _delay_us(1);
  }
}

static inline uint8_t _tdhtReadRawData(uint8_t pin, uint16_t sensorDelay, uint8_t *raw_data_buffer) {
  _delay_ms(sensorDelay);

  _tdhtPinToOut(pin);
  _tdhtPinLow(pin);
  _delay_ms(20);

  _tdhtPinToIn(pin);
  _tdhtPinHigh(pin);

  _tdhtPinChangeWait(pin, 1);
  _tdhtPinChangeWait(pin, 0);
  _tdhtPinChangeWait(pin, 1);

  for (uint8_t i = 0; i < 5; i++) {
    for (uint8_t j = 0; j < 8; j++) {
      _tdhtPinChangeWait(pin, 0);
      raw_data_buffer[i] <<= 1;
      _delay_us(TDHT_ONE_DELAY_US);
	  if (_tdhtGetPinValue(pin)) {
	    raw_data_buffer[i] |= 1;
	    _tdhtPinChangeWait(pin, 1);
	  }
    }
  }

  return (raw_data_buffer[4] == (uint8_t) (raw_data_buffer[0] + raw_data_buffer[1] + raw_data_buffer[2] + raw_data_buffer[3]));
}

static inline uint8_t tdhtReadDataDHT11(uint8_t pin, int16_t *temperature, uint16_t *humidity) {
  uint8_t raw_data[5] = {0, 0, 0, 0, 0};
  for (uint8_t i = 0; i < TDHT_READ_ATTEMPTS; i++) {
    if (_tdhtReadRawData(pin, 1500, raw_data)) {
      *temperature = (uint16_t) raw_data[2] * 10;
      *humidity = (uint16_t) raw_data[0] * 10;
      if (i > 0) return 1;
    }
  }
  return 0;
}

static inline uint8_t tdhtReadDataDHT22(uint8_t pin, int16_t *temperature, uint16_t *humidity) {
  uint8_t raw_data[5] = {0, 0, 0, 0, 0};
  for (uint8_t i = 0; i < TDHT_READ_ATTEMPTS; i++) {
    if (_tdhtReadRawData(pin, 2000, raw_data)) {
      *temperature = ((uint16_t) raw_data[2] << 8) | raw_data[3];
      *humidity = ((uint16_t) raw_data[0] << 8) | raw_data[1];
      if (i > 0) return 1;
    }
  }
  return 0;
}

#endif /* _TINYDHT_H_ */

/*
 * WeatherSensor.cpp
 *
 * Created: 14.09.2021 15:13:19
 * Author : SinuX
 */ 

#define F_CPU 1200000UL		// 1.2 MHz

#define TRF_TX_PIN      PB4	// Передатчик на 4 пине
#define TRF_DATA_SIZE   4	// Размер посылки 4 байта
#define TRF_RX_DISABLED	// Исключаем приемную часть TinyRF для экономии места

#define DHT22			// Тип датчика: DHT22/AM2320
#define DHT_PIN PB0		// Датчик на 0 пине

// Контакты VCC датчика и передатчика
#define TX_VCC_PIN	PB3
#define DHT_VCC_PIN	PB1

// Множитель циклов сна (значения от 1 до 255) позволяет настраивать интервал отправки данных от 8 секунд до 34 минут
#define SLEEP_MULTIPLIER 5  // Просыпаемся и отправляем инфу раз в 5 * 8 = 40 секунд
#define SENSOR_ID 0                // ID метеодатчика (значения от 0 до 7)

#include "tinydht.h"
#include "tinyrf.h"
#include <stdlib.h>
#include <avr/sleep.h>
#include <avr/wdt.h>

typedef union {
	struct {
		uint8_t sensorId : 3;
		uint8_t temperatureSign : 1;
		uint16_t temperature : 10;
		uint16_t humidity : 10;
		uint8_t checksum : 8;
	};
	uint8_t dataBytes[4];
	uint32_t data;
} TxData;

uint8_t volatile wakeupCounter = 0;

void sendData(int16_t temperature, uint16_t humidity) {
	TxData txData;
	txData.data = 0;
	txData.sensorId = SENSOR_ID;
	txData.temperatureSign = temperature < 0 ? 1 : 0;
	txData.temperature = abs(temperature);
	txData.humidity = humidity;
	txData.checksum = txData.sensorId + txData.temperatureSign + txData.temperature + txData.humidity;
	
	// Включаем передатчик и отправляем данные
	trf_init();
	PORTB |= (1 << TX_VCC_PIN);
	trf_send(txData.dataBytes);
}

ISR (WDT_vect) {
	// Если не настало время отправки - погружаемся обратно в сон
	if (++wakeupCounter < SLEEP_MULTIPLIER) {
		return;
	}
	
	wakeupCounter = 0;
	
	// Временно отключаем ватчдог, чтобы он не сбросил МК в процессе получения значений
	wdt_disable();
	
	// Включаем датчик и пытаемся получить данные
	PORTB |= (1 << DHT_VCC_PIN);
	int16_t temperature = 0;
	uint16_t humidity = 0;
	uint8_t readResult = 0;
	
	// DHT11
	#ifdef DHT11
	readResult = tdhtReadDataDHT11(DHT_PIN, &temperature, &humidity);
	#endif

	// DHT22
	#ifdef DHT22
	readResult = tdhtReadDataDHT22(DHT_PIN,  &temperature, &humidity);
	#endif
	
	// Отключаем датчик и отправляем инфу
	PORTB &= ~(1 << DHT_VCC_PIN);
	if (readResult) {
		sendData(temperature, humidity);
	}
}

int main(void) {
	DDRB |= (1 << TX_VCC_PIN);
	DDRB |= (1 << DHT_VCC_PIN);

	wdt_reset();
	sei();
	set_sleep_mode(SLEEP_MODE_PWR_DOWN);
	
	while(1) {
		// Отключаем пины, заводим "будильник" на 8 секунд и выключаемся
		PORTB = 0;
		wdt_enable(WDTO_8S);
		WDTCR |= (1 << WDTIE);
		sleep_enable();
		sleep_cpu();
	}
}

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();
unsigned long lastValue;

union {
  struct {
    uint8_t sensorId : 3;
    uint8_t temperatureSign : 1;
    uint16_t temperature : 10;
    uint16_t humidity : 10;
    uint8_t checksum : 8;
  };
  byte dataBytes[4];
} RxData;

void setup() {
  Serial.begin(9600);
  mySwitch.enableReceive(0);  // Receiver on interrupt 0 => that is pin #2
}

void loop() {
  if (mySwitch.available()) {
    unsigned long value = mySwitch.getReceivedValue();
    // Получена новая посылка, отличная от предыдущей
    if (lastValue != value) {
      lastValue = value;

      // Переворачиваем байты посылки
      for (int8_t i = 3; i >= 0; i--) {
        RxData.dataBytes[i] = (byte) value;
        value >>= 8;
      }
      
      // Выводим на экран, если контрольная сумма верна
      if (RxData.checksum == (byte)(RxData.sensorId + RxData.temperatureSign + RxData.temperature + RxData.humidity)) {
        Serial.print("Sensor: ");
        Serial.print(RxData.sensorId);
        Serial.print(", Temp: ");
        Serial.print(RxData.temperatureSign ? "-" : "");
        Serial.print(RxData.temperature / 10);
        Serial.print(".");
        Serial.print(RxData.temperature % 10);
        Serial.print("ºC, Humid: ");
        Serial.print(RxData.humidity / 10);
        Serial.print(".");
        Serial.print(RxData.humidity % 10);
        Serial.println("%");
      }
    }
    
    mySwitch.resetAvailable();
  }
}