smartpi 1.1.3__py3-none-any.whl → 1.1.4__py3-none-any.whl

smartpi/color_sensor.py

@@ -1,18 +0,0 @@
-# coding=utf-8
-import time
-from typing import List, Optional
-from smartpi import base_driver
-
-#��ɫ��ȡ  ��������ֵ��1-��ɫ��2-��ɫ��3-��ɫ��4-��ɫ��5-��ɫ��6-��ɫ��  ��ȡ����-1  
-def get_value(port:bytes) -> Optional[bytes]:
-    color_str=[0xA0, 0x04, 0x00, 0xBE]
-    color_str[0]=0XA0+port
-    color_str[2]=1
-    time.sleep(0.005)
-    response = base_driver.single_operate_sensor(color_str,0)        
-    if response == None:
-        return None
-    else:
-        return response[4]
-        
-        

smartpi/cw2015.py

@@ -1,179 +0,0 @@
-#!/usr/bin/env python3
-import os
-import sys
-import fcntl
-import time
-
-# I2C设备文件路径
-I2C_DEV_PATH = "/dev/i2c-2"  # 根据实际情况修改总线号
-
-# I2C从设备地址
-CW2015_ADDR = 0x62  # 7位地址
-
-# I2C通信常量
-I2C_SLAVE = 0x0703
-I2C_SMBUS = 0x0720  # SMBus传输
-
-# SMBus命令结构
-class i2c_smbus_ioctl_data:
-    def __init__(self, read_write, command, size, data):
-        self.read_write = read_write  # 0 = write, 1 = read
-        self.command = command        # 寄存器地址
-        self.size = size              # 数据大小
-        self.data = data              # 数据指针
-
-# 寄存器地址定义
-VERSION = 0x00
-VCELL_H = 0x02
-VCELL_L = 0x03
-SOC_B = 0x04
-SOC = 0x05
-RRT_H = 0x06
-RRT_L = 0x07
-CONFIG = 0x08
-MOOD = 0x0A
-
-class I2CDevice:
-    """通过设备文件直接访问I2C设备"""
-    def __init__(self, device_path, device_addr):
-        """
-        初始化I2C设备
-        :param device_path: I2C设备文件路径 (例如 "/dev/i2c-2")
-        :param device_addr: I2C从设备地址 (7位地址)
-        """
-        self.device_path = device_path
-        self.device_addr = device_addr
-        self.fd = None
-        
-        try:
-            # 打开设备文件
-            self.fd = os.open(device_path, os.O_RDWR)
-            # 设置从设备地址
-            fcntl.ioctl(self.fd, I2C_SLAVE, device_addr)
-            #print(f"成功打开 {device_path} 并设置地址 0x{device_addr:02X}")
-        except Exception as e:
-            print(f"打开I2C设备失败: {e}")
-            if self.fd:
-                os.close(self.fd)
-            sys.exit(1)
-    
-    def __del__(self):
-        """关闭设备文件"""
-        if self.fd:
-            os.close(self.fd)
-    
-    def write_byte(self, reg_addr, value):
-        """
-        向寄存器写入一个字节
-        :param reg_addr: 寄存器地址
-        :param value: 要写入的值
-        :return: 成功返回True，失败返回False
-        """
-        try:
-            # 构造写入数据：寄存器地址 + 值
-            data = bytes([reg_addr, value])
-            os.write(self.fd, data)
-            return True
-        except Exception as e:
-            print(f"写入寄存器0x{reg_addr:02X}失败: {e}")
-            return False
-    
-    def read_byte(self, reg_addr):
-        """
-        从寄存器读取一个字节
-        :param reg_addr: 寄存器地址
-        :return: 读取到的字节值，失败返回0
-        """
-        try:
-            # 先写入寄存器地址
-            os.write(self.fd, bytes([reg_addr]))
-            # 然后读取一个字节
-            value = os.read(self.fd, 1)
-            return value[0] if value else 0
-        except Exception as e:
-            print(f"读取寄存器0x{reg_addr:02X}失败: {e}")
-            return 0
-    
-    def read_word(self, reg_addr):
-        """
-        从寄存器读取两个字节（先高字节后低字节）
-        :param reg_addr: 寄存器地址（高字节寄存器）
-        :return: (高字节 << 8) | 低字节
-        """
-        try:
-            # 先写入寄存器地址
-            os.write(self.fd, bytes([reg_addr]))
-            # 读取两个字节
-            data = os.read(self.fd, 2)
-            if len(data) == 2:
-                return (data[0] << 8) | data[1]
-            else:
-                return 0
-        except Exception as e:
-            print(f"读取寄存器0x{reg_addr:02X}失败: {e}")
-            return 0
-
-class CW2015:
-    """CW2015电池监测芯片驱动"""
-    def __init__(self, i2c_dev_path=I2C_DEV_PATH, i2c_addr=CW2015_ADDR):
-        """
-        初始化CW2015
-        :param i2c_dev_path: I2C设备路径
-        :param i2c_addr: I2C地址
-        """
-        self.device = I2CDevice(i2c_dev_path, i2c_addr)
-    
-    def init(self):
-        """初始化芯片配置"""
-        # 写入配置
-        if not self.device.write_byte(CONFIG, 0x50):
-            print("配置寄存器写入失败")
-            return False
-        if not self.device.write_byte(MOOD, 0x00):
-            print("模式寄存器写入失败")
-            return False
-        
-        time.sleep(0.05)  # 50ms延时
-        #print("CW2015初始化完成")
-        return True
-    
-    def get_id(self):
-        """获取芯片ID"""
-        return self.device.read_byte(VERSION)
-    
-    def get_voltage(self):
-        """读取电池电压(mV)"""
-        # 读取电压高字节寄存器
-        vh = self.device.read_byte(VCELL_H)
-        # 读取电压低字节寄存器
-        vl = self.device.read_byte(VCELL_L)
-        
-        # 组合14位ADC值
-        adc_value = ((vh & 0x3F) << 8) | vl
-        # 转换为电压值 (305μV/LSB)
-        voltage = adc_value * 305 / 1000
-        return int(voltage)
-    
-    def get_soc(self, mode=0):
-        """读取电池剩余电量"""
-        if mode == 0:
-            return self.device.read_byte(SOC_B)  # 百分比整数
-        else:
-            return self.device.read_byte(SOC)     # 高精度值
-    
-    def get_remaining_time(self):
-        """获取剩余工作时间(分钟)"""
-        # 读取时间高字节寄存器
-        rh = self.device.read_byte(RRT_H)
-        # 读取时间低字节寄存器
-        rl = self.device.read_byte(RRT_L)
-        
-        # 提取剩余时间（13位）
-        remaining_time = ((rh & 0x1F) << 8) | rl
-        return remaining_time
-    
-    def get_alert_status(self):
-        """获取告警状态"""
-        rh = self.device.read_byte(RRT_H)
-        return (rh >> 7) & 0x01
-

