智能家居（工厂模式）

最新推荐文章于 2023-02-24 12:15:31 发布
最新推荐文章于 2023-02-24 12:15:31 发布
阅读量247 收藏 2
点赞数
原文链接：https://blog.csdn.net/zouchengzhi1021/article/details/114375529?spm=1001.2014.3001.5502
版权
该博客介绍了智能家居控制系统的框架设计，包括设备控制结构、输入命令处理和特定功能如灯光控制、火焰传感器及语音识别模块。通过创建设备链表和输入命令结构，实现了对不同设备的控制，并通过串口读取声音指令。进一步添加了socket服务器功能，以实现网络通信。最终，通过多线程分别处理语音和网络数据，构建了一个集成了语音和网络控制的智能家居系统。
摘要由CSDN通过智能技术生成

摘自：智能家居
作者：LEO-max
发布时间： 2021-03-05 00:38:07
网址：https://blog.csdn.net/zouchengzhi1021/article/details/114375529?spm=1001.2014.3001.5502

目录

主流程设计框架及某一功能框架编写

头文件：
	contrlDevices.h
	InputCommand.h
源文件：
	mainPro.c
	bathroomLight.c
	Camera.c
	fire.c
	livingroomLight.c
	lock.c
	restaurantLight.c
	socketContrl.c
	upstairLight.c
	usartContrl.c
	voiceContrl.c

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
InputCommand.h框架
struct InputCommander
{
	char commandName[128];	//名字
	char command[32];		//指令
	int (*Init)(char* name, char* ipAddress, char* port);	//操作函数
	int (*getCommand)(char* cmd);	//获得数据

	char log[1024];
	
	struct InputCommander* next;
};

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
contrlDevices.h框架
struct Devices
{
	char devicesName[128];
	int status;				//状态

	int (*open)();			//打开
	int (*close)();			//关闭
	int (*devicesInit)();	//初始化
	
	int (*readStatus)();	//读状态
	int(*changeStatus)(int status);		//改变状态

	struct Devices* next;
};

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
bathroomLight.c框架
#include "contrlDevices.h"

int bathroomLightOpen()
{
	
}

int bathroomLightClose()
{

}

int bathroomLightCloseInit()
{

}

int bathroomLightCloseStatus(int status)
{

}

struct Devices bathroomLight
{
	.name = "bathLight",
	.open = bathroomLightOpen,
	.close = bathroomLightClose,
	.deviceInit = bathroomLightCloseInit,
	.changeStatus = bathroomLightCloseStatus
};

struct Devices* addBathroomLightToDeviceLink(struct Devices* phead)
{
	if (phead == NULL) {
		return &bathroomLight;
	}
	else {
		bathroomLight.next = phead;	//	头插法
		phead = &bathroomLight
	}
};

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

四盏灯、火焰传感器及主程序代码（继电器输入控制）

bathroomLight.c
#include "contrlDevices.h"

int bathroomLightOpen(int pinNum)	//打开
{
	digitalWrite(pinNum, LOW);	//低电平开启
}

int bathroomLightClose(int pinNum)	//关闭
{
	digitalWrite(pinNum, HIGH);	//高电平关闭
}

int bathroomLightCloseInit(int pinNum)	//初始化
{
	pinMode(pinNum, OUTPUT);
	digitalWrite(pinNum, HIGH);
}

int bathroomLightCloseStatus(int status)	//保存
{

}

struct Devices bathroomLight =
{
	.devicesName = "bathLight",
	.pinNum = 22,
	.open = bathroomLightOpen,
	.close = bathroomLightClose,
	.deviceInit = bathroomLightCloseInit,
	.changeStatus = bathroomLightCloseStatus
};

struct Devices* addBathroomLightToDeviceLink(struct Devices* phead)
{
	if (phead == NULL) {
		return &bathroomLight;
	}
	else {
		bathroomLight.next = phead;	//	头插法
		phead = &bathroomLight;
	}
};

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
upstairLight.c
#include "contrlDevices.h"

int upstairsLightOpen(int pinNum)	//打开
{
	digitalWrite(pinNum, LOW);	//低电平开启
}

int upstairsLightClose(int pinNum)	//关闭
{
	digitalWrite(pinNum, HIGH);	//高电平关闭
}

int upstairsLightCloseInit(int pinNum)	//初始化
{
	pinMode(pinNum, OUTPUT);
	digitalWrite(pinNum, HIGH);
}

int upstairsLightCloseStatus(int status)	//保存
{

}

