Initial implementation

Author: nilscc

.gitignore

@@ -0,0 +1,7 @@
+*.swp
+*.pyc
+*.cpp
+*.c
+*.egg-info/
+dist/
+build/

Makefile

@@ -0,0 +1,18 @@
+.PHONY: all build install test clean uninstall
+
+all: install test
+
+build:
+	python3 setup.py build
+
+install:
+	python3 setup.py install --user
+
+uninstall:
+	pip3 uninstall am2302 -y
+
+test:
+	pytest
+
+clean:
+	rm -r build/ dist/ *.egg-info/ *.cpp *.c

am2302.pxd

@@ -0,0 +1,31 @@
+from libc.stdint cimport uint8_t, uint16_t, uint32_t
+from libcpp cimport bool
+
+cdef extern from 'wiringPi.h':
+    int wiringPiSetup()
+
+    int INPUT
+    int OUTPUT
+    void pinMode(int, int)
+
+    int HIGH
+    int LOW
+    void digitalWrite(int, int)
+    int digitalRead(int)
+
+    void delay(unsigned int)
+    void delayMicroseconds(unsigned int)
+
+cdef extern from 'am2302_py.hpp':
+
+    cdef cppclass CReader:
+        int m_pin
+        uint32_t m_start1, m_start2, m_start3
+        uint16_t m_temperature, m_humidity
+        uint8_t m_parity
+        bool m_tempDone, m_humidityDone, m_parityDone
+        int m_awaitLevel
+        int m_awaitBit
+        uint32_t m_awaitDuration
+
+        bool run()

am2302.pyx

@@ -0,0 +1,97 @@
+from libc.stdint cimport uint8_t
+from libcpp cimport bool
+
+cimport am2302
+
+cdef bool _initialized = False
+
+def setup():
+    global _initialized
+    if not _initialized:
+        wiringPiSetup()
+        _initialized = True
+
+def initialized():
+    return _initialized
+
+cdef class Reader:
+    cdef am2302.CReader m_reader
+
+    def __init__(self, pin=7):
+        self.m_reader.m_pin = pin
+
+    def run(self):
+        return self.m_reader.run()
+
+    # Main output properties
+
+    @property
+    def temperature(self):
+        t = self.m_reader.m_temperature
+        if t & 0x8000:
+            t = (~t + 1) | 0x8000
+        return float(t) / 10.0
+
+    @property
+    def humidity(self):
+        return float(self.m_reader.m_humidity) / 10.0
+
+    @property
+    def parity(self):
+        return self.m_reader.m_parity
+
+    @property
+    def valid(self):
+        h = self.m_reader.m_humidity
+        t = self.m_reader.m_temperature
+        p = self.m_reader.m_parity
+        return (((h >> 8) + h + (t >> 8) + t) & 0xFF) == p
+
+    # Debug properties
+
+    @property
+    def start1(self):
+        return self.m_reader.m_start1
+    @property
+    def start2(self):
+        return self.m_reader.m_start2
+    @property
+    def start3(self):
+        return self.m_reader.m_start3
+
+    @property
+    def tempDone(self):
+        return self.m_reader.m_tempDone
+    @property
+    def humidityDone(self):
+        return self.m_reader.m_humidityDone
+    @property
+    def parityDone(self):
+        return self.m_reader.m_parityDone
+
+    @property
+    def awaitLevel(self):
+        return self.m_reader.m_awaitLevel
+
+    @property
+    def awaitDuration(self):
+        return self.m_reader.m_awaitDuration
+
+    @property
+    def awaitBit(self):
+        return self.m_reader.m_awaitBit
+
+class am3202_data:
+    def __init__(self, temperature, humidity):
+        self.temperature = temperature
+        self.humidity = humidity
+
+def read(pin=7, retries=10):
+    setup()
+    reader = Reader(pin)
+    for r in range(retries):
+        if reader.run() and reader.valid:
+            return am3202_data(
+                temperature=reader.temperature, 
+                humidity=reader.humidity,
+            )

inc/am2302_py.hpp

