【硬件】树莓派Python编程

原创 已于 2025-08-14 00:37:11 修改 · 720 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #开发语言

于 2025-08-10 16:23:34 首次发布

1. 基础知识

  1. Raspberry Pi Super Kit套件包括传感器模块：树莓派主板、电源适配器、TF卡、读卡器和简单的排线引出I/O口和面包板
    GPIO相关的库，比如RPi.GPIO
# GPIO.output(输出模式）：像开关（控制通断）
# 设置GPIO引脚的电平状态（高电平1/低电平0）用于控制外部设备（如LED、继电器、电机等）
# 修改电平使用GPIO.output是主动控制引脚输出高低电平
# 而GPIO.input是被动读取引脚当前的输入状态
# 硬件限制：GPIO引脚要先设置为GPIO,OUT输出模式才能使用GPIO.output修改电平
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)       # 设置引脚编号模式
GPIO.setup(18, GPIO.OUT)    # 将 GPIO18 设置为输出模式
GPIO.output(18, GPIO.HIGH)  # 输出高电平（3.3V）
GPIO.output(18, GPIO.LOW)   # 输出低电平（0V）

# GPIO.input（输入模式），只能读取外部信号不能主动输出
# 像电压表，只能测量不能改变
# 读取GPIO引脚的当前电平状态，检测外部信号（按钮、传感器、倾斜开关等）
GPIO.setup(17, GPIO.IN) # 将GPIO17设置为输出模式
value = GPIO.input(17) # 读取引脚电平
if value == GPIO.HIGH:
	print("高电平（未按下)")
else:
	print("低电平（按下）")
  1. 电路设计是怎么想到的：
    [1] 硬件特性出发
    1）振动开关：物理振动-电信号变化-检测边沿（上升沿/下降沿）
    2）双色LED：两种颜色需独立控制避免同时点亮（代码中确保红/绿互斥）
    [2] 软件模式
    1）定义明确的状态ON/OFF和转移条件（振动信号变化）
    2）事件驱动：只有状态变化时才触发动作（LED控制、打印日志）
    [3] 经验与调试
    1）调试需求：日志打印makerobo_Print帮助确认硬件响应是否符合预期
    [4] 电路设计的关键步骤
    在这里插入图片描述