smartpi/flash.py

@@ -1,130 +0,0 @@
-import os
-import struct
-import fcntl
-
-# 配置文件路径 (当前目录下的flash.bin)
-FLASH_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "/home/Interface/flash/flash.bin")
-FLASH_FILE_2 = os.path.join(os.path.dirname(os.path.abspath(__file__)), "/home/Interface/flash/flash_2.bin")
-
-DATA_SIZE = 2  # 每个数据2字节
-TOTAL_SLOTS = 120  # 100个数据槽
-
-def _init_flash_file():
-    """初始化存储文件"""
-    if not os.path.exists(FLASH_FILE):
-        with open(FLASH_FILE, "wb") as f:
-            f.write(b'\x00' * DATA_SIZE * TOTAL_SLOTS)
-
-def write(address, data):
-    """
-    写入数据到指定地址
-    :param address: 地址编号 (1-100)
-    :param data: 要写入的整数数据 (2字节范围)
-    """
-    if not 1 <= address <= TOTAL_SLOTS:
-        raise ValueError(f"地址必须在1-{TOTAL_SLOTS}范围内")
-    
-    # 2字节数据范围: 0-65535 (0xFFFF)
-    if not 0 <= data <= 0xFFFF:
-        raise ValueError("数据必须在0-65535范围内")
-    
-    _init_flash_file()
-    
-    # 计算文件偏移量 (每个地址2字节)
-    offset = (address - 1) * DATA_SIZE
-    
-    with open(FLASH_FILE, "r+b") as f:
-        # 使用文件锁确保写入安全
-        fcntl.flock(f, fcntl.LOCK_EX)
-        f.seek(offset)
-        # 将整数打包为2字节小端格式
-        f.write(struct.pack('<H', data))
-        f.flush()
-        fcntl.flock(f, fcntl.LOCK_UN)
-
-def read(address):
-    """
-    从指定地址读取数据
-    :param address: 地址编号 (1-100)
-    :return: 读取到的整数数据
-    """
-    if not 1 <= address <= TOTAL_SLOTS:
-        raise ValueError(f"地址必须在1-{TOTAL_SLOTS}范围内")
-    
-    _init_flash_file()
-    
-    offset = (address - 1) * DATA_SIZE
-    
-    with open(FLASH_FILE, "rb") as f:
-        fcntl.flock(f, fcntl.LOCK_SH)  # 共享锁
-        f.seek(offset)
-        # 读取2字节并解包为整数
-        data_bytes = f.read(DATA_SIZE)
-        fcntl.flock(f, fcntl.LOCK_UN)
-        
-        if len(data_bytes) != DATA_SIZE:
-            return 0  # 返回默认值0
-            
-        return struct.unpack('<H', data_bytes)[0]
-
-# 可选扩展功能
-def erase_all():
-    """擦除所有数据(重置为0)"""
-    with open(FLASH_FILE, "wb") as f:
-        f.write(b'\x00' * DATA_SIZE * TOTAL_SLOTS)
-        
-            
-def _init_flash_file_2():
-    """初始化存储文件"""
-    if not os.path.exists(FLASH_FILE_2):
-        with open(FLASH_FILE_2, "wb") as f:
-            f.write(b'\x00' * DATA_SIZE * TOTAL_SLOTS)
-        
-def write_2(address, data):
-    if not 1 <= address <= TOTAL_SLOTS:
-        raise ValueError(f"地址必须在1-{TOTAL_SLOTS}范围内")
-    
-    # 2字节数据范围: 0-65535 (0xFFFF)
-    if not 0 <= data <= 0xFFFF:
-        raise ValueError("数据必须在0-65535范围内")
-    
-    _init_flash_file_2()
-    
-    # 计算文件偏移量 (每个地址2字节)
-    offset = (address - 1) * DATA_SIZE
-    
-    with open(FLASH_FILE_2, "r+b") as f:
-        # 使用文件锁确保写入安全
-        fcntl.flock(f, fcntl.LOCK_EX)
-        f.seek(offset)
-        # 将整数打包为2字节小端格式
-        f.write(struct.pack('<H', data))
-        f.flush()
-        fcntl.flock(f, fcntl.LOCK_UN)
-
-def read_2(address):
-    if not 1 <= address <= TOTAL_SLOTS:
-        raise ValueError(f"地址必须在1-{TOTAL_SLOTS}范围内")
-    
-    _init_flash_file_2()
-    
-    offset = (address - 1) * DATA_SIZE
-    
-    with open(FLASH_FILE_2, "rb") as f:
-        fcntl.flock(f, fcntl.LOCK_SH)  # 共享锁
-        f.seek(offset)
-        # 读取2字节并解包为整数
-        data_bytes = f.read(DATA_SIZE)
-        fcntl.flock(f, fcntl.LOCK_UN)
-        
-        if len(data_bytes) != DATA_SIZE:
-            return 0  # 返回默认值0
-            
-        return struct.unpack('<H', data_bytes)[0]
-
-# 可选扩展功能
-def erase_all_2():
-    """擦除所有数据(重置为0)"""
-    with open(FLASH_FILE_2, "wb") as f:
-        f.write(b'\x00' * DATA_SIZE * TOTAL_SLOTS)
-        

