适配3码互转算法

source/ReadMe.txt

@@ -88,4 +88,6 @@
     bootloader在启动app之前会初始化系统参数
     tran使用回调的方式接收handle的返回
     注码指令自动回读结果
+2023.6.13
+    适配3码互转算法
     

source/coder/PSDGenerate.c

@@ -0,0 +1,60 @@
+#include "PSDGenerate.h"
+
+/********************************************************************************************************************
+ *                                  新版密码支持BCD码                                                               *
+********************************************************************************************************************/
+
+uint64_t Scramble(uint64_t number, uint64_t max)
+{
+		int i = 0;
+		// some random values
+		uint64_t scramblers[] = { 3, 5, 7, 31, 343, 2348, 89897 };
+		number += (max / 7) + 6;
+		number %= max;
+		// shuffle according to divisibility
+		for (i = 0; i < 7; i++)
+		{
+				if (scramblers[i] >= max / 3) break;
+				number = ((number * scramblers[i]) % max)
+					+ ((number * scramblers[i]) / max);
+		}
+
+
+		return number % max;
+}
+
+int GetPasswordByUidCode(const uint8_t *uidcode,uint8_t* psd)
+{
+	uint64_t val = 0,val1 = 0;
+	int i= 0;
+	uint64_t ulBCDPsd = 0;
+
+	for(i=2;i<10;i++)
+	{
+		val *=10;
+		val += uidcode[i]-0x30;
+	}
+	val += uidcode[10];
+	
+	for(i=11;i<16;i++)
+	{
+		val1 *=10;
+		val1 += uidcode[i]-0x30;
+	}
+  val = val  + val1;
+  ulBCDPsd = Scramble(val, 0xFFFFFFFF);
+
+	
+	psd[0] = (ulBCDPsd&0xFF000000)>>24;
+	psd[1] = (ulBCDPsd&0x00FF0000)>>16;
+	psd[2] = (ulBCDPsd&0x0000FF00)>>8;
+	psd[3] =  ulBCDPsd&0x000000FF;
+	
+	return 0;
+}
+
+
+
+
+
+

source/coder/PSDGenerate.h

@@ -0,0 +1,13 @@
+#ifndef __PSDGENERATE_H__
+#define  __PSDGENERATE_H__
+#include <stdio.h>
+#include <stdbool.h>
+#include "stdint.h"
+
+
+
+int GetPasswordByUidCode(const uint8_t *uidcode,uint8_t* psd);
+
+
+
+#endif

source/coder/UIDGenerate.c

