基于边缘计算的自动识别一体化结算电子秤（二）_6idgzu.kmxqrd9.mom

原来打算用esp32_cam来进行边缘计算，但这个方式另一个项目中用过有雷同，决定用imx6ull直接拍照片并进行base64编码并利用linux中的网络编程知识向百度果蔬识别接口发送图片数据并获取结果。目前分步骤实现了部分功能（尚未进行交叉编译与移植）。

拍摄方面用的是正点原子ov7725摄像头。

#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/file.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <errno.h>
#include <sys/mman.h>
#include <linux/videodev2.h>
#include <linux/fb.h>
#define FRAMEBUFFER_COUNT 1
 
typedef struct camera_format{
    unsigned char description[32];
    unsigned int pixelformat;
} cam_fmt;
 
typedef struct cam_buf_info{
    unsigned short *start; //帧缓冲起始地址
    unsigned long length; //帧缓冲长度
} cam_nuf_info;
 
static cam_fmt camFmt[10];
static int v4l2_fd = -1;//摄像头文件描述符
struct cam_buf_info buf_Infos[3];
 
int set_v4l2(const char* dev)
{
    struct v4l2_format fmt = {0};
    struct v4l2_streamparm streamparm = {0};
 
    v4l2_fd = open(dev, O_RDWR);
    if(0 > v4l2_fd)
    {
        fprintf(stderr, "open error: %s:%s\n", dev, strerror(errno));
        return -1;
    }
 
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = 800;
    fmt.fmt.pix.height = 480;
    fmt.fmt.pix.pixelformat = 0x47504a4d;//Motion-JPEG
    if(0 > ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt))
    {
        perror("set error");
        return -1;
    }
 
    streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    ioctl(v4l2_fd, VIDIOC_G_PARM, &streamparm);
 
    //判断是否支持帧率设置
    if(V4L2_CAP_TIMEPERFRAME & streamparm.parm.capture.capability)
    {
        streamparm.parm.capture.timeperframe.numerator = 1;
        streamparm.parm.capture.timeperframe.denominator = 30;
        if(0 > ioctl(v4l2_fd, VIDIOC_S_PARM, &streamparm))
        {
            fprintf(stderr, "ioctl error: VIDIOC_S_PARM: %s\n", strerror(errno));
            return -1;
        }
    }
 
    return 0;
}
 
static int v4l2_init_buffer(void)
{
    struct v4l2_requestbuffers reqbuf = {0};
    struct v4l2_buffer buf = {0};
 
    //申请帧缓存
    reqbuf.count = FRAMEBUFFER_COUNT;//帧缓冲数量
    reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//设置type为视频采集
    reqbuf.memory = V4L2_MEMORY_MMAP;
    if(0 > ioctl(v4l2_fd, VIDIOC_REQBUFS, &reqbuf))
    {
        fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
        return -1;
    }
 
    //建立内存映射
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++)
    {
        ioctl(v4l2_fd, VIDIOC_QUERYBUF, &buf);
        buf_Infos[buf.index].length = buf.length;
        buf_Infos[buf.index].start = mmap(NULL, buf.length,
                                          PROT_READ | PROT_WRITE, MAP_SHARED,
                                          v4l2_fd, buf.m.offset);
        if(MAP_FAILED == buf_Infos[buf.index].start)
        {
            perror("mmap error");
            return -1;
        }
    }
 
    //入队
    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++)
    {
        if(0 > ioctl(v4l2_fd, VIDIOC_QBUF, &buf))
        {
            fprintf(stderr, "ioctl error: VIDIOC_QBUF: %s\n", strerror(errno));
            return -1;
        }
    }
 
    return 0;
}
 
static int v4l2_stream_off(void)
{
    //关闭摄像头
    enum v4l2_tuner_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
    if(0 > ioctl(v4l2_fd, VIDIOC_STREAMOFF, &type))
    {
        fprintf(stderr, "ioctl error: VIDIOC_STREAMOFF: %s\n", strerror(errno));
        return -1;
    }
 
    return 0;
}
 
static int v4l2_stream_on(void)
{
    //打开摄像头
    enum v4l2_tuner_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
    if(0 > ioctl(v4l2_fd, VIDIOC_STREAMON, &type))
    {
        fprintf(stderr, "ioctl error: VIDIOC_STREAMON: %s\n", strerror(errno));
        return -1;
    }
 
    return 0;
}
 