smartpi/humidity.py

@@ -1,20 +0,0 @@
-# coding=utf-8
-import time
-from typing import List, Optional
-from smartpi import base_driver
-
-             
-#湿度读取 port:连接P端口；正常返回：湿度数据; 读取错误：-1
-def get_value(port:bytes) -> Optional[bytes]:
-    humi_str=[0XA0, 0X0C, 0X01, 0X71, 0X00, 0XBE]
-    humi_str[0]=0XA0+port
-    humi_str[4]=0X01 
-    time.sleep(0.005)
-    response = base_driver.single_operate_sensor(humi_str,0)
-    if response == None:
-        return None
-    else:
-        return response[4]
-
-
-

smartpi/led.py

@@ -1,19 +0,0 @@
-# coding=utf-8
-import time
-from typing import List, Optional
-from smartpi import base_driver
-
-
-#�ʵƿ��� port:����P�˿ڣ�command:0:�صƣ�1:�죻2:�̣�3:����4:�ƣ�5:�ϣ�6:�ࣻ7:�ף�  �������أ�0; ��ȡ����-1  
-def set_color(port:bytes,command:bytes) -> Optional[bytes]:
-    color_lamp_str=[0xA0, 0x05, 0x00, 0xBE]
-    color_lamp_str[0]=0XA0+port
-    color_lamp_str[2]=command
-#    response = base_driver.single_operate_sensor(color_lamp_str,0)
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, color_lamp_str)
-#    if response == None:
-#        return None
-#    else:
-    return 0
-        

