OTA计划--OTA-HEX2BIN脚本--再次狗尾续貂

最新推荐文章于 2021-12-23 20:35:30 发布
最新推荐文章于 2021-12-23 20:35:30 发布
阅读量181 收藏
点赞数
分类专栏： TOUCH-KING C语言基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42381351/article/details/103348075
版权

自己做 追加BIN
1--加入长度
2--加入MD5
3--加入CRC【放弃】
4--加密【放弃】
一个脚本完成！放在最后！
效果：

 

 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>//free


/*所谓MD5就是给进去文件字符串啥的 给你一个摘要 结果是16个HEX或者32个char*/

/*MD5部分--------------------H*/
typedef struct
{
    unsigned int count[2];
    unsigned int state[4];
    unsigned char buffer[64];   
}MD5_CTX;
 
                         
#define F(x,y,z) ((x & y) | (~x & z))
#define G(x,y,z) ((x & z) | (y & ~z))
#define H(x,y,z) (x^y^z)
#define I(x,y,z) (y ^ (x | ~z))
#define ROTATE_LEFT(x,n) ((x << n) | (x >> (32-n)))
#define FF(a,b,c,d,x,s,ac) \
          { \
          a += F(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define GG(a,b,c,d,x,s,ac) \
          { \
          a += G(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define HH(a,b,c,d,x,s,ac) \
          { \
          a += H(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define II(a,b,c,d,x,s,ac) \
          { \
          a += I(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }                                            
void MD5Init(MD5_CTX *context);
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen);
void MD5Final(MD5_CTX *context,unsigned char digest[16]);
void MD5Transform(unsigned int state[4],unsigned char block[64]);
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len);
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len);
 

void test_MD51(void);
void test_MD52(void);			
void GMD5_str_IIO( unsigned char *input, unsigned char inputlen, unsigned char output[33] );


/*MD5部分--------------------C*/
unsigned char PADDING[]={0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
                         
void MD5Init(MD5_CTX *context)
{
     context->count[0] = 0;
     context->count[1] = 0;
     context->state[0] = 0x67452301;
     context->state[1] = 0xEFCDAB89;
     context->state[2] = 0x98BADCFE;
     context->state[3] = 0x10325476;
}
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen)
{
    unsigned int i = 0,index = 0,partlen = 0;
    index = (context->count[0] >> 3) & 0x3F;
    partlen = 64 - index;
    context->count[0] += inputlen << 3;
    if(context->count[0] < (inputlen << 3))
       context->count[1]++;
    context->count[1] += inputlen >> 29;
    
    if(inputlen >= partlen)
    {
       memcpy(&context->buffer[index],input,partlen);
       MD5Transform(context->state,context->buffer);
       for(i = partlen;i+64 <= inputlen;i+=64)
           MD5Transform(context->state,&input[i]);
       index = 0;        
    }  
    else
    {
        i = 0;
    }
    memcpy(&context->buffer[index],&input[i],inputlen-i);
}
void MD5Final(MD5_CTX *context,unsigned char digest[16])
{
    unsigned int index = 0,padlen = 0;
    unsigned char bits[8];
    index = (context->count[0] >> 3) & 0x3F;
    padlen = (index < 56)?(56-index):(120-index);
    MD5Encode(bits,context->count,8);
    MD5Update(context,PADDING,padlen);
    MD5Update(context,bits,8);
    MD5Encode(digest,context->state,16);
}
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len)
{
    unsigned int i = 0,j = 0;
    while(j < len)
    {
         output[j] = input[i] & 0xFF;  
         output[j+1] = (input[i] >> 8) & 0xFF;
         output[j+2] = (input[i] >> 16) & 0xFF;
         output[j+3] = (input[i] >> 24) & 0xFF;
         i++;
         j+=4;
    }
}
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len)
{
     unsigned int i = 0,j = 0;
     while(j < len)
     {
           output[i] = (input[j]) |
                       (input[j+1] << 8) |
                       (input[j+2] << 16) |
                       (input[j+3] << 24);
           i++;
           j+=4; 
     }
}
void MD5Transform(unsigned int state[4],unsigned char block[64])
{
	unsigned int a = state[0];
	unsigned int b = state[1];
	unsigned int c = state[2];
	unsigned int d = state[3];
	unsigned int x[64];
	MD5Decode(x,block,64);
	FF(a, b, c, d, x[ 0], 7, 0xd76aa478); /* 1 */
	FF(d, a, b, c, x[ 1], 12, 0xe8c7b756); /* 2 */
	FF(c, d, a, b, x[ 2], 17, 0x242070db); /* 3 */
	FF(b, c, d, a, x[ 3], 22, 0xc1bdceee); /* 4 */
	FF(a, b, c, d, x[ 4], 7, 0xf57c0faf); /* 5 */
	FF(d, a, b, c, x[ 5], 12, 0x4787c62a); /* 6 */
	FF(c, d, a, b, x[ 6], 17, 0xa8304613); /* 7 */
	FF(b, c, d, a, x[ 7], 22, 0xfd469501); /* 8 */
	FF(a, b, c, d, x[ 8], 7, 0x698098d8); /* 9 */
	FF(d, a, b, c, x[ 9], 12, 0x8b44f7af); /* 10 */
	FF(c, d, a, b, x[10], 17, 0xffff5bb1); /* 11 */
	FF(b, c, d, a, x[11], 22, 0x895cd7be); /* 12 */
	FF(a, b, c, d, x[12], 7, 0x6b901122); /* 13 */
	FF(d, a, b, c, x[13], 12, 0xfd987193); /* 14 */
	FF(c, d, a, b, x[14], 17, 0xa679438e); /* 15 */
	FF(b, c, d, a, x[15], 22, 0x49b40821); /* 16 */

	/* Round 2 */
	GG(a, b, c, d, x[ 1], 5, 0xf61e2562); /* 17 */
	GG(d, a, b, c, x[ 6], 9, 0xc040b340); /* 18 */
	GG(c, d, a, b, x[11], 14, 0x265e5a51); /* 19 */
	GG(b, c, d, a, x[ 0], 20, 0xe9b6c7aa); /* 20 */
	GG(a, b, c, d, x[ 5], 5, 0xd62f105d); /* 21 */
	GG(d, a, b, c, x[10], 9,  0x2441453); /* 22 */
	GG(c, d, a, b, x[15], 14, 0xd8a1e681); /* 23 */
	GG(b, c, d, a, x[ 4], 20, 0xe7d3fbc8); /* 24 */
	GG(a, b, c, d, x[ 9], 5, 0x21e1cde6); /* 25 */
	GG(d, a, b, c, x[14], 9, 0xc33707d6); /* 26 */
	GG(c, d, a, b, x[ 3], 14, 0xf4d50d87); /* 27 */
	GG(b, c, d, a, x[ 8], 20, 0x455a14ed); /* 28 */
	GG(a, b, c, d, x[13], 5, 0xa9e3e905); /* 29 */
	GG(d, a, b, c, x[ 2], 9, 0xfcefa3f8); /* 30 */
	GG(c, d, a, b, x[ 7], 14, 0x676f02d9); /* 31 */
	GG(b, c, d, a, x[12], 20, 0x8d2a4c8a); /* 32 */

	/* Round 3 */
	HH(a, b, c, d, x[ 5], 4, 0xfffa3942); /* 33 */
	HH(d, a, b, c, x[ 8], 11, 0x8771f681); /* 34 */
	HH(c, d, a, b, x[11], 16, 0x6d9d6122); /* 35 */
	HH(b, c, d, a, x[14], 23, 0xfde5380c); /* 36 */
	HH(a, b, c, d, x[ 1], 4, 0xa4beea44); /* 37 */
	HH(d, a, b, c, x[ 4], 11, 0x4bdecfa9); /* 38 */
	HH(c, d, a, b, x[ 7], 16, 0xf6bb4b60); /* 39 */
	HH(b, c, d, a, x[10], 23, 0xbebfbc70); /* 40 */
	HH(a, b, c, d, x[13], 4, 0x289b7ec6); /* 41 */
	HH(d, a, b, c, x[ 0], 11, 0xeaa127fa); /* 42 */
	HH(c, d, a, b, x[ 3], 16, 0xd4ef3085); /* 43 */
	HH(b, c, d, a, x[ 6], 23,  0x4881d05); /* 44 */
	HH(a, b, c, d, x[ 9], 4, 0xd9d4d039); /* 45 */
	HH(d, a, b, c, x[12], 11, 0xe6db99e5); /* 46 */
	HH(c, d, a, b, x[15], 16, 0x1fa27cf8); /* 47 */
	HH(b, c, d, a, x[ 2], 23, 0xc4ac5665); /* 48 */

	/* Round 4 */
	II(a, b, c, d, x[ 0], 6, 0xf4292244); /* 49 */
	II(d, a, b, c, x[ 7], 10, 0x432aff97); /* 50 */
	II(c, d, a, b, x[14], 15, 0xab9423a7); /* 51 */
	II(b, c, d, a, x[ 5], 21, 0xfc93a039); /* 52 */
	II(a, b, c, d, x[12], 6, 0x655b59c3); /* 53 */
	II(d, a, b, c, x[ 3], 10, 0x8f0ccc92); /* 54 */
	II(c, d, a, b, x[10], 15, 0xffeff47d); /* 55 */
	II(b, c, d, a, x[ 1], 21, 0x85845dd1); /* 56 */
	II(a, b, c, d, x[ 8], 6, 0x6fa87e4f); /* 57 */
	II(d, a, b, c, x[15], 10, 0xfe2ce6e0); /* 58 */
	II(c, d, a, b, x[ 6], 15, 0xa3014314); /* 59 */
	II(b, c, d, a, x[13], 21, 0x4e0811a1); /* 60 */
	II(a, b, c, d, x[ 4], 6, 0xf7537e82); /* 61 */
	II(d, a, b, c, x[11], 10, 0xbd3af235); /* 62 */
	II(c, d, a, b, x[ 2], 15, 0x2ad7d2bb); /* 63 */
	II(b, c, d, a, x[ 9], 21, 0xeb86d391); /* 64 */
	state[0] += a;
	state[1] += b;
	state[2] += c;
	state[3] += d;
}




//0XAB-->"AB" 长度会扩大一倍！注意：0没有结束符
static void G_1byteTo2str(unsigned char* strings,unsigned char* bytes,unsigned char len)
{
    unsigned char const StrRefer[]="0123456789abcdef";//"0123456789ABCDEF";
    #define GET_MSB_STR(x) (StrRefer[((x>>4)&0x0f)])
    #define GET_LSB_STR(x) (StrRefer[(x&0x0f)])
    for(char i=0,j=0;i<len;i++,j+=2)
    {
        strings[j]  =GET_MSB_STR(bytes[i]);
        strings[j+1]=GET_LSB_STR(bytes[i]);
    }

}
 



void test_MD51(void)
{
	int i;
	unsigned char encrypt[] ="admin";//21232f297a57a5a743894a0e4a801fc3
	unsigned char decrypt[16];
    unsigned char decrypt2[32];	
	MD5_CTX md5;
	MD5Init(&md5);         		
	MD5Update(&md5,encrypt,strlen((char *)encrypt));
	MD5Final(&md5,decrypt);        
	printf("加密前:%s\r\n加密后:",encrypt);
	for(i=0;i<16;i++)
	{
		printf("%02X",decrypt[i]);
	}
	printf("\r\n");
	
	G_1byteTo2str(decrypt2,decrypt,16);
	for(i=0;i<32;i++)
	{
		printf("%02X-",decrypt2[i]);
	}
		printf("\r\n");
}
//MD5出来都是16个0XFF 现在这个是基础可以连续 就是最后变一下 就是MD5FILE
void test_MD52(void)
{
		int i;
		unsigned char encrypt[] ="adminadminadmin123";//18个
		unsigned char decrypt[16];
		MD5_CTX md5;
		MD5Init(&md5);         		
		MD5Update(&md5,encrypt,strlen((char *)encrypt));
		MD5Final(&md5,decrypt);        
		printf("方法1加密前:%s\r\n加密后:",encrypt);//86A74E7F4570EC093FC62E3D99B233BB
		for(i=0;i<16;i++)
		{
		printf("%02X",decrypt[i]);
		}
		printf("\r\n+++++++++++++++++\r\n");
		memset(decrypt,0,16); 
		MD5Init(&md5);    
		for(char i=0;i<3;i++)
		MD5Update(&md5,&encrypt[6*i],6);
		MD5Final(&md5,decrypt);  
		printf("方法2加密前:%s\r\n加密后:",encrypt);
		for(i=0;i<16;i++)
		{
		printf("%02X",decrypt[i]);
		}
		printf("\r\n##################\r\n");
}

void GMD5_str_IIO( unsigned char *input, unsigned char inputlen, unsigned char output[33] )
{
	unsigned char decrypt[16];
	MD5_CTX md5;
	MD5Init(&md5);         		
	MD5Update(&md5,input,inputlen);
	MD5Final(&md5,decrypt);        
	G_1byteTo2str(output,decrypt,16);
//		for(int i=0;i<32;i++)
//	{
//		printf("%02X-",output[i]);
//	}
//		printf("\r\n");
}


char MD5FILE(unsigned char outmd5[16])
{

}

//完成'4'-->4  ‘A’-->10
unsigned char G_strTobyte(unsigned char dData)
{
	unsigned char rst=0;
	if((dData >= '0')&& (dData <= '9'))
				rst = dData-'0';
	else if((dData >= 'A')&&(dData <= 'F'))
				rst =  dData+10-'A';
	else if((dData >= 'a')&&(dData <= 'f'))
				rst =  dData+10-'a';
	else {printf("ERR G_strTobyte\r\n");rst = 0;}//不是ASCII的char就返回0 有点儿欠妥！
			
	return rst;
}
//压缩一半
//完成"10"--->0x10  "1234"--->0X12,0X34 
//len标识传入的strlen(strings)
//返回值是len的一半
char G_strsTobytes(void* Strings,void* Bytes,char len)
{
	unsigned char* strings=(unsigned char *)Strings;
	unsigned char* bytes  =(unsigned char *)Bytes;
	unsigned char i = 0,j=0,lowbits=0,highbits=0;
	if(len%2){printf("ERR G_strsTobytes\r\n");return 0;}//禁止奇数
	for (i = 0; i < len; i+=2)
	{           
		highbits = G_strTobyte(strings[i]  );
		lowbits  = G_strTobyte(strings[i+1]);
		bytes[j++] =( highbits << 4)|lowbits;
	}
	return j;
}

int main(int argc,char **argv)
{
	FILE *fp1,*fp2; 
	unsigned int lSize=0;
	char *name = NULL;
	unsigned char ch,start=0;
	unsigned char buf[44]={0},i=0,len=0,addr,type;
	unsigned char bin[16]={0},j=0;
	if(argc==1)
	{
		name = (char *)"1.bin";
		printf("NEWNAME %s\r\n",name);
	}
	else if(argc==2)
	{
		name = argv[1];
		printf("NEWNAME %s\r\n",name);
	}

	//fp1 = fopen("GTOUCH_STM32_L471RE/APP.hex", "r");
	fp1 = fopen("APP.hex", "r");
	if (NULL == fp1){ printf("NULL == fp1"); return 1;}

	fp2 = fopen(name, "wb");
	if (NULL == fp2){ printf("NULL == fp2");return 1;}
	

	while(1)
	{
		ch = fgetc(fp1);
		if(feof(fp1))		//如果读到了文件结尾，就退出 while循环
			break;
     
	    if(start == 0)
	    {
	    	if(ch==':'){start = 1;i=0;len=0;memset(buf,0,44);memset(bin,0,16);}
	    }	
		else 
		{
//  :1016500003F92802083010120878124408520418BE
//  :0E1660001003E529020848100002F8F80208FD
			buf[i++]=ch;
			if(i==2)//10
			{
			    len  = (G_strTobyte(buf[0]))*16 + (G_strTobyte(buf[1]));
				//源码这有问题比如上面0E就处理成21了 需要上面的函数 len  = (buf[0]-'0')*16 + (buf[1]-'0');
				//if(len!=16 && len!=8 && len!=0){start = 0;continue;}//要求长度是16 最后有个是8 其他的赶紧走
				//if(len ==2 || len==4 ){start = 0;continue;}//要求长度是16 最后有个是8 其他的赶紧走
				if(buf[0]=='1'&&buf[1]=='0')
				{}
				else 
				{printf("[%c-%c]\r\n",buf[0],buf[1]);}
			}
			if(i==2+4)//A640
			    addr = buf[2]+buf[3]+buf[4]+buf[5];
			if(i==2+4+2)//00
			{
				type = (buf[6]-'0')*16 + (buf[7]-'0');

				if(type!=0)//要求类别是00的才可以放入bin文件 别的赶紧走
				{ 
					//if(type==4)printf("不支持线下地址\r\n");
					//else if(type==2)printf("不支持扩展段\r\n");	
					//else if(type==1)printf("文件即将结束\r\n");	
					//else printf("type=%d\r\n",type);	
					start = 0;
				}
			}
	        if(i == 2+4+2+len*2)
	        {//0208116A0208B9690208E96B84190C1E
 	        	G_strsTobytes(&buf[8],bin,len*2);
	        	for(j=0;j<len;j++)
					fputc(bin[j] , fp2);
				start = 0;
				i=0;
	        }

		}
	}
	
	fclose(fp1);
	fclose(fp2);
	free(fp1);
	free(fp2);
	printf("******GKOSON FINISHED*******\r\n");

/*
自己做 追加BIN
1--加入长度
2--加入MD5
3--加入CRC【放弃】
4--加密【放弃】
一个脚本完成！放在最后！
*/

 	//1----完成文件长度的GET
	FILE *fp = fopen(name, "rb");
    if (NULL == fp){ printf("NULL == fp");return 1;}
	fseek(fp,0,SEEK_END);//光标到尾巴
	lSize = ftell(fp);//光标的位置就是长度了
	fclose(fp);
	free(fp);
    printf("bin len =%d = %dK\n",lSize,lSize/1024);

 	//2----完成文件MD5的GET
    FILE *fpMD5 = fopen(name, "rb");
    int filecnt,infilelen,addrpage;
    unsigned char infile[4096];//每次读到文件的buf//前面都是4096最后一页不是哦
    unsigned char  MD5rst[16];
    MD5_CTX md5;
    MD5Init(&md5);     

    filecnt = (lSize/4096)?(lSize/4096+1):(lSize/4096);

    for(i=0;i<filecnt-1;i++)
    {
        addrpage=0 + (i*4096);
		fseek(fpMD5,addrpage,SEEK_SET);//光标到开头
		
        infilelen=4096;
		
		fread (infile, sizeof(char), infilelen, fpMD5);
        MD5Update(&md5,infile,infilelen);

    }
    i=filecnt-1;
    addrpage=0 + (i*4096);
	fseek(fpMD5,addrpage,SEEK_SET);//光标到开头
	
    infilelen=(lSize)-((i)*4096);    printf("infilelen=%d\r\n",infilelen);
	
    fread (infile, sizeof(char), infilelen, fpMD5);
    MD5Update(&md5,infile,infilelen);
    MD5Final(&md5,MD5rst);        
    printf("MD5rst:\r\n");    for(i=0;i<16;i++)    printf("%02X",MD5rst[i]);    printf("\r\n");
   
   
   
   
    fclose(fpMD5);
	free(fpMD5);


//执行追加：	
	FILE *fpbin = fopen(name,  "ab+");//写
	//打开 默认在文件头 需要到尾巴wb--》wb+
	//fseek(fpbin,0,SEEK_END);//光标到尾巴
	//fseek(fpbin,lSize,SEEK_SET);//光标到尾巴
	unsigned char uintbuf[4];
	memcpy(uintbuf,&lSize,4);		
	//fwrite(uintbuf, sizeof(char), 4, fpbin);
	//fwrite(MD5rst, sizeof(char), 16, fpbin);
    for(j=0;j<4;j++)	fputc(uintbuf[j] , fpbin);
    for(j=0;j<16;j++)	fputc(MD5rst[j] ,  fpbin);
	fclose(fpbin);
	free(fpbin);

    printf("追加完毕\r\n");
	//scanf("%d\n",&ch);//人为堵塞一下
	getchar();//人为堵塞一下
	return 1;
}

 

GKoSon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OTA计划--OTA-HEX2BIN脚本--再次狗尾续貂-MD5+压缩
GKoSon的博客
12-11 274
做好BIN在后面追加MD5 文件分步压缩 追加长度 #include <stdio.h> #include <string.h> #include <stdlib.h>//free #define uint8_t unsigned char #define uint16_t unsigned short #define uint32_t ...
OTA-2HEX的合并脚本
GKoSon的博客
11-13 171
1-- 自己搞了一个文件夹 每次吧2个HEX拷贝过来 执行EXE 那就是不要路径 #include <stdio.h> int main(int argc,char **argv) { FILE *fp1,*fp2,*fp3; char ch; int lSize=0; fp1 = fopen("BOOT.hex", "r"); fp3 = fopen...
使用Hex view编写脚本生成特定格式刷写文件
anhui_boy的专栏
12-23 1万+
1.知识背景 汽车行业ECU基本都具有FBL（flash boot loader）功能。FBL可以基于UDS协议实现刷写功能。很多OEM厂商都有OTA的需求，但是对于整车内部ECU来说，仍然是基于UDS协议实现刷写。但是往往会要求刷写文件具有特定格式。如吉利/沃尔沃采用VBF（volov binary format）格式，吉利提供了VBF生成工具。长城要求具有特殊hearer area等特殊格式的BIN文件。 这时候往往需要对IDE编译产生的S19、HEX、BIN等格式进...
S19、Hex、Bin转换工具.rar
09-18
使用Burner工具，对后缀为S19、Bin、Hex的文件进行相互转换，常见的使用方法 S19转Hex，S19转Bin。 使用方法详见博客：https://blog.csdn.net/hb69222/article/details/100985995
可在线OTA升级的嵌入式系统设计方案
热门推荐
zhou_chenz的博客
02-07 1万+
什么是在线OTA升级 - OTA是Over-the-Air的简写，空中下载技术的意思。 - OTA在线升级在日常消费电子产品中很常见，比如手机，机顶盒等，通过网络，下载升级数据包，更新操作系统等底层固件进行系统更新升级。 - 在线升级系统对于批量化消费电子产品来说是相当重要的。因为销售给客户的电子产品，其中的软件系统可能有潜在的bug或者功能为实现不齐全，需要在售后进一步完善更新系统。一般都是通过网络远程给用户进行系统更新。
esp32-ota-update-mqtt
05-02
通过MQTT启动ESP32 OTA更新 此源允许通过MQTT触发ESP OTA更新。 您只需提供主机名/ binfile，ESP就会解析URL。 之后，更新将自动开始。 目前，这仅在端口80上有效！ 触发更新的示例MQTT消息（不要向主机名添加任何...
esp-ota-server：ESP8266 ESP32 HTTP OTA服务器
02-05
ESP-OTA-服务器非常简单的OTA固件服务器，适用于内置和 。 主要目的是提供固件文件并传递MD5哈希值-以验证闪存。 选项： -s --bind监听地址（默认值:8092 ） -d --data-dir数据存储位置。 <data>/<project>/<file> ...
esp32-ota-websockets-framework
03-18
档案文件slide-demo2.ino WiFiCred.h bcbaws.h bcbsdcard.h slide-demo2.ino内部rtc变量const char * ntpServer =“ pool.ntp.org”; const long gmtOffset_sec = -18000; const int daylightOffset_sec = 3600;定义...
ota_downloader:在RT-Thread OTA组件上使用的固件下载器
05-23
OTA下载器 | 英语 1.简介 该软件包是用于OTA升级的...2.如何打开OTA下载器 要使用OTA下载程序包，您需要在RT-Thread的包管理器中选择它。 具体路径如下： RT-Thread online packages IoT-internet of things --->
JN-5169空中升级(OTA)详解.pdf
最新发布
08-31
* 将 DimmableLight_JN5169_DR1175_LED_EXP_MONO_OTA_Client_v1.bin 固件烧入 JN-5169 芯片 * 启动 PC 端的 ZigBee Gateway 测试软件 ZGWUI.exe，设置"Set CMSK" 、"Start NWK" 和"Permit Join"功能后，建立 ZigBee ...
C语言实现计算一段字符串的MD5码
Magnum的博客
06-27 2215
MD5码的原理网上可以找到很多，这里只给出我自己封装的获取一段字符串的MD5码C语言实现！ 封装后的文件包含三部分：md5.h头文件、md5.c实现文件、test.c测试文件 1、md5.h头文件 #ifndef __MD5_H__ #define __MD5_H__ typedef struct { unsigned int count[2]; unsi...
Rom开发之OTA升级流程
忘冻鱼的博客
10-19 3020
不积跬步无以至千里 OTA之简介： OTA英文全称是Over-the-Air Technology，即空间下载技术的意思。 OTA升级是Android系统提供的标准软件升级方式。它功能强大，可以无损失升级系统，主要通过网络[例如WIFI、3G]自动下载OTA升级包、自动升级，但是也支持通过下载OTA升级包到SD卡升级,OTA的升级包非常的小，一般几M到十几M，如果你用网络升级，非常的方便，基本
FREERTOS必备知识-喂狗-死机
GKoSon的博客
11-26 2183
FREERTOS必备知识： MUST修改地方：D:\GKOSON_BACK_GARDEN\TOUCH_CLASS\TOUCH-KING\KEIL\Inc\FreeRTOSConfig.h #define configASSERT( x ) if ((x) == 0) {taskDISABLE_INTERRUPTS();printf(">>>>>>>&g...
MQTTpublish再次分析
GKoSon的博客
10-17 1643
【W5500W】socket recv : 34 37 00 33 2F 64 6F 77 6E 2F 66 63 37 65 32 37 31 33 33 32 66 37 66 36 65 36 38 34 64 35 63 32 36 34 39 65 36 31 39 62 61 62 2F 44 43 32 43 32 36 30 30 32 31 45 43 00 01 ...
EasyLogger快速移植
GKoSon的博客
10-22 1497
回到GIT的主分支 下载源码 解压在这里https://github.com/armink/EasyLogger D:\GKOSON_BACK_GARDEN\TOUCH_CLASS\TOUCH-KING\KEIL\Middlewares\Third_Party\EasyLogger-master 文件夹说明 D:\GKOSON_BACK_GARDEN\TOUCH_CLASS\TOUCH-KIN...
如何快速操作RTC模块
GKoSon的博客
10-26 918
看到工程已经有rtc.c--MX打钩的 我需要做的是BSPRTC 拷贝文件夹 Gbsp_rtc 怎么使用？三元组 初始化--没有必要了 因为有 MX_RTC_Init();即可 没有后台--因为rtc_alarm_callback 没有写 也就是直接用就可以！！test_rtc直接看看效果 注意：里面内部调用的函数需要放到内部的rt...
US-延时的实现方法1-大块切糕
GKoSon的博客
11-02 792
参考： https://blog.csdn.net/qq_22252423/article/details/76468161 核心思想是我做一个TIM他的CNT其实是在0--7200之前跑的 但是我暴力设置CNT为一个数字A--然后让他跑到B的时候停止 大块切糕 就是如此 拿出若干个等分吧。 void delay_us(uint16_t us) { uint16_t diff...
MQTT流程LOG
GKoSon的博客
10-17 724
MQTT流程LOG 第一次connect [#][MQTT协议学习TX] : [10 D8 01 00 04 4D 51 54 54 04 D6 00 3C 00 20 31 62 39 62 36 66 62 30 61 31 31 39 62 63 38 36 36 38 63 66 36 32 66 66 61 65 34 65 64 61 35 32 00 31 2F 75 70 2...
JN-5169 ZigBee OTA升级详解：原理、流程与请求机制
JN-5169空中升级(OTA)详解主要介绍了JN-5169芯片在物联网设备中的空中升级技术，这是一种通过无线网络对设备固件进行远程更新的方法。ZigBee联盟为实现这一功能制定了一个名为OTAUpgrade(0x0019)的系统可选模块规范...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值