static int v4l2_read_data(const char *file)
{
    struct v4l2_buffer buf = {0};
    int fd_w = -1, j;
    char fh[100];
 
    v4l2_stream_on();//打开摄像头
 
    fd_w = open(file, O_RDWR);
    if(0 > fd_w)
    {
        fprintf(stderr, "open error: %s:%s\n", file, strerror(errno));
        return -1;
    }
 
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    buf.index = 0;
    while (1)
    {
 
        flock(fd_w, LOCK_EX);
 
        read(fd_w, fh, sizeof ("success"));
 
        lseek(fd_w, 0, SEEK_SET);//移到头
 
        if(strcmp(fh, "success") == 0) {
            write(fd_w, "123", sizeof ("123"));
            lseek(fd_w, 0, SEEK_SET);//移到头
            break;
        }
 
        ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);//出队
 
        //数据处理完后再入队往复
        write(fd_w, buf_Infos[buf.index].start, buf_Infos[buf.index].length);
 
        lseek(fd_w, 0, SEEK_SET);//移到头
 
        ioctl(v4l2_fd, VIDIOC_QBUF, &buf);
 
        flock(fd_w, LOCK_UN);//解锁
    }
 
    close(fd_w);
 
    flock(fd_w, LOCK_EX);//解锁
 
    v4l2_stream_off();//关闭摄像头
 
    return 0;
}
int main(int argc, char **argv) {
    if(2 != argc)
    {
        fprintf(stderr, "Usage: %s <video_dev>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
 
    set_v4l2(argv[1]);
 
    v4l2_init_buffer();
 
    v4l2_read_data("/home/alientek/dzy/tp");
 
    close(v4l2_fd);
 
    return 0;
}

将结果（拍摄数据）进行内存映射并写入文件中（通过互斥锁实现原子操作），每次写入前先进行读取（如果另外的代码获取到结果后会向文件中写入"success"）。

对数据进行base64编码并发送http请求

base64编码

//
// Created by alientek on 1/19/24.
//
 
#include "base64.h"
 
static const char* base64_chars[2] = {
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz"
        "0123456789"
        "+/",
 
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz"
        "0123456789"
        "-_"};
 
// 定义
std::string base64_encode(unsigned char const* bytes_to_encode, size_t in_len, bool url) {
 
    size_t len_encoded = (in_len +2) / 3 * 4;
 
    unsigned char trailing_char = url ? '.' : '=';
 
    const char* base64_chars_ = base64_chars[url];
 
    std::string ret;
    ret.reserve(len_encoded);
 
    unsigned int pos = 0;
 
    while (pos < in_len) {
        ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0xfc) >> 2]);
 
        if (pos+1 < in_len) {
            ret.push_back(base64_chars_[((bytes_to_encode[pos + 0] & 0x03) << 4) + ((bytes_to_encode[pos + 1] & 0xf0) >> 4)]);
 
            if (pos+2 < in_len) {
                ret.push_back(base64_chars_[((bytes_to_encode[pos + 1] & 0x0f) << 2) + ((bytes_to_encode[pos + 2] & 0xc0) >> 6)]);
                ret.push_back(base64_chars_[  bytes_to_encode[pos + 2] & 0x3f]);
            }
            else {
                ret.push_back(base64_chars_[(bytes_to_encode[pos + 1] & 0x0f) << 2]);
                ret.push_back(trailing_char);
            }
        }
        else {
 
            ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0x03) << 4]);
            ret.push_back(trailing_char);
            ret.push_back(trailing_char);
        }
 
        pos += 3;
    }
 
    return ret;
}
 
unsigned char ToHex(unsigned char x)
{
    return x > 9 ? x + 55 : x + 48;
}
 
std::string UrlEncode(const std::string& str)
{
    std::string strTemp = "";
    size_t length = str.length();
    for (size_t i = 0; i < length; i++)
    {
        if (isalnum((unsigned char)str[i]) ||
            (str[i] == '-') ||
            (str[i] == '_') ||
            (str[i] == '.') ||
            (str[i] == '~'))
            strTemp += str[i];
        else if (str[i] == ' ')
            strTemp += "+";
        else
        {
            strTemp += '%';
            strTemp += ToHex((unsigned char)str[i] >> 4);
            strTemp += ToHex((unsigned char)str[i] % 16);
        }
    }
    return strTemp;
}
 

利用curl库发送数据

