package com.doumee.core.utils;
|
|
import java.security.MessageDigest;
|
|
/**
|
* Created by IntelliJ IDEA.
|
*
|
* @Author : Rk
|
* @create 2023/2/16 11:28
|
*/
|
public class Sha1Util {
|
public static void main(String[] args) {
|
System.out.println(getSha1("# Date 2023.07\n" +
|
"# Name QianJin Yang\n" +
|
"\n" +
|
"'''\n" +
|
"# 版本信息：\n" +
|
"# 修改：增加瓦力语音模块 库函数 tx=17 初始化设置\n" +
|
"# \n" +
|
"# 删减：合并了基于PCA9685舵机、电机控制函数库，为servos库函数增加_pin()、motorSpeed()控制函数\n" +
|
"#\n" +
|
"# 新增：点阵屏控制函数库文件\n" +
|
"# 基于GC7219主控核心点阵屏级联控制函数\n" +
|
"# 数值、字符、自定义表情的静态、动态显示控制\n" +
|
"'''\n" +
|
"\n" +
|
"import ustruct,math,framebuf\n" +
|
"from machine import I2C,SPI,UART,PWM,time_pulse_us,Pin\n" +
|
"from micropython import const\n" +
|
"from time import sleep, sleep_us, sleep_ms\n" +
|
"\n" +
|
"\n" +
|
"_DC_MOTORS = ((8, 9, 10), (11, 12, 13))\n" +
|
"\n" +
|
"class PCA9685:\n" +
|
" def __init__(self, i2c, address=0x40):\n" +
|
" self.i2c = i2c\n" +
|
" self.address = address\n" +
|
" self.reset()\n" +
|
"\n" +
|
" def _write(self, address, value):\n" +
|
" self.i2c.writeto_mem(self.address, address, bytearray([value]))\n" +
|
"\n" +
|
" def _read(self, address):\n" +
|
" return self.i2c.readfrom_mem(self.address, address, 1)[0]\n" +
|
"\n" +
|
" def reset(self):\n" +
|
" self._write(0x00, 0x00) # Mode1\n" +
|
"\n" +
|
" def freq(self, freq=None):\n" +
|
" if freq is None:\n" +
|
" return int(25000000.0 / 4096 / (self._read(0xfe) - 0.5))\n" +
|
" prescale = int(25000000.0 / 4096.0 / freq + 0.5)\n" +
|
" old_mode = self._read(0x00) # Mode 1\n" +
|
" self._write(0x00, (old_mode & 0x7F) | 0x10) # Mode 1, sleep\n" +
|
" self._write(0xfe, prescale) # Prescale\n" +
|
" self._write(0x00, old_mode) # Mode 1\n" +
|
" sleep_us(5)\n" +
|
" self._write(0x00, old_mode | 0xa1) # Mode 1, autoincrement on\n" +
|
"\n" +
|
" def pwm(self, index, on=None, off=None):\n" +
|
" if on is None or off is None:\n" +
|
" data = self.i2c.readfrom_mem(self.address, 0x06 + 4 * index, 4)\n" +
|
" return ustruct.unpack('<HH', data)\n" +
|
" data = ustruct.pack('<HH', on, off)\n" +
|
" self.i2c.writeto_mem(self.address, 0x06 + 4 * index, data)\n" +
|
"\n" +
|
" def duty(self, index, value=None, invert=False):\n" +
|
" if value is None:\n" +
|
" pwm = self.pwm(index)\n" +
|
" if pwm == (0, 4096):\n" +
|
" value = 0\n" +
|
" elif pwm == (4096, 0):\n" +
|
" value = 4095\n" +
|
" value = pwm[1]\n" +
|
" if invert:\n" +
|
" value = 4095 - value\n" +
|
" return value\n" +
|
" if not 0 <= value <= 4095:\n" +
|
" raise ValueError(\"Out of range\")\n" +
|
" if invert:\n" +
|
" value = 4095 - value\n" +
|
" if value == 0:\n" +
|
" self.pwm(index, 0, 4096)\n" +
|
" elif value == 4095:\n" +
|
" self.pwm(index, 4096, 0)\n" +
|
" else:\n" +
|
" self.pwm(index, 0, value)\n" +
|
" \n" +
|
"\n" +
|
"class Servos:\n" +
|
" def __init__(self, i2c=I2C(1,sda=Pin(26),scl=Pin(25),freq=10000), address=0x40, freq=100, min_us=600, max_us=2400,\n" +
|
" degrees=270):\n" +
|
" self.period = 1000000 / freq\n" +
|
" self.min_duty = self._us2duty(min_us)\n" +
|
" self.max_duty = self._us2duty(max_us)\n" +
|
" self.degrees = degrees\n" +
|
" self.freq = freq\n" +
|
" self.pca9685 = PCA9685(i2c, address)\n" +
|
" self.pca9685.freq(freq)\n" +
|
"\n" +
|
" def _us2duty(self, value):\n" +
|
" return int(4095 * value / self.period)\n" +
|
"\n" +
|
" def position(self, index, degrees=None, radians=None, us=None, duty=None):\n" +
|
" span = self.max_duty - self.min_duty\n" +
|
" if degrees is not None:\n" +
|
" duty = self.min_duty + span * degrees / self.degrees\n" +
|
" elif radians is not None:\n" +
|
" duty = self.min_duty + span * radians / math.radians(self.degrees)\n" +
|
" elif us is not None:\n" +
|
" duty = self._us2duty(us)\n" +
|
" elif duty is not None:\n" +
|
" pass\n" +
|
" else:\n" +
|
" return self.pca9685.duty(index)\n" +
|
" duty = min(self.max_duty, max(self.min_duty, int(duty)))\n" +
|
" self.pca9685.duty(index, duty)\n" +
|
" \n" +
|
" def _pin(self, pin, value=None):\n" +
|
" if value is None:\n" +
|
" return bool(self.pca9685.pwm(pin)[0])\n" +
|
" if value:\n" +
|
" self.pca9685.pwm(pin, 4096, 0)\n" +
|
" else:\n" +
|
" self.pca9685.pwm(pin, 0, 0)\n" +
|
" \n" +
|
" def motorSpeed(self, index, value=None):\n" +
|
" pwm, in2, in1 = _DC_MOTORS[index]\n" +
|
" if value is None:\n" +
|
" value = self.pca9685.duty(pwm)\n" +
|
" if self._pin(in2) and not self._pin(in1):\n" +
|
" value = -value\n" +
|
" return value\n" +
|
" if value < 0:\n" +
|
" # Forward\n" +
|
" self._pin(in2, False)\n" +
|
" self._pin(in1, True)\n" +
|
" elif value > 0:\n" +
|
" # Backward\n" +
|
" self._pin(in1, False)\n" +
|
" self._pin(in2, True)\n" +
|
" else:\n" +
|
" # Release\n" +
|
" self._pin(in1, False)\n" +
|
" self._pin(in2, False)\n" +
|
" self.pca9685.duty(pwm, abs(value))\n" +
|
" \n" +
|
" def release(self, index):\n" +
|
" self.pca9685.duty(index, 0)\n" +
|
"\n" +
|
"class Motors:\n" +
|
" def __init__(self,robotType):\n" +
|
" self.robotType = robotType\n" +
|
" self.motorPin = None\n" +
|
" if self.robotType == 'marsCar':\n" +
|
" self.motorPin = ((21,19),(26,25),(23,22),(33,32)) # 火星电机1~4接口对应ESP32的引脚\n" +
|
" if self.robotType == 'mecanumCar':\n" +
|
" self.motorPin = ((21,19),(23,22),(25,26),(32,33)) # 麦轮电机1~4接口对应ESP32的引脚\n" +
|
" \n" +
|
" def motorRuning(self,motorNum,speedVal):\n" +
|
" if speedVal >= 0: # 顺时针\n" +
|
" PWM(Pin(self.motorPin[motorNum][0]), freq=40000, duty=0)\n" +
|
" PWM(Pin(self.motorPin[motorNum][1]), freq=40000, duty=speedVal)\n" +
|
" else: # 逆时针\n" +
|
" PWM(Pin(self.motorPin[motorNum][0]), freq=40000, duty=-speedVal)\n" +
|
" PWM(Pin(self.motorPin[motorNum][1]), freq=40000, duty=0)\n" +
|
"\n" +
|
"class PS2: \n" +
|
" def __init__(self):\n" +
|
" self.psb_key_value = {\n" +
|
" \"NO_KEY_PRESS\": 0xFF,\n" +
|
" \"NO_KEY_PRESS_ERR\": 0x00,\n" +
|
" \"REPEATED_KEY_PRESS\": 0xFE,\n" +
|
" \"PSB_PAD_UP\": 0x10,\n" +
|
" \"PSB_PAD_DOWN\": 0x11,\n" +
|
" \"PSB_PAD_LEFT\": 0x12,\n" +
|
" \"PSB_PAD_RIGHT\": 0x13,\n" +
|
" \"PSB_GREEN\": 0x14,\n" +
|
" \"PSB_BLUE\": 0x15,\n" +
|
" \"PSB_RED\": 0x16,\n" +
|
" \"PSB_PINK\": 0x17,\n" +
|
" \"PSB_L1\": 0x18,\n" +
|
" \"PSB_R1\": 0x19,\n" +
|
" \"PSB_L2\": 0x1A,\n" +
|
" \"PSB_R2\": 0x1B,\n" +
|
" \"PSB_LX1\": 0x1C,\n" +
|
" \"PSB_LX2\": 0x1D,\n" +
|
" \"PSB_LY1\": 0x1E,\n" +
|
" \"PSB_LY2\": 0x1F,\n" +
|
" \"PSB_RX1\": 0x20,\n" +
|
" \"PSB_RX2\": 0x21,\n" +
|
" \"PSB_RY1\": 0x22,\n" +
|
" \"PSB_RY2\": 0x23,\n" +
|
" \"MPSB_PAD_UP\": 0x30,\n" +
|
" \"MPSB_PAD_DOWN\": 0x31,\n" +
|
" \"MPSB_PAD_LEFT\": 0x32,\n" +
|
" \"MPSB_PAD_RIGHT\": 0x33,\n" +
|
" \"MPSB_GREEN\": 0x34,\n" +
|
" \"MPSB_BLUE\": 0x35,\n" +
|
" \"MPSB_RED\": 0x36,\n" +
|
" \"MPSB_PINK\": 0x37,\n" +
|
" \"MPSB_L1\": 0x38,\n" +
|
" \"MPSB_R1\": 0x39,\n" +
|
" \"MPSB_L2\": 0x3A,\n" +
|
" \"MPSB_R2\": 0x3B,\n" +
|
" \"MPSB_LX1\": 0x3C,\n" +
|
" \"MPSB_LX2\": 0x3D,\n" +
|
" \"MPSB_LY1\": 0x3E,\n" +
|
" \"MPSB_LY2\": 0x3F,\n" +
|
" \"MPSB_RX1\": 0x40,\n" +
|
" \"MPSB_RX2\": 0x41,\n" +
|
" \"MPSB_RY1\": 0x42,\n" +
|
" \"MPSB_RY2\": 0x43,\n" +
|
" }\n" +
|
"\n" +
|
" self.psb_slowkey_value = {\n" +
|
" \"PSB_GREEN\": 0x14,\n" +
|
" \"PSB_BLUE\": 0x15,\n" +
|
" \"PSB_RED\": 0x16,\n" +
|
" \"PSB_PINK\": 0x17,\n" +
|
" }\n" +
|
" self.no_key_press_cnt = 0\n" +
|
" self.key_val_last = self.psb_key_value[\"NO_KEY_PRESS\"]\n" +
|
" self.key_val_now = self.psb_key_value[\"NO_KEY_PRESS\"]\n" +
|
" self.psbkey_val = self.psb_key_value[\"NO_KEY_PRESS\"]\n" +
|
"\n" +
|
" self.spi_usb = SPI(1, baudrate=2500, polarity=0, phase=0, sck=Pin(14), miso=Pin(12)) # 引脚定义\n" +
|
" self.spi_usb_cs = Pin(13, Pin.OUT)\n" +
|
" self.spi_usb_cs.value(1)\n" +
|
"\n" +
|
" def get_psbkey_value(self):\n" +
|
" psb_slowkey_value = self.psb_slowkey_value\n" +
|
" psb_key_value = self.psb_key_value\n" +
|
" spi_usb_cs = self.spi_usb_cs\n" +
|
" spi_usb = self.spi_usb\n" +
|
" no_key_press_cnt = self.no_key_press_cnt\n" +
|
" key_val_last = self.key_val_last\n" +
|
" key_val_now = self.key_val_now\n" +
|
" \n" +
|
" spi_usb_cs.value(0)\n" +
|
" spi_usb.read(2)\n" +
|
" spi_usb_cs.value(1)\n" +
|
" spi_usb_cs.value(0)\n" +
|
" usbkey_value = spi_usb.read(5)\n" +
|
" spi_usb_cs.value(1)\n" +
|
" if (usbkey_value[2] == psb_key_value[\"NO_KEY_PRESS\"]) or (usbkey_value[2] == psb_key_value[\"NO_KEY_PRESS_ERR\"]):\n" +
|
" no_key_press_cnt += 1\n" +
|
" if no_key_press_cnt > 4:\n" +
|
" no_key_press_cnt = 0\n" +
|
" no_key_press_flag = 1\n" +
|
" key_val_now = psb_key_value[\"NO_KEY_PRESS\"]\n" +
|
" key_val_last = psb_key_value[\"NO_KEY_PRESS\"]\n" +
|
" return psb_key_value[\"NO_KEY_PRESS\"]\n" +
|
" else:\n" +
|
" if key_val_last in psb_slowkey_value.values():\n" +
|
" return psb_key_value[\"REPEATED_KEY_PRESS\"]\n" +
|
" else:\n" +
|
" return key_val_last\n" +
|
" elif usbkey_value[2] in psb_slowkey_value.values():\n" +
|
" no_key_press_cnt = 0\n" +
|
" key_val_now = usbkey_value[2]\n" +
|
" if key_val_now != key_val_last:\n" +
|
" key_val_last = usbkey_value[2]\n" +
|
" return usbkey_value[2]\n" +
|
" else:\n" +
|
" return psb_key_value[\"REPEATED_KEY_PRESS\"]\n" +
|
" else:\n" +
|
" no_key_press_cnt = 0\n" +
|
" key_val_now = usbkey_value[2]\n" +
|
" key_val_last = usbkey_value[2]\n" +
|
" return usbkey_value[2]\n" +
|
"\n" +
|
"\n" +
|
"class HCSR04:\n" +
|
" def __init__(self,echo_timeout_us=500*2*30):\n" +
|
" self.echo_timeout_us = echo_timeout_us\n" +
|
" self.pinList = [[19,18],[23,22]] # 超声波[Trig,Echo]引脚列表\n" +
|
"\n" +
|
" def _send_pulse_and_wait(self,flag):\n" +
|
" self.trigger = Pin(self.pinList[flag][0], mode=Pin.OUT, pull=None)#trig\n" +
|
" self.trigger.value(0)\n" +
|
" self.echo = Pin(self.pinList[flag][1], mode=Pin.IN, pull=None)#echo \n" +
|
" \n" +
|
" self.trigger.value(0) \n" +
|
" sleep_us(5)\n" +
|
" self.trigger.value(1)\n" +
|
" sleep_us(10)\n" +
|
" self.trigger.value(0)\n" +
|
" try:\n" +
|
" pulse_time = time_pulse_us(self.echo, 1, self.echo_timeout_us)\n" +
|
" if pulse_time < 0:\n" +
|
" MAX_RANGE_IN_CM = const(500) \n" +
|
" pulse_time = int(MAX_RANGE_IN_CM * 29.1)\n" +
|
" return pulse_time\n" +
|
" except OSError as ex:\n" +
|
" if ex.args[0] == 110:\n" +
|
" raise OSError('Out of range')\n" +
|
" raise ex\n" +
|
"\n" +
|
" def getDistance(self,flag1,flag2): # flag1接口,flag2精度 \n" +
|
" pulse_time = self._send_pulse_and_wait(flag1)\n" +
|
" distanceVal = 0\n" +
|
" if flag2 == 0:\n" +
|
" distanceVal = pulse_time * 100 // 582 #毫米\n" +
|
" else:\n" +
|
" distanceVal = (pulse_time / 2) / 29.1 #厘米\n" +
|
" return distanceVal\n" +
|
" \n" +
|
"class Mp3Player:\n" +
|
" def __init__(self,robotType):\n" +
|
" self.robotType = robotType\n" +
|
" self.uart = None\n" +
|
" if self.robotType == 'waLi':\n" +
|
" self.uart = UART(1, baudrate=9600, tx=17)\n" +
|
" elif self.robotType == 'maiLun':\n" +
|
" self.uart = UART(1, baudrate=9600, tx=4)\n" +
|
"\n" +
|
" def playMusic(self,musicNum):\n" +
|
" voiceCmd = [(0x7E), (0x04), (0x03), (0x00), (musicNum), (0xEF)]\n" +
|
" for i in voiceCmd:\n" +
|
" data = bytes([i])\n" +
|
" self.uart.write(data)\n" +
|
"\n" +
|
"class DHT20(object):\n" +
|
" def __init__(self, i2c):\n" +
|
" self.i2c = i2c\n" +
|
" if (self.dht20_read_status() & 0x80) == 0x80:\n" +
|
" self.dht20_init() \n" +
|
" \n" +
|
" def read_dht20(self):\n" +
|
" self.i2c.writeto(0x38, bytes([0xac,0x33,0x00]))\n" +
|
" sleep_ms(80)\n" +
|
" cnt = 0\n" +
|
" while (self.dht20_read_status() & 0x80) == 0x80:\n" +
|
" sleep_ms(1)\n" +
|
" if cnt >= 100:\n" +
|
" cnt += 1\n" +
|
" break\n" +
|
" data = self.i2c.readfrom(0x38, 7, True)\n" +
|
" n = []\n" +
|
" for i in data[:]:\n" +
|
" n.append(i)\n" +
|
" return n\n" +
|
" \n" +
|
" def dht20_read_status(self):\n" +
|
" data = self.i2c.readfrom(0x38, 1, True)\n" +
|
" return data[0]\n" +
|
" \n" +
|
" def dht20_init(self):\n" +
|
" i2c.writeto(0x38, bytes([0xa8,0x00,0x00]))\n" +
|
" sleep_ms(10)\n" +
|
" i2c.writeto(0x38, bytes([0xbe,0x08,0x00]))\n" +
|
" \n" +
|
" def calc_crc8(self,data):\n" +
|
" crc = 0xff\n" +
|
" for i in data[:-1]:\n" +
|
" crc ^= i\n" +
|
" for j in range(8):\n" +
|
" if crc & 0x80:\n" +
|
" crc = (crc << 1) ^ 0x31\n" +
|
" else:\n" +
|
" crc = (crc << 1)\n" +
|
" return crc\n" +
|
" \n" +
|
" def dht20_temperature(self):\n" +
|
" data = self.read_dht20()\n" +
|
" Temper = 0\n" +
|
" if 1:\n" +
|
" Temper = (Temper | data[3]) << 8\n" +
|
" Temper = (Temper | data[4]) << 8\n" +
|
" Temper = Temper | data[5]\n" +
|
" Temper = Temper & 0xfffff\n" +
|
" Temper = (Temper * 200 * 10 / 1024 / 1024 - 500)/10\n" +
|
" return Temper\n" +
|
" def dht20_humidity(self):\n" +
|
" \n" +
|
" data = self.read_dht20()\n" +
|
" humidity = 0\n" +
|
" if 1:\n" +
|
" humidity = (humidity | data[1]) << 8\n" +
|
" humidity = (humidity | data[2]) << 8\n" +
|
" humidity = humidity | data[3]\n" +
|
" humidity = humidity >> 4\n" +
|
" humidity = (humidity * 100 * 10 / 1024 / 1024)/10\n" +
|
" return humidity\n" +
|
"\n" +
|
"\n" +
|
"\n" +
|
"TM1637_CMD1 = const(64) # 0x40 data command\n" +
|
"TM1637_CMD2 = const(192) # 0xC0 address command\n" +
|
"TM1637_CMD3 = const(128) # 0x80 display control command\n" +
|
"TM1637_DSP_ON = const(8) # 0x08 display on\n" +
|
"TM1637_DELAY = const(10) # 10us delay between clk/dio pulses\n" +
|
"TM1637_MSB = const(128) # msb is the decimal point or the colon depending on your display\n" +
|
"\n" +
|
"# 0-9, a-z, blank, dash, star\n" +
|
"_SEGMENTS = bytearray(b'\\x3F\\x06\\x5B\\x4F\\x66\\x6D\\x7D\\x07\\x7F\\x6F\\x77\\x7C\\x39\\x5E\\x79\\x71\\x3D\\x76\\x06\\x1E\\x76\\x38\\x55\\x54\\x3F\\x73\\x67\\x50\\x6D\\x78\\x3E\\x1C\\x2A\\x76\\x6E\\x5B\\x00\\x40\\x63')\n" +
|
"\n" +
|
"class TM1637(object):\n" +
|
" \"\"\"Library for quad 7-segment LED modules based on the TM1637 LED driver.\"\"\"\n" +
|
" def __init__(self, clk, dio, brightness=7):\n" +
|
" self.clk = clk\n" +
|
" self.dio = dio\n" +
|
"\n" +
|
" if not 0 <= brightness <= 7:\n" +
|
" raise ValueError(\"Brightness out of range\")\n" +
|
" self._brightness = brightness\n" +
|
"\n" +
|
" self.clk.init(Pin.OUT, value=0)\n" +
|
" self.dio.init(Pin.OUT, value=0)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
"\n" +
|
" self._write_data_cmd()\n" +
|
" self._write_dsp_ctrl()\n" +
|
"\n" +
|
" def _start(self):\n" +
|
" self.dio(0)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
" self.clk(0)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
"\n" +
|
" def _stop(self):\n" +
|
" self.dio(0)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
" self.clk(1)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
" self.dio(1)\n" +
|
"\n" +
|
" def _write_data_cmd(self):\n" +
|
" # automatic address increment, normal mode\n" +
|
" self._start()\n" +
|
" self._write_byte(TM1637_CMD1)\n" +
|
" self._stop()\n" +
|
"\n" +
|
" def _write_dsp_ctrl(self):\n" +
|
" # display on, set brightness\n" +
|
" self._start()\n" +
|
" self._write_byte(TM1637_CMD3 | TM1637_DSP_ON | self._brightness)\n" +
|
" self._stop()\n" +
|
"\n" +
|
" def _write_byte(self, b):\n" +
|
" for i in range(8):\n" +
|
" self.dio((b >> i) & 1)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
" self.clk(1)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
" self.clk(0)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
" self.clk(0)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
" self.clk(1)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
" self.clk(0)\n" +
|
" sleep_us(TM1637_DELAY)\n" +
|
"\n" +
|
" def brightness(self, val=None):\n" +
|
" \"\"\"Set the display brightness 0-7.\"\"\"\n" +
|
" # brightness 0 = 1/16th pulse width\n" +
|
" # brightness 7 = 14/16th pulse width\n" +
|
" if val is None:\n" +
|
" return self._brightness\n" +
|
" if not 0 <= val <= 7:\n" +
|
" raise ValueError(\"Brightness out of range\")\n" +
|
"\n" +
|
" self._brightness = val\n" +
|
" self._write_data_cmd()\n" +
|
" self._write_dsp_ctrl()\n" +
|
"\n" +
|
" def write(self, segments, pos=0):\n" +
|
" \"\"\"Display up to 6 segments moving right from a given position.\n" +
|
" The MSB in the 2nd segment controls the colon between the 2nd\n" +
|
" and 3rd segments.\"\"\"\n" +
|
" if not 0 <= pos <= 5:\n" +
|
" raise ValueError(\"Position out of range\")\n" +
|
" self._write_data_cmd()\n" +
|
" self._start()\n" +
|
"\n" +
|
" self._write_byte(TM1637_CMD2 | pos)\n" +
|
" for seg in segments:\n" +
|
" self._write_byte(seg)\n" +
|
" self._stop()\n" +
|
" self._write_dsp_ctrl()\n" +
|
"\n" +
|
" def encode_digit(self, digit):\n" +
|
" \"\"\"Convert a character 0-9, a-f to a segment.\"\"\"\n" +
|
" return _SEGMENTS[digit & 0x0f]\n" +
|
"\n" +
|
" def encode_string(self, string):\n" +
|
" \"\"\"Convert an up to 4 character length string containing 0-9, a-z,\n" +
|
" space, dash, star to an array of segments, matching the length of the\n" +
|
" source string.\"\"\"\n" +
|
" segments = bytearray(len(string))\n" +
|
" for i in range(len(string)):\n" +
|
" segments[i] = self.encode_char(string[i])\n" +
|
" return segments\n" +
|
"\n" +
|
" def encode_char(self, char):\n" +
|
" \"\"\"Convert a character 0-9, a-z, space, dash or star to a segment.\"\"\"\n" +
|
" o = ord(char)\n" +
|
" if o == 32:\n" +
|
" return _SEGMENTS[36] # space\n" +
|
" if o == 42:\n" +
|
" return _SEGMENTS[38] # star/degrees\n" +
|
" if o == 45:\n" +
|
" return _SEGMENTS[37] # dash\n" +
|
" if o >= 65 and o <= 90:\n" +
|
" return _SEGMENTS[o-55] # uppercase A-Z\n" +
|
" if o >= 97 and o <= 122:\n" +
|
" return _SEGMENTS[o-87] # lowercase a-z\n" +
|
" if o >= 48 and o <= 57:\n" +
|
" return _SEGMENTS[o-48] # 0-9\n" +
|
" raise ValueError(\"Character out of range: {:d} '{:s}'\".format(o, chr(o)))\n" +
|
"\n" +
|
" def hex(self, val):\n" +
|
" \"\"\"Display a hex value 0x0000 through 0xffff, right aligned.\"\"\"\n" +
|
" string = '{:04x}'.format(val & 0xffff)\n" +
|
" self.write(self.encode_string(string))\n" +
|
"\n" +
|
" def number(self, num):\n" +
|
" \"\"\"Display a numeric value -999 through 9999, right aligned.\"\"\"\n" +
|
" # limit to range -999 to 9999\n" +
|
" num = max(-999, min(num, 9999))\n" +
|
" string = '{0: >4d}'.format(num)\n" +
|
" self.write(self.encode_string(string))\n" +
|
"\n" +
|
" def numbers(self, num1, num2, colon=True):\n" +
|
" \"\"\"Display two numeric values -9 through 99, with leading zeros\n" +
|
" and separated by a colon.\"\"\"\n" +
|
" num1 = max(-9, min(num1, 99))\n" +
|
" num2 = max(-9, min(num2, 99))\n" +
|
" segments = self.encode_string('{0:0>2d}{1:0>2d}'.format(num1, num2))\n" +
|
" if colon:\n" +
|
" segments[1] |= 0x80 # colon on\n" +
|
" self.write(segments)\n" +
|
"\n" +
|
" def temperature(self, num):\n" +
|
" if num < -9:\n" +
|
" self.show('lo') # low\n" +
|
" elif num > 99:\n" +
|
" self.show('hi') # high\n" +
|
" else:\n" +
|
" string = '{0: >2d}'.format(num)\n" +
|
" self.write(self.encode_string(string))\n" +
|
" self.write([_SEGMENTS[38], _SEGMENTS[12]], 2) # degrees C\n" +
|
"\n" +
|
" def show(self, string, colon=False):\n" +
|
" segments = self.encode_string(string)\n" +
|
" if len(segments) > 1 and colon:\n" +
|
" segments[1] |= 128\n" +
|
" self.write(segments[:4])\n" +
|
"\n" +
|
" def scroll(self, string, delay=250):\n" +
|
" segments = string if isinstance(string, list) else self.encode_string(string)\n" +
|
" data = [0] * 8\n" +
|
" data[4:0] = list(segments)\n" +
|
" for i in range(len(segments) + 5):\n" +
|
" self.write(data[0+i:4+i])\n" +
|
" sleep_ms(delay)\n" +
|
"\n" +
|
"\n" +
|
"class TM1637Decimal(TM1637):\n" +
|
" \"\"\"Library for quad 7-segment LED modules based on the TM1637 LED driver.\n" +
|
"\n" +
|
" This class is meant to be used with decimal display modules (modules\n" +
|
" that have a decimal point after each 7-segment LED).\n" +
|
" \"\"\"\n" +
|
"\n" +
|
" def encode_string(self, string):\n" +
|
" \"\"\"Convert a string to LED segments.\n" +
|
"\n" +
|
" Convert an up to 4 character length string containing 0-9, a-z,\n" +
|
" space, dash, star and '.' to an array of segments, matching the length of\n" +
|
" the source string.\"\"\"\n" +
|
" segments = bytearray(len(string.replace('.','')))\n" +
|
" j = 0\n" +
|
" for i in range(len(string)):\n" +
|
" if string[i] == '.' and j > 0:\n" +
|
" segments[j-1] |= TM1637_MSB\n" +
|
" continue\n" +
|
" segments[j] = self.encode_char(string[i])\n" +
|
" j += 1\n" +
|
" return segments\n" +
|
"\n" +
|
"\n" +
|
"class HCSR04:\n" +
|
" def __init__(self, trigger_pin, echo_pin, echo_timeout_us=500*2*30):\n" +
|
"\n" +
|
" self.echo_timeout_us = echo_timeout_us\n" +
|
" self.trigger = Pin(trigger_pin, mode=Pin.OUT, pull=None)\n" +
|
" self.trigger.value(0)\n" +
|
" self.echo = Pin(echo_pin, mode=Pin.IN, pull=None)\n" +
|
"\n" +
|
" def _send_pulse_and_wait(self):\n" +
|
" self.trigger.value(0) \n" +
|
" sleep_us(5)\n" +
|
" self.trigger.value(1)\n" +
|
" sleep_us(10)\n" +
|
" self.trigger.value(0)\n" +
|
" try:\n" +
|
" pulse_time = time_pulse_us(self.echo, 1, self.echo_timeout_us)\n" +
|
" if pulse_time < 0:\n" +
|
" pulse_time = int(500 * 29.1)\n" +
|
" return pulse_time\n" +
|
" except OSError as ex:\n" +
|
" if ex.args[0] == 110:\n" +
|
" raise OSError('Out of range')\n" +
|
" raise ex\n" +
|
"\n" +
|
" def distance_mm(self):\n" +
|
" pulse_time = self._send_pulse_and_wait()\n" +
|
" mm = pulse_time * 100 // 582\n" +
|
" return mm\n" +
|
"\n" +
|
" def distance_cm(self):\n" +
|
" pulse_time = self._send_pulse_and_wait()\n" +
|
" cms = (pulse_time / 2) / 29.1\n" +
|
" return cms\n" +
|
"\n" +
|
"\n" +
|
"\n" +
|
"class accel():\n" +
|
" error=[0,0,0]\n" +
|
" def __init__(self, i2c, addr=0x68):\n" +
|
" self.iic = i2c\n" +
|
" self.addr = addr\n" +
|
" self.iic.start()\n" +
|
" sleep_ms(1)\n" +
|
" self.iic.writeto(self.addr, bytearray([107, 0]))\n" +
|
" sleep_ms(1)\n" +
|
" self.iic.writeto_mem(self.addr,0x19,b'\\x07') #gyro 125hz\n" +
|
" sleep_ms(1)\n" +
|
" self.iic.writeto_mem(self.addr,0x1a,b'\\x04') #low filter 21hz\n" +
|
" sleep_ms(1)\n" +
|
" self.iic.writeto_mem(self.addr,0x1b,b'\\x08') #gryo 500/s 65.5lsb/g\n" +
|
" sleep_ms(1)\n" +
|
" self.iic.writeto_mem(self.addr,0x1c,b'\\x08') #acceler 4g ,8192lsb.g\n" +
|
" sleep_ms(1)\n" +
|
" self.iic.stop()\n" +
|
"\n" +
|
" def get_raw_values(self):\n" +
|
" self.iic.start()\n" +
|
" a = self.iic.readfrom_mem(self.addr, 0x3B, 14)\n" +
|
" self.iic.stop()\n" +
|
" return a\n" +
|
"\n" +
|
" def get_ints(self):\n" +
|
" b = self.get_raw_values()\n" +
|
" c = []\n" +
|
" for i in b:\n" +
|
" c.append(i)\n" +
|
" return c\n" +
|
"\n" +
|
" def bytes_toint(self, firstbyte, secondbyte):\n" +
|
" if not firstbyte & 0x80:\n" +
|
" return firstbyte << 8 | secondbyte\n" +
|
" return - (((firstbyte ^ 255) << 8) | (secondbyte ^ 255) + 1)\n" +
|
"\n" +
|
" def error_gy(self):\n" +
|
" sleep(3)\n" +
|
" global error\n" +
|
" error=[0,0,0]\n" +
|
" vals = {}\n" +
|
" for i in range(0,10):\n" +
|
"\t raw_ints = self.get_raw_values()\n" +
|
"\t vals[\"GyX\"] = self.bytes_toint(raw_ints[8], raw_ints[9])\n" +
|
"\t vals[\"GyY\"] = self.bytes_toint(raw_ints[10], raw_ints[11])\n" +
|
"\t vals[\"GyZ\"] = self.bytes_toint(raw_ints[12], raw_ints[13])\n" +
|
"\t error[0]= error[0]+vals[\"GyX\"]\n" +
|
"\t error[1]= error[1]+vals[\"GyY\"]\n" +
|
"\t error[2]= error[2]+vals[\"GyZ\"]\n" +
|
"\t sleep_ms(8)\n" +
|
" error[1]=error[1]/10.0\n" +
|
" error[2]=error[2]/10.0\n" +
|
" error[0]=error[0]/10.0\n" +
|
"\t\t\n" +
|
" def get_values(self):\n" +
|
" global error\n" +
|
" vals = {}\n" +
|
" raw_ints = self.get_raw_values()\n" +
|
" vals[\"AcX\"] = self.bytes_toint(raw_ints[0], raw_ints[1])\n" +
|
" vals[\"AcY\"] = self.bytes_toint(raw_ints[2], raw_ints[3])\n" +
|
" vals[\"AcZ\"] = self.bytes_toint(raw_ints[4], raw_ints[5])\n" +
|
" vals[\"Tmp\"] = self.bytes_toint(raw_ints[6], raw_ints[7]) / 340.00 + 36.53\n" +
|
" vals[\"GyX\"] = self.bytes_toint(raw_ints[8], raw_ints[9])-error[0]\n" +
|
" vals[\"GyY\"] = self.bytes_toint(raw_ints[10], raw_ints[11])-error[1]\n" +
|
" vals[\"GyZ\"] = self.bytes_toint(raw_ints[12], raw_ints[13])-error[2]\n" +
|
" #vals[\"GyZ1\"] = self.bytes_toint(raw_ints[12], raw_ints[13])\n" +
|
" return vals # returned in range of Int16\n" +
|
" # -32768 to 32767\n" +
|
"\n" +
|
"Kp=0.8 #比例增益支配率收敛到加速度计/磁强计\n" +
|
"Ki=0.001 #积分增益支配率的陀螺仪偏见的衔接\n" +
|
"halfT=0.004 #采样周期的一半\n" +
|
"q0=1\n" +
|
"q1=0\n" +
|
"q2=0\n" +
|
"q3=0; #四元数的元素 ,代表估计方向\n" +
|
"exInt=0\n" +
|
"eyInt=0\n" +
|
"ezInt=0 #按比例缩小积分误差\n" +
|
"def IMUupdate(gx,gy,gz,ax,ay,az):\n" +
|
" K=0.7\n" +
|
" a=[0,0,0,0,0,0,0,0]\n" +
|
" global Kp,Ki,halfT,q0,q1,q2,q3,exInt,eyInt,ezInt\n" +
|
" if ax!=0 or ay!=0 or az!=0: \n" +
|
" norm=math.sqrt(ax*ax+ay*ay+az*az);\n" +
|
" ax=ax/norm; #单位化\n" +
|
" ay=ay/norm;\n" +
|
" az=az/norm;\n" +
|
" #估计方向的重力\n" +
|
" vx=2* (q1*q3-q0*q2 );\n" +
|
" vy=2* (q0*q1+q2*q3 );\n" +
|
" vz=q0*q0-q1*q1-q2*q2+q3*q3;\n" +
|
" #错误的领域和方向传感器测量参考方向之间的交叉乘积的总和\n" +
|
" ex= (ay*vz-az*vy );\n" +
|
" ey= (az*vx-ax*vz );\n" +
|
" ez= (ax*vy-ay*vx );\n" +
|
" #积分误差比例积分增益\n" +
|
" exInt=exInt+ex*Ki;\n" +
|
" eyInt=eyInt+ey*Ki;\n" +
|
" ezInt=ezInt+ez*Ki;\n" +
|
" #调整后的陀螺仪测量\n" +
|
" gx=gx+Kp*ex+exInt;\n" +
|
" gy=gy+Kp*ey+eyInt;\n" +
|
" gz=gz+Kp*ez+ezInt;\n" +
|
" #整合四元数率和正常化\n" +
|
" q0=q0+ (-q1*gx-q2*gy-q3*gz )*halfT;\n" +
|
" q1=q1+ (q0*gx+q2*gz-q3*gy )*halfT;\n" +
|
" q2=q2+ (q0*gy-q1*gz+q3*gx )*halfT;\n" +
|
" q3=q3+ (q0*gz+q1*gy-q2*gx )*halfT;\n" +
|
" #正常化四元\n" +
|
" norm=math.sqrt(q0*q0+q1*q1+q2*q2+q3*q3 );\n" +
|
" q0=q0/norm;\n" +
|
" q1=q1/norm;\n" +
|
" q2=q2/norm;\n" +
|
" q3=q3/norm;\n" +
|
" Pitch=math.asin (-2*q1*q3+2*q0*q2 )*57.3; #pitch ,转换为度数\n" +
|
" if -2*q1*q1-2*q2*q2+1!=0:\n" +
|
" Roll=math.atan ((2*q2*q3+2*q0*q1)/(-2*q1*q1-2*q2*q2+1) )*57.3; #rollv\n" +
|
" a[0]=Pitch\n" +
|
" a[1]=Roll\n" +
|
" if ay*ay+az*az!=0:\n" +
|
" a[2]=-math.atan(ax/math.sqrt(ay*ay+az*az))*57.2957795\n" +
|
" if ax*ax+az*az!=0:\n" +
|
" a[3]=math.atan(ay/math.sqrt(ax*ax+az*az))*57.2957795\n" +
|
" a[4]=gx\n" +
|
" a[5]=gy\n" +
|
" a[6]=gz\n" +
|
" a[0]=-K*Pitch-(1-K)*a[2]\n" +
|
" a[1]=K*Roll+(1-K)*a[3]\n" +
|
" return a\n" +
|
"\n" +
|
"\n" +
|
"_NOOP = const(0)\n" +
|
"_DIGIT0 = const(1)\n" +
|
"_DECODEMODE = const(9)\n" +
|
"_INTENSITY = const(10)\n" +
|
"_SCANLIMIT = const(11)\n" +
|
"_SHUTDOWN = const(12)\n" +
|
"_DISPLAYTEST = const(15)\n" +
|
"\n" +
|
"class Matrix8x8:\n" +
|
" def __init__(self, spi, num):\n" +
|
" if spi == 1:\n" +
|
" self.spi = SPI(1,1000000,sck = Pin(14),mosi = Pin(13),miso = Pin(19))\n" +
|
" self.cs = Pin(12)\n" +
|
" elif spi == 2:\n" +
|
" self.spi = SPI(1,1000000,sck = Pin(14),mosi = Pin(13),miso = Pin(19))\n" +
|
" self.cs = Pin(12)\n" +
|
" self.cs.init(self.cs.OUT, True)\n" +
|
" self.buffer = bytearray(8 * num)\n" +
|
" self.num = num\n" +
|
" fb = framebuf.FrameBuffer(self.buffer, 8 * num, 8, framebuf.MONO_HLSB)\n" +
|
" self.framebuf = fb\n" +
|
" self.fill = fb.fill # (col)\n" +
|
" self.pixel = fb.pixel # (x, y[, c])\n" +
|
" self.hline = fb.hline # (x, y, w, col)\n" +
|
" self.vline = fb.vline # (x, y, h, col)\n" +
|
" self.line = fb.line # (x1, y1, x2, y2, col)\n" +
|
" self.rect = fb.rect # (x, y, w, h, col)\n" +
|
" self.fill_rect = fb.fill_rect # (x, y, w, h, col)\n" +
|
" self.text = fb.text # (string, x, y, col=1)\n" +
|
" self.scroll = fb.scroll # (dx, dy)\n" +
|
" self.blit = fb.blit # (fbuf, x, y[, key])\n" +
|
" self.init()\n" +
|
"\n" +
|
" def _write(self, command, data):\n" +
|
" self.cs(0)\n" +
|
" for m in range(self.num):\n" +
|
" self.spi.write(bytearray([command, data]))\n" +
|
" self.cs(1)\n" +
|
"\n" +
|
" def init(self):\n" +
|
" for command, data in (\n" +
|
" (_SHUTDOWN, 0),\n" +
|
" (_DISPLAYTEST, 0),\n" +
|
" (_SCANLIMIT, 7),\n" +
|
" (_DECODEMODE, 0),\n" +
|
" (_SHUTDOWN, 1),\n" +
|
" ):\n" +
|
" self._write(command, data)\n" +
|
"\n" +
|
" def brightness(self, value):\n" +
|
" if not 0 <= value <= 15:\n" +
|
" raise ValueError(\"Brightness out of range\")\n" +
|
" self._write(_INTENSITY, value)\n" +
|
"\n" +
|
" def show(self):\n" +
|
" for y in range(8):\n" +
|
" self.cs(0)\n" +
|
" for m in range(self.num):\n" +
|
" self.spi.write(bytearray([_DIGIT0 + y, self.buffer[(y * self.num) + m]]))\n" +
|
" self.cs(1)\n" +
|
" \n" +
|
" def scrollShow(self, num):\n" +
|
" msg = str(num)\n" +
|
" length = len(msg)\n" +
|
" for x in range(8,-8*length,-1):\n" +
|
" self.text(msg,x,1,1)\n" +
|
" self.show()\n" +
|
" sleep_ms(80)\n" +
|
" self.fill(0)\n" +
|
"\n" +
|
" def text_from_glyph(self, s, glyphs, x_offset=0, y_offset=0):\n" +
|
" col = 0\n" +
|
" for char in s:\n" +
|
" glyph = glyphs.get(char)\n" +
|
"\n" +
|
" if glyph:\n" +
|
" for y in range(8):\n" +
|
" for x in range(8):\n" +
|
" self.pixel(x+col+x_offset, y+y_offset, glyph[y][x])\n" +
|
" else:\n" +
|
" self.text(char, col+x_offset, y_offset)\n" +
|
"\n" +
|
" col += 8\n" +
|
"\n" +
|
"\n" +
|
"\n" +
|
"# --------------------------------------------------------------------\n" +
|
"#该函数为RGB彩虹灯灯控制函数\n" +
|
"def ledon(rgbColor,rgbId):\n" +
|
" import neopixel,machine\n" +
|
" np = neopixel.NeoPixel(machine.Pin(23), 28) #RGB此时与 接口E 相连\n" +
|
" if rgbColor == 'red':\n" +
|
" np[rgbId]=(255,0,0)\n" +
|
" elif rgbColor == 'green':\n" +
|
" np[rgbId]=(0,255,0)\n" +
|
" elif rgbColor =='blue':\n" +
|
" np[rgbId]=(0,0,255)\n" +
|
" elif rgbColor =='cyan':\n" +
|
" np[rgbId]=(0,255,255)\n" +
|
" elif rgbColor =='purple':\n" +
|
" np[rgbId]=(255,0,255)\n" +
|
" elif rgbColor =='yellow':\n" +
|
" np[rgbId]=(255,255,0)\n" +
|
" elif rgbColor =='orange':\n" +
|
" np[rgbId]=(255,30,0)\n" +
|
" elif rgbColor =='pink':\n" +
|
" np[rgbId]=(255,0,30)\n" +
|
" elif rgbColor == 'white':\n" +
|
" np[rgbId]=(150,150,150)\n" +
|
" np.write()\n" +
|
"\n" +
|
"def ledonzb(rgbColor1,hang2,lie2):\n" +
|
" import neopixel,machine\n" +
|
" np = neopixel.NeoPixel(machine.Pin(23), 28) #RGB此时与 接口E 相连\n" +
|
" if rgbColor1 =='red':\n" +
|
" np[hang2*7+lie2]=(255,0,0)\n" +
|
" elif rgbColor1 =='green':\n" +
|
" np[hang2*7+lie2]=(0,255,0)\n" +
|
" elif rgbColor1 =='blue':\n" +
|
" np[hang2*7+lie2]=(0,0,255)\n" +
|
" elif rgbColor1 =='cyan':\n" +
|
" np[hang2*7+lie2]=(0,255,255)\n" +
|
" elif rgbColor1 =='purple':\n" +
|
" np[hang2*7+lie2]=(255,0,255)\n" +
|
" elif rgbColor1 =='yellow':\n" +
|
" np[hang2*7+lie2]=(255,255,0)\n" +
|
" elif rgbColor1 =='orange':\n" +
|
" np[hang2*7+lie2]=(255,30,0)\n" +
|
" elif rgbColor1 =='pink':\n" +
|
" np[hang2*7+lie2]=(255,0,30)\n" +
|
" elif rgbColor1 == 'white':\n" +
|
" np[hang2*7+lie2]=(150,150,150)\n" +
|
" np.write()\n" +
|
" \n" +
|
"def ledoff(rgbId1):\n" +
|
" import neopixel,machine\n" +
|
" np = neopixel.NeoPixel(machine.Pin(23), 28) #RGB此时与 接口E 相连\n" +
|
" np[rgbId1]=(0,0,0)\n" +
|
" np.write()\n" +
|
" \n" +
|
"def ledoffzb(hang3,lie3):\n" +
|
" import neopixel,machine\n" +
|
" np = neopixel.NeoPixel(machine.Pin(23), 28) #RGB此时与 接口E 相连\n" +
|
" np[hang3*7+lie3]=(0,0,0)\n" +
|
" np.write()\n" +
|
" \n" +
|
"def p0servo(degreeVal):\n" +
|
" p0 = PWM(Pin(32))\n" +
|
" p0.freq(50)\n" +
|
" p0.duty_u16(1638+int((8192-1638)/180*degreeVal))\n" +
|
"\n" +
|
"#森林公园自行车-教研部\n" +
|
"# 2023.06.30\n" +
|
"# end\n"));
|
}
|
public static String getSha1(String str) {
|
char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
'a', 'b', 'c', 'd', 'e', 'f' };
|
try {
|
MessageDigest mdTemp = MessageDigest.getInstance("SHA1");
|
mdTemp.update(str.getBytes("UTF-8"));
|
byte[] md = mdTemp.digest();
|
int j = md.length;
|
char buf[] = new char[j * 2];
|
int k = 0;
|
for (int i = 0; i < j; i++) {
|
byte byte0 = md[i];
|
buf[k++] = hexDigits[byte0 >>> 4 & 0xf];
|
buf[k++] = hexDigits[byte0 & 0xf];
|
}
|
return new String(buf);
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
}
|