@@ -0,0 +1,303 @@
+#include "UIDGenerate.h"
+#include "string.h"
+
+
+//static u8 _CalcCrc8(u8 *Ptr,u8 num);
+
+static uint32_t UINT32_ENDIAN_CHANGE(uint32_t val);
+
+static bool YMUid_Valid_check(uint8_t *u8ArrayYMUid);
+
+static uint8_t CalcCrc8(uint8_t *Ptr,uint8_t num);
+
+static void string2hex(char* src,size_t srclen,char* dst,size_t *dstlen);
+static bool byte2String(uint8_t *src, size_t srcoffset, size_t srclen, char* dst, size_t dstoffset, size_t *dstlen);
+
+
+
+bool UidCode_JQ2YM(const PST_JQUID_TYPEDEF pstJQUID,PST_YMUID_TYPEDEF pstYMUID)
+{
+	UNION_VALUE_CHANGE_TYPEDEF stDate;
+	UNION_VALUE_CHANGE_TYPEDEF stSerialCode ;
+	uint8_t i=0;
+	uint16_t u16Year = 0;
+	uint16_t u16Month = 0;
+	uint8_t u8Day = 0;
+	uint16_t u16Date =0;
+	ST_JQUID_TYPEDEF _stJQUID;
+	
+	uint16_t sum=0;
+	
+	for(i=0;i<8;i++)
+	{
+		sum=sum+pstJQUID->u8ArrayJQUidCode[i];
+		_stJQUID.u8ArrayJQUidCode[7-i]=pstJQUID->u8ArrayJQUidCode[i];				//逆序detid
+	}
+	memcpy(pstJQUID->u8ArrayJQUidCode,_stJQUID.u8ArrayJQUidCode,8);
+	
+	if(sum == 0)  						//全0时，CRC码也为0，所以需要避免这种情况	
+		return 0;   
+	
+	
+	if(pstJQUID->u8ArrayJQUidCode[7] != CalcCrc8(pstJQUID->u8ArrayJQUidCode,7))
+		return false;
+	
+	pstYMUID->ucArrayYMUidCode[0] = pstJQUID->u8ArrayJQUidCode[0]/10+0x30;
+	pstYMUID->ucArrayYMUidCode[1] = pstJQUID->u8ArrayJQUidCode[0]%10+0x30;
+	
+	
+	
+	pstYMUID->ucArrayYMUidCode[4] = pstJQUID->u8ArrayJQUidCode[1];//特征码
+	
+	u16Date = pstJQUID->u8ArrayJQUidCode[2];
+	u16Date = u16Date<<8 | pstJQUID->u8ArrayJQUidCode[3];
+	
+	u16Year = (u16Date>>9)&0x7F;
+	u16Month = (u16Date>>5)&0x0F;
+	u8Day = u16Date&0x1F;
+	
+	pstYMUID->ucArrayYMUidCode[2] = u16Year/10+0x30;
+	pstYMUID->ucArrayYMUidCode[3] = u16Year%10+0x30;
+	
+	pstYMUID->ucArrayYMUidCode[5] = u16Month/10+0x30;
+	pstYMUID->ucArrayYMUidCode[6] = u16Month%10+0x30;
+	
+	pstYMUID->ucArrayYMUidCode[7] = u8Day/10+0x30;
+	pstYMUID->ucArrayYMUidCode[8] = u8Day%10+0x30;
+	
+	
+	memcpy(stSerialCode.u8Val+1,pstJQUID->u8ArrayJQUidCode+4,3);
+	stSerialCode.u32Value = UINT32_ENDIAN_CHANGE( stSerialCode.u32Value);
+	
+	pstYMUID->ucArrayYMUidCode[DEF_YM_SPECIALCODE_INDEX] = (stSerialCode.u32Value>>17) & 0x7F;
+	stSerialCode.u32Value = stSerialCode.u32Value&0x1FFFF;
+	
+	for(i=14;i>=10;i--)
+	{
+			pstYMUID->ucArrayYMUidCode[i] = (stSerialCode.u32Value%10+0x30);
+			stSerialCode.u32Value = stSerialCode.u32Value/10;
+		
+	}
+	
+	
+	if(!YMUid_Valid_check(pstYMUID->ucArrayYMUidCode))
+		return false;
+	
+	return true;
+}
+
+bool UidCode_JQ2YM_NoBackwardSequence(const PST_JQUID_TYPEDEF pstJQUID,PST_YMUID_TYPEDEF pstYMUID)
+{
+	uint8_t i=0;
+	uint8_t ucYear = 0;
+	uint8_t ucMonth = 0;
+	uint8_t ucDay = 0;
+	uint32_t ulNumber =0;
+	uint8_t ucTeZhengMa = 0;
+	uint16_t usBoxCode = 0;
+	uint8_t ucIndexCode = 0;
+	size_t len = 16;
+	
+	if(pstJQUID->u8ArrayJQUidCode[7] != CalcCrc8(pstJQUID->u8ArrayJQUidCode,7))
+		return false;
+	
+	byte2String(pstJQUID->u8ArrayJQUidCode,0,2,(char *)pstYMUID->ucArrayYMUidCode,0,&len);//AD58
+	pstYMUID->ucArrayYMUidCode[4] = pstYMUID->ucArrayYMUidCode[2];
+	pstYMUID->ucArrayYMUidCode[5] = pstYMUID->ucArrayYMUidCode[3];
+	
+	
+	ucYear = pstJQUID->u8ArrayJQUidCode[2]>>1;
+	pstYMUID->ucArrayYMUidCode[2] = ucYear/10+0x30;
+	pstYMUID->ucArrayYMUidCode[3] = ucYear%10+0x30;
+	
+	ucMonth = ((pstJQUID->u8ArrayJQUidCode[2]&0x01)<<3)|((pstJQUID->u8ArrayJQUidCode[3]>>5));
+	pstYMUID->ucArrayYMUidCode[6] = ucMonth/10+0x30;
+	pstYMUID->ucArrayYMUidCode[7] = ucMonth%10+0x30;
+	
+	ucDay = (pstJQUID->u8ArrayJQUidCode[3]&0x1F);
+	pstYMUID->ucArrayYMUidCode[8] = ucDay/10+0x30;
+	pstYMUID->ucArrayYMUidCode[9] = ucDay%10+0x30;
+	
+	ulNumber = pstJQUID->u8ArrayJQUidCode[4];
+	ulNumber <<= 8;
+	ulNumber |= pstJQUID->u8ArrayJQUidCode[5];
+	ulNumber <<= 8;
+	ulNumber |= pstJQUID->u8ArrayJQUidCode[6];
+	
+	ucTeZhengMa = ulNumber/100000;
+	pstYMUID->ucArrayYMUidCode[10] = ucTeZhengMa;
+	
+	ulNumber = ulNumber%100000;
+	usBoxCode = ulNumber/100;
+	pstYMUID->ucArrayYMUidCode[11] = usBoxCode/100 + 0x30;
+	usBoxCode%=100;
+	pstYMUID->ucArrayYMUidCode[12] = usBoxCode/10+0x30;
+	pstYMUID->ucArrayYMUidCode[13] = usBoxCode%10 + 0x30;
+	
+	ucIndexCode = ulNumber%100;
+	pstYMUID->ucArrayYMUidCode[14] = ucIndexCode/10+0x30;
+	pstYMUID->ucArrayYMUidCode[15] = ucIndexCode%10 + 0x30;
+		
+	if(!YMUid_Valid_check(pstYMUID->ucArrayYMUidCode))
+		return false;
+	
+	return true;
+}
+
+
+
+bool UidCode_YM2JQ(PST_JQUID_TYPEDEF pstJQUID,const PST_YMUID_TYPEDEF pstYMUID)
+{
+
+	uint8_t i=0;
+	uint16_t usYear = 0;
+	uint16_t usMonth = 0;
+	uint16_t usDay = 0;
+	uint32_t ulNumber =0;
+	uint16_t usBoxCode = 0;
+	uint8_t ucIndexCode = 0;
+	size_t dataLen = 0;
+	
+	if(!YMUid_Valid_check(pstYMUID->ucArrayYMUidCode))
+		return false;
+	
+	string2hex((char *)pstYMUID->ucArrayYMUidCode,6,(char *)pstJQUID->u8ArrayJQUidCode,&dataLen); //0xAD 0x23 0x58
+	
+	pstJQUID->u8ArrayJQUidCode[1] = pstJQUID->u8ArrayJQUidCode[2];//0xAD 0x58
+	
+	//转换 年 月 日
+	usYear = (pstYMUID->ucArrayYMUidCode[2]-0x30)*10 + (pstYMUID->ucArrayYMUidCode[3]-0x30);
+	usMonth = (pstYMUID->ucArrayYMUidCode[6]-0x30)*10 + (pstYMUID->ucArrayYMUidCode[7]-0x30);
+	usDay = (pstYMUID->ucArrayYMUidCode[8]-0x30)*10 + (pstYMUID->ucArrayYMUidCode[9]-0x30);
+	
+	usYear = usYear<<9|usMonth<<5|usDay;
+
+	pstJQUID->u8ArrayJQUidCode[2] = (usYear&0xFF00)>>8;
+	pstJQUID->u8ArrayJQUidCode[3] = (usYear&0xFF);
+	
+	
+	
+	ulNumber = pstYMUID->ucArrayYMUidCode[10]*100000;
+	usBoxCode = (pstYMUID->ucArrayYMUidCode[11]-0x30)*100+ (pstYMUID->ucArrayYMUidCode[12]-0x30)*10+(pstYMUID->ucArrayYMUidCode[13]-0x30);
+	ucIndexCode = (pstYMUID->ucArrayYMUidCode[14]-0x30)*10+(pstYMUID->ucArrayYMUidCode[15]-0x30);
+	
+	ulNumber += usBoxCode*100+ucIndexCode;
+	
+	pstJQUID->u8ArrayJQUidCode[4] = (ulNumber&0xFF0000)>>16;
+	pstJQUID->u8ArrayJQUidCode[5] = (ulNumber&0xFF00)>>8;
+	pstJQUID->u8ArrayJQUidCode[6] = (ulNumber&0xFF);
+
+	
+	pstJQUID->u8ArrayJQUidCode[7] = CalcCrc8(pstJQUID->u8ArrayJQUidCode,7);
+	
+	return true;
+}
+
+
+static bool YMUid_Valid_check(uint8_t *u8ArrayYMUid)
+{
+	uint8_t i=0;
+	uint8_t u8ValidDataCounter = 0;
+	
+	for(i=0;i<16;i++)
+	{
+		if(u8ArrayYMUid[i] >= '0' && u8ArrayYMUid[i] <= '9')
+		{
+			u8ValidDataCounter++;
+			continue;
+		}
+		if(u8ArrayYMUid[i] >= 'A' && u8ArrayYMUid[i] <= 'Z')
+		{
+			u8ValidDataCounter++;
+			continue;
+		}
+		if(u8ArrayYMUid[i] >= 'a' && u8ArrayYMUid[i] <= 'z')
+		{
+			u8ValidDataCounter++;
+			continue;
+		}
+	}
+	
+	if(u8ValidDataCounter < 7)
+		return false;
+	return true;
+}
+
+static uint32_t UINT32_ENDIAN_CHANGE(uint32_t val)
+{
+	
+	return  ((( val & 0x000000ff)<< 24 ) | ( ( val & 0x0000ff00 ) << 8 ) | ( ( val & 0x00ff0000 ) >> 8 ) | ( ( val & 0xff000000 ) >> 24 ));
+}
+
+static void string2hex(char* src,size_t srclen,char* dst,size_t *dstlen)
+{
+	size_t i=0;
+	uint8_t tmp1=0,tmp2=0;
+	for(;i<srclen;i++){
+		if(src[i]<='9')
+			tmp1 = src[i]-'0';
+		else
+			tmp1 = src[i]-'A'+10;
+		i++;
+		if(src[i]<='9')
+			tmp2 = src[i]-'0';
+		else
+			tmp2 = src[i]-'A'+10;
+		*dst++ = tmp1*16+tmp2;
+		(*dstlen)++;
+	}
+}
+
+
+static bool byte2String(uint8_t *src, size_t srcoffset, size_t srclen, char* dst, size_t dstoffset, size_t *dstlen)
+{
+	char MatirxHex[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+	size_t i = 0;
+	
+	if((srclen-srcoffset)*2 > *dstlen-dstoffset)
+		return false;
+	
+	dst += dstoffset;
+	
+	for(i=srcoffset;i<srclen;i++)
+	{
+		*dst++ = MatirxHex[(src[i]&0xF0)>>4];
+		*dst++ = MatirxHex[src[i]&0x0F];
+	}
+	
+	*dstlen = (i-1)*2;
+	
+	return true;
+}
+
+//============================================================================//
+//8位CRC效验计算,只计算缓存区前6个字节
+//输入参数：需要计算数据缓存区头指针
+//返 回 值：效验值
+//============================================================================//
+static uint8_t CalcCrc8(uint8_t *Ptr,uint8_t num)         
+{
+    uint8_t i,j,crc = 0;
+ 
+    for (j = 0; j < num; j++)
+    {
+        crc ^= *(Ptr+j);
+        for ( i = 0; i < 8; i++)
+        {
+            if ((crc & 0x01) != 0)
+            {
+                crc >>= 1;
+                crc ^= 0x8c;
+            }
+            else
+            {
+                crc >>= 1;
+            }
+        }
+    }
+    return crc;
+}
+
+
+
+

source/coder/UIDGenerate.h

@@ -0,0 +1,37 @@
+#ifndef __UIDGENERATE_H__
+#define __UIDGENERATE_H__
+#include <stdio.h>
+#include <stdbool.h>
+#include "stdint.h"
+
+
+
+#define DEF_YM_SPECIALCODE_INDEX 9
+
+#pragma pack(1) 
+typedef struct
+{
+	unsigned char  ucArrayYMUidCode[16];
+}ST_YMUID_TYPEDEF,*PST_YMUID_TYPEDEF;
+
+typedef struct 
+{
+	uint8_t u8ArrayJQUidCode[8];
+}ST_JQUID_TYPEDEF,*PST_JQUID_TYPEDEF;
+
+typedef union
+{
+	uint32_t u32Value;
+	uint8_t u8Val[4];
+}UNION_VALUE_CHANGE_TYPEDEF,*PST_VALUE_CHANGE_TYPEDEF;
+
+#pragma pack()
+
+bool UidCode_YM2JQ(PST_JQUID_TYPEDEF pstJQUID,const PST_YMUID_TYPEDEF pstYMUID);
+
+bool UidCode_JQ2YM(const PST_JQUID_TYPEDEF pstJQUID,PST_YMUID_TYPEDEF pstYMUID);
+
+bool UidCode_JQ2YM_NoBackwardSequence(const PST_JQUID_TYPEDEF pstJQUID,PST_YMUID_TYPEDEF pstYMUID);
+
+#endif
+

source/coder/coder_lib.c

@@ -0,0 +1,202 @@
+#include "coder_lib.h"
+#include "string.h"
+#include "mystring.h"
+#include "crc.h"
+#include "stdio.h"
+
+/*
++-----------------------------------------------------------------------+
+|                         管壳码格式(ascii)                             |
++-----------------------------------------------------------------------+
+|                              13byte                                   |
++-----------------------------------------------------------------------+
+| 雷管厂代号 |  生产年份  |  生产月份  |  生产日  |  特征号  |  流水号  |
++------------+------------+------------+----------+----------+----------+
+|    2byte   |    1byte   |    2byte   |   2byte  |   1byte  |   5byte  |
++-----------------------------------------------------------------------+
+
+
+
++-----------------------------------------------------------------------+
+|                          UID码格式(ascii)                             |
++-----------------------------------------------------------------------+
+|                              16byte                                   |
++-----------------------------------------------------------------------+
+| 芯片厂代号 | 生产年份 | 雷管厂代号 |  月 |  日 | 特征码 | 盒号 | 序号 |
++------------+----------+------------+-----+-----+--------+------+------+
+|    2byte   |   2byte  |    2byte   |2byte|2byte|  1byte | 3byte| 2byte|
++-----------------------------------------------------------------------+
+
+
+
++-----------------------------------------------------------------------+
+|                        UID码存储格式(hex)                             |
++-----------------------------------------------------------------------+
+|                              8byte                                    |
++-----------------------------------------------------------------------+
+| 芯片厂代号 | 雷管厂代号 |      年月日      |   特征码盒号序号  | crc8 |
++------------+------------+------------------+-------------------+------+
+|    1byte   |    1byte   |   2byte(大端)    |    3byte(大端)    | 1byte|
++-----------------------------------------------------------------------+
+
+
+
+年月日(ascii)->年月日(hex)
+年(y),月(m),日(d)
+time=((((y[0]-'0')*10)+(y[1]-'0'))<<9)|\
+  ((((m[0]-'0')*10)+(m[1]-'0'))<<5)|\
+  (((d[0]-'0')*10)+(d[1]-'0'))
+
+特征码盒号序号(ascii)->特征码盒号序号(hex)
+特征码(c),盒号(b),序号(i)
+code=c*10000+((b[0]-'0')*100+(b[1]-'0')*10+(b[2]-'0'))*100+\
+  ((i[1]-'0')*10+(i[2]-'0'))
+
+
+*/
+
+
+
+
+
+// 根据管壳码和年份信息生成uid的年份信息
+static int coder_calc_year(const char *year,const char shell_year,char *uid_year)
+{
+  int y=0;
+  for(int i=0;i<4;i++)
+  {
+    y*=10;y+=year[i]-'0';
+  }
+  // year是实时数据，鉴于12月31生产的雷管，year可能不同
+  // 此时year-1来保证与uid码上的相同
+  if(year[3]!=shell_year)
+    y--;
+  uid_year[1]=y%100/10+'0';
+  uid_year[0]=y%10+'0';
+  if(uid_year[0]==shell_year)
+    return 0;
+  else
+    return -1;
+}
+
+
+
+// 管壳码转uid码
+int coder_shell_to_uid(const char *year,const char *shell_code,char *uid_code)
+{
+  int ret=0;
+  memset(uid_code,0,16);
+  // 添加芯片企业代号(2byte)
+  memcpy(&uid_code[0],"AD",2);
+  // 添加年份(2y=byte)
+  ret=coder_calc_year(year,shell_code[2],&uid_code[2]);
+  // 添加雷管厂代号(2byte)
+  memcpy(&uid_code[4],&shell_code[0],2);
+  // 添加月日特征码流水号
+  memcpy(&uid_code[6], &shell_code[3],10);
+  
+  return ret;
+}
+
+
+
+// 转换hex字符串为一个byte
+static int coder_strhex_to_byte(const char *str_hex)
+{
+  char buff[3]={0};
+  buff[0]=str_hex[0];
+  buff[1]=str_hex[1];
+  return str_ahextoi(buff);
+}
+// 转换int字符串为一个整形
+static int coder_strint_to_byte(const char *str_int,int len)
+{
+  char buff[10]={0};
+  if(len>10) return 0;
+  memcpy(buff,str_int,len);
+  return str_atoi(buff);
+}
+
+// uid码转存储码
+int coder_uid_to_save(const char *uid_code,uint8_t *save_code)
+{
+  uint16_t ymd=0;
+  uint32_t feature=0;
+  save_code[0]=coder_strhex_to_byte(&uid_code[0]);
+  save_code[1]=coder_strhex_to_byte(&uid_code[4]);
+  ymd=coder_strint_to_byte(&uid_code[2],2)<<9;
+  ymd|=coder_strint_to_byte(&uid_code[6],2)<<5;
+  ymd|=coder_strint_to_byte(&uid_code[8],2);
+  save_code[2]=ymd>>8;
+  save_code[3]=ymd&0xff;
+  feature=uid_code[10]*10000;
+  feature+=coder_strint_to_byte(&uid_code[11],3)*100;
+  feature+=coder_strint_to_byte(&uid_code[13],2);
+  save_code[4]=feature>>16;
+  save_code[5]=feature>>8;
+  save_code[6]=feature&0xff;
+  save_code[7]=crc_crc8(save_code,7);
+  return 0;
+}
+
+// 转换byte为hex字符串
+static int coder_byte_to_strhex(const uint8_t byte,char *str_hex)
+{
+  char buff[10]={0};
+  sprintf(buff,"%02X",byte);
+  str_hex[0]=buff[0];
+  str_hex[1]=buff[1];
+  return 0;
+}
+// 转换int为int字符串
+static int coder_int_to_strint(const int n,char *str_int,int len)
+{
+  char buff[10]={0};
+  sprintf(buff,"%05d",n);
+  memcpy(str_int,buff+(strlen(buff)-len),len);
+  return 0;
+}
+
+// 存储码转uid
+int coder_save_to_uid(const uint8_t *save_code,char *uid_code)
+{
+  uint16_t ymd=0;
+  uint32_t feature=0;
+  int ret=0;
+  if(save_code[7]!=crc_crc8(save_code,7))
+  {
+    return -1;
+  }
+  ret|=coder_byte_to_strhex(save_code[0],&uid_code[0]);
+  ret|=coder_byte_to_strhex(save_code[1],&uid_code[4]);
+  ymd=(save_code[2]<<8)|save_code[3];
+  feature=(save_code[4]<<16)|(save_code[5]<<8)|(save_code[6]);
+  ret|=coder_int_to_strint(ymd>>9,&uid_code[2],2);
+  ret|=coder_int_to_strint((ymd>>5)&0x0f,&uid_code[6],2);
+  ret|=coder_int_to_strint((ymd)&0x1f,&uid_code[8],2);
+  uid_code[10]=feature/10000;
+  ret|=coder_int_to_strint(feature%10000/100,&uid_code[11],3);
+  ret|=coder_int_to_strint(feature%100,&uid_code[14],2);
+  return ret;
+}
+
+
+
+// uid码转管壳码
+int coder_uid_to_shell(const char *uid_code,char *shell_code)
+{
+  memset(shell_code,0,13);
+  // 添加雷管厂代号
+  memcpy(&shell_code[0],&uid_code[4],2);
+  // 添加生产年份
+  memcpy(&shell_code[2],&uid_code[3],1);
+  // 添加月日特征码流水号
+  memcpy(&shell_code[3],&uid_code[6],10);
+  
+  return 0;
+}
+
+
+
+
+

source/coder/coder_lib.h

@@ -0,0 +1,36 @@
+#ifndef coder_lib_h__
+#define coder_lib_h__
+
+
+#include "stdint.h"
+
+
+
+
+
+
+
+// 管壳码转uid码
+int coder_shell_to_uid(const char *year,const char *shell_code,char *uid_code);
+
+// uid码转存储码
+int coder_uid_to_save(const char *uid_code,uint8_t *save_code);
+
+// 存储码转uid
+int coder_save_to_uid(const uint8_t *save_code,char *uid_code);
+
+// uid码转管壳码
+int coder_uid_to_shell(const char *uid_code,char *shell_code);
+
+
+
+
+
+
+
+
+
+
+
+#endif
+

source/main/compiler_info.h

@@ -6,7 +6,7 @@
 
 
 
-#define BUILD_DATE  "2023-06-09 18:00:05"
+#define BUILD_DATE  "2023-06-13 17:34:13"
 
 
 

source/soft/mystring.c

@@ -137,7 +137,7 @@ static int str_ainttoi(const char *s)
   }
   return ret*sig;
 }