#include <cstdio>
#include <string>
#include <cstdlib>
#include <sys/file.h>
#include <fcntl.h>
#include "base64.h"
#include <unistd.h>
int main(int argc, char *argv[]) {
    int fd, fd1;
 
    fd = open("/home/alientek/dzy/tp", O_RDWR);
    fd1 = open("/home/alientek/dzy/tp1", O_RDWR);
 
    flock(fd, LOCK_EX);
 
    off_t off = lseek(fd, 0, SEEK_END);
 
    lseek(fd, 0, SEEK_SET);
 
    unsigned char *buff = (unsigned char*) malloc(off);//100mb
    unsigned char const *buff1 ;
 
    int fh = read(fd, buff, off);
 
    lseek(fd, 0, SEEK_SET);
 
    write(fd, "success", sizeof ("success"));
    lseek(fd, 0, SEEK_SET);
 
    flock(fd, LOCK_UN);
 
    close(fd);
    write(fd1, buff, off);//将图片数据写入另一个图片文件
 
    lseek(fd1, 0, SEEK_SET);
 
    close(fd1);
 
    buff1 = buff;
    if(0 > fh)
    {
        perror("read failed");
    }
 
    std::string tp;
    tp = base64_encode(buff1, off );
 
    std::string tp1 = UrlEncode(tp);
    const char *my ="24.83e0923ff371ca356ae957ea750e8636.2592000.1708223470.282335-47117094";
    char *buf = ( char*) malloc(sizeof (char)*8*1024*1024*200);//100mb
 
    sprintf(buf,"curl -i -k 'https://aip.baidubce.com/rest/2.0/image-classify/v1/classify/ingredient?access_token=%s' -o 'jg' --data 'image=%s' -H 'Content-Type:application/x-www-form-urlencoded'", my, tp1.c_str());
    system(buf);
 
    free(buff);
    free(buf);
    return 0;
}

不会用socket向接口发数据并得到返回数据

本来打算自己封装http通过socket进行发送与监控但不知是否是百度接口缘故一直得不到回应，这里贴出代码，希望有大哥帮忙指正。

#include <cstdio>
#include <string>
#include <sys/socket.h>
#include <netinet/in.h>
#include <cstdlib>
#include <cerrno>
#include <cctype>
#include <netdb.h>
#include <arpa/inet.h>
#include <string.h>
 
 
int get_ips_by_domain(const char * const domain){
    struct hostent *_hostent = NULL;
    _hostent =  gethostbyname(domain);
    int i = 0;
    while(_hostent->h_addr_list[i] != NULL){
        char *ipaddr = inet_ntoa(*((struct in_addr *)_hostent->h_addr_list[i]));
        printf("ip addr%d: %s\n",i+1,ipaddr);
        i++;
    }
    return 0;
}
#define PORT 80
//socket -> bind -> listen
int main(int argc, char *argv[]) {
    printf("1");
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket error\n");
        return -1;
    }
    printf("socket");
    struct sockaddr_in lst_addr;
    lst_addr.sin_family = AF_INET;
    lst_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, "183.240.98.54", &lst_addr.sin_addr);
    //lst_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    socklen_t len = sizeof(struct sockaddr_in);
    int ret = connect(sockfd, (struct sockaddr *) &lst_addr, sizeof (lst_addr));
    if (ret < 0) {
        perror("connect error\n");
        return -1;
    }
    char *buff = (char*) malloc(sizeof (char)*8*1024*1024*200);//100mb
    const char *tp = "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";
    printf("服务器连接成功\n");
    sprintf(buff, "%s\r\n%s\r\n%s\r\n%s\r\n\r\n%s=%s", "POST HTTP/1.1", "Location:/rest/2.0/image-classify/v1/classify/ingredient",
                "Content-Type:application/x-www-form-urlencoded", "access_token:24.83e0923ff371ca356ae957ea750e8636.2592000.1708223470.282335-47117094","image",tp);
 
    int ret1 = send(sockfd, buff, strlen(buff), 0);
    printf("%d\n",ret1);
    if(0 > ret1){
        perror("send error");
    }
    //    if (listen(sockfd, 5) < 0) {
//        perror("listen error\n");
//        return -1;
//    }
//    while (1)
//    {
//        struct sockaddr_in cli_addr;
//        int newfd = accept(sockfd, (struct sockaddr *) &cli_addr, &len);
//        if (newfd < 0) {
//            perror("accept error\n");
//            continue;
//        }
//        char buff[1024] = {0};
//        int ret = recv(newfd, buff, 1023, 0);
//        if (ret > 0) {
//            printf("req:%s\n", buff);
//        }
//        char *rsp = "OK";
//        memset(buff, 0x00, 1024);
//        sprintf(buff, "%s\r\n%s%d\r\n%s\r\n\r\n%s%", "POST HTTP/1.1", "Content-Length: ", strlen(rsp),
//                "Content-Type:text/html:charset=UTF-8", rsp);
//        printf("%s", buff);
//        send(newfd, buff, strlen(buff), 0);
//        close(newfd);
//    }
    return 0;
}

