Skip to content

C
car-controlserver
Commit 9452065b authored by 957dd's avatar 957dd
Browse files
Options

更新了注释

parents
Show whitespace changes
Inline Side-by-side
Showing with 1621 additions and 0 deletions
Deviceld.txt 0 → 100644
View file @ 9452065b
01030100000000
\ No newline at end of file
httpserver.py 0 → 100755
View file @ 9452065b
import os
import socket
import time
time.sleep(20)
def get_local_ip():
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
ip = s.getsockname()[0]
s.close()
return ip
except Exception as e:
print(f"获取本地IP地址时出错: {e}")
return None
def write_to_file(data):
try:
# 打开文件，模式为写入模式（会清空已有内容）
with open("/home/orangepi/car/master/Deviceld.txt", "w", encoding="utf-8") as file:
file.write(data)
print("数据已成功写入 Deviceld.txt")
except Exception as e:
print(f"写入文件时出错: {e}")
def read_from_file():
try:
if os.path.exists("/home/orangepi/car/master/Deviceld.txt"):
with open("/home/orangepi/car/master/Deviceld.txt", "r", encoding="utf-8") as file:
return file.read()
return "文件内容为空。"
except Exception as e:
print(f"读取文件时出错: {e}")
return "无法读取文件内容。"
if __name__ == '__main__':
local_ip = get_local_ip()
if local_ip is None:
print("无法获取本地IP地址，程序退出。")
else:
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_address = (local_ip, 8080)
server_socket.bind(server_address)
server_socket.listen(5)
print(f'Server is running on http://{server_address[0]}:{server_address[1]}')
while True:
client_socket, client_address = server_socket.accept()
print(f'Accepted connection from {client_address[0]}:{client_address[1]}')
try:
request_data = client_socket.recv(1024).decode('utf-8')
if not request_data:
continue
request_lines = request_data.split('\n')
request_line = request_lines[0]
method, path, _ = request_line.split(' ')
print(f'Received {method} request for {path}')
if method == "POST" and path == "/submit":
# 从请求体中提取数据
body = request_lines[-1] # 请求体在最后一行
data = body.split('=')[1] if '=' in body else body
# 保存数据到文件
write_to_file(data)
# 返回确认响应
response_body = f"""
<html>
<head><title>数据提交成功</title></head>
<body>
<h1>数据已成功提交！</h1>
<a href="/">返回主页</a>
</body>
</html>
"""
status_code = '200 OK'
elif method == "GET" and path == "/":
# 读取文件内容
file_content = read_from_file()
# 返回 HTML 页面
response_body = f'''
<html>
<head>
<title>设备输入页面</title>
<style>
body {{ font-family: Arial, sans-serif; background-color: #f4f4f9; margin: 0; padding: 0; }}
.container {{ max-width: 600px; margin: 50px auto; padding: 20px;
background: white; border-radius: 8px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); }}
h1 {{ text-align: center; }}
textarea {{ width: 100%; height: 150px; margin: 10px 0;
padding: 10px; border: 1px solid #ccc; border-radius: 4px; resize: none; }}
form {{ margin-top: 20px; }}
input[type="text"] {{ width: 90%; padding: 10px;
margin: 10px 0; border: 1px solid #ccc; border-radius: 4px; font-size: 16px; }}
input[type="submit"] {{ background: #007bff; color: white;
padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; font-size: 16px; }}
input[type="submit"]:hover {{ background: #0056b3; }}
</style>
</head>
<body>
<div class="container">
<h1>欢迎进入设备管理界面！</h1>
<textarea readonly>{file_content}</textarea>
<form action="/submit" method="post">
<input type="text" name="data" placeholder="请输入一些数据" required>
<input type="submit" value="提交">
</form>
</div>
</body>
</html>
'''
status_code = '200 OK'
else:
response_body = '<h1>404 Not Found</h1>'
status_code = '404 Not Found'
response_headers = (
f'HTTP/1.1 {status_code}\n'
f'Content-Type: text/html; charset=utf-8\n'
f'Content-Length: {len(response_body.encode("utf-8"))}\n'
f'Connection: close\n\n'
)
response = response_headers + response_body
client_socket.sendall(response.encode('utf-8'))
except Exception as e:
print(f'Error handling request: {e}')
error_response = (
'HTTP/1.1 500 Internal Server Error\n'
'Content-Type: text/html; charset=utf-8\n'
'Connection: close\n\n'
'<h1>500 内部服务器错误</h1>'
)
client_socket.sendall(error_response.encode('utf-8'))
finally:
client_socket.close()
lib/INA226.h 0 → 100644
View file @ 9452065b
#ifndef INA226_H
#define INA226_H
#include <stdint.h>
#include <stdbool.h>
#include <wiringPi.h>
#include <stdio.h>
#include <math.h>
extern int sda_pin; // GPIO0
extern int scl_pin; // GPIO1
#define INA226_ADDRESS (0x40) // INA226 的 I2C 地址
#define INA226_REG_CONFIG (0x00)
#define INA226_REG_SHUNTVOLTAGE (0x01)
#define INA226_REG_BUSVOLTAGE (0x02)
#define INA226_REG_POWER (0x03)
#define INA226_REG_CURRENT (0x04)
#define INA226_REG_CALIBRATION (0x05)
// 初始化 INA226
bool INA226_begin(int sda_pin, int scl_pin);
// 配置 INA226
bool INA226_configure(int sda_pin, int scl_pin);
// 校准 INA226
bool INA226_calibrate(int sda_pin, int scl_pin, float rShuntValue, float iMaxExpected);
// 读取总线电压
float INA226_readBusVoltage(int sda_pin, int scl_pin);
// 读取电流
float INA226_readCurrent(int sda_pin, int scl_pin);
#endif // INA226_H
\ No newline at end of file
lib/delay.h 0 → 100755
View file @ 9452065b
#ifndef __DELAY_H__
#define __DELAY_H__
#include <stdio.h>
#include <time.h>
void Delay_Ms(int sec,int msec);
#endif
\ No newline at end of file
lib/gpio_pwm.h 0 → 100755
View file @ 9452065b
#ifndef __GPIO_PWM_H__
#define __GPIO_PWM_H__
#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
// 定义 PWM 引脚的 WiringPi 编号
void pwm_speed();//pwm控制函数
void midde_pwm();//车pwm停止函数
void speed_change(unsigned char *buf);//速度和转向值处理mqtt函数
void pin_init();//坦克、车的引脚初始化
void pin_all_default();//拉低车的控制引脚
void pin_value(int pin,int value);//控制引脚高低
void pin_ship_init();
void ship_speed_change(unsigned char *buf);
void ship_stop_pwm();//船pwm停止函数
void pin_all_ship_default();//拉低船引脚
#endif
\ No newline at end of file
lib/ip.h 0 → 100755
View file @ 9452065b
#ifndef __IP_H__
#define __IP_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <ifaddrs.h>
extern char ip_address[INET_ADDRSTRLEN];//读到的ip地址
int ipaddr();//ip地址函数
#endif
lib/main.h 0 → 100755
View file @ 9452065b
#ifndef __MAIN_H__
#define __MAIN_H__
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <termios.h>
#include <wiringPi.h>
#include "gpio_pwm.h"
#include "ip.h"
#include "mqtt.h"
#include "delay.h"
#include "opensh.h"
#include "INA226.h"
#define filename "/home/orangepi/car/master/Deviceld.txt"
pthread_t thread[4];
char buffer[30]; // 用于存储文件内容
//开启线程
int thread_start(void *AppExit(void *arg),void *Mqttbeat(void *arg),void *opensh(void *arg),void *Mqtt_onnect(void *arg)){
if(pthread_create(&thread[0],NULL,AppExit,NULL)!=0) {
perror("Failed to create thread 0");
return 0;
}
if(pthread_create(&thread[1],NULL,Mqttbeat,NULL)!=0) {
perror("Failed to create thread 1");
return 1;
}
if(pthread_create(&thread[2],NULL,opensh,NULL)!=0){
perror("Failed to create thread 2");
return 2;
}if(pthread_create(&thread[3],NULL,Mqtt_onnect,NULL)!=0) {
perror("Failed to create thread 3");
return 3;
}
return 0;
}
void *AppExit(void *arg){ //出现意外自动停止
while(1){
Delay_Ms(0,100);
gPwmCount++;
if(gPwmCount>=5)
{
if(AppExit_pin_pwm==1) {//车异常问题处理
midde_pwm();
pin_all_default();
}
if(AppExit_pin_pwm==2) {//坦克异常问题处理
midde_pwm();
pin_all_default();
digitalWrite(2, LOW);
digitalWrite(21, LOW);
}
if(AppExit_pin_pwm==3) {//船异常问题处理
ship_stop_pwm();
pin_all_ship_default();
}
gPwmCount=6;
}
}
return NULL;
}
void *Mqttbeat(void *arg) {
printf("Mqttbeat start\n");
Delay_Ms(15,0);
while(1) {
ipaddr();//获取ip
Delay_Ms(3,0);
mqtt_wirte();//心跳，3s一个
}
return NULL;
}
void *opensh(void *arg) {
Delay_Ms(5,0);
printf("open cam\n");
opencamsh();//10s后打开游览器并且进入网址
return NULL;
}
void *Mqtt_onnect(void *arg) {//mqtt异常处理，断开自动重连，简单粗暴
Delay_Ms(5,0);
mqtt_init();//mqtt初始化
mqtt_create(mosq);//创建mqtt客户端
while(1){
mqtt_create(mosq);//创建mqtt客户端
mqtt_cycle(mosq); //进入mqtt死循环，异常退出继续执行while
}
mqtt_clean(mosq);
return NULL;
}
char *device_inspect() {//读出文件函数
FILE *file;
while (1) {
file = fopen(filename, "r"); // 以只读模式打开文件
if (file == NULL) {
printf("文件 %s 打开失败，等待中...\n", filename);
}
else {
// 尝试读取文件内容
if (fgets(buffer, sizeof(buffer), file) != NULL) {
// 如果文件内容不为空
fclose(file);
printf("读取到文件内容: %s\n", buffer);
return buffer;
} else {
printf("文件为空，等待中...\n");
}
fclose(file);
}
Delay_Ms(1,0); // 等待1秒后再次检查
}
}
// 等待线程结束
void thread_end() {
pthread_join(thread[0], NULL);
pthread_join(thread[1], NULL);
pthread_join(thread[2], NULL);
pthread_join(thread[3], NULL);
}
#endif
\ No newline at end of file
lib/mqtt.h 0 → 100755
View file @ 9452065b
#ifndef __MQTT_H__
#define __MQTT_H__
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <mosquitto.h>
#include <cjson/cJSON.h>
#include<time.h>
#include "ip.h"
#include "opensh.h"
#include "gpio_pwm.h"
#include "INA226.h"
extern char* TOPIC ;//="app2dev/controlcar0004"
extern char* TOPIC2 ;//="dev2app/controlcar0004"
extern char* TOPIC3;//= "controlcar0004"
#define BROKER_ADDRESS "119.45.167.177"
#define BROKER_PORT 1883
extern uint8_t AppExit_pin_pwm;
#define USERNAME "admin" // 替换为你的用户名
#define PASSWORD "admin" // 替换为你的密码
extern struct mosquitto *mosq;//创建客服端
extern time_t gStart;//开始时间戳
extern int gPwmCount; // 计数
extern int gmessage_type;//message消息值
int mqtt_init();//mqtt初始化
void mqtt_create(struct mosquitto *mosq);//创建mqtt客服端
void on_connect(struct mosquitto *mosq, void *obj, int rc);//回调函数
void on_message(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message);//消息回调函数
void mqtt_wirte();//发送mqtt，现为心跳
void mqtt_cycle(struct mosquitto *mosq);//循环
void mqtt_clean(struct mosquitto *mosq);//清理
#endif
\ No newline at end of file
lib/opensh.h 0 → 100755
View file @ 9452065b
#ifndef __opensh_H__
#define __opensh_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "mqtt.h"
int opencamsh();//打开摄像头函数
void refresh_cam();//刷新摄像头函数
#endif
\ No newline at end of file
lib/pthrpoll.h 0 → 100644
View file @ 9452065b
#ifndef PTHRPOLL_H
#define PTHRPOLL_H
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
// 任务结构体
typedef struct Task {
void (*function)(void *);
void *argument;
struct Task *next;
} Task;
// 任务队列结构体
typedef struct {
Task *head;
Task *tail;
int size;
pthread_mutex_t mutex;
pthread_cond_t cond;
} TaskQueue;
// 线程池结构体
typedef struct {
pthread_t *threads;
int thread_count;
TaskQueue task_queue;
int shutdown;
pthread_mutex_t mutex;
} ThreadPool;
#endif
\ No newline at end of file
main 0 → 100755
View file @ 9452065b
File added
makefile 0 → 100755
View file @ 9452065b
# 编译器
CC = gcc
# 编译选项
CFLAGS = -Wall -g -Ilib
# 链接库
LDFLAGS = -lwiringPi -lmosquitto -lcjson -lm
# 目标可执行文件
TARGET = main
# 源文件目录
SRC_DIR = usr src
# 头文件目录
INC_DIR = lib
# 查找所有 .c 文件
SRCS = $(foreach dir,$(SRC_DIR),$(wildcard $(dir)/*.c))
# 目标文件
OBJS = $(SRCS:.c=.o)
# 默认目标
all: $(TARGET)
# 链接目标文件生成可执行文件
$(TARGET): $(OBJS)
$(CC) $(CFLAGS) -o $(TARGET) $(OBJS) $(LDFLAGS)
# 编译每个 .c 文件为 .o 文件
%.o: %.c
$(CC) $(CFLAGS) -c $< -o $@
# 清理生成的文件
clean:
rm -f $(OBJS) $(TARGET)
src/INA226.c 0 → 100644
View file @ 9452065b
#include "INA226.h"
float currentLSB ;
int sda_pin=0; // GPIO0
int scl_pin=1; // GPIO1
// 软件 I2C 延时
void i2c_delay() {
delayMicroseconds(5);
}
// I2C 起始信号
void i2c_start(int sda_pin, int scl_pin) {
digitalWrite(sda_pin, HIGH);
digitalWrite(scl_pin, HIGH);
i2c_delay();
digitalWrite(sda_pin, LOW);
i2c_delay();
digitalWrite(scl_pin, LOW);
i2c_delay();
}
// I2C 停止信号
void i2c_stop(int sda_pin, int scl_pin) {
digitalWrite(sda_pin, LOW);
digitalWrite(scl_pin, LOW);
i2c_delay();
digitalWrite(scl_pin, HIGH);
i2c_delay();
digitalWrite(sda_pin, HIGH);
i2c_delay();
}
// I2C 发送一个字节
void i2c_write_byte(int sda_pin, int scl_pin, uint8_t data) {
for (int i = 7; i >= 0; i--) {
digitalWrite(sda_pin, (data >> i) & 0x01);
i2c_delay();
digitalWrite(scl_pin, HIGH);
i2c_delay();
digitalWrite(scl_pin, LOW);
i2c_delay();
}
// 接收 ACK
pinMode(sda_pin, INPUT);
digitalWrite(scl_pin, HIGH);
i2c_delay();
digitalWrite(scl_pin, LOW);
pinMode(sda_pin, OUTPUT);
}
// I2C 读取一个字节
uint8_t i2c_read_byte(int sda_pin, int scl_pin, bool ack) {
uint8_t data = 0;
pinMode(sda_pin, INPUT);
for (int i = 7; i >= 0; i--) {
digitalWrite(scl_pin, HIGH);
i2c_delay();
data |= (digitalRead(sda_pin) << i);
digitalWrite(scl_pin, LOW);
i2c_delay();
}
// 发送 ACK/NACK
pinMode(sda_pin, OUTPUT);
digitalWrite(sda_pin, ack ? LOW : HIGH);
digitalWrite(scl_pin, HIGH);
i2c_delay();
digitalWrite(scl_pin, LOW);
pinMode(sda_pin, INPUT);
return data;
}
// 初始化 INA226
bool INA226_begin(int sda_pin, int scl_pin) {
pinMode(sda_pin, OUTPUT);
pinMode(scl_pin, OUTPUT);
digitalWrite(sda_pin, HIGH);
digitalWrite(scl_pin, HIGH);
return true;
}
// 配置 INA226
bool INA226_configure(int sda_pin, int scl_pin) {
uint16_t config = 0x4127; // 默认配置：16 次平均，1.1ms 转换时间，连续模式
i2c_start(sda_pin, scl_pin);
i2c_write_byte(sda_pin, scl_pin, INA226_ADDRESS << 1);
i2c_write_byte(sda_pin, scl_pin, INA226_REG_CONFIG);
i2c_write_byte(sda_pin, scl_pin, config >> 8);
i2c_write_byte(sda_pin, scl_pin, config & 0xFF);
i2c_stop(sda_pin, scl_pin);
return true;
}
// 校准 INA226
bool INA226_calibrate(int sda_pin, int scl_pin, float rShuntValue, float iMaxExpected) {
currentLSB = iMaxExpected/32767.0 ; // 计算电流 LSB,/INA226_REG_CALIBRATION
uint16_t calibrationValue = (uint16_t)(0.00512 / (currentLSB * rShuntValue));
i2c_start(sda_pin, scl_pin);
i2c_write_byte(sda_pin, scl_pin, INA226_ADDRESS << 1);
i2c_write_byte(sda_pin, scl_pin, INA226_REG_CALIBRATION);
i2c_write_byte(sda_pin, scl_pin, calibrationValue >> 8);
i2c_write_byte(sda_pin, scl_pin, calibrationValue & 0xFF);
i2c_stop(sda_pin, scl_pin);
return true;
}
// 读取总线电压
float INA226_readBusVoltage(int sda_pin, int scl_pin) {
i2c_start(sda_pin, scl_pin);
i2c_write_byte(sda_pin, scl_pin, INA226_ADDRESS << 1);
i2c_write_byte(sda_pin, scl_pin, INA226_REG_BUSVOLTAGE);
i2c_start(sda_pin, scl_pin);
i2c_write_byte(sda_pin, scl_pin, (INA226_ADDRESS << 1) | 1);
uint8_t high = i2c_read_byte(sda_pin, scl_pin, true);
uint8_t low = i2c_read_byte(sda_pin, scl_pin, false);
i2c_stop(sda_pin, scl_pin);
int16_t value = (high << 8) | low;
return value * 0.00125; // 1.25mV/LSB
}
// 读取电流
float INA226_readCurrent(int sda_pin, int scl_pin) {
i2c_start(sda_pin, scl_pin);
i2c_write_byte(sda_pin, scl_pin, INA226_ADDRESS << 1);
i2c_write_byte(sda_pin, scl_pin, INA226_REG_CURRENT);
i2c_start(sda_pin, scl_pin);
i2c_write_byte(sda_pin, scl_pin, (INA226_ADDRESS << 1) | 1);
uint8_t high = i2c_read_byte(sda_pin, scl_pin, true);
uint8_t low = i2c_read_byte(sda_pin, scl_pin, false);
i2c_stop(sda_pin, scl_pin);
int16_t value = (high << 8) | low;
return value * currentLSB; // 假设电流 LSB 为 1mA
}
\ No newline at end of file
src/INA226.o 0 → 100644
View file @ 9452065b
File added
src/delay.c 0 → 100755
View file @ 9452065b
#include "delay.h"
void Delay_Ms(int sec,int msec)
{
struct timespec ts;
ts.tv_sec = sec; // 秒
ts.tv_nsec = msec*1000000; // 1毫秒 = 1000000纳秒
nanosleep(&ts,NULL);
}
\ No newline at end of file
src/delay.o 0 → 100644
View file @ 9452065b
File added
src/gpio_pwm.c 0 → 100755
View file @ 9452065b
#include "gpio_pwm.h"
// 定义 PWM 引脚的 WiringPi 编号
#define PWM_PIN_SPEED 21
#define PWM_PIN_CHANGE 2
const int gpioWPi[] = {5, 6, 7, 10, 16, 20, 22, 23, 24, 25, 26, 27};//车能使用高低引脚
const int gpioWPi_ship[] = {5, 6, 7,10, 16, 20, 22, 23, 24,25,26, 27};//船能使用高低引脚
void pin_init() {//初始化引脚,车和坦克共用
int gpioCount = sizeof(gpioWPi) / sizeof(gpioWPi[0]);
// 设置所有GPIO为输出模式
for(int i = 0; i < gpioCount; i++) {
pinMode(gpioWPi[i], OUTPUT);
digitalWrite(gpioWPi[i], LOW); // 初始化所有引脚为低电平
}
}
void pin_all_default() {//全部至低电平,车和坦克共用
int gpioCount = sizeof(gpioWPi) / sizeof(gpioWPi[0]);
for (int i=0;i<gpioCount;i++)
{
digitalWrite(gpioWPi[i], LOW);
}
}
void pin_ship_init() {//初始化引脚,车和坦克共用
int gpioCount = sizeof(gpioWPi_ship) / sizeof(gpioWPi_ship[0]);
// 设置所有GPIO为输出模式
for(int i = 0; i < gpioCount; i++) {
pinMode(gpioWPi_ship[i], OUTPUT);
digitalWrite(gpioWPi_ship[i], LOW); // 初始化所有引脚为低电平
}
}
void pin_all_ship_default() {//全部至低电平,船用
int gpioCount = sizeof(gpioWPi_ship) / sizeof(gpioWPi_ship[0]);
for (int i=0;i<gpioCount;i++)
{
digitalWrite(gpioWPi_ship[i], LOW);
}
}
void pin_value(int pin,int value) {
if(value==1) {
digitalWrite(pin, HIGH);
printf("pin:%d,%d\n",pin,HIGH);
}else if(value==0) {
digitalWrite(pin, LOW);
printf("pin:%d,%d\n",pin,LOW);
}
}
void pwm_speed() {
int pwm_clock = 24000000 / (50 * 1000);// 定义 PWM 频率为 50Hz
pinMode(PWM_PIN_SPEED,PWM_OUTPUT);
pinMode(PWM_PIN_CHANGE,PWM_OUTPUT);
pwmSetClock(PWM_PIN_SPEED,pwm_clock);//=19200*1000/(hz*2000)
pwmSetRange(PWM_PIN_SPEED,1000);//占空比范围
pwmSetClock(PWM_PIN_CHANGE,pwm_clock);//=19200*1000/(hz*2000)
pwmSetRange(PWM_PIN_CHANGE,1000);//占空比范围
}
void midde_pwm() {//车停止pwm值
pwmWrite(PWM_PIN_SPEED,75);
pwmWrite(PWM_PIN_CHANGE,70);
}
void ship_stop_pwm() {//船停止pwm值
pwmWrite(PWM_PIN_SPEED,0);
pwmWrite(PWM_PIN_CHANGE,0);
digitalWrite(5, LOW);
digitalWrite(7, LOW);
digitalWrite(24, LOW);
digitalWrite(26, LOW);
}
/*车的速度转向函数*/
void mode_1_flont(unsigned char gval) {
if (gval < 50) {
pwmWrite(PWM_PIN_SPEED, 75);
} else if (gval <= 55) {
pwmWrite(PWM_PIN_SPEED, 72);
} else if (gval <= 60) {
pwmWrite(PWM_PIN_SPEED, 72);
} else if (gval <= 65) {
pwmWrite(PWM_PIN_SPEED, 70);
} else if (gval <= 70) {
pwmWrite(PWM_PIN_SPEED, 70);
} else if (gval <= 75) {
pwmWrite(PWM_PIN_SPEED, 69);
} else if (gval <= 90) {
pwmWrite(PWM_PIN_SPEED, 68);
} else if (gval <= 100) {
pwmWrite(PWM_PIN_SPEED, 68);
} else if (gval <= 110) {
pwmWrite(PWM_PIN_SPEED, 66);
} else if (gval <= 120) {
pwmWrite(PWM_PIN_SPEED, 65);
} else if (gval <= 130) {
pwmWrite(PWM_PIN_SPEED, 64);
} else if (gval <= 140) {
pwmWrite(PWM_PIN_SPEED, 62);
} else if (gval <= 150) {
pwmWrite(PWM_PIN_SPEED, 60);
} else if (gval <= 160) {
pwmWrite(PWM_PIN_SPEED, 59);
} else if (gval <= 170) {
pwmWrite(PWM_PIN_SPEED, 58);
} else if (gval <= 180) {
pwmWrite(PWM_PIN_SPEED, 57);
} else if (gval <= 190) {
pwmWrite(PWM_PIN_SPEED, 56);
} else if (gval <= 200) {
pwmWrite(PWM_PIN_SPEED, 55);
}
}
void mode_2_back(unsigned char gval) {
if(gval<50) {
pwmWrite(PWM_PIN_SPEED,75);
}else if(50<=gval&&gval<=55) {
pwmWrite(PWM_PIN_SPEED,76);
}else if(55<gval&&gval<=60) {
pwmWrite(PWM_PIN_SPEED,77);
}else if(60<gval&&gval<=65) {
pwmWrite(PWM_PIN_SPEED,77);
}else if(65<gval&&gval<=70) {
pwmWrite(PWM_PIN_SPEED,78);
}else if(70<gval&&gval<=75) {
pwmWrite(PWM_PIN_SPEED,78);
}else if(75<gval&&gval<=90) {
pwmWrite(PWM_PIN_SPEED,79);
}else if(90<gval&&gval<=100) {
pwmWrite(PWM_PIN_SPEED,80);
}else if(110<gval&&gval<=120) {
pwmWrite(PWM_PIN_SPEED,81);
}else if(120<gval&&gval<=130) {
pwmWrite(PWM_PIN_SPEED,82);
}else if(130<gval&&gval<=140) {
pwmWrite(PWM_PIN_SPEED,83);
}else if(140<gval&&gval<=150) {
pwmWrite(PWM_PIN_SPEED,84);
}else if(150<gval&&gval<=160) {
pwmWrite(PWM_PIN_SPEED,85);
}else if(160<gval&&gval<=170) {
pwmWrite(PWM_PIN_SPEED,86);
}else if(170<gval&&gval<=180) {
pwmWrite(PWM_PIN_SPEED,87);
}else if(180<gval&&gval<=190) {
pwmWrite(PWM_PIN_SPEED,88);
}else if(190<gval&&gval<=200) {
pwmWrite(PWM_PIN_SPEED,89);
}
}
void mode_3_left(unsigned char gval) {
if (gval < 45) {
pwmWrite(PWM_PIN_CHANGE, 70);
} else if (gval <= 51) {
pwmWrite(PWM_PIN_CHANGE, 80);
} else if (gval <= 57) {
pwmWrite(PWM_PIN_CHANGE, 83);
} else if (gval <= 63) {
pwmWrite(PWM_PIN_CHANGE, 85);
} else if (gval <= 69) {
pwmWrite(PWM_PIN_CHANGE, 90);
} else if (gval <= 75) {
pwmWrite(PWM_PIN_CHANGE, 95);
} else if (gval <= 81) {
pwmWrite(PWM_PIN_CHANGE, 98);
} else if (gval <= 87) {
pwmWrite(PWM_PIN_CHANGE, 100);
} else if (gval <= 93) {
pwmWrite(PWM_PIN_CHANGE, 102);
} else if (gval <= 100) {
pwmWrite(PWM_PIN_CHANGE, 105);
}
}
void mode_4_right(unsigned char gval) {
if (gval < 45) {
pwmWrite(PWM_PIN_CHANGE, 70);
} else if (gval <= 51) {
pwmWrite(PWM_PIN_CHANGE, 60);
} else if (gval <= 57) {
pwmWrite(PWM_PIN_CHANGE, 57);
} else if (gval <= 63) {
pwmWrite(PWM_PIN_CHANGE, 54);
} else if (gval <= 69) {
pwmWrite(PWM_PIN_CHANGE, 50);
} else if (gval <= 75) {
pwmWrite(PWM_PIN_CHANGE, 45);
} else if (gval <= 81) {
pwmWrite(PWM_PIN_CHANGE, 42);
} else if (gval <= 87) {
pwmWrite(PWM_PIN_CHANGE, 40);
} else if (gval <= 93) {
pwmWrite(PWM_PIN_CHANGE, 38);
} else if (gval <= 100) {
pwmWrite(PWM_PIN_CHANGE, 35);
}
}
void speed_change(unsigned char *buf) {//车速度和转向引脚数值处理函数
unsigned char mode=buf[1];
unsigned char val=buf[2];
switch(mode){
case 1:
mode_1_flont(val);
break;
case 2:
mode_2_back(val);
break;
case 3:
mode_3_left(val);
break;
case 4:
mode_4_right(val);
break;
default:
break;
}
}
/*船的速度转向*/
void ship_mode_1_flont(unsigned char gval) {
digitalWrite(5, HIGH);
digitalWrite(7, LOW);
digitalWrite(24, HIGH);
digitalWrite(26, LOW);
if (gval < 50) {
pwmWrite(PWM_PIN_SPEED, 0);
pwmWrite(PWM_PIN_CHANGE, 0);
} else if (gval <= 55) {
pwmWrite(PWM_PIN_SPEED, 200);
pwmWrite(PWM_PIN_CHANGE, 200);
} else if (gval <= 60) {
pwmWrite(PWM_PIN_SPEED, 300);
pwmWrite(PWM_PIN_CHANGE, 300);
} else if (gval <= 65) {
pwmWrite(PWM_PIN_SPEED, 350);
pwmWrite(PWM_PIN_CHANGE, 350);
} else if (gval <= 70) {
pwmWrite(PWM_PIN_SPEED, 400);
pwmWrite(PWM_PIN_CHANGE, 400);
} else if (gval <= 75) {
pwmWrite(PWM_PIN_SPEED, 450);
pwmWrite(PWM_PIN_CHANGE, 450);
} else if (gval <= 90) {
pwmWrite(PWM_PIN_SPEED, 500);
pwmWrite(PWM_PIN_CHANGE, 500);
} else if (gval <= 100) {
pwmWrite(PWM_PIN_SPEED, 550);
pwmWrite(PWM_PIN_CHANGE, 550);
} else if (gval <= 110) {
pwmWrite(PWM_PIN_SPEED, 600);
pwmWrite(PWM_PIN_CHANGE, 600);
} else if (gval <= 120) {
pwmWrite(PWM_PIN_SPEED, 650);
pwmWrite(PWM_PIN_CHANGE, 650);
} else if (gval <= 130) {
pwmWrite(PWM_PIN_SPEED, 700);
pwmWrite(PWM_PIN_CHANGE, 700);
} else if (gval <= 140) {
pwmWrite(PWM_PIN_SPEED, 750);
pwmWrite(PWM_PIN_CHANGE, 750);
} else if (gval <= 150) {
pwmWrite(PWM_PIN_SPEED, 800);
pwmWrite(PWM_PIN_CHANGE, 800);
} else if (gval <= 160) {
pwmWrite(PWM_PIN_SPEED, 850);
pwmWrite(PWM_PIN_CHANGE, 850);
} else if (gval <= 170) {
pwmWrite(PWM_PIN_SPEED, 900);
pwmWrite(PWM_PIN_CHANGE, 900);
} else if (gval <= 180) {
pwmWrite(PWM_PIN_SPEED, 950);
pwmWrite(PWM_PIN_CHANGE, 950);
} else if (gval <= 190) {
pwmWrite(PWM_PIN_SPEED, 1000);
pwmWrite(PWM_PIN_CHANGE, 1000);
} else if (gval <= 200) {
pwmWrite(PWM_PIN_SPEED, 1000);
pwmWrite(PWM_PIN_CHANGE, 1000);
}
}
void ship_mode_2_back(unsigned char gval)
{
digitalWrite(5, LOW);
digitalWrite(7, HIGH);
digitalWrite(24, LOW);
digitalWrite(26,HIGH );
if (gval < 50) {
pwmWrite(PWM_PIN_SPEED, 0);
pwmWrite(PWM_PIN_CHANGE, 0);
} else if (gval <= 55) {
pwmWrite(PWM_PIN_SPEED, 200);
pwmWrite(PWM_PIN_CHANGE, 200);
} else if (gval <= 60) {
pwmWrite(PWM_PIN_SPEED, 300);
pwmWrite(PWM_PIN_CHANGE, 300);
} else if (gval <= 65) {
pwmWrite(PWM_PIN_SPEED, 350);
pwmWrite(PWM_PIN_CHANGE, 350);
} else if (gval <= 70) {
pwmWrite(PWM_PIN_SPEED, 400);
pwmWrite(PWM_PIN_CHANGE, 400);
} else if (gval <= 75) {
pwmWrite(PWM_PIN_SPEED, 450);
pwmWrite(PWM_PIN_CHANGE, 450);
} else if (gval <= 90) {
pwmWrite(PWM_PIN_SPEED, 500);
pwmWrite(PWM_PIN_CHANGE, 500);
} else if (gval <= 100) {
pwmWrite(PWM_PIN_SPEED, 550);
pwmWrite(PWM_PIN_CHANGE, 550);
} else if (gval <= 110) {
pwmWrite(PWM_PIN_SPEED, 600);
pwmWrite(PWM_PIN_CHANGE, 600);
} else if (gval <= 120) {
pwmWrite(PWM_PIN_SPEED, 650);
pwmWrite(PWM_PIN_CHANGE, 650);
} else if (gval <= 130) {
pwmWrite(PWM_PIN_SPEED, 700);
pwmWrite(PWM_PIN_CHANGE, 700);
} else if (gval <= 140) {
pwmWrite(PWM_PIN_SPEED, 750);
pwmWrite(PWM_PIN_CHANGE, 750);
} else if (gval <= 150) {
pwmWrite(PWM_PIN_SPEED, 800);
pwmWrite(PWM_PIN_CHANGE, 800);
} else if (gval <= 160) {
pwmWrite(PWM_PIN_SPEED, 850);
pwmWrite(PWM_PIN_CHANGE, 850);
} else if (gval <= 170) {
pwmWrite(PWM_PIN_SPEED, 900);
pwmWrite(PWM_PIN_CHANGE, 900);
} else if (gval <= 180) {
pwmWrite(PWM_PIN_SPEED, 950);
pwmWrite(PWM_PIN_CHANGE, 950);
} else if (gval <= 190) {
pwmWrite(PWM_PIN_SPEED, 1000);
pwmWrite(PWM_PIN_CHANGE, 1000);
} else if (gval <= 200) {
pwmWrite(PWM_PIN_SPEED, 1000);
pwmWrite(PWM_PIN_CHANGE, 1000);
}
}
void ship_mode_3_left(unsigned char gval)
{
digitalWrite(24, LOW);
digitalWrite(26, LOW);
}
void ship_mode_4_right(unsigned char gval)
{
digitalWrite(5, LOW);
digitalWrite(7, LOW);
}
void ship_speed_change(unsigned char *buf)//船速度和转向引脚数值处理函数
{
unsigned char mode=buf[1];
unsigned char val=buf[2];
switch(mode)
{
case 1:
ship_mode_1_flont(val);
break;
case 2:
ship_mode_2_back(val);
break;
case 3:
ship_mode_3_left(val);
break;
case 4:
ship_mode_4_right(val);
break;
default:
break;
}
}
src/gpio_pwm.o 0 → 100644
View file @ 9452065b
File added
src/ip.c 0 → 100755
View file @ 9452065b
#include "ip.h"
struct ifaddrs *ifap, *ifa;
struct sockaddr_in *sa;
char ip_address[INET_ADDRSTRLEN];
int ipaddr() {//获取ip
if (getifaddrs(&ifap) == -1) {
perror("getifaddrs() error");
return -1;
}
for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
if (ifa->ifa_addr != NULL && ifa->ifa_addr->sa_family == AF_INET) {
sa = (struct sockaddr_in *) ifa->ifa_addr;
inet_ntop(AF_INET, &sa->sin_addr, ip_address, sizeof(ip_address));
}
}
printf("ip:%s\n",ip_address);
freeifaddrs(ifap);
return 0;
}
src/ip.o 0 → 100644
View file @ 9452065b
File added
src/mqtt.c 0 → 100755
View file @ 9452065b
#include "mqtt.h"
char* TOPIC;
char* TOPIC2;
char* TOPIC3;
int gPwmCount = 0; // 计数
int gmessage_type=10086;
int message;//存放gmessage_type的值发送心跳，2，3消息为1；
uint8_t AppExit_pin_pwm=0;//判断坦克或者车的退出
int rc=0;//判断mqtt是否成功创建
unsigned char modeTemp=0;
unsigned char typeTemp=0;
unsigned char pinTemp=0;
unsigned char valTemp=0;
unsigned char gvalt[4];//存放mqtt接收的tpye，mode等
struct mosquitto *mosq;
time_t gStart;
char *glat=NULL;//加入gps后删除，心跳预留，不更改
char *glon=NULL;//加入gps后删除，心跳预留，不更改
int mqtt_init() {
// 初始化 mosquitto 库
mosquitto_lib_init();
mosq = mosquitto_new(NULL, true, NULL);
if (!mosq) {
fprintf(stderr, "Failed to create Mosquitto client\n");
return -1;
}
mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
return 0;
}
void on_connect(struct mosquitto *mosq, void *obj, int rc) {//回调函数
if (rc == 0)
{
printf("Connected to broker\n");
mosquitto_subscribe(mosq, NULL, TOPIC, 0);
}
else
{
fprintf(stderr, "Connection failed with code %d\n", rc);
}
}
void mqtt_wirte(){//心跳格式
float voltage = INA226_readBusVoltage(sda_pin, scl_pin);
float current = INA226_readCurrent(sda_pin, scl_pin);
char voltage_str[20]; // 足够存储转换后的字符串的缓冲区
sprintf(voltage_str, "%.2f", voltage);
char current_str[20]; // 足够存储转换后的字符串的缓冲区
sprintf(current_str, "%.2f", current);
message=1;
cJSON *root = cJSON_CreateObject();
cJSON *body = cJSON_CreateObject();
cJSON *head = cJSON_CreateObject();
cJSON_AddStringToObject(body, "ip", ip_address);
cJSON_AddStringToObject(body, "ID", TOPIC);
cJSON_AddStringToObject(body, "V:", voltage_str);
cJSON_AddStringToObject(body, "I:", current_str);
cJSON_AddStringToObject(body, "N", glat);
cJSON_AddStringToObject(body, "E", glon);
cJSON_AddNumberToObject(head, "message_type",message);
cJSON_AddItemToObject(root, "body", body);
cJSON_AddItemToObject(root, "head",head);
char *payload = cJSON_PrintUnformatted(root);
printf("%s\n",payload);
mosquitto_publish(mosq, NULL, TOPIC2, strlen(payload), payload, 0, false);
mosquitto_publish(mosq, NULL, TOPIC3, strlen(payload), payload, 0, false);
}
void message_3(cJSON *body,cJSON *pwm_ctrl){//message_type为3，控制pwm
cJSON *mode = cJSON_GetObjectItem(pwm_ctrl, "mode"); //mode=1 速度，mode=2 转向(unsigned char)
cJSON *type = cJSON_GetObjectItem(pwm_ctrl, "type");
cJSON *val = cJSON_GetObjectItem(pwm_ctrl, "val"); //val为pwm的值 0~100(unsigned char)(unsigned char)
modeTemp= mode->valueint;
typeTemp=type->valueint;
valTemp= val->valueint;
if(typeTemp==3){
valTemp= val->valueint;
}
gvalt[0]=typeTemp;
gvalt[1]=modeTemp;
gvalt[2]=valTemp;
gPwmCount = 0;
printf("typeTemp:%d\n",gvalt[0]);
printf("modeTemp:%d\n",gvalt[1]);
printf("valTemp:%d\n",gvalt[2]);
if(AppExit_pin_pwm==1)speed_change(gvalt);
if(AppExit_pin_pwm==3)ship_speed_change(gvalt);
}
void message_4(cJSON *body, cJSON *pin_setctrl){//message 为4时候
cJSON *pin = cJSON_GetObjectItem(pin_setctrl, "pin");
cJSON *val = cJSON_GetObjectItem(pin_setctrl, "val"); //val为pwm的值 0~100(unsigned char)(unsigned char)
pinTemp=pin->valueint;
valTemp= val->valueint;
if(valTemp>=1){
valTemp=1;
}
gPwmCount=0;
gvalt[0]=0;
gvalt[1]=pinTemp;
gvalt[2]=valTemp;
printf("pinTemp:%d\n",gvalt[1]);
printf("valTemp:%d\n",gvalt[2]);
pin_value(gvalt[1],gvalt[2]);
}
void on_message(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message) {//消息回环函数
time_t end = time(NULL);
if(gStart+5>end){
printf("正在处理过期消息\n");
return;
}
// 确保消息有效
if (message->payload && message->payloadlen) { // 将消息内容转换为字符串
char *payload_str = (char *)malloc(message->payloadlen + 1);
if (!payload_str) {
return;
}
memcpy(payload_str, message->payload, message->payloadlen);
payload_str[message->payloadlen] = '\0';
// 解析 JSON
cJSON *json = cJSON_Parse(payload_str);
if (json == NULL) {
fprintf(stderr, "Error before: [%s]\n", cJSON_GetErrorPtr());
free(payload_str);
}
else {// 提取 head 对象
cJSON *head = cJSON_GetObjectItem(json, "head");
if (!cJSON_IsObject(head)) {
free(payload_str);
return;
}
// 提取 message_type
cJSON *message_type = cJSON_GetObjectItem(head, "message_type");
if (!cJSON_IsNumber(message_type)) {
free(payload_str);
return;
}
//提取 body数据段
cJSON *body = cJSON_GetObjectItem(json, "body");
if (!cJSON_IsObject(body)) {
free(payload_str);
return;
}
cJSON *pwm_ctrl = cJSON_GetObjectItem(body, "pwm_ctrl");
cJSON *pin_setctrl = cJSON_GetObjectItem(body, "pin_setctrl");
if(pwm_ctrl==NULL||pin_setctrl==NULL){
free(payload_str);
return;
}
gmessage_type=message_type->valueint;
printf("message_type: %d\n",message_type->valueint);
switch(gmessage_type){
case 1:
system("sudo reboot");//重启香橙派
break;
case 2:
refresh_cam();
break;
case 3:
message_3(body,pwm_ctrl);
break;
case 4:
message_4(body,pin_setctrl);
break;
default:
break;
}
}
// 释放 payload 字符串
free(payload_str);
}
}
void mqtt_create(struct mosquitto *mosq) {//创建mqtt客服端
mosquitto_reconnect_delay_set(mosq, 2, 10, true);
// 设置连接和消息回调
mosquitto_connect_callback_set(mosq, on_connect);
mosquitto_message_callback_set(mosq, on_message);
//设置用户名和密码
mosquitto_username_pw_set(mosq, USERNAME, PASSWORD);
// 创建 mosquitto 客户端
rc = mosquitto_connect(mosq, BROKER_ADDRESS, BROKER_PORT, 60);
if (rc != MOSQ_ERR_SUCCESS) {
fprintf(stderr, "Failed to connect to broker: %s\n", mosquitto_strerror(rc));
mosquitto_destroy(mosq);
//return EXIT_FAILURE;
}
}
void mqtt_cycle(struct mosquitto *mosq){
mosquitto_loop_forever(mosq, -1, 1); // -1 表示无限等待，1 表示处理消息的最大数量
}
void mqtt_clean(struct mosquitto *mosq){
// 清理
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
}
\ No newline at end of file
src/mqtt.o 0 → 100644
View file @ 9452065b
File added
src/opensh.c 0 → 100755
View file @ 9452065b
#include "opensh.h"
char gwebcam[254];//存放启动火狐网站命令
int opencamsh(){
const char* url = "https://jywy.yd-ss.com?dev=";
char urls[50];
sprintf(urls,"%s%s",url,TOPIC3);
//setenv("DISPLAY", ":0", 1);//设置环境变量https://jywy.yd-ss.com?dev=controcar0004 --new-window sudo
sprintf(gwebcam,"su - orangepi -c \"chromium-browser --use-fake-ui-for-media-stream %s\"",urls);
system(gwebcam);
printf("%s\n",gwebcam);
printf("open cam\n");
return 0;
}
void refresh_cam() {//刷新页面
setenv("XAUTHORITY", "/home/orangepi/.Xauthority", 1);//加入授权
const char *search_command = "xdotool search --class \"chromium-browser\"";//获取窗口id
FILE *fp = popen(search_command, "r");
if (!fp) {
perror("Failed to execute search command");
return;
}
char window_id[32];
while (fgets(window_id, sizeof(window_id), fp) != NULL) {
window_id[strcspn(window_id, "\n")] = '\0';
char activate_command[128];
snprintf(activate_command, sizeof(activate_command), "xdotool windowactivate --sync %s key Ctrl+r", window_id);
pid_t pid = fork();
if (pid == 0) {
// 子进程执行命令
execl("/bin/sh", "sh", "-c", activate_command, (char *)NULL);
perror("Failed to execute command");
exit(EXIT_FAILURE);
} else if (pid > 0) {
// 父进程不等待子进程结束，继续执行
printf("Executing in child process: %s\n", activate_command);
} else {
perror("Failed to fork");
}
}
pclose(fp);
printf("recam\n");
}
src/opensh.o 0 → 100644
View file @ 9452065b
File added
src/pthrpoll.c 0 → 100644
View file @ 9452065b
#include "pthrpoll.h"
// 初始化任务队列
int task_queue_init(TaskQueue *queue) {
queue->head = NULL;
queue->tail = NULL;
queue->size = 0;
if (pthread_mutex_init(&queue->mutex, NULL) != 0) {
return -1;
}
if (pthread_cond_init(&queue->cond, NULL) != 0) {
pthread_mutex_destroy(&queue->mutex);
return -1;
}
return 0;
}
// 向任务队列中添加任务
int task_queue_add(TaskQueue *queue, void (*function)(void *), void *argument) {
Task *task = (Task *)malloc(sizeof(Task));
if (task == NULL) {
return -1;
}
task->function = function;
task->argument = argument;
task->next = NULL;
pthread_mutex_lock(&queue->mutex);
if (queue->tail == NULL) {
queue->head = queue->tail = task;
} else {
queue->tail->next = task;
queue->tail = task;
}
queue->size++;
pthread_cond_signal(&queue->cond);
pthread_mutex_unlock(&queue->mutex);
return 0;
}
// 从任务队列中取出任务
Task *task_queue_remove(TaskQueue *queue, ThreadPool *pool) {
pthread_mutex_lock(&queue->mutex);
while (queue->size == 0 && !pool->shutdown) {
pthread_cond_wait(&queue->cond, &queue->mutex);
}
if (pool->shutdown && queue->size == 0) {
pthread_mutex_unlock(&queue->mutex);
return NULL;
}
Task *task = queue->head;
queue->head = queue->head->next;
if (queue->head == NULL) {
queue->tail = NULL;
}
queue->size--;
pthread_mutex_unlock(&queue->mutex);
return task;
}
// 工作线程函数
void *worker_thread(void *arg) {
ThreadPool *pool = (ThreadPool *)arg;
while (1) {
Task *task = task_queue_remove(&pool->task_queue, pool);
if (task == NULL) {
break; // 收到关闭信号且队列为空
}
task->function(task->argument);
free(task->argument); // 释放任务参数
free(task); // 释放任务本身
}
return NULL;
}
// 初始化线程池
ThreadPool *thread_pool_init(int thread_count) {
if (thread_count <= 0) {
errno = EINVAL;
return NULL;
}
ThreadPool *pool = (ThreadPool *)malloc(sizeof(ThreadPool));
if (pool == NULL) {
return NULL;
}
pool->threads = (pthread_t *)malloc(thread_count * sizeof(pthread_t));
if (pool->threads == NULL) {
free(pool);
return NULL;
}
if (task_queue_init(&pool->task_queue) != 0) {
free(pool->threads);
free(pool);
return NULL;
}
pool->thread_count = thread_count;
pool->shutdown = 0;
if (pthread_mutex_init(&pool->mutex, NULL) != 0) {
pthread_mutex_destroy(&pool->task_queue.mutex);
pthread_cond_destroy(&pool->task_queue.cond);
free(pool->threads);
free(pool);
return NULL;
}
for (int i = 0; i < thread_count; i++) {
if (pthread_create(&pool->threads[i], NULL, worker_thread, pool) != 0) {
// 创建线程失败，关闭已创建的线程
pool->shutdown = 1;
pthread_cond_broadcast(&pool->task_queue.cond);
for (int j = 0; j < i; j++) {
pthread_join(pool->threads[j], NULL);
}
pthread_mutex_destroy(&pool->mutex);
pthread_mutex_destroy(&pool->task_queue.mutex);
pthread_cond_destroy(&pool->task_queue.cond);
free(pool->threads);
free(pool);
return NULL;
}
}
return pool;
}
// 向线程池添加任务
int thread_pool_add_task(ThreadPool *pool, void (*function)(void *), void *argument) {
if (pool == NULL || function == NULL) {
return -1;
}
pthread_mutex_lock(&pool->mutex);
if (pool->shutdown) {
pthread_mutex_unlock(&pool->mutex);
return -1;
}
pthread_mutex_unlock(&pool->mutex);
// 复制参数，确保生命周期
void *arg_copy = malloc(sizeof(*argument));
if (arg_copy == NULL) {
return -1;
}
*(int *)arg_copy = *(int *)argument;
return task_queue_add(&pool->task_queue, function, arg_copy);
}
// 销毁线程池
void thread_pool_destroy(ThreadPool *pool) {
if (pool == NULL) {
return;
}
pthread_mutex_lock(&pool->mutex);
pool->shutdown = 1;
pthread_mutex_unlock(&pool->mutex);
// 唤醒所有等待的线程
pthread_cond_broadcast(&pool->task_queue.cond);
// 等待所有线程退出
for (int i = 0; i < pool->thread_count; i++) {
pthread_join(pool->threads[i], NULL);
}
// 清理剩余任务
Task *task = pool->task_queue.head;
while (task != NULL) {
Task *next = task->next;
free(task->argument);
free(task);
task = next;
}
// 释放资源
free(pool->threads);
pthread_mutex_destroy(&pool->task_queue.mutex);
pthread_cond_destroy(&pool->task_queue.cond);
pthread_mutex_destroy(&pool->mutex);
free(pool);
}
src/pthrpoll.o 0 → 100644
View file @ 9452065b
File added
usr/main.c 0 → 100755
View file @ 9452065b
#include "main.h"
int Device_File_Init() {
const char *readbuf=device_inspect();
//将第3个和第4个字符提取出来
char *sub_str=malloc(3);
sub_str[0]=readbuf[2];
sub_str[1]=readbuf[3];
sub_str[2]='\0';
printf("开始初始化了");
if(strcmp(sub_str,"02")==0){//坦克的编码
pin_init();
pinMode(2, OUTPUT);//pwm引脚改为普通引脚
pinMode(21, OUTPUT);//pwm引脚改为普通引脚
digitalWrite(2, LOW);
digitalWrite(21, LOW);
AppExit_pin_pwm=1;//坦克的异常停止值
free(sub_str);
}else if(strcmp(sub_str,"01")==0){//车的编码
pwm_speed(); //pwm初始化，车为停止
pin_init();
AppExit_pin_pwm=2;//车的异常停止值
free(sub_str);
}else if(strcmp(sub_str,"03")==0){//船的编码
pwm_speed();
pin_ship_init(); //pwm初始化，车为停止
AppExit_pin_pwm=3;//车的异常停止值
free(sub_str);
}
Delay_Ms(20,0);
TOPIC=malloc(24);
TOPIC2=malloc(24);
TOPIC3= malloc(16);
sprintf(TOPIC2,"dev2app/%s",readbuf);
sprintf(TOPIC,"app2dev/%s",readbuf);
sprintf(TOPIC3,"%s",readbuf);
printf("1:%s,2:%s,3:%s\n",TOPIC,TOPIC2,TOPIC3);
return 0;
}
int main(int argc, char *argv[]) {
if (wiringPiSetup() == -1) {
printf("WiringPi setup failed!\n");
return 1;
}
if (!INA226_begin(sda_pin, scl_pin)) {
printf("INA226 初始化失败！\n");
return 2;
}
if(Device_File_Init()!=0) {
printf("设备文件读取初始化失败！\n");
return 3;
}
system("pkill chromium");
// 配置 INA226
INA226_configure(sda_pin, scl_pin);
// 校准 INA226
float rShuntValue = 0.1; // 分流电阻值（单位：欧姆）
float iMaxExpected = 5; // 最大预期电流（单位：安培）
INA226_calibrate(sda_pin, scl_pin, rShuntValue, iMaxExpected);
gStart=time(NULL);//开始时间戳
ipaddr();//获取ip
thread_start(AppExit,Mqttbeat,opensh,Mqtt_onnect);//开启线程
thread_end();
return EXIT_SUCCESS;
}
\ No newline at end of file
usr/main.o 0 → 100644
View file @ 9452065b
File added
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment