C语言实现http下载器（附代码）

本次给大家分享一个C语言实现http的下载器。比如做OTA升级功能时，我们能直接拿到的往往只是升级包的链接，需要我们自己去下载，这时候就需要用到http下载器。

这里分享一个：

功能：

1、支持chunked方式传输的下载

2、被重定向时能下载重定向页面

3、要实现的接口为int http_download(char *url, char *save_path)

思路：

1、解析输入的URL，分离出主机，端口号，文件路径的信息

2、解析主机的DNS

3、填充http请求的头部，给服务器发包

4、解析收到的http头，提取状态码，Content-length, Transfer-Encoding等字段信息

（1）如果是普通的头则进行接下来的正常收包流程

（2）如果状态码为302，则从头里提取出重定向地址，用新的地址重新开始下载动作

（3）如果传送方式是chunked的，则进行分段读取数据并拼接

（4）如果是404或其他状态码则打印错误信息

缺陷：

太多错误处理，让代码看起来不太舒服

其他：

1、如何移植到没有文件系统的系统中？

修改sava_data接口里面的保存就好了

2、如何提高下载速度？

增大读写buffer缓冲区

改为多线程，使用Range字段分段读取，最后再拼在一起

代码：

/************************************************************
Copyright (C), 2016, Leon, All Rights Reserved.
FileName: download.c
coding: UTF-8
Description: 实现简单的http下载功能
Author: Leon
Version: 1.0
Date: 2016-12-2 1032
Function:

History:
         
 Leon

************************************************************/

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define HOST_NAME_LEN   256
#define URI_MAX_LEN     2048
#define RECV_BUF        8192
#define RCV_SND_TIMEOUT (10*1000)   //收发数据超时时间(ms)

typedef struct {
    int sock;                       //与服务器通信的socket
    FILE *in;                       //sock描述符转为文件指针，方便读写
    char host_name[HOST_NAME_LEN];  //主机名
    int port;                       //主机端口号
    char uri[URI_MAX_LEN];          //资源路径
    char buffer[RECV_BUF];          //读写缓冲
    int status_code;                //http状态码
    int chunked_flag;               //chunked传输的标志位
    int len;                        //Content-length里的长度
    char location[URI_MAX_LEN];     //重定向地址
    char *save_path;                //保存内容的路径指针
    FILE *save_file;                //保存内容的文件指针
    int recv_data_len;              //收到数据的总长度
    time_t start_recv_time;         //开始接受数据的时间
    time_t end_recv_time;           //结束接受数据的时间
} http_t;

/* 打印宏 */
#define MSG_DEBUG   0x01
#define MSG_INFO    0x02
#define MSG_ERROR   0x04

static int print_level = /*MSG_DEBUG |*/ MSG_INFO | MSG_ERROR;

#define lprintf(level, format, argv...) do{     
    if(level & print_level)     
        printf("[%s][%s(%d)]:"format, #level, __FUNCTION__, __LINE__, ##argv);  
}while(0)

#define MIN(x, y) ((x) > (y) ? (y) : (x))

#define HTTP_OK         200
#define HTTP_REDIRECT   302
#define HTTP_NOT_FOUND  404

/* 不区分大小写的strstr */
char *strncasestr(char *str, char *sub)
{
    if(!str || !sub)
        return NULL;

    int len = strlen(sub);
    if (len == 0)
    {
        return NULL;
    }

    while (*str)
    {
        if (strncasecmp(str, sub, len) == 0)
        {
            return str;
        }
        ++str;
    }
    return NULL;
}

/* 解析URL, 成功返回0，失败返回-1 */
/* http://127.0.0.1:8080/testfile */
int parser_URL(char *url, http_t *info)
{
    char *tmp = url, *start = NULL, *end = NULL;
    int len = 0;

    /* 跳过http:// */
    if(strncasestr(tmp, "http://"))
    {   
        tmp += strlen("http://");
    }
    start = tmp;
    if(!(tmp = strchr(start, '/')))
    {
        lprintf(MSG_ERROR, "url invaild
");
        return -1;      
    }
    end = tmp;

    /*解析端口号和主机*/
    info->port = 80;   //先附默认值80

    len = MIN(end - start, HOST_NAME_LEN - 1);
    strncpy(info->host_name, start, len);
    info->host_name[len] = '';

    if((tmp = strchr(start, ':')) && tmp < end)
    {
        info->port = atoi(tmp + 1);
        if(info->port <= 0 || info->port >= 65535)
        {
            lprintf(MSG_ERROR, "url port invaild
");
            return -1;
        }
        /* 覆盖之前的赋值 */
        len = MIN(tmp - start, HOST_NAME_LEN - 1);
        strncpy(info->host_name, start, len);
        info->host_name[len] = '';
    }

    /* 复制uri */
    start = end;
    strncpy(info->uri, start, URI_MAX_LEN - 1);

    lprintf(MSG_INFO, "parse url ok
host:%s, port:%d, uri:%s
", 
        info->host_name, info->port, info->uri);
    return 0;
}

/* dns解析,返回解析到的第一个地址，失败返回-1，成功则返回相应地址 */
unsigned long dns(char* host_name)
{

    struct hostent* host;
    struct in_addr addr;
    char **pp;

    host = gethostbyname(host_name);
    if (host == NULL)
    {
        lprintf(MSG_ERROR, "gethostbyname %s failed
", host_name);
        return -1;
    }

    pp = host->h_addr_list;

    if (*pp!=NULL)
    {
        addr.s_addr = *((unsigned int *)*pp);
        lprintf(MSG_INFO, "%s address is %s
", host_name, inet_ntoa(addr));
        pp++;
        return addr.s_addr;
    }

    return -1;
}

/* 设置发送接收超时 */
int set_socket_option(int sock)
{
    struct timeval timeout;

    timeout.tv_sec = RCV_SND_TIMEOUT/1000;
    timeout.tv_usec = RCV_SND_TIMEOUT%1000*1000;
    lprintf(MSG_DEBUG, "%ds %dus
", (int)timeout.tv_sec, (int)timeout.tv_usec);
    //设置socket为非阻塞
    // fcntl(sock ,F_SETFL, O_NONBLOCK); //以非阻塞的方式，connect需要重新处理

    // 设置发送超时
    if(-1 == setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, 
            sizeof(struct timeval)))
    {
        lprintf(MSG_ERROR, "setsockopt error: %m
");
        return -1;
    }

    // 设置接送超时
    if(-1 == setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, 
            sizeof(struct timeval)))
    {
        lprintf(MSG_ERROR, "setsockopt error: %m
");
        return -1;
    }

    return 0;
}

/* 连接到服务器 */
int connect_server(http_t *info)
{
    int sockfd;
    struct sockaddr_in server;
    unsigned long addr = 0;
    unsigned short port = info->port;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd)
    {
        lprintf(MSG_ERROR, "socket create failed
");
        goto failed;
    }

    if(-1 == set_socket_option(sockfd))
    {
        goto failed;
    }

    if ((addr = dns(info->host_name)) == -1)
    {
        lprintf(MSG_ERROR, "Get Dns Failed
");
        goto failed;
    }
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET; 
    server.sin_port = htons(port); 
    server.sin_addr.s_addr = addr;

    if (-1 == connect(sockfd, (struct sockaddr *)&server, sizeof(struct sockaddr)))
    {
        lprintf(MSG_ERROR, "connect failed: %m
");
        goto failed;
    }

    info->sock = sockfd;
    return 0;

failed:
    if(sockfd != -1)
        close(sockfd);
    return -1;
}

/* 发送http请求 */
int send_request(http_t *info)
{
    int len;

    memset(info->buffer, 0x0, RECV_BUF);
    snprintf(info->buffer, RECV_BUF - 1, "GET %s HTTP/1.1
"
        "Accept: */*
"
        "User-Agent: Mozilla/5.0 (compatible; MSIE 5.01; Windows NT 5.0)
"
        "Host: %s
"
        "Connection: Close

", info->uri, info->host_name);

    lprintf(MSG_DEBUG, "request:
%s
", info->buffer);
    return send(info->sock, info->buffer, strlen(info->buffer), 0);
}

/* 解析http头 */
int parse_http_header(http_t *info)
{
    char *p = NULL;

    // 解析第一行
    fgets(info->buffer, RECV_BUF, info->in);
    p = strchr(info->buffer, ' ');
    //简单检查http头第一行是否合法
    if(!p || !strcasestr(info->buffer, "HTTP"))
    {
        lprintf(MSG_ERROR, "bad http head
");
        return -1;
    }
    info->status_code = atoi(p + 1);   
    lprintf(MSG_DEBUG, "http status code: %d
", info->status_code);

    // 循环读取解析http头
    while(fgets(info->buffer, RECV_BUF, info->in))
    {
        // 判断头部是否读完
        if(!strcmp(info->buffer, "
"))
        {
            return 0;   /* 头解析正常 */
        }
        lprintf(MSG_DEBUG, "%s", info->buffer);
        // 解析长度 Content-length: 554
        if(p = strncasestr(info->buffer, "Content-length"))
        {
            p = strchr(p, ':');
            p += 2;     // 跳过冒号和后面的空格
            info->len = atoi(p);
            lprintf(MSG_INFO, "Content-length: %d
", info->len);
        }
        else if(p = strncasestr(info->buffer, "Transfer-Encoding"))
        {
            if(strncasestr(info->buffer, "chunked"))
            {
                info->chunked_flag = 1;
            }
            else
            {
                /* 不支持其他编码的传送方式 */
                lprintf(MSG_ERROR, "Not support %s", info->buffer);
                return -1;
            }
            lprintf(MSG_INFO, "%s", info->buffer);
        }
        else if(p = strncasestr(info->buffer, "Location"))
        {
            p = strchr(p, ':');
            p += 2;     // 跳过冒号和后面的空格
            strncpy(info->location, p, URI_MAX_LEN - 1);
            lprintf(MSG_INFO, "Location: %s
", info->location);
        }
    }
    lprintf(MSG_ERROR, "bad http head
");
    return -1;  /* 头解析出错 */
}

/* 保存服务器响应的内容 */
int save_data(http_t *info, const char *buf, int len)
{
    int total_len = len;
    int write_len = 0;

    // 文件没有打开则先打开
    if(!info->save_file)
    {
        info->save_file = fopen(info->save_path, "w");
        if(!info->save_file)
        {
            lprintf(MSG_ERROR, "fopen %s error: %m
", info->save_path);
            return -1;
        }
    }

    while(total_len)
    {
        write_len = fwrite(buf, sizeof(char), len, info->save_file);
        if(write_len < len && errno != EINTR)
        {
            lprintf(MSG_ERROR, "fwrite error: %m
");
            return -1;
        }
        total_len -= write_len;
    }
}

/* 读数据 */
int read_data(http_t *info, int len)
{
    int total_len = len;
    int read_len = 0;
    int rtn_len = 0;

    while(total_len)
    {
        read_len = MIN(total_len, RECV_BUF);
        // lprintf(MSG_DEBUG, "need read len: %d
", read_len);
        rtn_len = fread(info->buffer, sizeof(char), read_len, info->in);
        if(rtn_len < read_len)
        {
            if(ferror(info->in))
            {
                if(errno == EINTR) /* 信号中断了读操作 */
                {
                    ;   /* 不做处理继续往下走 */
                }
                else if(errno == EAGAIN || errno == EWOULDBLOCK) /* 超时 */
                {
                    lprintf(MSG_ERROR, "socket recvice timeout: %dms
", RCV_SND_TIMEOUT);
                    total_len -= rtn_len;
                    lprintf(MSG_DEBUG, "read len: %d
", rtn_len);
                    break;
                }
                else    /* 其他错误 */
                {
                    lprintf(MSG_ERROR, "fread error: %m
");
                    break;
                }
            }
            else    /* 读到文件尾 */
            {
                lprintf(MSG_ERROR, "socket closed by peer
");
                total_len -= rtn_len;
                lprintf(MSG_DEBUG, "read len: %d
", rtn_len);
                break;
            }
        }

        // lprintf(MSG_DEBUG, " %s
", info->buffer);
        total_len -= rtn_len;
        lprintf(MSG_DEBUG, "read len: %d
", rtn_len);
        if(-1 == save_data(info, info->buffer, rtn_len))
        {
            return -1;
        }
        info->recv_data_len += rtn_len;
    }
    if(total_len != 0)
    {
        lprintf(MSG_ERROR, "we need to read %d bytes, but read %d bytes now
", 
            len, len - total_len);
        return -1;
    }
}

/* 接收服务器发回的chunked数据 */
int recv_chunked_response(http_t *info)
{
    long part_len;

    //有chunked，content length就没有了
    do{
        // 获取这一个部分的长度
        fgets(info->buffer, RECV_BUF, info->in);
        part_len = strtol(info->buffer, NULL, 16);
        lprintf(MSG_DEBUG, "part len: %ld
", part_len);
        if(-1 == read_data(info, part_len))
            return -1;

        //读走后面的
两个字符
        if(2 != fread(info->buffer, sizeof(char), 2, info->in))
        {
            lprintf(MSG_ERROR, "fread \r\n error : %m
");
            return -1;
        }
    }while(part_len);
    return 0;
}

/* 计算平均下载速度，单位byte/s */
float calc_download_speed(http_t *info)
{
    int diff_time = 0; 
    float speed = 0.0;

    diff_time = info->end_recv_time - info->start_recv_time;
    /* 最小间隔1s，避免计算浮点数结果为inf */
    if(0 == diff_time)
        diff_time = 1;
    speed = (float)info->recv_data_len / diff_time;

    return  speed;
}

/* 接收服务器的响应数据 */
int recv_response(http_t *info)
{
    int len = 0, total_len = info->len;

    if(info->chunked_flag)
        return recv_chunked_response(info);

    if(-1 == read_data(info, total_len))
        return -1;

    return 0;
}

/* 清理操作 */
void clean_up(http_t *info)
{
    if(info->in)
        fclose(info->in);
    if(-1 != info->sock)
        close(info->sock);
    if(info->save_file)
        fclose(info->save_file);
    if(info)
        free(info);
}

/* 下载主函数 */
int http_download(char *url, char *save_path)
{
    http_t *info = NULL;
    char tmp[URI_MAX_LEN] = {0};

    if(!url || !save_path)
        return -1;

    //初始化结构体
    info = malloc(sizeof(http_t));
    if(!info)
    {
        lprintf(MSG_ERROR, "malloc failed
");
        return -1;
    }
    memset(info, 0x0, sizeof(http_t));
    info->sock = -1;
    info->save_path = save_path;

    // 解析url
    if(-1 == parser_URL(url, info))
        goto failed;

    // 连接到server
    if(-1 == connect_server(info))
        goto failed;

    // 发送http请求报文
    if(-1 == send_request(info))
        goto failed;

    // 接收响应的头信息
    info->in = fdopen(info->sock, "r");
    if(!info->in)
    {
        lprintf(MSG_ERROR, "fdopen error
");
        goto failed;
    }

    // 解析头部
    if(-1 == parse_http_header(info))
        goto failed;

    switch(info->status_code)
    {
        case HTTP_OK:
            // 接收数据
            lprintf(MSG_DEBUG, "recv data now
");
            info->start_recv_time = time(0);
            if(-1 == recv_response(info))
                goto failed;

            info->end_recv_time = time(0);
            lprintf(MSG_INFO, "recv %d bytes
", info->recv_data_len);
            lprintf(MSG_INFO, "Average download speed: %.2fKB/s
", 
                    calc_download_speed(info)/1000);
            break;
        case HTTP_REDIRECT:
            // 重启本函数
            lprintf(MSG_INFO, "redirect: %s
", info->location);
            strncpy(tmp, info->location, URI_MAX_LEN - 1);
            clean_up(info);
            return http_download(tmp, save_path);

        case HTTP_NOT_FOUND:
            // 退出
            lprintf(MSG_ERROR, "Page not found
");
            goto failed;
            break;

        default:
            lprintf(MSG_INFO, "Not supported http code %d
", info->status_code);
            goto failed;
    }

    clean_up(info);
    return 0;
failed:
    clean_up(info);
    return -1;
}

/****************************************************************************
测试用例:
(1)chunked接收测试
./a.out "http://www.httpwatch.com/httpgallery/chunked/chunkedimage.aspx" test.aspx
(2)重定向测试
./a.out "192.168.10.1/main.html" test.txt
(3)错误输入测试
./a.out "32131233" test.txt
(4)根目录输入测试
./a.out "www.baidu.com/" test.txt
(5)端口号访问测试
./a.out "192.168.0.200:8000/FS_AC6V1.0BR_V15.03.4.12_multi_TD01.bin" test.txt
****************************************************************************/

int main(int argc, char *argv[])
{
    if(argc < 3)
        return -1;

    http_download(argv[1], argv[2]);
    return 0;
}

　　审核编辑：汤梓红

阅读全文

C语言(123564) C语言(123564)
HTTP(30245) HTTP(30245)
下载器(12628) 下载器(12628)

C语言实现：见缝插针游戏！代码思路+源码分享

见缝插圆我们昨天已经用C语言实现了，今天将实现一个见缝插针的游戏。

2022-12-05 11:02:12

463

介绍一个C语言实现的http下载器

做OTA升级功能时，能直接拿到的往往只是升级包的链接，需要我们自己去下载，这时候就需要用到http下载器，下文介绍一个C语言实现的http下载器。

2023-02-22 10:25:23

238

51单片机C语言实例

51单片机C语言实例下载

2013-03-14 20:14:36

80c51单片机使用c语言实现P2接口

80c51单片机使用c语言实现P2接口led灯依次点亮周期循环#include unsigned int a ;unsigned char i ;void main(){while(1){ for(i=0;i

2021-07-15 09:38:29

C++语言实现火车排序功能.doc

C++语言实现火车排序功能.doc

2017-08-05 22:01:19

C语言实用数字图像处理

C语言实用数字图像处理，有需要的可以下载参考

2022-07-05 10:31:25

C语言实现FFT(快速傅里叶变换)

2013-10-25 21:33:41

C语言实现一款猜数字游戏【附源码】

C语言实现一款猜数字游戏【附源码】最经典的猜数字游戏的例子来展示条件结构在程序中的作用，今天看到另外一种猜数字的玩法，也挺有趣：这个游戏由三个人一起玩，一个人做主持人，心中默想一个1到100之间

2020-05-15 10:25:35

C语言实现常用排序算法是什么？

2021-10-19 06:41:46

C语言实现数字信号处理算法

2012-08-16 23:17:38

C语言实现的泛型函数swap()

C语言实现的泛型函数swap()：交换两个变量中的数据.

2022-01-20 07:10:47

c语言实例解析

` 本帖最后由 libinaaazzz 于 2013-10-30 13:12 编辑学习c语言实例的好东东`

2013-10-15 15:19:35

c语言实验指导书

c语言实验指导书C++程序设计语言实验指导书书说明：第一章 C++实验基础知识...61.1 C++语言实验环境配置.61.2 Visual C++ 6.0 的使用..61.2.1 Visual

2008-09-21 16:26:36

c语言实现库仑计电池容量的计算，剩余电量的实现

大神们帮忙解决一下，c语言实现库仑计电池容量的计算，剩余电量的实现，要考虑到温度对电池容量的影响，充电次对电池容量的影响以及自耗三个因素的影响，超级感谢哦

2017-04-23 18:01:56

ADUC7061如何使用C语言实现EEPROM功能？

我使用ADUC7061做的信号采集，现在客户需要实现EEPROM功能来保存3-5个数据，请问如何使用C语言实现？不使用外部EEPROM 专用IC。

2024-01-12 06:56:45

CRC算法和c语言实现

2012-08-20 19:21:44

MCU是怎样用c语言实现查询红外解码的

红外的编码格式是怎样的？MCU是怎样用c语言实现查询红外解码的？

2022-02-25 07:44:34

PID控制算法的C语言实现

网上的资料，程序原理与实现上主要参考了“PID控制算法的C语言实现.(绝对的好东西)”。本次PID主要是通过固态继电器控制加热片进行加热，温度探测使用的DS18B20，稳定后在0.5

2022-01-14 09:01:15

PID控制算法的C语言实现(完整版)

2019-08-10 09:40:19

PID控制算法的C语言实现(完整版)

2020-02-06 17:08:52

PID控制算法的C语言实现(完整版)

2020-04-02 11:39:13

PID控制算法的C语言实现(完整版)

2020-05-01 11:03:55

vhdl语言实例大全下载

2008-05-20 09:36:01

使用多种编程语言实现对I2C总线设备（传感器）进行控制

使用多种编程语言实现对I2C总线设备（传感器）进行控制1、概述Ginkgo I2C总线适配器可以使用各类编程语言方便、快捷的对各种I2C设备进行控制，主要包括：C

2017-05-17 10:01:10

凹槽凸轮轮廓线的解析设计及C语言实现

2013-06-04 10:44:03

单片机C语言实例有哪些

单片机C语言实例(400例)/单片机C语言实例(400例)/1-IO输出-点亮1个LED灯方法1/单片机C语言实例(400例)/1-IO输出-点亮1个LED灯方法1/IO输出.Opt单片机C语言实

2021-07-15 10:06:30

在PSOC中，怎样用C语言实现整型向字符型的转换

在PSOC中，怎样用C语言实现整型向字符型的转换？

2012-11-19 15:43:46

基于Miracl库的中国剩余定理C语言实现资料分享

/article/details/102755680针对大数的中国剩余定理C语言实现一、算法介绍二、代码实现三、结果截图一、算法介绍中国剩余定理又称孙子定理，是中国人在古代数学上的一点智慧果实（fina...

2021-07-02 06:18:14

基于Proteus和C语言实现

基于Proteus和C语言实现一共四个题目，有没有人愿意尝试一下？

2021-07-14 06:20:45

基于汇编语言实现最简单的LED灯闪烁

汇编实现LED灯闪1. 本文目的基于汇编语言实现最简单的LED灯闪烁。汇编语言（assembly language）是一种用于电子计算机、微处理器、微控制器或其他可编程器件的低级语言，亦称为符号语言

2021-10-27 07:34:55

如何使用C语言实现模糊PID控制？

2021-09-24 08:54:18

如何使用c语言实现LED流水灯

单片机实验：使用c语言实现LED流水灯目的：实现一个简单的流水灯程序仿真软件：Portues编程软件：KeilPortues 原理图绘制：需要用到的模块：单片机：AT89C51电容

2021-11-30 07:52:33

如何利用c语言实现中文“大”字的显示？

2021-11-02 06:25:39

如何利用单片机和C语言实现按键菜单程序的设计？

2021-10-14 07:58:24

如何用C语言实现OOP编程？

老大看到OOP编程很好，就让我学，怎么用C语言实现OOP编程的，请大侠指点

2019-10-30 03:45:28

如何用C语言实现一款猜数字游戏

2021-01-06 07:10:06

如何用C语言实现字符数组转换为16进制数组？

2021-11-03 07:47:14

如何用C语言实现显示16只灯的状态并开关灯？

2021-10-19 09:39:16

如何用C语言实现面向对象编程

1 用C语言实现面向对象编程GOF的《设计模式》一书的副标题叫做“可复用面向对象软件的基础”，从标题就能看出面向对象是设计模式基本思想。由于C语言并不是面向对象的语言，C语言没有直接提供封装、继承

2021-07-12 07:24:18

如何用VHDL语言实现帧同步的设计？

帧同步是什么工作原理？如何用VHDL语言实现帧同步的设计？

2021-04-08 06:33:59

小白求助，求基于Proteus和C语言实现的程序和仿真

2021-10-19 06:20:34

嵌入式平台C语言实现二阶滤波器的方法

最近想从嵌入式平台上用C语言实现二阶滤波器，于是先从Matlab上验证二阶滤波器公式，再编写C语言来验证。算法移植（实现过程）①先用Matlab自带公式的二阶滤波器实现；②运用公式Matlab实现

2021-12-15 09:12:52

快速傅里叶变换C语言实现

快速傅里叶变换C语言实现模拟采样进行频谱分析FFT是DFT的快速算法用于分析确定信号(时间连续可积信号、不一定是周期信号)的频率(或相位、此处不研究相位)成分，且傅里叶变换对应的ω\omega

2021-07-20 06:01:26

普中开发板的定时器中断C语言实现

普中开发板的定时器中断C语言实现，间隔时间可能比一秒短，可以改变最下面的n值来修改间隔时间还有就是显示前六位后两位可以复制代码#include "reg52.h"

2021-07-21 06:36:12

最全PID控制算法的C语言实现(转)

最近项目中用到PID控制算法，查了很多资料，资料上说的一塌糊涂，什么手动调节啊？说的和没说一样，对于刚接触PID的人根本弄不明白。当我看到《最全PID控制算法的C语言实现》的时候，只看了前面一部分就搞明白了，里面还有C语言代码。很好的一份资料，希望对大家有用。

2015-06-01 10:53:00

求助：如何用C语言实现直接寻址

如何用C语言实现直接寻址，就像汇编里面的mov 0x80,0x60

2014-05-13 16:39:17

求助：用FPGA中的verilog语言实现BPSK调制！

最近在做个课题，需要用FPGA中的verilog语言实现BPSK调制，fpga不是很会，望大神指导下，急求代码啊！谢谢

2013-03-06 18:12:36

用verilog语言实现电子钟

各位大神求救啊用verilog语言实现电子钟

2014-05-04 16:37:51

C语言实时操作系统源代码

2007-06-05 12:36:02

用JAVA语言实现RSA公钥密码算法

用JAVA语言实现RSA公钥密码算法:本文阐述了公开密钥密码体制RSA算法的原理及实现技术。并在此基础上，给出了JAVA语言实现的RSA算法源代码。关键词：ILSA体制；公钥；密钥

2010-02-10 10:27:15

用C语言实现FFT算法

用C语言实现FFT算法 /*****************fft programe*********************/#include "typedef.h" #include "math.h" struct compx EE(struct compx

2008-10-30 13:39:56

6179

DSP算法的c语言实现

DSP算法的c语言实现，又需要的朋友下来看看。

2016-05-09 10:59:26

5402 C语言实例

TMS320LF5402 C语言实例源代码分享

2016-05-23 18:21:16

C语言实现运算器的原理完整编程代码

C语言实现运算器的原理完整编程代码C language implementation of the principle of the operator complete programming code

2016-07-08 11:33:08

4个重要算法C语言实现源代码

2018-06-10 08:00:00

位置型PID的C语言代码的实现过程详细资料概述

上一节中已经抽象出了位置性 PID 和增量型 PID 的数学表达式，这一节，重点讲解 C 语言代码的实现过程，算法的 C 语言实现过程具有一般性，通过 PID 算法的 C 语言实现，可以以此类推，设计其它算法的 C 语言实现。

2018-07-16 08:00:00

使用C语言实现51单片机中的PID算法代码免费下载

本文档的主要内容详细介绍的是使用使用C语言实现51单片机中的PID算法代码免费下载。

2019-09-25 17:17:00

如何使用C语言实现一个比较简单的猜数游戏的程序免费下载

本文档的主要内容详细介绍的是如何使用C语言实现一个比较简单的猜数游戏的程序免费下载

2019-04-24 18:31:00

使用C语言实现的串口助手应用程序免费下载

本文档的主要内容详细介绍的是使用C语言实现的串口助手应用程序免费下载直接可执行文件。

2019-11-22 08:00:00

使用C语言实现抽奖系统的设计资料和源代码说明

本文档的主要内容详细介绍的是使用C语言实现抽奖系统的设计资料说明。

2019-11-21 14:09:34

使用C语言实现静态网页的代码免费下载

本文档的主要内容详细介绍的是使用C语言实现静态网页的代码免费下载。

2019-11-22 16:20:15

使用C语言实现万年历星期速算法的源代码免费下载

本文档的主要内容详细介绍的是使用C语言实现万年历星期速算法的源代码免费下载。

2020-01-24 17:19:00

2699

1578

C语言实现《别碰白块》小游戏！全部代码+思路注释

今天我们将用C语言实现一个小球跳跃躲避方块的游戏。

2022-12-08 09:06:34

702

基于VHDL语言实现远程防盗报警设计

德赢Vwin官网网站提供《基于VHDL语言实现远程防盗报警设计.pdf》资料免费下载

2023-11-08 14:33:11

已全部加载完成

搜索历史

C语言实现http下载器（附代码）

评论