struct Devices upstairsLight =
{
	.devicesName = "upstairsLight",
	.pinNum = 21,
	.open = upstairsLightOpen,
	.close = upstairsLightClose,
	.deviceInit = upstairsLightCloseInit,
	.changeStatus = upstairsLightCloseStatus
};

struct Devices* addUpstairsLightToDeviceLink(struct Devices* phead)
{
	if (phead == NULL) {
		return &upstairsLight;
	}
	else {
		upstairsLight.next = phead;	//	头插法
		phead = &upstairsLight;
	}
};

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
livingroomLight.c
#include "contrlDevices.h"

int livingroomLightOpen(int pinNum)	//打开
{
	digitalWrite(pinNum, LOW);	//低电平开启
}

int livingroomLightClose(int pinNum)	//关闭
{
	digitalWrite(pinNum, HIGH);	//高电平关闭
}

int livingroomLightCloseInit(int pinNum)	//初始化
{
	pinMode(pinNum, OUTPUT);
	digitalWrite(pinNum, HIGH);
}

int livingroomLightCloseStatus(int status)	//保存
{

}

struct Devices livingroomLight =
{
	.devicesName = "livingroomLight",
	.pinNum = 23,
	.open = livingroomLightOpen,
	.close = livingroomLightClose,
	.deviceInit = livingroomLightCloseInit,
	.changeStatus = livingroomLightCloseStatus
};

struct Devices* addLivingroomLightToDeviceLink(struct Devices* phead)
{
	if (phead == NULL) {
		return &livingroomLight;
	}
	else {
		livingroomLight.next = phead;	//	头插法
		phead = &livingroomLight;
	}
};

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
restaurantLight.c
#include "contrlDevices.h"

int livingroomLightOpen(int pinNum)	//打开
{
	digitalWrite(pinNum, LOW);	//低电平开启
}

int livingroomLightClose(int pinNum)	//关闭
{
	digitalWrite(pinNum, HIGH);	//高电平关闭
}

int livingroomLightCloseInit(int pinNum)	//初始化
{
	pinMode(pinNum, OUTPUT);
	digitalWrite(pinNum, HIGH);
}

int livingroomLightCloseStatus(int status)	//保存
{

}

struct Devices livingroomLight =
{
	.devicesName = "livingroomLight",
	.pinNum = 23,
	.open = livingroomLightOpen,
	.close = livingroomLightClose,
	.deviceInit = livingroomLightCloseInit,
	.changeStatus = livingroomLightCloseStatus
};

struct Devices* addLivingroomLightToDeviceLink(struct Devices* phead)
{
	if (phead == NULL) {
		return &livingroomLight;
	}
	else {
		livingroomLight.next = phead;	//	头插法
		phead = &livingroomLight;
	}
};

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
fire.c
#include "contrlDevices.h"


int fireStatusRead(int pinNum)
{
	return digitalWrite(pinNum, HIGH);
}

int fireInit(int pinNum)	//初始化
{
	pinMode(pinNum, INPUT);
	digitalWrite(pinNum, HIGH);
}


struct Devices fire =
{
	.devicesName = "fire",
	.pinNum = 25,
	.deviceInit = fireInit,
	.readStatus = fireStatusRead
};

struct Devices* addFireToDeviceLink(struct Devices* phead)
{
	if (phead == NULL) {
		return &fire;
	}
	else {
		fire.next = phead;	//	头插法
		phead = &fire;
	}
};

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
mainPro.c
#include <stdio.h>
#include <string.h>
#include "contrlDevices.h"

struct Devices* findDeviceByName(char* name, struct Devices* phead)
{
	struct Devices* tmp = phead;
	if (phead == NULL) {
		return NULL;
	}
	else {
		while (tmp != NULL) {
			if (strcmp(tmp->devicesName, name) == 0) {
				return tmp;
			}
			tmp = tmp->next;
		}
		return NULL;
	}
}