-static int str_ahextoi(const char *s)
+int str_ahextoi(const char *s)
 {
   int ret=0;
   while(*s)
@@ -164,7 +164,7 @@ static int str_ahextoi(const char *s)
 }
 int str_atoi(const char *s)
 {
-  if(s[0]=='0'&&s[1]=='x'){
+  if(s[0]=='0'&&((s[1]=='x')||(s[1]=='X'))){
     return str_ahextoi(&s[2]);
   }else{
     return str_ainttoi(s);

source/soft/mystring.h

@@ -12,6 +12,7 @@ extern "C" {
 const char *str_find_char_right(const char *s, char c);
 const char *str_find_char_right_p(const char *s,const char *const p, char c);
 const char *str_find_char_left(const char *const p,const char *s, char c);
+int str_ahextoi(const char *s);
 int str_atoi(const char *s);
 int str_len(const char *s);
 int str_cpystr(char *s1, const char *s2, char c);

source/task/handle_for_coder.c

@@ -55,7 +55,7 @@ static void code_dolater(handle_def *h,uint8_t src,uint8_t cmd,array_def *data,c
       port_set_busy(h->p,0);
       port_timer_stop(h->p);
       DBG_LOG("slave:%d, start failed",port_get_addr(h->p));
-      emit port_end_signal(h->p,h->p,0,0,"start failed");
+      emit port_end_signal(h->p,h->p,0,-1,"start failed");
     }
   }else if(cmd==0x18)
   {

source/task/tran_for_coder2.c

@@ -8,18 +8,27 @@
 #include "prot_uc.h"
 #include "handle_for_coder.h"
 #include "handle_for_checker.h"
-
+#include "coder_lib.h"
+#include "PSDGenerate.h"
 
 // 这个文件解析跟赋码仪相关的命令
 
 
 
+
+
+
 typedef struct{
   ucport_def u;
   uint8_t addrs_num;
   char year[10];
-  char uid[10][20];
-  uint8_t ack[380];
+  struct{
+    char shell_code[20];
+    char uid_code[20];
+    char password[10];
+    uint8_t uid_pw_hex[15];
+  }item[10];
+  uint8_t ack[390];
   uint8_t ack_num;
   void (*doexert)(ucport_def *u);
 }write_uid_def;
@@ -35,14 +44,25 @@ static void write_uid_end(ucport_def *u,port_mcu *src,void *data,int ack,char *e
     DBG_WARN("addr err:%d",addr);
     return;
   }
-  w->ack[addr-1]=ack;
+  uint8_t *d=&w->ack[(addr-1)*39];
   w->ack_num++;
+  d[0]=addr-1;
+  d[1]=ack;
+  if(ack==0)
+  {
+    memcpy(&d[2],w->item[addr-1].shell_code,13);
+    memcpy(&d[2+13],w->item[addr-1].uid_code,16);
+    memcpy(&d[2+13+16],w->item[addr-1].password,8);
+  }else{
+    // 失败的数据全部填充'0'
+    memset(&d[2],'0',37);
+  }
   if(w->ack_num>=10)
   {
     array_def *a=arr_creat();
     arr_append(a,w->addrs_num);
-    arr_appends(a,w->ack,380);
-    emit tran_send_signal(w->u.p,0x81,arr_temp(a));
+    arr_appends(a,w->ack,390);
+    emit tran_send_signal(w->u.p,0x82,arr_temp(a));
     tran_set_busy(w->u.p,0);
   }
 }
@@ -60,9 +80,9 @@ static void write_uid_return_ok(void *p)
   {
     arr_append(a,i);
     arr_append(a,0);
-    arr_append_num(a,36,0);
+    arr_append_num(a,37,'0');
   }
-  emit tran_send_signal(u->u.p,0x81,arr_temp(a));
+  emit tran_send_signal(u->u.p,0x82,arr_temp(a));
   tran_set_busy(u->u.p,0);
 }
 
@@ -88,13 +108,22 @@ static ucport_def *write_uid(tran_def *t, uint8_t cmd,array_def *data)
   // 数据固定140字节，如果不检测某通道，则该通道填充占位符
   for(int i=0;i<10;i++)
   {
-    memcpy(u->uid[i],arr_data(data)+1+i*14,14);
+    memcpy(u->item[i].shell_code,arr_data(data)+1+i*14,14);
+    // 生成uid码
+    coder_shell_to_uid(u->year,u->item[i].shell_code,u->item[i].uid_code);
+    // 生成存储码
+    coder_uid_to_save(u->item[i].uid_code,u->item[i].uid_pw_hex);
+    // 生成密码
+    GetPasswordByUidCode((uint8_t *)u->item[i].uid_code,&u->item[i].uid_pw_hex[8]);
+    // 生成密码字符串
+    sprintf(u->item[i].password,"%02X%02X%02X%02X",u->item[i].uid_pw_hex[8],
+      u->item[i].uid_pw_hex[9],u->item[i].uid_pw_hex[10],u->item[i].uid_pw_hex[11]);
   }
   // 默认失败
   for(int i=0;i<10;i++)
   {
-    u->ack[i*38+0]=i;
-    u->ack[i*38+1]=1;
+    u->ack[i*39+0]=i;
+    u->ack[i*39+1]=1;
   }
   tran_set_busy(t,1);
   for(int i=0;i<10;i++)
@@ -103,7 +132,7 @@ static ucport_def *write_uid(tran_def *t, uint8_t cmd,array_def *data)
       port_mcu *mcu=tran_get_portm(u->u.p,i);
       // 这里打开赋码操作
       if(mcu){
-        //port_start(mcu,code_creat(15,8,&u->uid[i]));
+        port_start(mcu,code_creat(8,4,u->item[i].uid_pw_hex));
       }
     }
   }