数据处理部分

感觉没什么需要存储的数据用sqlite过于臃肿就自己用cJSON库手搓了个简易版数据库（自己瞎捣鼓的也不知道对不对，有问题大家可得好好骂）

初始化数据库代码

//
// Created by alientek on 2/1/24.
//
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "cJSON.h"
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
    if(2 != argc)
    {
        fprintf(stderr, "Usage: %s <jg>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
 
    cJSON *cJson = NULL, *value = NULL;
    cJson = cJSON_CreateObject();
 
    value = cJSON_CreateArray();
    cJSON_AddItemToObject(cJson, "value", value);
 
    char *str = NULL;
    str = cJSON_Print(cJson);
    printf("%s\n", str);
    int fd = open(argv[1], O_RDWR);
    lseek(fd, 0, SEEK_SET);
    printf("%d\n", fd);
    off_t off = write(fd, str, strlen(str));
    printf("%ld\n", off);
    close(fd);
    cJSON_free(str);
    cJSON_Delete(cJson);
    cJSON_Delete(value);
    return 0;
}

插入数据代码

//
// Created by alientek on 2/1/24.
//
 
//
// Created by alientek on 2/1/24.
//
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "cJSON.h"
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdbool.h>
 
int main(int argc, char *argv[])
{
 
    if(4 != argc)
    {
        fprintf(stderr, "Usage: %s <jg>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
 
    double price = 0;
    int fd = 0, num = 0;
    cJSON *cJson = NULL, *value = NULL, *value1 = NULL, *cJson1 = NULL, *dq = NULL, *dq1 = NULL, *dq2 = NULL;
    char *str = NULL;
 
    price = atof(argv[3]);
 
    fd = open(argv[1], O_RDWR);
    if(fd == -1)
    {
        fprintf(stderr, "open %s error\n", argv[1]);
        exit(EXIT_FAILURE);
    }
 
    off_t off = lseek(fd, 0, SEEK_END);
 
    lseek(fd, 0, SEEK_SET);
 
    char *buf = malloc(sizeof (char) * off);
    read(fd, buf, off);
 
    lseek(fd, 0, SEEK_SET);
 
    cJson = cJSON_Parse(buf);
    value1 = cJSON_CreateArray();
    cJson1 = cJSON_CreateObject();
    free(buf);
 
    value = cJSON_GetObjectItem(cJson, "value");//结果是个数组
 
    num = cJSON_GetArraySize(value);
 
    printf("%d\n", num);
    int pd = 0;
    for (int i = 0; i < num; ++i)
    {
        dq = cJSON_GetArrayItem(value, i);
        dq1 = cJSON_CreateObject();
        if(strcmp(argv[2], dq->child->valuestring) == 0)      //有的话更新价格
        {
            dq->child->next->valuedouble = price;
            pd = 1;
        }
        cJSON_AddStringToObject(dq1, "name", dq->child->valuestring);
        cJSON_AddNumberToObject(dq1, "price", dq->child->next->valuedouble);
        cJSON_AddItemToArray(value1, dq1);
    }
 
    if(pd == 0)       //没有的话就添加进去
    {
        dq2 = cJSON_CreateObject();
        cJSON_AddStringToObject(dq2, "name", argv[2]);
        cJSON_AddNumberToObject(dq2, "price", price);
        cJSON_AddItemToArray(value1, dq2);
    }
 
    cJSON_AddItemToObject(cJson1, "value", value1);
    str = cJSON_Print(cJson1);
    off_t off1 = write(fd, str, strlen(str));
    printf("%ld\n", off1);
 
    cJSON_free(str);
    close(fd);
    cJSON_Delete(cJson);
    cJSON_Delete(value);
    cJSON_Delete(cJson1);
    cJSON_Delete(dq);
    cJSON_Delete(dq1);
    cJSON_Delete(dq2);
    cJSON_Delete(value1);
    return 0;
}

 通过cJSON解析接口返回的数据并与数据库中的数据进行比对，选择出最匹配的项写入文件中，如果没找到就写入error。

UI用的是qt框架（界面大概做完了触发函数用的系统shell脚本执行上面代码，同样也不知道对不对希望有哥能帮忙指正）