@@ -0,0 +1,149 @@
+#include <wiringPi.h>
+#include <cstdint>
+
+class CTimer
+{
+    private:
+        const uint32_t m_t0;
+
+    public:
+
+        CTimer() : m_t0(micros()) {}
+
+        uint32_t duration() const {
+            const uint32_t t = micros();
+            // check if we wrapped
+            if (t < m_t0)
+                return 0xFFFFFFFF - m_t0 + t + 1;
+            else
+                return t - m_t0;
+        }
+};
+
+template <typename T>
+struct CBitLength { static const uint8_t bitLength = 0U; };
+
+template <>
+struct CBitLength<uint8_t> { static const uint8_t bitLength = 8U; };
+
+template <>
+struct CBitLength<uint16_t> { static const uint8_t bitLength = 16U; };
+
+class CReader
+{
+    public:
+        int m_pin;
+
+        uint32_t m_start1, m_start2, m_start3;
+
+        uint16_t m_temperature, m_humidity;
+        uint8_t m_parity;
+
+        bool m_tempDone, m_humidityDone, m_parityDone;
+
+        int m_awaitLevel;
+        int m_awaitBit;
+        uint32_t m_awaitDuration;
+
+        CReader()
+            : m_pin(0)
+            , m_start1(0U)
+            , m_start2(0U)
+            , m_start3(0U)
+            , m_temperature(0U)
+            , m_humidity(0U)
+            , m_parity(0U)
+            , m_tempDone(false)
+            , m_humidityDone(false)
+            , m_parityDone(false)
+            , m_awaitLevel(-1)
+            , m_awaitBit(-1)
+            , m_awaitDuration(0U)
+        {}
+
+    private:
+
+        bool await(int level, uint32_t min, uint32_t max, uint32_t *count = nullptr) {
+            const CTimer l_timer;
+            while (l_timer.duration() < max) {
+                if (digitalRead(m_pin) == level) {
+                    const auto duration = l_timer.duration();
+                    if (count != nullptr)
+                        *count = duration;
+                    if (duration >= min)
+                        return true;
+                    else {
+                        // store debug info
+                        m_awaitLevel = level;
+                        m_awaitDuration = duration;
+                        return false;
+                    }
+                }
+                delayMicroseconds(1);
+            }
+
+            // store debug info
+            m_awaitLevel = level;
+            m_awaitDuration = l_timer.duration();
+            return false;
+        }
+
+        void low() { digitalWrite(m_pin, LOW); }
+        void high() { digitalWrite(m_pin, HIGH); }
+        void input() { pinMode(m_pin, INPUT); }
+        void output() { pinMode(m_pin, OUTPUT); }
+
+        template <typename T>
+        bool receive(T *f_val) {
+            for (int i = 0; i < CBitLength<T>::bitLength; ++i) {
+                if (!await(HIGH, 0U, 100U)) {
+                    m_awaitBit = i;
+                    return false;
+                }
+
+                uint32_t l_count;
+                if (!await(LOW, 0U, 100U, &l_count))
+                    return false;
+
+                if (l_count > 50)
+                    *f_val |= (1U << (CBitLength<T>::bitLength - 1 - i));
+            }
+            return true;
+        }
+
+        bool start()
+        {
+            output();
+            low();
+            delay(3);
+            input();
+            return await(LOW, 0U, 100U, &m_start1)
+                && await(HIGH, 50U, 120U, &m_start2)
+                && await(LOW, 50U, 120U, &m_start3);
+        }
+
+        bool receiveTemp() {
+            const bool l_res = receive(&m_temperature);
+            m_tempDone = true;
+            return l_res;
+        }
+        bool receiveHumidity() {
+            const bool l_res = receive(&m_humidity);
+            m_humidityDone = true;
+            return l_res;
+        }
+        bool receiveParity() {
+            const bool l_res = receive(&m_parity);
+            m_parityDone = true;
+            return l_res;
+        }
+
+    public:
+
+        bool run() {
+            return start()
+                && receiveHumidity()
+                && receiveTemp()
+                && receiveParity();
+        }
+};

readme.md

@@ -0,0 +1,12 @@
+Install
+#######
+
+Install all requirements:
+
+    pip3 install -r requirements.txt
+
+Then run `setup.py`:
+
+    python3 setup.py install
+
+Run with the `--user` flag to install without root rights.

requirements.txt

@@ -0,0 +1,2 @@
+cython
+pytest

setup.py

@@ -0,0 +1,25 @@
+import setuptools
+import Cython.Build
+
+class BinaryDistribution(setuptools.Distribution):
+    def is_pure(self):
+        return False
+
+setuptools.setup(
+    name='am2302',
+    version='0.1.0',
+    distclass=BinaryDistribution,
+
+    ext_modules=Cython.Build.cythonize([
+        setuptools.Extension(
+            name='am2302',
+            language='c++',
+            sources=['am2302.pyx'],
+            include_dirs=['inc'],
+            #library_dirs=['lib'],
+            libraries=['wiringPi'],
+            #define_macros=[],
+            #extra_compile_args=[],
+        ),
+    ], language_level=3),
+)

test/test_read.py

@@ -0,0 +1,23 @@
+import time
+import am2302
+
+def test_read():
+    # sleep a lil so we don't overload the sensor
+    time.sleep(1)
+
+    assert not am2302.initialized()
+
+    # read data
+    d = am2302.read()
+
+    # everything should be initialized
+    assert am2302.initialized()
+
+    # result should be valid
+    assert d is not None
+
+    # some simple range checks
+    assert d.humidity >= 0.0
+    assert d.humidity <= 100.0
+    assert d.temperature >= -50.0
+    assert d.temperature <= 100.0