#include <DHT.h>

#define   DHTPIN    3
#define DHTTYPE    DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  // put your setup code here, to run once:

  Serial.begin(9600);

  dht.begin();

  Serial.println("Hi Vcancy. Arduino is running...");

}

/**
  Arduino loop
  @param none
  @return none
*/
char target[] = "GET TH";

void loop() {
  // 每次等待2秒后再输出（这里必须等大于1秒，不然不准确）
  delay(2000);
  // 从串口读数据并判断
  if (Serial.available() > 0) {
    if ( Serial.find(target)) {
      // 获取温度或者湿度需要250毫秒!
      // 传感器获取到的温度和湿度可能是2秒内的

      float h = dht.readHumidity();// 读取当前的湿度

      float t = dht.readTemperature(); // 读取当前的温度，单位C

      float f = dht.readTemperature(true);//读取当前的温度，单位F

      // 如果读取失败则退出，再读取一次
      if (isnan(h) || isnan(t) || isnan(f)) {
        Serial.println("Failed to read from DHT sensor!");
        return;
      }

      // 读取体感温度，单位F
      float hif = dht.computeHeatIndex(f, h);
      // 读取体感温度，单位C
      float hic = dht.computeHeatIndex(t, h, false);

      Serial.print("湿度: ");
      Serial.print(h);
      Serial.print(" %\t");
      Serial.print("温度: ");
      Serial.print(t);
      Serial.print(" *C ");
      Serial.print(f);
      Serial.print(" *F\t");
      Serial.print("体感温度: ");
      Serial.print(hic);
      Serial.print(" *C ");
      Serial.print(hif);
      Serial.println(" *F");
    }
  }

}

import serial
ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=1)

try:
    while 1:
        ser.write(b"GET TH")
        response = str(ser.readline().decode())
        if response.startswith('湿度:'):
            print(response.strip('\n'))
except KeyboardInterrupt:
    ser.close()

class ConnectionPool(object):
    def __init__(self, size, **kwargs):
        if not isinstance(size, int):
            raise TypeError("Pool 'size' arg must be an integer")

        if not size > 0:
            raise ValueError("Pool 'size' arg must be greater than zero")

        logger.debug(
            "Initializing connection pool with %d connections", size)

        self._lock = threading.Lock()
        self._queue = queue.LifoQueue(maxsize=size)
        self._thread_connections = threading.local()

        connection_kwargs = kwargs
        connection_kwargs['autoconnect'] = False

        for i in range(size):
            connection = Connection(**connection_kwargs)
            self._queue.put(connection)

        # The first connection is made immediately so that trivial
        # mistakes like unresolvable host names are raised immediately.
        # Subsequent connections are connected lazily.
        with self.connection():
            pass

try:
    # Open connection, because connections are opened lazily.
    # This is a no-op for connections that are already open.
    connection.open()

    # Return value from the context manager's __enter__()
    yield connection

    connection.close()

except (TException, socket.error):
    # Refresh the underlying Thrift client if an exception
    # occurred in the Thrift layer, since we don't know whether
    # the connection is still usable.
    logger.info("Replacing tainted pool connection")
    connection._refresh_thrift_client()
    if autoconnect:
        connection.open()

import happybase
import time

def put(pool,data):
    with pool.connection() as conn:
        table = conn.table('Log')
        row_key = str(int(time.time())) + '000001'
        data = data
        table.put(row_key, data)

if __name__ == '__main__':
    pool = happybase.ConnectionPool(size=3, host='127.0.0.1', table_prefix='TL')
    put(pool,{})
    time.sleep(60) # 模拟间隔时间
    put(pool, {})

@contextlib.contextmanager
def connection(self, timeout=None):
    connection = getattr(self._thread_connections, 'current', None)
    return_after_use = False
    if connection is None:
        return_after_use = True
        connection = self._acquire_connection(timeout)
        with self._lock:
            self._thread_connections.current = connection
    try:
        connection.open()
        yield connection
    except (TException, socket.error):
        logger.info("Replacing tainted pool connection")
        connection._refresh_thrift_client()
        connection.open()
        raise
    finally:
        if return_after_use:
            del self._thread_connections.current
            self._return_connection(connection)

import happybase
import time

def put(pool,data):
    with pool.connection() as conn:
        table = conn.table('Log')
        row_key = str(int(time.time())) + '000001'
        data = data
        table.put(row_key, data)
        conn.close() # 关闭连接

if __name__ == '__main__':
    pool = happybase.ConnectionPool(size=3, host='127.0.0.1', table_prefix='TL')
    put(pool,{})
    time.sleep(60) # 模拟间隔时间
    put(pool, {})

docker ps 表示查看当前正在运行的容器 

-a，查看所有容器包括停止状态的容器 

-l，查看最新创建的容器 

-n=x，查看最后创建的x个容器

将文件里的默认的官方软件源用# 注释掉,添加以下：

```deb http://mirrors.ustc.edu.cn/raspbian/raspbian/ stretch main contrib non-free rpi

将文件里的默认的官方软件源用# 注释掉,添加以下：

```deb http://mirrors.ustc.edu.cn/archive.raspberrypi.org/ stretch main ui

echo "deb [arch=armhf] https://download.docker.com/linux/debian \

    $(lsb_release -cs) stable" | \

    sudo tee /etc/apt/sources.list.d/docker.list

### 安装docker

```sudo apt-get install docker-ce

{

  "registry-mirrors": [

    "https://registry.docker-cn.com"

  ]

}

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

engine = create_engine('sqlite:///:memory:', echo=True)
DB_Session = sessionmaker(bind=engine)
session = DB_Session()

from sqlalchemy.orm import scoped_session
from sqlalchemy.orm import sessionmaker
from contextlib import contextmanager
from sqlalchemy import create_engine, MetaData

# 线程安全session
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3306/mydb?charset=utf8")

session_factory = sessionmaker(bind=engine)
sc_session = scoped_session(session_factory)

@contextmanager
def session_scope():
    """Provide a transactional scope around a series of operations."""
    session = sc_session()
    try:
        yield session
    except:
        raise
    finally:
        sc_session.remove()