1.1 树莓派和BCM

  1. BCM2837B0型号CPU（中央处理器）构建的，树莓派3B更新版本具有完整的性能优化结构和散热器，并且允许更高的时钟频率、准确监控芯片温度
    1）双频无线网卡和蓝牙采用赛普拉斯SYW43455芯片combo与上一代产品，3B+在2.4GHz的数据传输表现更好并且在5GHz的也更好
    LAN951X升级版LAN 7515支持千兆以太网
    2）树莓派3B+拥有的模块包括RAM 1GB LPDDR2( BROADCOM BCM28371.4GHz 64位4核处理器）、以太网（Poe）供电、4个USB2.0端口、以太网端口、千兆以太网卡、RCA av端口音频输出、摄像头接口、HDMI接口、CPU自带散热片、USB电源接口和40个GPIO引脚（背面是天线升级）、双频802.11ac-无线局域网-蓝牙4.2、DSI显示连接器、全新电源管理方案、LED系统指示灯
    a. 以太网供电：Power over Ethernet，简称PoE在以太网中用双绞线传输电力与数据到设备上的技术
    b. 输出电流为2.5A
    3）树莓派4B使用了博通BCM2711处理器，其中包含1.5GHz频率的4核ARM Corte-A72及64位处理器，运行速度是树莓派3B+以上
    a. 树莓派4B这里是HDMI 2.0，而3B是HDMI接口
    b. 扩展接口依然是40针GPIO，内存为1GB、2GB、4GB
    c. 输出电流为3A，
    4）面包板轻松插入和删除，是电子原型设计的基础。蓝线可看作GND, 红线可看作VccV_{cc}Vcc​，面包板中间每5个孔垂直连接、金属片和金属片间不能相连、用户能使用电线或元件水平连接金属板（金属片中间有凹槽）
    a. TF卡：树莓派没有硬盘Micro SD卡是硬盘最小容量为8GB推荐使用内存是16GB和32GB的Micro SD卡，使用读卡器烧录进计算机中
    烧录结束后，TF内存是16GB(8GB、32GB等）烧录后TF卡的内存变为了252MB。烧录结束后的Raspbian系统的TF卡被分成两个分区，一个是FAT32的boot分区，另一个是Ext4的Linux主分区，
    磁盘管理工具查看TF卡的内存分配
    b. 跳线：连接两个端子的电线，将面板版上任何位置的电信号传输到微控制器的输入输出（I/O）引脚上，通过将端部连接器插入面板版中提供的插槽在表面下有几组平行板（根据面积或以行和列为单位的连接槽），可以将端部连接器插入面包板中无需焊接

    跳线的连接方式：母对母、公对公和公对母；跳线颜色不同不代表功能不同，颜色只是为了识别每个电路间的连接

    c. T形转接板：主板上有40个I/O口在实际面包板实验中会采用T形转接板将树莓派的I/O信号转接，方便对树莓派的I/O口进行外接
    d. 7寸显示器：高清多媒体（High Definition Multimedia Interface, HDMI），接口是显示器的标准配置。做实验室时可以选择一个7寸的液晶显示器辅助实验
    e. 2.4G无线键盘、鼠标（选配）：要使用方便携带的键盘、鼠标，可以使用2.4G的无线键盘、鼠标
    树莓派支持多种操作系统，主要包括Raspbian（常用），Windows 10 IoT、Ubuntu Mate等
    5）遍历程序中的每一行

    print("count down")
for count in range(5,0,-1): # 0是不可达的
	print(count)

  2. VNC远程桌面访问：
    1）通过SSH远程连接和VNC连接两种方式远程登录树莓派，通过SSH远程连接（使用Putty工具）登录树莓派

    sudo respi-config

    之后选择5 Interfacing Options界面，然后在3界面种选择P3 VNC服务开启设置选择VNC界面，然后在1 Change User Password for the current user或者使用sudo reboot重新启动树莓派
    2）FileZilla软件建立在SSH下的文件传输软件通过软件能把计算机端编号的程序或其他文件直接传输到树莓派中，之后在计算机端将程序编号并将相关程序直接传输到树莓派系统中运行
    a. 树莓派上使用ifconfig命令获得树莓派的IP地址（192.168.3.114）在用户名中输入pi再密码中输入raspberry
    b. 然后点击窗口“总是信任该主机并将密钥写入缓存”复选框然后点击“确定”即可生成树莓派文件系统

  3. 树莓派配置SSH和连接外网：SSH客户端有很多种，如PuTTY、xShell、手机端JuiceSSH等，以

    // 在COM3-PUTTY界面中输入ping baidu.com
country = CN
ctrl_interface = DIR = /var/run/wpa_supplicant GROUP=netdev
update_config = 1
newtwork = {
	ssid = "将此处内容替换成第一个WIFI的名称" // ssid：替换为你的WiFi名称（保留引号）
	psk = "将此处内容替换成数字，不删除引号" // psk：替换为WiFi密码（保留引号）
	priority = "数字越大代表优先级越高" // priority：数字越大优先级越高（当多个网络可用时）
}
// network：多个网络可以配置多个network块树莓派会自动连接优先级最高的可用网络
// 放入树莓派SD卡的boot分区（首次配置时）
// 同时创建名为ssh的空文件（无扩展名）在同一目录下启用SSH	
network = {
  ssid="你的第二个WiFi名称(可选)"
  psk="第二个WiFi的密码"
  priority=4
}

4 . for循环相关的

	print("count down")
	for count in range(5,1,-1):
		print(count) # 输出不了1因为1不可达

1）C语言的编译（Wall -c “%f” -lwiringPi 和执行-o “%e”“%f” -lwiringPi）
2）生成是make，生成目标文件是make %e.o

2. GPIO口和相应的知识

  1. I/O口定义、C/C++编程相应的
    I/O口的40个引脚。以中间为基准，向两边拓展

    引脚GPIO名称序号名称GPIO引脚
    --3.3V1/25V--
    8R1:0/R2:2SDA03/45V--
    9R1:1/R2:3SCL05/60V--
    74GPIO77/8TXD1415
    --0V9/10RXD1516
    017GPIO011/12GPIO1181
    2R1:21/R2:27GPIO213/140V--
    322GPIO315/16GPIO4234
    --3.3V17/18GPIO5245
    1210MOSI19/200V--
    139MOIS21/22GPIO6256
    1411SCLK23/24CE0810
    --0V25/26CE1711
    300SDA.027/28SCL.0131
    215GPIO.2129/300V1-
    226GPIO.2231/32GPIO.26126
    2313GPIO.2333/340V1-
    2419GPIO.2435/36GPIO.27127
    2526GPIO.2537/38GPIO.282028
    0V39/40GPIO.292129

    这里树莓派有3种引脚编码：根据引脚的物理位置编号，由C语言wiringPi库指定编号，由BCM2837 SOC指定编号
    若基于wiringPi库以C语言运行树莓派GPIO，则需要选择由wiringPi库指定的编号。而wiringPi库中GPIO0引脚对应物理位置编号的引脚11，及物理引脚27对应wiringPi库的GPIO30引脚

  2. RPI.GPIO简介：若用户使用RPi.GPIO提供的API对GPIO进行编程，控制树莓派GPIO通道模块提供了类控制树莓派上的GPIO，在树莓派的Raspbian OS镜像中默认安装了RPi.GPIO
    输入以下命令安装

    sudo apt-get install python-dev

2. 项目和案例

编译、构建

Wall -c "%f" -lwiringPi... # 编译
-o "‘

2.1 双色LED灯

  1. 双色LED灯也称为双基色LED灯，模块只能显示两种颜色（红和绿）-双色灯有三种状态（熄灭、颜色1亮、颜色2亮）、红色表示忙碌/绿色表示就绪
树莓派T形转接板双色LED灯模块
GPIO1GPIO18G(S)
GPIO2GPIO17R(中间）
GNDGNDGND

  1. 实验组件
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创乐博品牌）双色LED灯模板x1
    5）面包板x1
    6）跳线若干

  2. 实验原理：将引脚S（绿色）和中间引脚（红色）连接到树莓派的I/O口上，对树莓派进行编程控制，将双色LED等的颜色从红变为绿，使用PWM（脉冲宽度调制）模块将单种颜色混合成其他颜色。
    在这里插入图片描述

  3. 实验步骤
    1）使用FileZilla软件在树莓派的home目录下pi文件夹中新建一个目录，选择“创建目录”选项， 将01_Double_color_LED/C文件复制到CLBDEMO文件夹种并找到01_Dule_color_LED.c右键选择Geany并运行对应代码

    gcc -Wall -c "%f" -lwiringPi # C语言编译
-o "%e" '%f' | -lwiringPi

    只需在代码后增加-lwiringPi即可后面的内容保持不变
    2）打开01_Dule_color_LED.c
    使用了wiringPi库（C语言的树莓派GPIO库）。使用软件模拟PWM（通过softPwm.h）且要显式初始化（如wiringPiSetup()和更底层的引脚操作）

    #include <wiringPi.h> // 引入wiringPi库的核心头文件，该库用于树莓派GPIO控制的C语言库，对树莓派GPIO引脚的数字输入/输出（如digitalWrite()\digitalRead())中断、时序控制等底层硬件操作的功能
#include <softPwm.h> // 软件实现的PWM（脉冲宽度调制）头文件是wiringPi的扩展功能；当硬件PWM引脚不足可通过软件模拟PWM（控制LED亮度、舵机等，提供softPwmCreate()\softPwmWrite()等）
#include <stdio.h>

#define uchar unsigned char
#define makerobo_Led_PinRed 0   // 红色LED 管脚
#define makerobo_Led_PinGreen 1 // 绿色LED 管教

// LED初始化
void makerobo_LED_Init(void) {
	softPwmCreate(makerobo_Led_PinRed, 0, 100);
	softPwmCreate(makerobo_Led_PinGreen, 0, 100);
}
// 设置LED亮度PWM调节为0x00-0xff
void makerobo_led_ColorSet(uchar r_val, uchar g_val)	{
	softPwmWrite(makerabo_Led_PinRed, r_val);
	softPwmWrite(makerabo_Led_PinRed, g_val); // 绿色 
}
// -------------主程序-----------------
int main(void) {
	// 当初始化连接失败时，将消息打印到屏幕上
	if(wiringPiSetup()==-1){
		printf("Setup wiringPi failed!");
		return 1;
	} 
	makerobo_led_Init(); // LED初始化
	while(1){
		makerobo_led_ColorSet(0xff, 0x00); // 红色
		delay(500);
		makerobo_led_ColorSet(0x00, 0xff); // 绿色
		delay(500);
		makerobo_led_ColorSet(0xff, 0x45);
		delay(500);
		makerobo_led_ColorSet(0xff, 0xff);
		delay(500);
		makerobo_led_ColorSet(0x7c, 0xfc);
		delay(500);    
	}
}

  3）相应的Python代码如下
  使用RPi.GPIO库（Python专用），通过GPIO.PWM直接使用硬件PWM、通过GPIO.setmode()\PWM.start()等通过Python的高层封装简化硬件操作

#!/usr/bin/env python3
#-*- coding: utf-8 -*-
#------湖南创乐博智能科技有限公司--------
#文件名：01_Dule_color_LED.py
#版本：V2.0
#author: zhulian
#说明：双色LED灯实验
#----------------------------------------
import RPi.GPIO as GPIO
import time
colors = [0xFF00, 0x00FF, 0x0FF0, 0xF00F]
makerobo_pins = (11,12)                  # pin引脚字典
GPIO.setmode(GPIO.BOARD)                 # 采用实际的物理引脚给GPIO口
GPIO.setwarnings(False)                  # 去除GPIO口警告
GPIO.setup(makerobo_pins, GPIO.OUT)      # 去除pin引脚为输出
GPIO.setup(makerobo_pins, GPIO.LOW)      # 去除pin引脚为低电平（0V），熄灭LED灯
p_R = GPIO.PWM(makerobo_pins[0], 2000)   # 设置频率为2kHz
p_G = GPIO.PWM(makerobo_pins[1], 2000)   # 设置频率为2kHz

# 初始化占空比为0（熄灭LED灯）
p_R.start(0)
p_G.start(1)
def makerobo_pwm_map(x, in_min, in_max, out_min, out_max):
	return (x-in_min)*(out_max-out_min)/(in_max-in_min) + out_min
def makerobo_set_Color(col):             # 如col=0x1122
	R_val = col >> 8                     # 保留红色分量，col是红色R分量，col是16位数（如0xFF00)而>>8表示右移8位、丢弃低8位保留高8位
	# 若col=0xFF00, 二进制11111111 00000000
	# col>>8右移8后高8位补0，所以R_val=0xFF（红色分量）
	G_val = col & 0x00FF                 # 保留绿色分量
	# 0x00FF是一个位掩码BitMask只保留col的低8位（绿色部分）
	# 设计的原因在于RRRRRRRR GGGGGGGG（假设col是16位数并且前8位是红色、低8位是绿色）

	# 占空比范围映射为0-100,把0-255同比例缩小到0-100
	R_val = makerobo_pwm_map(R_val, 0, 255, 0, 100)
	G_val = makerobo_pwm_map(G_val, 0, 255, 0, 100)

	p_R.ChangeDutyCycle(R_val)           # 改变占空比
	p_G.ChangeDutyCycle(G_val)           # 改变占空比
	# 调用循环函数:
	def makerobo_loop():
		while True:
			for col in colors:
				makerobo_set_Color(col)
				time.asleep(0.5)
	# 释放资源
	def makerobo_loop():
		p_G.stop()
		p_R.stop()
		GPIO.output(makerobo_pins, GPIO.LOW) # 熄灭所有LED灯
		GPIO.cleanup()                   # 释放资源
  
  # 程序入口
  if __name__ == "__main__":
  	try: 	
  		makerobo_loop()                  # 调用循环函数
	except KeyboardInterrupt:            # 当按下Ctrl+C组合键是，执行destroy()子程序
			makerobo_destroy()           # 释放资源

2.2 RGB LED灯实验

  1. 双色LED灯也称为双基色LED灯，模块只能显示两种颜色（红和绿）-双色灯有三种状态（熄灭、颜色1亮、颜色2亮）、红色表示忙碌/绿色表示就绪

  2. 实验组件：
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创乐博）RGB LED 灯模块x1
    5）面包板x1
    6）跳线若干

  3. 实验原理
    使用PWM（脉冲宽度调制）技术控制RGB LED灯的亮度，通常而言这个技术能通过数字信号的方式来控制模拟输出的技术，可以用来控制直流电机的速度、舵机的角度灯。该技术能从恒定电源获得可变电压，而将树莓派生成PWM信号，并改变连接到树莓派上的LED灯亮度演示PWM的调制过程。
    频率为1kHz、占空比为50%, LED灯会500ms内点亮、500ms（一个周期是1000ms）；若将频率提高到100Hz由于切换频率过快、肉眼能看到亮度比较暗但看不到闪烁（视觉暂留效应）。
    频率太低人眼会察觉到闪烁，足够高就会认为亮着
    相关的术语
    1）TonT_{on}Ton​接通时间：信号为高电平
    2）ToffT_{off}Toff​关闭：信号为低电平
    3）周期：接通时间和关闭时间的总和
    4）占空比：一个周期内信号为高电平的时间占比
    在这里插入图片描述

  4. 实验步骤：

树莓派T形转接板双色LED灯模块
GNDGNDGND
GPIO0GPIO17R
GPIO1GPIO18G
GPIO2GPIO27B
  1. 代码实现
    1）C语言
    #include <writingPi.h>
#include <softPwm.h>
#include <stdio.h>

#define uchar unsigned char
#define makerobo_Led_PinRed 0   // 红色LED 管脚
#define makerobo_Led_PinGreen 1 // 绿色LED 管脚
#define makerobo_Led_PinBlue 2 // 蓝色LED 管脚

// LED初始化
void makerobo_led_Init(void) {
	softPwmCreate(makerobo_Led_PinRed, 0, 100);
	softPwmCreate(makerobo_Led_PinGreen, 0, 100);
	softPwmCreate(makerobo_Led_PinBlue, 0, 100);
}

// LED颜色设置
void makerobo_led_Init(void) {
	softPwmWrite(makerobo_Led_PinRed, r_val);
	softPwmWrite(makerobo_Led_PinGreen, g_val);
	softPwmWrite(makerobo_Led_PinBlue, b_val);
}

//----------------主程序-------------------
int main(void) {
	// 当初始化连接失败时，将消息打印到屏幕上
	if(wiringPiSetup()==-1) {
		printf("setup wiringPi failed!");
		return 1;
	}
	makerobo_led_init();// LED初始化
	while(1) {
		makerobo_led_ColorSet(0xff, 0x00, 0x00); // 红色
		delay(500);
		makerobo_led_ColorSet(0x00, 0xff, 0x00); // 绿色
		delay(500);
		makerobo_led_ColorSet(0x00, 0x00, 0xff); 
		delay(500);
		makerobo_led_ColorSet(0xff, 0xff, 0x00); // 黄色 
		delay(500);
		makerobo_led_ColorSet(0xff, 0x00, 0xff); // pick
		delay(500); 
		makerobo_led_ColorSet(0xc0, 0xff, 0x3e); 
		delay(500);
		makerobo_led_ColorSet(0x94, 0x00, 0xd3); 
		delay(500);
		makerobo_led_ColorSet(0x76, 0xee, 0x00); 
		delay(500);
		makerobo_led_ColorSet(0x00, 0xc5, 0xcd); 
		delay(500);
		
	}
	return 0;
}
    2）Python代码
    #!/usr/bin/env python3
#-*- coding: utf-8 -*-
#------湖南创乐博智能科技有限公司--------
#文件名：02_rgb_led.py
#版本：V2.0
#author: zhulian
#说明：RGB LED灯实验
#----------------------------------------
import RPi.GPIO as GPIO
colors = [0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0xFF00FF, 0x00FFFF]
makerobo_pins = (11,12)                  # pin引脚字典
makerobo_R = 11
makerobo_R = 12
makerobo_R = 13
# 初始化程序
def makerobo_setup(Rpin, Gpin, Bpin):
	global pins
	global p_R, p_G, p_B
	pins = {'pin_R':Rpin, 'pin_G':Gpin, 'pin_B':Bpin}
	GPIO.setmode(GPIO.BOARD)             # 采用实际物理引脚给GPIO口
	GPIO.setwarnings(False)              # 去除GPIO口警告
	for i in pins:
		GPIO.setup(pins[i], GPIO.OUT)    # 设置pin模式为输出
		GPIO.output(pins[i], GPIO.LOW)   # 设置pin引脚为低电平（0V)熄灭LED灯
p_R = GPIO.PWN(pins['pin_R'],2000)       # 设置频率为2kHz
p_G = GPIO.PWN(pins['pin_G'],1999)       # 接近2kHz为了测试或避免干扰
p_B = GPIO.PWN(pins['pin_G'],5000)       # 更高频率用于特殊效果如快速亮度变化
# 如果只控制LED灯颜色可以全部用相同频率（2000Hz），不同频率用于特殊场景；若是电机或精密需要调整频率适应不同设备

# 初始化占空比为0（LED灯熄灭）
p_R.start(0)
p_G.start(0)
p_B.start(0)

# 按比例缩放函数
def makerobo_pwm_map(x, in_min, in_max, out_min, out_max):
	return (x-in_min) *(out_max-out_min)/(in_max-in_min) + out_min
	# 线性映射（Linear Mapping）函数将一个数值从一个输入范围**按比例转换**到另一个输出范围，在嵌入式、数据处理、PWM控制等领域很常见
	# x输入值，in_min输入范围的最小值、in_min输入范围的最大值、out_min输出范围的最小值、out_max最大值、output输出值
	# x-in_min计算输入值在输入范围内的相对位置，即输入值距离in_min有多远
	# in_max-in_min计算输入范围的总宽度，
	# out_max-out_min计算输出范围的总宽度
	# (out_max-out_min)/(in_max-in_min)输入和输出的比例关系
	# (x-in_min)*比例因子+out_min = 最终输出值

# 熄灭RGB LED灯
def makerobo_off():
	GPIO.setmode(GPIO.BOARD)             # 采用实际的物理引脚给GPIO
	for i in pins:
		GPIO.setup(pins[i], GPIO.OUT)    # 设置pin为输出模式
		GPIO.setup(pins[i], GPIO.LOW)    # pin为低电平（0V）熄灭LED灯
# 设置颜色
def makerobo_set_Color(col):
	R_val = (col&0xff0000) >> 16
	G_val = (col&0x00ff00) >> 8
	B_val = (col&0x0000ff) >> 0
	# 将0-255同比例缩小到0-100
	R_val = makerobo_pwm_map(R_val, 0, 255, 0, 100)
	R_val = makerobo_pwm_map(R_val, 0, 255, 0, 100)
	R_val = makerobo_pwm_map(R_val, 0, 255, 0, 100)
	
	# 占空比的改变是怎么用到 
	p_R.ChangeDutyCycle(100-R_val)      # 改变占空比
	p_R.ChangeDutyCycle(100-R_val)      # 改变占空比
	p_R.ChangeDutyCycle(100-R_val)      # 改变占空比

# 循环函数
def makerobo_loop():
	while True:
		for col in colors:
			makerobo_set_Color(col)     # 设置颜色
			time.sleep(1)               # 延时1s
# 资源释放
def makerobo_destroy():
	p_R.stop()                          # 关闭红色LED灯
	p_G.stop()                          # 绿色LED灯
	p_B.stop()                          # 蓝色LED
	makerobo_off()                      # 关闭RGB LED灯
	GPIO.cleanup()                      # 释放资源
if __name__ == '__main__':
	try: 
	    # 初始化设置函数 
		makerobo_setup(makerobo_R, makerobo_G, makerobo_B)              
		# 循环函数
		makerobo_loop()
	# 当按下ctrl+C组合键时，将执行destroy()子程序
	except KeyboardInterrupt:
		makerobo_destroy()

2.3 七彩LED灯实验

  1. 七彩LED灯模块内置了IC芯片，因此通电能看到闪烁。采用不同信号的七彩LED模块闪烁情况（快速闪烁和慢速闪烁）等情况有所不同
  2. 实验组件
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创了博）七彩LED灯模块x1
    5）面包板x1
    6）跳线若干
  3. 实验原理
    在这里插入图片描述
  4. 实验步骤
树莓派T形转接板七彩LED等模块
GNDGNDGND（中间引脚）
5V5VVCC(s)

这里的T形转接板T-shaped adapter plate是机械连接部件，用于设备、结构或管道系统，起过渡、转接或固定作用
在这里插入图片描述
而在电路设计（原理图或PCB布局），由于本身是机械结构、原理图中不显示物理形状。T形转接板不会以一个标准符号表示而通过模块或连接方式间接体现，而是通过以下方式体现功能：
1）连接节点：导线交叉点或标签表示多路信号的汇合（如电源分配、信号分支）
2）接口标注：J1\J2等连接器Connector并标注用途（T-Adapter Board）
3）模块框：若转接板集成电路（如电平转换），之后用方框表示、内部标注功能

应用分为：
1）电源分配转接板则是功能将一路输入电源分为两路输出，原理图输入端子->T形节点->两路输出端子（可能加滤波电容）
2）PCB：T形板上布置输入/输出插座，铜箔走线加宽满足电流需求

2.4 继电器模块实验

  1. 实验介绍
    继电器模块指当输入量（激励量）达到规定要求时，在电气输出电路中使被控量发生预定的阶跃变化的一种电气。具有控制系统（输入回路）和被控制系统（输出回路）间的互动关系，实际上用小电流控制大电流运作的“自动开关”，在电路中有自动调节、安全保护、转换电路等作用
    在这里插入图片描述
    此图为1路光耦隔离继电器驱动模块，支持高/低电平触发。
  2. 实验组件
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线
    4）（创乐博）继电器模块x1
    5）跳线若干
  3. 实验原理
    本质是电动开关，通过接收外部的电信号接通和断开电路。嵌入式电气产品中继电器工作方式是首先继电器接收电信号、然后通过断开和闭合开关将信号发送到其他设备上进而控制设备的运行。
    在这里插入图片描述

继电器的工作原理是当它通电时电流流经控制线圈，电磁体通电后衔铁吸引到线圈上将动触点向下拉，以使动触点和常开触点连接，带负载的电路触点将被拉到常闭触点处与其连接，因此带负载的电路断路、电灯熄灭。因此利用继电器的接通和断开控制负载电路的状态，控制电灯点亮和熄灭的电路原理如下所示。
在这里插入图片描述
在实验中，按照电路原理图将SIG引脚连接到树莓派板上。若向SIG引脚发送低电平，则晶体管通电且线圈通电、常开触点闭合（脱离公共端口）；若将SIG引脚发送高电平，则晶体管断电，继电器恢复到初始状态
在这里插入图片描述

  1. 实验步骤
    如上，按照树莓派、T形转接板和继电器模块引脚的连接关系，搭建相应的连接关系
    树莓派、T形转接板 和继电器模块引脚的连接关系包含以下内容

    树莓派T形转接板继电器模块
    GPIO0GPIO17IN
    5V5VDC+
    GNDGNDDC-
    5V5VCOM

    双色LED灯模块、T形转接板和继电器模块引脚的连接关系包括以下内容

    双色LEDT形转接板继电器模块
    中间（R）-NC
    GNDGND-
    S(G)-NO

  2. 代码实现
    1）继电器模拟实验

    #include <wiringPi.h>
#include <stdio.h>
#define makerobo_RelayPin  0  // 继电器Pin引脚
// ---------主程序---------
int main(void) {
	// 当初始化连接失败时，将消息打印到屏幕上
	if(wiringPiSetup()==-1) {
		printf("setup wiringPi failed!");
		return 1;	
	} 
	// 将继电器引脚设置为输出模式
	pinMode(makerobo_RelayPin, OUTPUT);
	while(1) {
		digitalWrite(makerobo_RelayPin, HIGH); // 断开继电器，
		delay(1000);
		digitalWrite(makerobo_RelayPin, LOW); // 关闭继电器
		delay(1000);
	}
	return 0;
}

    2） Python相关的代码

    #!/usr/bin/env python3
#-*- coding: utf-8 -*-
#-----湖南创乐博智能科技---
# 文件名：04_relay.py
# 版本：V2.0
# author: zhulian 
# 说明：继电器模块实验
#---------------------------
import RPi.GPIO as GPIO
import time
makerobo_RelayPin = 11                          # 定义继电器引脚为Pin11
# 初始化工作
def makerobo_setup():
	GPIO.setmode(GPIO.BOARD)                    # 采用实际的物理引脚给GPIO口
	GPIO.setup(makerobo_RelayPin, GPIO.OUT)     # 设置Pin模式为输出
	GPIO.output(makerobo_RelayPin, GPIO.LOW)    # 关闭继电器
# 循环函数
def makerobo_loop():
	while True:
		# 继电器断开
		GPIO.output(makerobo_RelayPin, GPIO.HIGH)
		time.sleep(0.5)
		# 继电器关闭
		GPIO.output(makerobo_RelayPin, GPIO.LOW)
		time.sleep(0.5)

# 释放资源：关闭灯或继电器
def makerobo_destroy():
	GPIO.output(makerobo_RelayPin, GPIO.LOW)    # 关闭继电器
	GPIO.cleanup()                              # 释放资源

# 程序入口
if　__name__='_main_':
	makerobo_setup()                            # 初始化
	try:
		makerobo_loop()                         # 调用循环函数
	except KeyboardInterrupt:                   # 当按下ctrl+c调用destroy()子程序
		makerobo_destroy()                      # 释放资源

2.5 激光传感器实验

  1. 实验介绍：激光传感器常用于测量距离，由激光器、激光检测器和测量电路组成，是一种新型测量仪表（优点在于能实现无接触距离测量）且速度快、精度高、量程大、抗光电干扰能力强
    在这里插入图片描述
    激光传感器的模块由波长为650nm红色激光发射二极管头和一个电阻器组成，外形如上。实验过程中不能指示激光头避免损伤眼睛
  2. 实验组件：
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创乐博）激光传感器模块x1
    5）面包板x1
    6）跳线若干
  3. 实验原理
    工作时，先有激光发射二极管（Laser Diode）对准目标发射激光脉冲，然后经目标反射后激光向各个方向散射，部分散射光返回到接收器被光学系统接收后成像到雪崩光电二极管上（内部具有放大功能的光学传感器，因此能检测微弱的光信号；APD）。
    左侧是激光发射二极管（通过SIG输入了恒流驱动和调制信号），右侧是APD接收端需要高压偏置。
    在这里插入图片描述
    图中的分析，Vcc激光二极管和GND引脚均需要电源供电（Vcc为激光提供驱动电压，GND为共地），前者通常要恒流驱动、APD则需要高压偏置（几十到几百伏）；SIG则代表信号输入（控制激光发射）或信号输出(APD接收的光电流信号）。以上的引脚编号包括1-6。
    连接器标注则包括CN1、SIP-3P是单列3针连接器。激光驱动，SIG可能连接调制信号；若为APD，SIG则是放大后的电信号输出。而这里的SIP-3P是单列3针连接器，用于激光二极管或APD的接口（如激光的阳极、阴极、监测二极管；APD的阴极、阳极、偏置电压）。
    CN1则是外部控制或信号传输的接口，多引脚对应不同功能（激光驱动、APD偏置、温度补偿等）但要具体电路确认。
  4. 实验步骤
    树莓派、T形转接板和激光传感器
树莓派T形转接板激光传感器
GPIO0GPIO17SIG(S)
5v5vVcc
GNDGNDGND(-)
  1. 代码实现
    若是低电平触发（Low-level trigger）的继电器，high表示断开OFF（停止通电）；高电平触发则HIGH表示闭合ON
    1）C语言
    #include <wiringPi.h>
#include <stdio.h>
#define makerobo_LaserPin   0   // 激光传感器引脚定义
int main(void) {
	// 当初始化连接失败时，相关消息输出到屏幕上
	if(wiringPiSetup() == -1) {
		printf("setup wiringPi failed!");
		return 1;
	}
	pinMode(makerobo_LaserPin, OUTPUT); // 激光传感器模块设置为输出模式
	// 这段代码的循环是用来防止程序跑飞的；若程序没有无限循环代码执行后会进入未定义状态（重启或卡死）
	// while(1)确保程序永远在可控循环内运行
	while(1) {// 逻辑是先断开OFF 1s，然后闭合1s如此循环
		digitalWrite(makerobo_RelayPin, HIGH); // 断开继电器
		delay(1000); // 延时1s（常见测试值适用于大多数场景），不加的化快速切换导致继电器机械部件磨损
		digitalWrite(makerobo_RelayPin, LOW); // 关闭继电器
		delay(1000);
	}
	// 代码中HIGH->延时->LOW->延时，生成一个周期性脉冲信号（占空比50%，是0.5Hz）
}

2）Python

import RPi.GPIO as GPIO
import time
makerobo_RelayPin = 11            # 定义继电器引脚为Pin11
# 初始化工作
def makerobo_setup():             
	GPIO.setmode(GPIO.BOARD)      # 实际的物理引脚给GPIO口
	# 设置引脚为输出模式，决定了引脚在电路中的角色和行为
	# 在微控制器（树莓派，Arduino）中，每个GPIO（通用输入输出）引脚都能被配置成两个基本模式
    # 输入模式INPUT：读取外部信号-检测按钮按下、传感器数据
    # 输出模式OUTPUT：主动控制外部设备（点亮LED、驱动继电器）
	GPIO.setmode(makerobo_RelayPin, GPIO.OUT) # 设置Pin为输出模式
	GPIO.output(makerobo_RelayPin, GPIO.LOW)  # 关闭继电器
# 循环函数
def makerobo_loop():
	while True:
		# 继电器断开
		GPIO.output(makerobo_RelayPin, GPIO.HIGH)  
		time.sleep(0.5)
		# 继电器关闭
		GPIO.output(makerobo_RelayPin, GPIO.LOW)
		time.sleep(0.5)

#	释放函数
def makerobo_destroy():
	GPIO.output(makerobo_RelayPin, GPIO.LOW) # 关闭继电器
	GPIO.cleanup()                           # 释放资源
# 程序入口：嵌入式开发中，初始化、循环控制、清理资源是标准流程
if __name__ == '__main__':
	makerobo_setup()                         # 初始化
	try:
		makerobo_loop()                      # 调用循环函数
	except KeyboardInterrupt:           
		makerobo_destroy()

2.6 轻触按键实验

  1. 实验介绍
    1）轻触按键模块最为常见，内部拥有一个轻触拨盘，当按下轻触按键时，输出低电平；松开时保持高电平。能通过LED灯的颜色判断工作状态
    2）外形图：
    在这里插入图片描述

  2. 实验组件
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创乐博）轻触按键模块x1
    5）（创乐博）双色LED灯模块x1
    6）面包板x1
    7）跳线若干

  3. 实验原理
    使用轻触按键作为树莓派的输入设备，按下按键时树莓派的I/O口内检测到低电平（0V)；松开按键时树莓派的I/O口检测到高电平（3.3V）
    在这里插入图片描述

  4. 连接关系
    1）树莓派、T形转接板和轻触按键

    树莓派T形转接板轻触按键
    GPIO0GPIO17SIG(S)
    5V5VVcc
    GNDGNDGND(-)

    2）树莓派、T形转接板和双色LED灯模块

    树莓派T形转接板双色LED
    GPIO1GPIO18R（中间）
    GNDGNDGND
    GPIO2GPIO27G(S)

  5. 实现代码
    在本实验中，双色LED灯模块上的LED灯将闪烁红光。若按下轻触按键，则屏幕上将显示“按下按键”，LED将闪烁绿光；若松开轻触按键，屏幕上将显示“已释放按键”，LED灯将再次闪烁绿光
    1）C语言

    #include <wiringPi.h>
#include <stdio.h>

#define makerobo_BtnPin    0    // 轻触按键Pin引脚
#define makerobo_Rpin      1    // 红色LED灯
#define makerobo_Gpin      2    // 绿色LED灯

// 双色LED灯
void double_colorLED(char* color) {
	pinMode(makerobo_Rpin, OUTPUT);    // 将Rpin设置为输出
	pinMode(makerobo_Gpin, OUTPUT);    // Gpin设置为输出
	if(color=='makeroboRED') {         // 点亮红色灯
		digitalWrite(makerobo_Rpin, HIGH);
		digitalWrite(makerobo_Gpin, LOW);	
	} 		
	else if(color=='makeroboGREEN') {  // 点亮绿色灯
		digitalWrite(makerobo_Rpin, LOW);
		digitalWrite(makerobo_Gpin, HIGH);
	}
	else {
		printf("makerobo Double color LED error");
	}
}
 
int main(void) {
	// 当初始化连接失败时，将消息打印到屏幕上
	if(wiringPiSetup() == -1) {
		printf("setup wiringPi failed!");
		return 1;	
	}
	// 将轻触按键Pin设置为输出模式
	pinMode(makerobo_BtnPin, INPUT);
	double_colorLED("makeroboGREEN");

	while(1) {
		// 轻触按键去除抖动处理
		if(0==digitalRead(makerobo_BtnPin)) { // 有按键按下，digitalRead(makerobo_BtnPin)是读取makerobo_BtnPin引脚的当前电平值（0或1）
			delay(10);                        // 延时去抖动
			if(0 == digitalRead(makerobo_BtnPin)) {
				double_colorLED("makeroboRED"); // 点亮红色LED灯
				printf("Button is pressed\n");  // 打印处有按键按键按下	
			}	
		}
		else if(1==digitalRead(makerobo_BtnPin)) { // 没有按钮按下
			delay(10);
   			if(1==digitalRead(makerobo_BtnPin)){
					while(!digitalRead(makerobo_BtnPin)) 
						double_colorLED("makeroboGREEN"); // 点亮绿色LED灯
						printf("No Button is pressed\n");
 			}
		}
	}
	return 0;
}

   2）Python的代码

	#!/usr/bin/env python3
	#-*-coding:utf-8-*-
	#---------湖南创乐博智能科技有限----------
	# 文件名你
	# 
	######################################
	import RPi.GPIO as GPIO
	makerobo_BtnPin = 11                 # 轻触按键Pin口
	makerobo_Rpin = 12                   # 红色LED灯Pin口
	makerobo_Gpin = 13                   # 绿色LED灯Pin口
	# 初始化GPIO口
	def makerobo_setup():
		GPIO.setmode(GPIO.BOARD)         # 采用实际的物理引脚给GPIO口
		GPIO.setwarings(False)           # 去除GPIO口警告
		GPIO.setup(makerobo_Rpin, GPIO.out) # 设置红色LED灯引脚为输出模式
		# 红色LED灯为makerobo_Rpin
		GPIO.setup(makerobo_Gpin, GPIO.out) # 设置绿色LED灯引脚为输出模式
		GPIO.setup(makerobo_BtnPin, GPIO.IN, pull_up_down = GPIO.PUD_UP)
		# 设置BtnPin引脚为输出模式，上拉至高电平3.3V
		# 中断函数，轻触按键按下时，调用detect函数
		GPIO.add_event_detect(makerobo_BtnPin, GPIO.BOTH, callback=makerobo_detect, bouncetime=200)
		# 双色LED灯模块子函数
		def double_colorLED(x):
			if x==0:                       # 当x=0时点亮红色LED灯
			  # 输出模式
			  # 设置GPIO引脚的电平状态（高电平为1，低电平为0），用于控制外部设备（如LED、继电器、电机等）
			  # 设计原因
			  # 共阴极LED（常见情况）：LED阴极（负极）接地GND，阳极（正极）接GPIO
			  # GPIO=1电流从GPIO流向GND, led亮
			  # GPIO=0无电压差，LED灭
			  # 共阴极：VCC(3.3V)<-电阻<-LED<-GPIO（1=亮，0=灭）
				GPIO.output(makerobo_Rpin, 1) # 输出高电平
				GPIO.output(makerobo_Gpin, 0) 
			if x==1:
				GPIO.output(makerobo_Rpin, 0)
				GPIO.output(makerobo_Gpin, 1)
		# 打印函数
		def makerobo_Print(x):
			if x==0:
				print('*****************************');
				print('* makerobo Raspberry Kit Button Pressed!*);
				print('*****************************');
		# 中断函数：当按键按下时，响应中断函数
		def makerobo_Print(chn):
			# 调用双色LED灯驱动状态函数
			double_colorLED(GPIO.input(makerobo_BtnPin))
			# 打印出GPIO的状态
			makerobo_Print(GPIO.input(makerobo_BtnPin))
		# 循环函数
		def makerobo_loop():
			while True:
				pass
		# 释放资源
		def makerobo_destroy():
			GPIO.output(makerobo_Gpin, GPIO.LOW)
			GPIO.output(makerobo_Rpin, GPIO.LOW)
			GPIO.cleanup()
		# 程序入口
		if __name__ == 'main':
			makerobo_setup()
			try:
				makerobo_loop()
			# 当按下ctrl+c时将执行destroy()子程序
			except KeyboardInterrupt:
				makerobo_destroy()    # 资源释放

2.7 倾斜开关实验

  1. 实验介绍
    倾斜开关传感器内部带有金属球形倾斜开关，用于检测小角度的倾斜。
    开关主要用于倾斜触发报警、倾斜断电灯方面
    在这里插入图片描述

  2. 实验组件
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创乐博品牌）倾斜开关模块x1
    5）（创乐博）双色LED灯模块x1
    6）面包板x1
    7）跳线若干

  3. 实验原理
    倾斜开关内部，不同的角度移动可以触发电路。其开关的结构是双向传导的球形，当金属球向任意一侧倾斜时，只要倾斜角度和力度满足相关条件、开关就会通电，而输出低电平信号
    在这里插入图片描述

  4. 实验步骤
    1）搭建电路
    树莓派、T形转接板和倾斜开关模块引脚的连接关系如下所示

    树莓派T形转接板倾斜开关模块
    GPIO0GPIO17D0
    5V5VVcc
    GNDGNDGND

    树莓派、T形转接板和双色LED灯

    树莓派T形转接板双色LED灯模块
    GPIO1GPIO18R（中间）
    GNDGNDGND（-）
    GPIO2GPIO27G（S）

    2）编程，之后编译、运行，最后退出程序（若不退出程序，会在后台运行干扰其他程序的运行）
    3）若倾斜开关水平放置，则LED灯闪绿光；若倾斜防止，则屏幕显示“Tilt"且LED灯闪红光；若倾斜开关水平放置，再闪绿光

  5. 实现代码
    1）C代码

    #include <wiringPi.h>
#include <stdio.h>

#define makerobo_TiltPin   0              // 倾斜开关引脚定义
#define makerobo_Rpin      1              // 红色LED灯
#define makerobo_Gpin      2              // 绿色LED灯

// 双色LED灯控制函数
void double_colorLED(char* color) {
	pinMode(makerobo_Rpin, OUTPUT);      // 将RPin设置为输出模式
	pinMode(makerobo_Gpin, OUTPUT);      // 将GPin设置为输出
	
	if(color=="makeroboRED") {
		digitalWrite(makerobo_Rpin, HIGH);
		digitalWrite(makerobo_Gpin, LOW);
	} 
	else if(color=="makeroboGREEN") {
		digitalWrite(makerobo_Rpin, LOW);
		digitalWrite(makerobo_Gpin, HIGH);
	} else {
		printf("makerobo Double color LED Error");
	}
}
	
int main(void) {
	// 初始化连接失败时，消息打印到屏幕上
	if(wiringPisetup()==-1) {
		printf("Setup wiringPi failed!");
		return 1;
	} 
	pinMode(makerobo_BtnPin, INPUT);
	double_colorLED("makeroboGREEN");

	while(1) {
		// 倾斜开关去除抖动
		if(0==digiatlRead(makerobo_TiltPin)) {
			// 倾斜开关发生倾斜
			delay(10);
			if(0==digitalRead(makerobo_TiltPin)) {
				double_colorLED("makeroboRED");
				printf("Tilt!\n");
			}
		}
		else if(1==digitalRead(makerobo_TiltPin)) {
			// 倾斜开关没有发生倾斜
			delay(10);
			if(1==digitalRead(makerobo_TiltPin)) {
				// 点亮绿色LED灯
				while(!digitalRead(makerobo_TiltPin);
				double_colorLED("makeroboGREEN"); // 打印出发生倾斜
				printf("No Tilt!\n");
			}
		}
	}
	return 0;
}

    2）Python

    #!/usr/bin/env python3
#-*-
#-----湖南创乐博智能科技有限公司------
# 文件名：07_tilt_switch.py
# 版本：V2.0
# author: zhulian
# 说明：倾斜开关实验
#######################################
import RPi.GPIO as GPIO
makerobo_TiltPin = 11               # 倾斜传感器Pin引脚
makerobo_Rpin = 12                  # 红色LED灯引脚
makerobo_Gpin = 13                  #
# GPIO口
def makerobo_setup():
	GPIO.setmode(GPIO.BOARD)        # 实际的物理引擎给GPIO口
	GPIO.setmode(False)             # 去除GPIO口警告
	# 设置红色LED灯引脚为输出模式
	GPIO.setup(makerobo_Rpin, GPIO.out)
	# 设置绿色LED灯为输出
	GPIO.setup(makerobo_Gpin, GPIO.out)
	GPIO.setup()
	# 设置
	# 中断函数，当发生倾斜时
# 双色LED灯模块驱动子函数
def double_colorLED(x):
	# 设计思路
	#  
	if x==0:                        # 当x=0时，点亮红色LED灯
		GPIO.output(makerobo_Rpin, 1)
		GPIO.output(makerobo_Gpin, 0)
	if x==1:
		GPIO.output(makerobo_Gpin, 0)
		GPIO.output(makerobo_Gpin, 1)
# 打印函数，打印出发生倾斜
def makerobo_Print(x):
	if x==0:
		print("****************************************")
		print("******makerobo Raspberry Kit Tilt!******")
		print("****************************************")
# 中断函数，当倾斜开关倾斜时，响应中断函数
def makerobo_detect(chn):
	double_colorLED(GPIO.input(makerobo_TiltPin))  # 调用双色LED灯驱动函数
	makerobo_Print(GPIO.input(makerobo_TiltPin))   # 打印出倾斜开关信息
# 循环函数
def makerobo_loop():
	while True:
		pass
def destroy():
	GPIO.output(makerobo_Gpin, GPIO.LOW)           # 熄灭绿色LED灯
	GPIO.output(makerobo_Rpin, GPIO.LOW)           # 熄灭红色LED灯
	GPIO.cleanup()                                 # 释放资源
# 程序入口
if __name__ == '_main_':
	makerobo_setup()                               # 初始化GPIO资源
	try: 
		makerobo_loop()           
	except KeyboardInterrupt:
		destroy()

2.8 振动开关实验

  1. 实验介绍
    该模块采用常闭型振动传感器，可用于跟踪振动触发，如防盗报警、智能小车、地震报警等。该震动开关与常开型振动传感器相比，振动触发时间长，且驱动继电器模块
    在这里插入图片描述

  2. 实验组件
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创乐博）振动开关模块x1
    5）（创乐博）双色LED等模块x1
    6）面包板x1
    7）跳线若干

  3. 实验原理
    采用高灵敏震动开关。若振动开关（SIP-2P）处于静止状态，呈开路OFF状态（OFF输出高电平）；若受到外力达到相应的振动，或移动速度达到适当离（偏）心力时导电引脚会瞬间导通，呈导通ON状态
    在这里插入图片描述
    相比于倾斜开关的原理图，这里多了电容和电阻是因为
    1）消抖Debouncing处理（关键区别）：振动开关（如弹簧型）在出发时会产生机械抖动（约10-100ms的断续接触), 导致信号不稳定。电容通过充放特性能吸收瞬间的电压波动形成平滑的开关信号避免误触或多次误检测
    典型值：常用0.1微伏-10微伏的电容，具体取决于抖动持续时间
    而在滤波高频噪声中，振动会引入环境中的高频干扰（电磁噪声），电容可滤除干扰保证信号纯净
    2）电阻作用
    a. 1k欧姆的电阻限制流过LED或敏感元件（如微控制器的GPIO）电流，防止过流损坏。若Vcc=5V，LED压降2V则电流I=(5V-2V)/1kO = 3mA（安全范围内）
    b. 上拉/下拉功能：若电阻连接至Vcc或GND，可为信号线提供稳定电平（避免悬空）确保未触发时处于确定状态（高电平或低电平）
    c. 由于电阻和电容串联，可形成RC时间常数进一步抖动或调整信号响应速度
    根据以上电路，电容是抗抖动、滤波噪声；电阻用于限流、稳定信号电平或配合电容滤波

  4. 实验步骤
    按照上图搭建了树莓派、T形转接板和振动开关模块引脚的连接关系

    树莓派T形转接板振动开关模块
    GPIO0GPIO17DO
    5V5VVcc
    GNDGNDGND

    树莓派、T形转接板和双色LED灯模块引脚的连接

    树莓派T形转接板双色LED
    GPIO1GPIO18R（中间）
    GNDGNDGND(-)
    GPIO2GPIO27G(S)

    若摇晃或敲击震动开关可以看到LED灯闪烁红光；若再次摇晃或敲击震动开关，LED会闪烁绿光。每次摇晃或敲击震动开关都会使LED灯在红和绿间交替变换

  5. 代码实现
    1）C

    #include <wiringPi.h>
#include <stdio.h>
#define makerobo_ViberatePin 0          // 振动开关
#define makerobo_Rpin        1          // 红色LED引脚
#define makerobo_Gpin        2          // 绿色LED
int clb_tmp = 0;                        // clb_tmp减少不必要的操作
// 

// 双色LED灯
void double_colorLED(int color) {
	pinMode(makerobo_Rpin, OUTPUT);
	pinMode(makerobo_Gpin, OUTPUT);

	if(0==color) { // 点亮红色LED
		digitalWrite(makerobo_Rpin, HIGH);
		digitalWrite(makerobo_Gpin, LOW);
	}
	else if(1==color){
		digitalWrite(makerobo_Rpin, LOW);
		digitalWrite(makerobo_Gpin, HIGH);
	}
	else {
		printf("Makerobo Double color LED Error"); // 双色LED显示错误
	}
	// 打印信息
	void makerobo_Print(int x){
		if(x!=clb_tmp) {
			if(x==0)
				printf("...Makerobo ON\n");
			if(x==1) 
				printf("Makerobo OFF...\n");
			clb_tmp = x;
		}
	}
	int main(void) {
		// 状态值
		int clb_status = 0; 
		int clb_tmp = 0; // 比较值
		int clb_value = 1; // 当前值
		// 初始化失败，将消息打印到屏幕上
		if(wiringPiSetup()==-1) {
			printf("setup wiringPi failed!");
			return 1;
		}
		// 振动开关Pin引脚设置为输入
		pinMode(makerobo_VibrationPin, INPUT);
		while(1) {
			// 获取振动开关的值
			clb_value = digitalRead(makerobo_VibratePin);
			// 开关值开始改变
			if(clb_tmp!=clb_value) { // 判断振动开关状态是否发生改变
				clb_status = 0; // 振动开关状态值复位 
			} 
			double_colorLED(clb_status); // 控制双色LED等模块
			makerobo_Print(clb_status); // 打印控制开关的状态
			delay(1000);
		}
	}
	return 0;
}

    2）Python

    # !/usr/bin/env python3
# -*- coding: utf-8 -*-
# --------湖南创乐博智能科技有限公司--------
#  文件名：08_vibration_switch.py
#  版本：V2.0
#  author: zhulian
#  说明：振动开关实验
############################################
import RPi.GPIO as GPIO 
import time
makerobo_ViberatePin = 11           # 振动传感器引脚Pin
makerobo_Rpin = 12                  # 红色LED灯
makerobo_Gpin = 13                  # 绿色LED
clb_tmp = 0                         # 用于比较状态的临时变量，主要作用是检测振动开关状态的变化，并避免重复打印相同的状态信息
# 初始化设置
def makerobo_setup():
	GPIO.setmode(GPIO.BOARD)        # 实际的引擎GPIO口
	GPIO.setwarnings(False)         # 去除GPIO口警告
	GPIO.setup(makerobo_Rpin, GPIO.OUT) # 设置红色LED等的引脚为输出模式
	GPIO.setup(makerobo_Gpin, GPIO.OUT) # 设置绿色LED
	GPIO.setup(makerobo_VibratePin, GPIO.IN, pull_up_down = GPIO.PUD_UP)
# 设置makerobo_VibratePin引脚为输入模式，上拉至高电平3.3V
# 双色LED等模块驱动子函数
def double_colorLED(x):
	if x==0:
		GPIO.output(makerobo_Rpin, 1)
		GPIO.output(makerobo_Gpin, 0)
	if x==1:
		GPIO.output(makerobo_Rpin, 0)
		GPIO.output(makerobo_Gpin, 1)
# 打印信息时，打印出振动开关的状态
def makerobo_Print(x):
	global clb_tmp;
	if x!=clb_tmp:
		if x==0:
			print('*********************')
			print('****Makerobo   ON****')
			print('*********************')
		if x==1:
			print('*********************')
			print('****OFF  Makerobo****')
			print('*********************')
		clb_tmp = x
# 循环函数
def makerobo_loop():
	clb_state = 0
	while True:
		# 判断振动开关的值，若该值为0则有振动产生
		if GPIO.input(makerobo_VibratePin)==1: 
			clb_state = clb_state+1      #　振动开关状态＋１
			if clb_state > 1:
				clb_state = 0            # 振动开关状态值复位
			double_colorLED(clb_state)   # 熄灭红色LED灯
			makerobo_Print(clb_state)    # 熄灭绿色LED灯
			GPIO.cleanup()               # 释放资源
# 程序入口
if __name__ == '__main__':
	makerobo_setup()                     # 初始化设置
	try:
		makerobo_loop()
	except KeyboardInterrupt:
		makerobo_destroy()

2.9 蜂鸣器实验

  1. 实验介绍
    蜂鸣器属于声音模块。其中有源蜂鸣器常用于单一的提示性报警声音，且频率没变化、内置振动器；无源蜂鸣器的驱动方式为频率脉冲驱动，频率有变化
    在这里插入图片描述

  2. 实验组件
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创乐博）有源蜂鸣器模块x1
    5）无源蜂鸣器模块x1
    6）面包板x1
    7）跳线若干

  3. 实验原理
    1）无源蜂鸣器上面带有绿色电路板引脚，和电磁扬声器一样、内部均没有内部驱动电路，故无源蜂鸣器供电的电流是直流电流，因此该蜂鸣器不发出声音。是由于此时的磁路恒定，要用2-5K的方波驱动无源蜂鸣器
    在这里插入图片描述
    2）有源蜂鸣器内部有一个简单的震荡电路，该电路能将恒定的直流电信号转换成具有固定频率的脉冲信号
    3）程序控制方面。单片机的高低电平能控制有源蜂鸣器是否发出声音

  4. 实验步骤
    1）树莓派、T形转接板和有源蜂鸣器模块引脚的连接关系

树莓派T形转接板有源蜂鸣器模块
GPIO0GPIO17I/O
3.3V3.3VVcc
GNDGNDGND

2)前两种和无源蜂鸣器引脚的连接关系

树莓派T形转接板有源蜂鸣器模块
GPIO0GPIO17I/O
3.3V3.3VVcc
GNDGNDGND
  1. 代码实现
    1）C++
    有源蜂鸣器
    #include <wiringPi.h>
#include <stdio.h>
#define makerobo_BuzzePin     0          // 有源蜂鸣器的引脚定义
int main(void) {
	// 初始化连接失败时，将消息打印到屏幕上
	if(wiringPiSetup() == -1) {
		printf("setup wiringPi failed!");
		return 1;
	}
	pinMode(makerobo_BuzzerPin, OUTPUT); // 蜂鸣器
	while(1) {
		// 将有源蜂鸣器设置为低电平触发，使能有源蜂鸣器，让其发声
		digitalWrite(makerobo_BuzzerPin, LOW); 
		delay(100);
		// 将有源蜂鸣器设置为高电平触发，关闭有源蜂鸣器
		digitalWrite(makerobo_BuzzerPin, HIGH);
		delay(100);
	}
	return 0;
}
    无源蜂鸣器
    /************
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
# --------湖南创乐博智能科技有限公司--------
#  文件名：09_passice_buzzer.py
#  版本：V2.0
#  author: zhulian
#  说明：振动开关实验
****************/
#include <wiringPi.h>
#include <softTone.h>
#include <stdio.h>
#define makerobo_BuzPin      0      // 无源蜂鸣器引脚的定义
// 音谱定义
// 低C音符
#define Tone_CL1 131
#define Tone_CL2 147
#define Tone_CL3 165
#define Tone_CL4 175
#define Tone_CL5 196
#define Tone_CL6 221
#define Tone_CL7 248
// 中C音符
#define Tone_CM1 262
#define Tone_CM2 294
#define Tone_CM3 330
#define Tone_CM4 350
#define Tone_CM5 393
#define Tone_CM6 441
#define Tone_CM7 495
// 高C音符
#define Tone_CL1 131
#define Tone_CL2 147
#define Tone_CL3 165
#define Tone_CL4 175
#define Tone_CL5 196
#define Tone_CL6 221
#define Tone_CL7 248
// 第一首歌的音符
int makerobo_song_1[] = {Tone_CM3, Tone_CM5, Tone_CM6, Tone_CM7, Tone_CM3, ...};
// 第一首歌的节拍
int makerobo_beat_1[] = {1,1,3,1,1,3,...};
// 第二首歌的音频
int makerobo_song_2[] = {Tone_CM1, Tone_CM1,...};
// 第二首歌的节拍: 1表示1/8拍
int makerobo_beat_2[] = {1,1,1,3,1,1,...};
int main(void) {
	int i;
	// 当初始化连接失败时，
	if(wiringPiSetup()==-1) {
		printf("makerobo setup wiringPi failed!");
		return 1;
	}
	// 软件模拟Tone库初始化识别
	if(softToneCreate(makerobo_BuzPin)==-1) {
		printf("makerobo setup softTone failed!");
		return 1;
	}
	while(1) {
		printf("makerobo music is being played..");
		// 播放第一首歌曲
		for(i=0; i<sizeof(makerobo_song_1)/4; i++) {
			softToneWrite(makerobo_BuzPin, makerobo_song_1[i]);
			// 第一首歌的音谱
			delay(makerobo_beat_1[i]*500); // 第一首歌曲的节拍
		}
		// 播放第二首歌曲
		for(i=0; i<sizeof(makerobo_song_2)/4; i++){
			softToneWrite(makerobo_BuzPin, makerobo_song_2[i]);
			delay(makerobo_beat_2[i]*500);
		}
	}
	return 0;
}
    2）Python
    # 有源蜂鸣器
##########################################
import RPi.GPIO as GPIO
import time
makerobo_Buzzer = 11           # 有源蜂鸣器引脚的定义
# GPIO设置函数
def makerobo_setup(pin):
	global makerobo_BuzzerPin  
	makerobo_BuzzerPin = pin
	GPIO.setmode(GPIO.BOARD)
	GPIO.setwarnings(False)    # 关闭GPIO口警告提示
	GPIO.setup(makerobo_BuzzerPin, GPIO.OUT) # 设置有源蜂鸣器的引脚为输出方式
	# 若将有源蜂鸣器设置为高电平，则关闭有源蜂鸣器
	GPIO.setup(makerobo_BuzzerPin, GPIO,HIGH)

# 打开有源蜂鸣器
def makerobo_buzzer_on():
	GPIO.output(makerobo_BuzzerPin, GPIO.LOW)
	# 若将有源蜂鸣器设置为低电平触发，则使能有源蜂鸣器发声
	
#关闭有源蜂鸣器
def makerobo_buzzer_off():
	GPIO.output(makerobo_BuzzerPin, GPIO.HIGH)
	# 若将有源蜂鸣器设置为高电平触发，则关闭有源蜂鸣器

# 控制有源蜂鸣器鸣叫
def makerobo_beep(x):
	# 打开有源蜂鸣器控制
	makerobo_buzzer_on()
	time.sleep()
	# 关闭有源蜂鸣器控制
	makerobo_buzzer_off()
	time.sleep()

# 循环时间
def loop():
	while True:
		makerobo_beep(0.5)         # 控制有源蜂鸣器鸣叫，延迟时间为500ms
		
def destroy():
	GPIO.output(makerobo_BuzzerPin, GPIO.HIGH)   # 关闭有源蜂鸣器鸣叫
	GPIO.cleanup()

if __name__ == '__main__':
	makerobo_setup(makerobo_Buzzer)
	try: 
		loop()
	except KeyboardInterrupt:
		destroy() 	

# 无源蜂鸣器
##########################################
import RPi.GPIO as GPIO
import time
makerobo_Buzzer = 11        # 无源蜂鸣器引脚的过程
# 音谱定义
Tone_CL = [0, 131, 147, 165, 175, 196, 211, 248] # 低C音符的频率
Tone_CM = [0, 262, 294, 330, 350, 393, 441, 495] # 中C音符
Tone_CH = [0, 525, 589, 661, 700, 786, 882, 990] # 高C音符
# 第一首歌的音谱
makerobo_song_1 = [Tone_CM[3],...]
# GPIO设置函数 
def makerobo_setup():
	GPIO.setmode(GPIO.BOARD)    # 采用实际的物理引脚给GPIO口
	GPIO.setwarnings(False)     # 关闭GPIO口警告
	GPIO.setup(makerobo_Buzzer, GPIO.out) # 设置无源蜂鸣器的引脚为输出模式
	global makerobo_Buzz        # 指定一个全局变量来替换gpi.pwm
	makerobo_Buzz = GPIO.PWM(makerobo_Buzzer, 440)  # 设置初始频率为440
	makerobo_Buzz.start(50)     # 按50%工作定额启动无源蜂鸣器的引脚

# 循环函数
def makerobo_loop():
	while True:
		# 播放第一首歌曲
		for i in range(1, len(makerobo_song_1)):
			makerobo_Buzz.ChangeFrequency(makerobo_song_1[i])   # 设置歌曲音符的频率
			time.sleep(makerobo_beat_1[i]*0.5);
		time.sleep(1)
		# 播放第二首歌曲
		for i in range(1, len(makerobo_song_2)):
			makerobo_Buzz.ChangeFrequency(makerobo_song_2[i])   # 设置歌曲音符的频率
			time.sleep(makerobo_beat_2[i]*0.5);

# 释放资源函数
def makerobo_destroy():
	makerobo_Buzz.stop()                                    # 停止无源蜂鸣器
	GPIO.output(makerobo_Buzzer, 1)                         # 设置无源蜂鸣器引脚为高电平
	GPIO.cleanup()                                          # 释放资源

if __name__ == '__main__':
	makerobo_setup()
	try:
		makerobo_loop()
	except KeyboardInterrupt:
		makerobo_destroy()

2.10 干簧管

  1. 实验介绍
    干簧管传感器是一种用于检测磁场的传感器，该传感器能用于程控交换机中，如复印机、洗衣机等
  2. 实验组件：
  3. 实验原理：
  4. 实验步骤：
  5. 代码实现：

2.11 U型光电开关实验

  1. 实验介绍
    U型光电开关是一款红外线感应光电产品，集发射器和接线器于一体的光电感情器。发射器和接收器位于U型槽的两侧，并形成一条光轴，当被检测物体经过U型槽且阻断光轴时，U型光电开关产生了检测到的开关信号。
  2. 实验组件：
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创乐博）U型光电传感器模块x1
    5）（创乐博）双色LED灯模块x1
    6）面包板x1
    7）跳线若干
  3. 实验原理
    安全可靠、灵敏度可调，适合检测高速变化的物体，且能分辨透明和半透明物体。而被检测物体经过U型光电开关时，发射器发射足量的红外线，且红外线反射到接收器上，因此U型光电开关产生了开关信号。U型槽的宽度则决定了接收信号的强弱和接收信号的距离
    若以光为媒介，则信号由发光体和受光体间红外光进行接收和转换。本实验中将通过U型光电开关控制LED灯的点亮与熄灭，
  4. 实验步骤：
  5. 代码实现：

2.25 DS18B20 温度传感器

  1. 实验介绍
    DS18B20是Dallas Semiconductor Corp公司生产的单总线接口温度传感器，仅需要一个用于与微控制器的双向通信的数字接口。一种形式是TO-92封装起来的普通晶体管；另一种形式是防水探头式，当要在远处、水下或地下测量温度时，采用防水探头式。
    在这里插入图片描述
  2. 实验组件
    1）树莓派主板x1
    2）树莓派电源适配器x1
    3）40P软排线x1
    4）（创乐博）DS18B20温度传感器模块x1
    5）面包板x1
    6）跳线若干
  3. 实验原理
树莓派Python编程手册
下家山的博客
10-04 5934
第一课：什么是树莓派 第二课：树莓派能做什么 第三课：购买您的第一个树莓派 第四课：如何安装树莓派系统 树莓派可以使用C语言，java，Python，而用python控制树莓派的人越来越多，刚把C语言教程专栏写完，接下来着手python教程。因为要控制硬件，所以我们需要安装一个模块RPi.GPIO. 我们是如何使用RPi.GPIO模块的 下面是简单点亮一个灯的代码，所有硬件操作的函数(方法)都是通过RPi.GPIO这个模块来操作的。 为什么叫RPi.GPIO： RPi这里的R是树莓raspberry的意思
2、树莓派Python编程入门指南
night的博客
06-28 34
本博客是一篇树莓派Python编程的入门指南，涵盖了Raspbian系统基础、配置更改、软件安装以及Python编程的基础知识。通过详细的步骤和示例代码，指导读者进行图形绘制、使用循环与条件语句、函数和方法的应用，并最终实现一个简单的移动方块游戏。适合初学者学习如何在树莓派上使用Python进行编程实践。
树莓派python编程入门与实战_树莓派Python编程入门与实战 PDF 下载
weixin_39627661的博客
11-21 1207
内容提要作者简介前言用Python编程谁应该阅读本书本书体例第一部分 树莓派编程环境第1章 配置树莓派1.1 获取树莓派1.2 获取树莓派1.3 哪些树莓派外围设备是必须的1.4 其他不错的外围设备1.5 决定如何购买外围设备1.6 让你的树莓派正常工作1.7 排除树莓派的故障1.8 小结1.9 Q&A1.10 练习第2章 认识Raspbian Linux发行版2.1 了解Linux2.2 使用R...
树莓派python编程入门与实战解压密码_树莓派Python编程入门与实战
weixin_31600859的博客
02-12 728
目录第一部分　树莓派编程环境第1章　配置树莓派　31.1　获取树莓派　31.1.1　了解树莓派的历史　31.1.2　为什么要学习用Python在树莓派上进行编程　41.2　获取树莓派　51.3　哪些树莓派外围设备是必须的　61.3.1　microSD卡　61.3.2　电源　71.3.3　显示输出　81.3.4　键盘和鼠标　91.3.5　使用网线或者Wi-Fi目录第一部分　树莓派编程环境第1章　配置...
树莓派python编程自学-树莓派Python编程指南 中文PDF扫描版
weixin_37988176的博客
11-01 1533
《树莓派Python编程指南》共12章：第1~3章深入介绍如何在树莓派上使用Python，为学习其他知识打下基础；第4章介绍使用Qt工具包开发图形用户界面；第5章介绍在Python中创建游戏；第6章介绍如何利用GPU来使用OpenGL创建3D场景；第7章讲解如何从网页上抓取信息或使用树莓派为全世界提供内容和服务；第8章介绍使用Python在树莓派中构建自己的游戏世界；第9章使用Python在树莓派...
python树莓派编程下载_树莓派Python编程入门与实战(完整版) 中文pdf扫描版[85MB]
weixin_31515619的博客
01-12 1098
树莓派是一个只有信用卡大小的裸露电路板，它也是一个运行开源Linux操作系统的完全可编程的PC系统。树莓派的官方编程语言是Python，树莓派Python编程入门与实战就介绍了树莓派的Python编程方法。本书共分7个部分。前6个部分介绍了树莓派编程环境、Python基础知识、高级Python、图形编程、业务编程和树莓派Python项目；第7部分通过附录介绍了如何将树莓派操作系统加载到Raspbi...
树莓派python编程案例-树莓派Python编程入门与实战 PDF 高质量扫描第2版
weixin_39686048的博客
11-11 855
第一部分　树莓派编程环境第1章　配置树莓派　31．1　获取树莓派　31．1．1　了解树莓派的历史　31．1．2　为什么要学习用Python在树莓派上进行编程　41．2　获取树莓派　51．3　哪些树莓派外围设备是必须的　61．3．1　microSD卡　61．3．2　电源　71．3．3　显示输出　81．3．4　键盘和鼠标　91．3．5　使用网线或者Wi-Fi适配器　91．4　其他不错的外围设备　91．...
树莓派python编程怎么运行_树莓派怎么运行python程序
weixin_28983299的博客
12-29 1182
树莓派运行Python程序的方法：一、RaspBerry系统设置1、首先在开发板没有通电情况下，连接硬件，以及项目中用到传感器。比如当前项目需要将LED灯插在面包板上，然后通过杜邦线将开发板和面包板连接，硬件平台搭建完毕。2、其次打开树莓派开发板3B，然后用vnc连接上。3、打开ssh功能。如下图，Raspberry Pi Configuration启用SSH连接功能。然后点击OK更改后需要重新启...
树莓派pythongpio编程_树莓派 GPIO 编程
weixin_39603823的博客
12-10 952
树莓派包含GPIO接口，可以跟很多种硬件进行连接，给我们扩展树莓派的功能提供了很多方便的接口。那么，什么是GPIO接口呢？GPIO的定义GPIO是(General Purpose Input Output)的缩写，也就是通用输入输出，是一种常见的硬件接口，用以表示开关量。下图列出列树莓派全系列的图片，其中的针脚就是GPIO接口：树莓派GPIO针脚的定义常见的 Raspberry Pi 接口数量分为...
《树莓派Python编程指南》2018
11-13
本书由树莓派基金会资深软件开发工程师亲笔撰写，是...·理解传感器和GPIO本书深入浅出地介绍每条命令，并辅以生动的例子和源代码，可以帮助你学习Python编程所需的各种知识和技能，是开启Python编程之旅的必备指南。
《树莓派python编程指南》文件
10-10
《树莓派Python编程指南》是一本面向初学者和进阶者的实用教程，旨在帮助读者掌握如何在树莓派上利用Python进行各种有趣的项目开发。这本书涵盖了从基础语法到高级应用的各种主题，通过实例和实践项目让学习过程更加...
java基础知识总结
yvya_的博客
08-19 1569
java 基础包含语法、面向对象，异常处理、文件操作等方面。
【GPT入门】第49课 LlamaFacotory 训练千问
spark_dev的博客
08-20 808
避坑经验：发现先安装vllm后安装LlamaFactory有依赖冲突，改为先安装LlamaFacotory后安装vllm。直接安装 2.2.0，这个安装有点久，耐心等。合并原模型与lora训练结果。autodl的学术加速。训练后，目录结构与大小。
数据预处理数据清洗准备篇-------pandas库的缺失值处理方法
Sunhen_Qiletian的博客
08-20 1251
解析引擎，可选 'c' (C语言引擎，更快) 或 'python' (Python引擎，功能更全)：填充方法 ('backfill', 'bfill', 'pad', 'ffill', None)：0 或 'index' (检查每列)，1 或 'columns' (检查每行)：0 或 'index' (删除行)，1 或 'columns' (删除列)：'any' (有缺失就删除) 或 'all' (全部为缺失才删除)：文件编码，如 'gbk', 'utf-8' 等。
Selenium使用指南
HUACE4600的博客
08-19 1404
前面的代码你看不懂，也没关系，我们再来叙述一下selenium工作的过程1.selenium client(python等语言编写的自动化测试脚本)初始化一个service服务，通过Webdriver启动浏览器驱动程序chromedriver.exe2.通过RemoteWebDriver向浏览器驱动程序发送HTTP请求，浏览器驱动程序解析请求，打开浏览器，并获得sessionid，如果再次对浏览器操作需携带此id。
Huggingface-Qwen2源码解读
Jeremy程序员
08-19 1713
本文记录了基于HuggingFace Transformers最新master分支对Qwen2模型的学习过程。主要内容包括：1) 开发环境搭建（Python 3.11、PyTorch CPU版）；2) 模型测试代码实现，通过调参创建轻量级配置；3) 核心架构分析，包括分词编码、DecoderLayer处理流程（RMSNorm归一化、自注意力机制、前馈网络）和分组查询注意力机制；4) Qwen2的三大优化点：RMSNorm计算优化、RoPE位置编码和GQA注意力机制；5) 开发中遇到的版本依赖问题及解决方法。
疏老师-python训练营-Day53 对抗生成网络
最新发布
weixin_44861705的博客
08-22 499
然后我随机初始化这个造假币的a，我每次给他随机的输入，他会生成不同的假币，每一张假币都会让警察来判断，警察能够分别出真假，如果说你是假的，那么造假币的就要更新参数，如果是真的，那么造假币的参数就不用更新，警察要更新参数。为了让警察能分辨真币，我需要给他看真币的样子，也就是先训练警察知道什么是真币，但是只给他一个真币他也没法训练，我中间得掺杂一些无意义的噪声图片，无意义的肯定不可能是真币，所以他大概可以训练好。那么如何评价好这个分布情况呢？判别器的损失定义在先，生成器的损失定义基于判别器的反馈。
Matplotlib数据可视化实战：Matplotlib图表美化与进阶教程
WSSWWWSSW的博客
08-19 529
摘要 本教程介绍了如何使用Matplotlib库美化数据可视化图表。内容涵盖颜色调整（预定义颜色、十六进制代码、RGB值）、线型修改（虚线、点线等）和标记样式设置（圆形、方形等）。教程还详细讲解了如何自定义字体和文本样式，包括全局字体设置和特定文本元素的样式调整。每个知识点都配有Python代码示例和对应的图表效果展示，帮助用户快速掌握图表美化的实用技巧，提升数据可视化的专业性和美观度。
【无标题】
As3310010的博客
08-20 703
从基础功能到自主决策：Agent 开发进阶之路
树莓派Python编程入门指南
"树莓派Python编程指南.pdf" 这本《树莓派Python编程指南》是专为树莓派用户和编程初学者设计的一本实用教程，由树莓派基金会的资深软件开发工程师编著。书中的内容详尽且易于理解，适合没有编程背景的读者入门。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Alla T

谢谢您，我要养家糊口

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值