int main()
{
	//char* name = "bathroomLight";
	char name[128];
	struct Devices* tmp = NULL;

	if (wiringPiSetup() == -1) {
		return -1;
	}
	struct Devices* pdeviceHead = NULL;
	pdeviceHead = addBathroomLightToDeviceLink(pdeviceHead);
	pdeviceHead = addUpstairsLightToDeviceLink(pdeviceHead);
	pdeviceHead = addLivingroomLightToDeviceLink(pdeviceHead);
	pdeviceHead = addRestaurantLightToDeviceLink(pdeviceHead);
	pdeviceHead = addFireToDeviceLink(pdeviceHead)

	//struct Devices* tmp = findDeviceByName(name, pdeviceHead);
	while(1){
		printf("Inupt:\n");
		scanf("%s", name);
		tmp = findDeviceByName(name, pdeviceHead);

		if (tmp != NULL) {
			tmp->deviceInit(tmp->pinNum);
			tmp->open(tmp->pinNum);
	}

	// 1.指令工厂初始化
	
	// 2.设备控制工厂初始化

	// 3.线程池建立
	// 3.1 语音线程
	// 3.2 socket线程
	// 3.3 摄像头线程
	// 3.4 火灾线程
	
	return 0;
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
contrlDevices.h
#include <wiringPi.h>
#include <stdlib.h>

struct Devices
{
	char devicesName[128];
	int status;				//状态
	int pinNum;

	int (*open)(int pinNum);			//打开
	int (*close)(int pinNum);			//关闭
	int (*deviceInit)(int pinNum);	//初始化
	
	int (*readStatus)();	//读状态
	int(*changeStatus)(int status);		//改变状态

	struct Devices* next;
};

struct Devices* addRestaurantLightToDeviceLink(struct Devices* phead);
struct Devices* addLivingroomLightToDeviceLink(struct Devices* phead);
struct Devices* addBathroomLightToDeviceLink(struct Devices* phead);
struct Devices* addUpstairsLightToDeviceLink(struct Devices* phead);
struct Devices* addFireToDeviceLink(struct Devices* phead)


 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

添加声音识别模块的串口读取功能

voiceContrl.c
#include "InputCommand.h"
#include <wiringPi.h>
#include <wiringSerial.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int voiceInit(struct InputCommander *voicer, char* ipAddress, char* port)
{
	int fd;

	if ((fd = serialOpen(voicer->deviceName, 9600)) == -1) {	//初始化串口，波特率9600
		exit(-1);
	}
	voicer->fd = fd;
	return fd;
}

int voiceGetCommand(struct InputCommander* voicer)
{
	int nread = 0;
	nread = read(voicer->fd, voicer->command, sizeof(voicer->command));
	if (nread == 0) {
		printf("usart for voice read over time\n");
	}
	else {
		return nread;
	}
}

struct InputCommander voiceContrl = 
{
	.commandName = "voice",
	.deviceName = "/dev/ttyAMAO",
	.command = {'\0'},
	.Init = voiceInit,
	.getCommand = voiceGetCommand,
	.log = {'\0'},
	.next = NULL
};

struct InputCommander* addVoiceContrlToCommandLink(struct InputCommander* phead)
{
	if (phead == NULL) {
		return &voiceContrl;
	}
	else {
		voiceContrl.next = phead;	//	头插法
		phead = &voiceContrl;
	}
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
InputCommand.h
#include "InputCommand.h"
#include <wiringPi.h>
#include <wiringSerial.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int voiceInit(struct InputCommander *voicer, char* ipAddress, char* port)
{
	int fd;

	if ((fd = serialOpen(voicer->deviceName, 9600)) == -1) {	//初始化串口，波特率9600
		exit(-1);
	}
	voicer->fd = fd;
	return fd;
}

int voiceGetCommand(struct InputCommander* voicer)
{
	int nread = 0;
	nread = read(voicer->fd, voicer->command, sizeof(voicer->command));
	if (nread == 0) {
		printf("usart for voice read over time\n");
	}
	else {
		return nread;
	}
}

struct InputCommander voiceContrl = 
{
	.commandName = "voice",
	.deviceName = "/dev/ttyAMAO",
	.command = {'\0'},
	.Init = voiceInit,
	.getCommand = voiceGetCommand,
	.log = {'\0'},
	.next = NULL
};

struct InputCommander* addVoiceContrlToCommandLink(struct InputCommander* phead)
{
	if (phead == NULL) {
		return &voiceContrl;
	}
	else {
		voiceContrl.next = phead;	//	头插法
		phead = &voiceContrl;
	}
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
mainPro.c
#include <stdio.h>
#include <string.h>
#include "contrlDevices.h"
#include "InputCommand.h"

struct Devices* findDeviceByName(char* name, struct Devices* phead)
{
	struct Devices* tmp = phead;
	if (phead == NULL) {
		return NULL;
	}
	else {
		while (tmp != NULL) {
			if (strcmp(tmp->devicesName, name) == 0) {
				return tmp;
			}
			tmp = tmp->next;
		}
		return NULL;
	}
}

int main()
{
	//char* name = "bathroomLight";
	char name[128];
	struct Devices* tmp = NULL;

	if (wiringPiSetup() == -1) {
		return -1;
	}
	struct Devices* pdeviceHead = NULL;
	struct InputCommander* pcommandHead = NULL;
	pdeviceHead = addBathroomLightToDeviceLink(pdeviceHead);
	pdeviceHead = addUpstairsLightToDeviceLink(pdeviceHead);
	pdeviceHead = addLivingroomLightToDeviceLink(pdeviceHead);
	pdeviceHead = addRestaurantLightToDeviceLink(pdeviceHead);
	pdeviceHead = addFireToDeviceLink(pdeviceHead);
	pcommandHead = addVoiceContrlToCommandLink(pcommandHead);

	//struct Devices* tmp = findDeviceByName(name, pdeviceHead);
	while(1){
		printf("Inupt:\n");
		scanf("%s", name);
		tmp = findDeviceByName(name, pdeviceHead);

		if (tmp != NULL) {
			tmp->deviceInit(tmp->pinNum);
			tmp->open(tmp->pinNum);
	}

	// 1.指令工厂初始化
	
	// 2.设备控制工厂初始化

	// 3.线程池建立
	// 3.1 语音线程
	// 3.2 socket线程
	// 3.3 摄像头线程
	// 3.4 火灾线程
	
	return 0;
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63

添加socket服务器功能

socketContrl.c
#include "InputCommand.h"
#include <wiringPi.h>
#include <wiringSerial.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>

int socketInit(struct InputCommander* socketMes, char* ipAddress, char* port)
{
	int s_fd;
	int c_fd;

	struct sockaddr_in s_addr;
	/*struct sockaddr_in c_addr;*/

	//做初始化
	memset(&s_addr, 0, sizeof(struct sockaddr_in));
	/*memset(&c_addr, 0, sizeof(struct sockaddr_in));*/

	// socket
	s_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (s_fd == -1) {
		perror("socket");
		exit(-1);
	}

	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(socketMes->port));
	inet_aton(socketMes->ipAddress, &s_addr.sin_addr);

	// bind
	bind(s_fd, (struct sockaddr*) & s_addr, sizeof(struct sockaddr_in));

	//listen
	listen(s_fd, 10);
	socketMes->sfd = s_fd;
	return s_fd;
}

int socketGetCommand(struct InputCommander* socketMes)
{
	int c_fd;
	int n_read;
	struct sockaddr_in c_addr;
	memset(&c_addr, 0, sizeof(struct sockaddr_in));
	int clen = sizeof(struct sockaddr_in);
	c_fd = accept(socketMes->sfd, (struct sockaddr*) & c_addr, &clen);

	n_read = read(c_fd, socketMes->command, sizeof(socketMes->command));
	if (n_read == -1) {
		perror("read");
	}
	else if (n_read > 0) {
		printf("\get:%d\n", n_read);
	}
	else {
		printf("client quit\n");
		
	}

	return n_read;
}

struct InputCommander socketContrl =
{
	.commandName = "socketServer",
	.command = {'\0'},
	.port = "8088",
	.ipAddress = "192.168.4.126",
	.Init = socketInit,
	.getCommand = socketGetCommand,
	.log = {'\0'},
	.next = NULL
};

struct InputCommander* addSocketContrlToCommandLink(struct InputCommander* phead)
{
	if (phead == NULL) {
		return &socketContrl;
	}
	else {
		socketContrl.next = phead;	//	头插法
		phead = &socketContrl;
	}
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
InputCommand.h
#include <wiringPi.h>
#include <stdlib.h>

struct InputCommander
{
	char commandName[128];	//名字
	char deviceName[128];
	char command[32];		//指令
	int (*Init)(struct InputCommander* voicer, char* ipAddress, char* port);	//操作函数
	int (*getCommand)(struct InputCommander* voicer);	//获得数据
	char log[1024];
	int fd;
	char  port[12];
	char ipAddress[32];
	int sfd;
	struct InputCommander* next;
};

struct InputCommander* addVoiceContrlToCommandLink(struct InputCommander* phead);
struct InputCommander* addSocketContrlToCommandLink(struct InputCommander* phead);

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
mainPro.c
#include <stdio.h>
#include <string.h>
#include "contrlDevices.h"
#include "InputCommand.h"

struct Devices* findDeviceByName(char* name, struct Devices* phead)
{
	struct Devices* tmp = phead;
	if (phead == NULL) {
		return NULL;
	}
	else {
		while (tmp != NULL) {
			if (strcmp(tmp->devicesName, name) == 0) {
				return tmp;
			}
			tmp = tmp->next;
		}
		return NULL;
	}
}

int main()
{
	//char* name = "bathroomLight";
	char name[128];
	struct Devices* tmp = NULL;

	if (wiringPiSetup() == -1) {
		return -1;
	}
	struct Devices* pdeviceHead = NULL;
	struct InputCommander* pcommandHead = NULL;
	pdeviceHead = addBathroomLightToDeviceLink(pdeviceHead);
	pdeviceHead = addUpstairsLightToDeviceLink(pdeviceHead);
	pdeviceHead = addLivingroomLightToDeviceLink(pdeviceHead);
	pdeviceHead = addRestaurantLightToDeviceLink(pdeviceHead);
	pdeviceHead = addFireToDeviceLink(pdeviceHead);
	pcommandHead = addVoiceContrlToCommandLink(pcommandHead);
	pcommandHead = addSocketContrlToCommandLink(pcommandHead);

	//struct Devices* tmp = findDeviceByName(name, pdeviceHead);
	while(1){
		printf("Inupt:\n");
		scanf("%s", name);
		tmp = findDeviceByName(name, pdeviceHead);

		if (tmp != NULL) {
			tmp->deviceInit(tmp->pinNum);
			tmp->open(tmp->pinNum);
	}

	// 1.指令工厂初始化
	
	// 2.设备控制工厂初始化

	// 3.线程池建立
	// 3.1 语音线程
	// 3.2 socket线程
	// 3.3 摄像头线程
	// 3.4 火灾线程
	
	return 0;
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64

主程序代码编写，实现语音和网络线程

socketContrl.c
#include "InputCommand.h"
#include <wiringPi.h>
#include <wiringSerial.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int socketInit(struct InputCommander* socketMes, char* ipAddress, char* port)
{
	int s_fd;
	int c_fd;

	struct sockaddr_in s_addr;
	/*struct sockaddr_in c_addr;*/

	//做初始化
	memset(&s_addr, 0, sizeof(struct sockaddr_in));
	/*memset(&c_addr, 0, sizeof(struct sockaddr_in));*/

	// socket
	s_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (s_fd == -1) {
		perror("socket");
		exit(-1);
	}

	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(socketMes->port));
	inet_aton(socketMes->ipAddress, &s_addr.sin_addr);

	// bind
	bind(s_fd, (struct sockaddr*) & s_addr, sizeof(struct sockaddr_in));

	//listen
	listen(s_fd, 10);
	printf("socket Server listening\n");
	socketMes->sfd = s_fd;
	return s_fd;
}

int socketGetCommand(struct InputCommander* socketMes)
{
	int c_fd;
	int n_read=0;
	struct sockaddr_in c_addr;
	memset(&c_addr, 0, sizeof(struct sockaddr_in));
	int clen = sizeof(struct sockaddr_in);
	c_fd = accept(socketMes->sfd, (struct sockaddr*) & c_addr, &clen);

	n_read = read(c_fd, socketMes->command, sizeof(socketMes->command));
	if (n_read == -1) {
		perror("read");
	}
	else if (n_read > 0) {
		printf("\get:%d\n", n_read);
	}
	else {
		printf("client quit\n");
		
	}

	return n_read;
}

struct InputCommander socketContrl =
{
	.commandName = "socketServer",
	.command = {'\0'},
	.port = "8088",
	.ipAddress = "192.168.4.126",
	.Init = socketInit,
	.getCommand = socketGetCommand,
	.log = {'\0'},
	.next = NULL
};

struct InputCommander* addSocketContrlToCommandLink(struct InputCommander* phead)
{
	if (phead == NULL) {
		return &socketContrl;
	}
	else {
		socketContrl.next = phead;	//	头插法
		phead = &socketContrl;
	}
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
voiceContrl.c
#include "InputCommand.h"
#include <wiringPi.h>
#include <wiringSerial.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int voiceInit(struct InputCommander* voicer, char* ipAddress, char* port)
{
	int fd;

	if ((fd = serialOpen(voicer->deviceName, 9600)) == -1) {	//初始化串口，波特率9600
		exit(-1);
	}
	voicer->fd = fd;
	return fd;
}

int voiceGetCommand(struct InputCommander* voicer)
{
	int nread = 0;

	memset(voicer->command, '\0',sizeof(voicer->command));
	nread = read(voicer->fd, voicer->command, sizeof(voicer->command));
	if (nread == 0) {
		printf("voice no datas\n");
	}
	else {
		return nread;
	}
	

}

struct InputCommander voiceContrl = 
{
	.commandName = "voice",
	.deviceName = "/dev/ttyAMAO",
	.command = {'\0'},
	.Init = voiceInit,
	.getCommand = voiceGetCommand,
	.log = {'\0'},
	.next = NULL
};

struct InputCommander* addVoiceContrlToCommandLink(struct InputCommander* phead)
{
	if (phead == NULL) {
		return &voiceContrl;
	}
	else {
		voiceContrl.next = phead;	//	头插法
		phead = &voiceContrl;
	}
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
mainPro.c
#include <stdio.h>
#include <string.h>
#include "contrlDevices.h"
#include "InputCommand.h"
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

//全局变量
struct InputCommander* pcommandHead = NULL;
struct Devices* pdeviceHead = NULL;
struct InputCommander* socketHandler = NULL;
int c_fd;

struct Devices* findDeviceByName(char* name, struct Devices* phead)
{
	struct Devices* tmp = phead;
	if (phead == NULL) {
		return NULL;
	}
	else {
		while (tmp != NULL) {
			if (strcmp(tmp->devicesName, name) == 0) {
				return tmp;
			}
			tmp = tmp->next;
		}
		return NULL;
	}
}

struct InputCommander* findCommandByName(char* name, struct InputCommander* phead)
{
	struct InputCommander* tmp = phead;
	if (phead == NULL) {
		return NULL;
	}
	else {
		while (tmp != NULL) {
			if (strcmp(tmp->commandName, name) == 0) {
				return tmp;
			}
			tmp = tmp->next;
		}
		return NULL;
	}
}

void* voice_thread(void* datas)
{
	struct InputCommander* voiceHandler;
	int nread;

	voiceHandler = findCommandByName("voice", pCommandHead);

	if (voiceHandler == NULL) {
		printf("find voiceHandler error");
		pthread_exit(NULL);
		//return NULL;
	}
	else {
		if (voiceHandler->Init(voiceHandler,NULL,NULL) < 0) {
			printf("voice init error\n");
			pthread_exit(NULL);
			//return NULL;
		}
		else {
			printf("%s init success\n", voiceHandler->commandName);
		}
		while (1) {
			nread = voiceHandler->getCommand(voiceHandler);
			if (nread == 0) {
				printf("nodata from voice\n");
			}
			else {
				printf("do divece contrl:%s\n", voiceHandler->command);

			}
		}
	}
}

void* read_thread(void* datas)
{
	int n_read;
	memset(socketHandler->command,'\0', sizeof(socketHandler->command));
	n_read = read(c_fd, socketHandler->command, sizeof(socketHandler->command));

	if (n_read == -1) {
		perror("read");
	}
	else if (n_read > 0) {
		printf("\nget:%d,%s\n", n_read, socketHandler->command);
	}
	else {
		printf("client quit\n");

	}

	return n_read;
}

void* socket_thread(void* datas)
{
	
	int n_read=0;
	pthread_t* readThread;

	struct sockaddr_in c_addr;
	memset(&c_addr, 0, sizeof(struct sockaddr_in));
	int clen = sizeof(struct sockaddr_in);

	
	//int nread;

	socketHandler = findCommandByName("socketServer", pdeviceHead);

	if (socketHandler == NULL) {
		printf("find socketHandler error");
		pthread_exit(NULL);
		//return NULL;

	}
	else {
		printf("%s init success\n", socketHandler->commandName);
	}
	socketHandler->Init(socketHandler,NULL,NULL);
	while (1) {
		c_fd = accept(socketHandler->sfd, (struct sockaddr*) & c_addr, &clen);
		pthread_create(&readThread, NULL, read_thread, NULL);
	}
}

int main()
{
	//char* name = "bathroomLight";
	char name[128];
	struct Devices* tmp = NULL;

	pthread_t* voiceThread;
	pthread_t* socketThread;

	if (wiringPiSetup() == -1) {
		return -1;
	}

	// 1.指令工厂初始化
	
	pcommandHead = addVoiceContrlToCommandLink(pcommandHead);
	pcommandHead = addSocketContrlToCommandLink(pcommandHead);

	// 2.设备控制工厂初始化
	
	pdeviceHead = addBathroomLightToDeviceLink(pdeviceHead);
	pdeviceHead = addUpstairsLightToDeviceLink(pdeviceHead);
	pdeviceHead = addLivingroomLightToDeviceLink(pdeviceHead);
	pdeviceHead = addRestaurantLightToDeviceLink(pdeviceHead);
	pdeviceHead = addFireToDeviceLink(pdeviceHead);
	
	// 3.线程池建立
	// 3.1 语音线程
	pthread_create(&voiceThread,NULL, voice_thread,NULL);
	// 3.2 socket线程
	pthread_create(&socketThread, NULL, socket_thread, NULL);
	
	// 3.3 摄像头线程
	// 3.4 火灾线程

	//struct Devices* tmp = findDeviceByName(name, pdeviceHead);
	/*
	while (1) {
		printf("Inupt:\n");
		scanf("%s", name);
		tmp = findDeviceByName(name, pdeviceHead);

		if (tmp != NULL) {
			tmp->deviceInit(tmp->pinNum);
			tmp->open(tmp->pinNum);
		}
	}*/

	//不退出，等待线程
	pthread_join(voiceThread,NULL);
	pthread_join(socketThread, NULL);

	
	return 0;
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
行稳方能走远
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
智能家居项目开发（一）：简单工厂设计模式引入
weixin_55374007的博客
11-20 552
设计模式(英语 design pattern)是对面向对象设计中反复出现的问题的解决方案。这个术语是在1990年代由Erich Gamma等人从建筑设计领域引入到计算机科学中来的。这个术语的含义还存有争议。算法不是设计模式，因为算法致力于解决问题而非设计问题。
智能家居项目开发: 设计模式（工厂模式）+ 线程池 + Socket (持续更新中)
weixin_44278698的博客
05-05 4189
智能家居项目开发一、智能家居功能细节拆分控制区：外设区：面向对象类和对象的该概念结构体新玩法二、工厂模式1. 工厂模式的概念2. 工厂模式的实现3. 工厂模式使用及功能验证 一、智能家居功能细节拆分 控制区： 语音识别模块，socket客户端 外设区： 继电器组控制灯，远程终端子系统控制灯，窗帘等，火灾报警，摄像头。 面向对象类和对象的该概念 类：是一种用户定义的引用的数据类型，也称类类型，（结构体） 对象：类的一种具象 struct Animal { char name[128];
智慧家居整体解决方案.ppt
06-23
智慧方案
智能家居
知足且坚定，温柔且上进
03-05 527
目录主流程设计框架及某一功能框架编写InputCommand.h框架contrlDevices.h框架bathroomLight.c框架四盏灯、火焰传感器及主程序代码（继电器输入控制）bathroomLight.cupstairLight.clivingroomLight.crestaurantLight.cfire.cmainPro.ccontrlDevices.h添加声音识别模块的串口读取功能voiceContrl.cInputCommand.hmainPro.c 主流程设计框架及某一功能框架编写 头文
智能家居项目—简单工厂模式
little_rookie__的博客
07-22 381
文章目录前言一、简单工厂模式二、简单工厂模式代码示例 前言 回顾之前我们写的C语言代码，不管是学生成绩管理系统还是FTP服务器，代码逻辑都非常混乱，写着写着就会出错，也不好调试，代码的可扩展性较差。这时候就需要借助设计模式了。 设计模式是代码设计经验的总结，是一系列的编程思想，使得代码的稳定性、拓展性更强。 一、简单工厂模式 简单工厂模式是23种设计模式的一种，是最常用的设计模式之一，这种类型的模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且
智能家居 (3) ——智能家居工厂模式介绍&实现继电器控制灯
zhuguanlin121的博客
05-19 1978
这里写目录标题一级目录往期文章 一级目录 往期文章 智能家居 (1) ——智能家居整体功能框架 智能家居 (2) ——设计模式引入 智能家居 (3) ——工厂模式继电器控制灯 智能家居 (4) ——工厂模式火焰报警器 智能家居 (5) —— LD3320语音模块二次开发 智能家居 (6) ——语音识别控制（多线程） 智能家居 (7) ——网络控制（多线程） 智能家居 (8) ——内容整合（网络TCP、语音控制灯，火灾报警系统） 网络编程知识预备(1) ——了解OSI网络模型 网络编程知识预备(2) ——浅
智能家居工厂模式
weixin_49001476的博客
07-07 156
设计模式，是从建筑设计领域引入到计算机科学中来的，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。是一系列编程的思想，总共有23种设计模式，可以到菜鸟教程里进行系统的学习。要把算法和设计模式区分开，算法是致力于解决问题而非设计问题设计模式通常描述了一组相互紧密作用的类与对象工厂模式（Factory Pattern）是最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在
智能家居——工厂模式
NRWHF的博客
11-16 241
智能家居——工厂模式与智能家居设计
树莓派——智能家居工厂模式实现四个场景灯的控制
weixin_59622415的博客
02-24 217
如上，对比上一篇的room，只需要在outting.c文件内把room改成outting就好了，再更改以下输出引脚号，最后把该设备的成链函数放到contrlDevices.h头文件内即可。如上，用树莓派基于工厂模式完成了四个场景灯的控制。
智能家居的物联网技术及其应用 (1).pdf
07-15
文中提到的“基于感知的智能家居操作模式”强调了感知层数据在智能家居系统中的重要性。通过收集家庭环境中的各种数据，并结合用户的习惯和需求，可以对智能家居系统进行优化和控制，实现更高效的能源管理和更智能的...
智能家居(1) —— 工厂模式引入&工厂模式实现继电器控制
Zy_1213的博客
09-03 1407
1、什么是设计模式 设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 2、类和对象 类是一种用户定义的引用数据类型（结构体），类的实例称为对象。 3、工厂模式 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 工厂模式的实现及验证 四、工厂模式实现继电器控制
树莓派开发实战项目 智能家居--简单工厂模式(简单工厂模式介绍)
zBig_Head的博客
11-03 679
一、智能家居架构代码文件工程 二、搭建模型
树莓派-智能家居-扩展是wemosD1
枕上青灯竹书香的博客
07-25 3814
本文只是匆匆的上传一下代码而已，很多细节比没有讲。 运用的是简单工厂设计模式，简化main函数代码，便于阅读。所有控制以及外设的设备都做成对象，连成一个控制链表，一个外设设备的链表，方便以后功能模块的添加。其中为了能分别做好控制，我们采用多线程来实现。 控制端： 语音控制，socket控制 硬件设备： 树莓派、语音模块、wemos D1、继电器组、433M 射频模块、摄像头、火焰传感器、电磁锁、蜂鸣器。 项目描述： 树莓派机通过串口连接各模块硬件...
AutoTS-0.3.5-py3-none-any.whl.zip
09-01
AutoTS-0.3.5-py3-none-any.whl.zip
基于python的warrior管理系统笔记 (21).zip
最新发布
09-01
基于python的warrior管理系统笔记 (21).zip
弹性力学数值方法：变分法：变分法原理与应用.docx
09-01
弹性力学数值方法：变分法：变分法原理与应用.docx
弹性力学优化算法：蚁群算法(ACO)：弹性力学基础理论.docx
09-01
弹性力学优化算法：蚁群算法(ACO)：弹性力学基础理论.docx
544、基于单片机设计的32x64双色点阵程序、音乐频谱、多功能时钟、温度显示等（原理图、PCB图、设计说明、程序、协议）
09-01
544、基于单片机设计的32x64双色点阵程序、音乐频谱、多功能时钟、温度显示等（原理图、PCB图、设计说明、程序、协议） 音乐频谱--控制卡使用说明： 1、按键S1 亮度控制 说明：一共有10极 按一下亮度加一级 2、按键S2 16分频与64分频切换 3、按键S3 切换柱条和漂浮点颜色 说明：显示颜色有 红柱绿漂 红柱黄漂 绿柱红漂 绿柱黄漂 4、按键S4 无功能 多功能时钟--控制卡使用说明：使用前保证已经下载好对应的功能程序 1、按键S1 时钟复位 2、按键S2 调时模式移位（进行年、月、日、时、分、秒以及补偿时间 、 自动和手动切换显示信息的改变） 3、按键S3 + 4、按键S4 - 自动与手动切换显示的 改变 通过按S2进行菜单调整按到 ，按到点阵屏出现自动或者手动切换界面 ，可以通过S3进行改变手动和自动切换， 如果是自动可以设置自动的时间默认3S。
智能家居设备布置：抽象工厂模式的应用与解耦
在第2.2章的《设计模式》讲义中，王晓蒙教授讨论了抽象工厂模式，针对智能家居设备布置的场景进行教学。用户需要通过智能音箱（SmartBox）连接不同品牌（如小米、华为、海信）的智能设备，比如空调（AirConditioner...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值