@@ -114,7 +143,7 @@ static ucport_def *write_uid(tran_def *t, uint8_t cmd,array_def *data)
   emit tran_reply_signal(u->u.p,arr_temp(a));
 
   // test:稍后返回成功
-  later_execute(write_uid_return_ok,u,500);
+  //later_execute(write_uid_return_ok,u,500);
   
   return (ucport_def *)u;
 }
@@ -124,6 +153,101 @@ transmit_export(ym_checker,0x02,write_uid)
 
 
 
+// 复检完成
+static void write_uid2_end(ucport_def *u,port_mcu *src,void *data,int ack,char *err_str)
+{
+  write_uid_def *w=(write_uid_def *)u;
+  uint8_t addr=port_get_addr(src);
+  if(addr<=0||addr>10){
+    DBG_WARN("addr err:%d",addr);
+    return;
+  }
+  uint8_t *d=&w->ack[(addr-1)*39];
+  w->ack_num++;
+  d[0]=addr-1;
+  d[1]=ack;
+  if(ack==0)
+  {
+    memcpy(&d[2],w->item[addr-1].shell_code,13);
+    memcpy(&d[2+13],w->item[addr-1].uid_code,16);
+    memcpy(&d[2+13+16],w->item[addr-1].password,8);
+  }else{
+    // 失败的数据全部填充'0'
+    memset(&d[2],'0',37);
+  }
+  if(w->ack_num>=10)
+  {
+    array_def *a=arr_creat();
+    arr_append(a,w->addrs_num);
+    for(int i=0;i<10;i++)
+    {
+      uint8_t *d=&w->ack[i*39];
+      arr_appends(a,d,2);
+    }
+    emit tran_send_signal(w->u.p,0x83,arr_temp(a));
+    tran_set_busy(w->u.p,0);
+  }
+}
+
+static ucport_def *write_uid2(tran_def *t, uint8_t cmd,array_def *data)
+{
+  if(arr_length(data)<242){
+    DBG_WARN("cmd format err.");
+    return 0;
+  }
+  write_uid_def *u=calloc(1,sizeof(write_uid_def));
+  u->u.p=t;
+  u->u.del=write_del;
+  u->u.doend=write_uid2_end;
+  u->addrs_num=arr_get(data,0);
+  memcpy(u->year,arr_data(data)+1,4);
+  // 数据固定140字节，如果不检测某通道，则该通道填充占位符
+  for(int i=0;i<10;i++)
+  {
+    memcpy(u->item[i].shell_code,arr_data(data)+1+i*14,14);
+    // 生成uid码
+    coder_shell_to_uid(u->year,u->item[i].shell_code,u->item[i].uid_code);
+    // 生成存储码
+    coder_uid_to_save(u->item[i].uid_code,u->item[i].uid_pw_hex);
+    // 生成密码
+    GetPasswordByUidCode((uint8_t *)u->item[i].uid_code,&u->item[i].uid_pw_hex[8]);
+    // 生成密码字符串
+    sprintf(u->item[i].password,"%02X%02X%02X%02X",u->item[i].uid_pw_hex[8],
+      u->item[i].uid_pw_hex[9],u->item[i].uid_pw_hex[10],u->item[i].uid_pw_hex[11]);
+  }
+  // 默认失败
+  for(int i=0;i<10;i++)
+  {
+    u->ack[i*39+0]=i;
+    u->ack[i*39+1]=1;
+  }
+  tran_set_busy(t,1);
+  for(int i=0;i<10;i++)
+  {
+    if(1){
+      port_mcu *mcu=tran_get_portm(u->u.p,i);
+      // 这里打开赋码操作
+      if(mcu){
+        port_start(mcu,code_creat(8,4,u->item[i].uid_pw_hex));
+      }
+    }
+  }
+  
+  array_def *a=arr_creat();
+  arr_append(a,u->addrs_num);
+  arr_append(a,0);
+  emit tran_reply_signal(u->u.p,arr_temp(a));
+
+  // test:稍后返回成功
+  //later_execute(write_uid_return_ok,u,500);
+  
+  return (ucport_def *)u;
+}
+
+// 复检，与注码动作相同，但返回值不同
+transmit_export(ym_checker,0x03,write_uid2)
+
+
 
 
 
@@ -152,8 +276,10 @@ static void check_end(ucport_def *u,port_mcu *src,void *data,int ack,char *err_s
     return;
   }
   uint8_t *ack_d=&w->ack[(addr-1)*6];
+  ack_d[0]=addr-1;
   ack_d[1]=ack;
   // TODO: 还有4字节数据
+  
   w->ack_num++;
   if(w->ack_num>=10)
   {
@@ -216,9 +342,9 @@ static ucport_def *check(tran_def *t, uint8_t cmd,array_def *data)
     if(1){
       port_mcu *mcu=tran_get_portm(u->u.p,i);
       // 这里打开检测
-//      if(mcu){
-//        port_start(mcu,check_creat(check_scheme()));
-//      }
+      if(mcu){
+        port_start(mcu,check_creat(check_scheme()));
+      }
     }
   }
   
@@ -229,7 +355,7 @@ static ucport_def *check(tran_def *t, uint8_t cmd,array_def *data)
   emit tran_reply_signal(u->u.p,arr_temp(a));
 
   // test:稍后返回成功
-  later_execute(check_return_ok,u,500);
+  //later_execute(check_return_ok,u,500);
   
   return (ucport_def *)u;
 }