smartpi/light_sensor.py

@@ -1,72 +0,0 @@
-# coding=utf-8
-import time
-from typing import List, Optional
-from smartpi import base_driver
-
-#����ֵ��ȡ port:����P�˿ڣ�  �������أ���ֵ����; ��ȡ����-1  
-def turn_off(port:bytes) -> Optional[bytes]:
-    light_str=[0xA0, 0x02, 0x00, 0xBE]
-    light_str[0]=0XA0+port
-    light_str[2]=0x03
-#    response = base_driver.single_operate_sensor(light_str,0) 
-    base_driver.write_data(0X01, 0X02, light_str)     
-#    if response == None:
-#        return None
-#    else:
-    return 0
-
-#����ֵ��ȡ port:����P�˿ڣ�  �������أ���ֵ����; ��ȡ����-1  
-def get_value(port:bytes) -> Optional[bytes]:
-    light_str=[0xA0, 0x02, 0x00, 0xBE]
-    light_str[0]=0XA0+port
-    light_str[2]=0x01
-    time.sleep(0.005)
-    response = base_driver.single_operate_sensor(light_str,0)       
-    if response == None:
-        return None
-    else:
-        light_data=response[4:-1]
-        light_num=int.from_bytes(light_data, byteorder='big', signed=True)
-        return light_num
-        
-#�����ֵ���� port:����P�˿ڣ� threshold�����õ���ֵ0~4000
-def set_threshold(port:bytes,threshold:int) -> Optional[bytes]:
-    light_str=[0xA0, 0x02, 0x00, 0x81, 0x00, 0x00, 0xBE]
-    light_str[0]=0XA0+port
-    light_str[2]=0x04
-    light_str[4]=threshold//256
-    light_str[5]=threshold%256
-    time.sleep(0.005)
-    base_driver.write_data(0X01, 0X02, light_str)
-#    response = base_driver.single_operate_sensor(light_str,0)       
-#    if response == None:
-#        return None
-#    else:
-    return 0
-        
-#�����ֵ��ȡ port:����P�˿ڣ�  
-def get_threshold(port:bytes) -> Optional[bytes]:
-    light_str=[0xA0, 0x02, 0x00, 0xBE]
-    light_str[0]=0XA0+port
-    light_str[2]=0x05
-    time.sleep(0.005)
-    response = base_driver.single_operate_sensor(light_str,0)       
-    if response == None:
-        return None
-    else:
-        light_data=response[4:-1]
-        light_num=int.from_bytes(light_data, byteorder='big', signed=True)
-        return light_num
-        
-#����ȡ��ǰֵ���趨��ֵ�ȽϺ��boolֵ port:����P�˿ڣ�  
-def get_bool_data(port:bytes) -> Optional[bytes]:
-    light_str=[0xA0, 0x02, 0x00, 0xBE]
-    light_str[0]=0XA0+port
-    light_str[2]=0x06
-    time.sleep(0.005)
-    response = base_driver.single_operate_sensor(light_str,0)       
-    if response == None:
-        return None
-    else:
-        return response[4]
-