怎么使用STM8L001J3设计一个简单的遥控器

你好Sisto，
这个话题在这个论坛上已经讨论过了。你可以参考这两个主题：
 https://community.st.com/0D50X00009XkXB0SAN
https://community.st.com/community/stm8-community/stm8-mcus/blog/2017/12/09/stm8l001j3-low-power-stm8-mcu-in-8-pin-so-8-package
在第二个线程唯一ID中
讨论了STM8L001J3，所以在你提到的设备中。
问候
Szymon
 
 注意：原始帖子包含大量线程对话，只能迁移到第9级



以下为原文




Hello Sisto,
This topic was already discussed a bit on this forum. You can refer to these two threads:

• https://community.st.com/0D50X00009XkXB0SAN
  
• https://community.st.com/community/stm8-community/stm8-mcus/blog/2017/12/09/stm8l001j3-low-power-stm8-mcu-in-8-pin-so-8-package
  

In second thread Unique Id in
STM8L001J3 is discussed, so in device, which you mentioned.

Regards

Szymon

Note: the original post contained a large number of threaded conversations and was only able to be migrated to the 9th level

大家好，
 
我道歉，但是，也许，我没有很好地解释。
问题不是读取UNIQUE ID（参见简单的asm列表），而是使用它来计算唯一的24位序列号以识别遥控器。
这样我就不需要使用滚动码芯片或DIP开关。
我基本上必须使用96位UNIQUE ID来获得唯一的24位数字。
...
TINY uint8_t UNIQUE_ID_BUF [12];
...
//读取STM8L001J3 MCU UNIQUE_ID
 #pragma asm
 ldw x，＃11
 L1：ld a，（$ 4925，x）
 ld（_UNIQUE_ID_BUF，x），a
 decw x
 jrsge L1
#pragma endasm



以下为原文




Hello to all,

I apologize, but, perhaps, I have not well explained.
The question is not to read UNIQUE ID (see simple asm listing), but use it to calculate a unique 24bit serial number to identifiy the remote control.
In this way I do not need to use rolling code chips or dip switches.
I basically have to use 96-bit UNIQUE ID to get a unique 24-bit number.
...

TINY uint8_t  UNIQUE_ID_BUF[12];

...

// Read STM8L001J3 MCU UNIQUE_ID

#pragma asm

       ldw x,#11

   L1: ld a,($4925,x)

       ld (_UNIQUE_ID_BUF,x),a

       decw x

       jrsge L1

#pragma endasm

使用散列函数计算24位代码。它不能保证是唯一的，但与从可用的96中提取24个任意位相比，不太可能发生冲突。



以下为原文




Use a hashing function to compute a 24-bits code. It isn't guaranteed to be unique, but is less likely to have collisions than extracting 24 arbitrary bits from the 96 available.

“
但用它来计算一个独特的24位序列号来识别遥控器。
1）简单地从uid中选取24位数据;要么
2）在uid上使用哈希函数。喜欢crc 24。



以下为原文




'
but use it to calculate a unique 24bit serial number to identifiy the remote control.'

1) simply pick 24 bits of data from the uid; or

2) use a hash function on the uid. like crc24.

最后，这是我简单，经过测试的最终解决方案：
/ *
使用STM8L001J3,96位
 UNIQUE_ID，为遥控器计算唯一的24位序列号：
 输入：UNIQUE_ID []
 
= 12字节Micro ID缓冲区
 输出：SERIAL_NUM
 
=唯一的24位远程序列号
 
 
TELE_FRAME_BUF [] =编译要传输的遥控帧的前三个字段
* /
空虚
 CALC_SERIAL_NUM（无效
）
{
 
uint8_t inx;
 
uint32_t Serial_1，Serial_2;
 // Leggi MCU UNIQUE_ID
 
#pragma asm
 
ldw x，＃11
 
L1：
 
ld a，（4925美元
，X）
 
ld（_UNIQUE_ID_BUF，x），a
 
decw x
 
jrsge L1
 
#pragma endasm
 // -----------------------
 对于
（INX = 0
; INX＆LT; 4
; INX ++）
 
{
 
Serial_1 + = UNIQUE_ID_BUF [inx];
 
Serial_1＆lt;＆lt; = 8
;
 
}
 
对于
（INX = 4
; INX＆LT; 8
; INX ++）
 
{
 
Serial_2 + = UNIQUE_ID_BUF [inx];
 
Serial_2＆lt;＆lt; = 8
;
 
}
 
Serial_1 + = Serial_2;
 
对于
（INX = 8
; INX＆LT; 12
; INX ++）
 
{
 
Serial_1 + = UNIQUE_ID_BUF [inx];
 
}
 // --------------------------------------
 
SERIAL_NUM
= Serial_1;
 
Serial_1＆gt;＆gt; = 24
;
 
SERIAL_NUM＆amp; = 0xFFFFFF
;
 
SERIAL_NUM + = Serial_1;
 
TELE_FRAME_BUF [0
] =（uint8_t）（（SERIAL_NUM＆amp; 0xFF0000
）＆gt;＆gt; 16
）;
 
TELE_FRAME_BUF [1
] =（uint8_t）（（SERIAL_NUM＆amp; 0x00FF00
）＆gt;＆gt; 8
）;
 
TELE_FRAME_BUF [2
] =（uint8_t）（SERIAL_NUM＆amp; 0x0000FF
）;
}



以下为原文




At last, this is my simple, tested, final solution:

/*


Using the STM8L001J3, 96bit
UNIQUE_ID, calculate a unique 24 bit serial number for the remote control:
Input : UNIQUE_ID[]
      
= 12 bytes Micro ID Buffer
Output : SERIAL_NUM
     
= Unique 24 bit of remote serial number

        
TELE_FRAME_BUF[] = Compile the first three fields of remote control frame to    transmit
*/


void
CALC_SERIAL_NUM(void
)
{


   
uint8_t inx;

   
uint32_t Serial_1,Serial_2;
   // Leggi MCU UNIQUE_ID


   
#pragma asm

      
ldw x,#11


   
L1:

      
ld a,($4925
,x)

      
ld (_UNIQUE_ID_BUF,x),a

      
decw x

      
jrsge L1

   
#pragma endasm
  //-----------------------


   for
(inx=0
; inx<4
; inx++)

   
{

      
Serial_1 += UNIQUE_ID_BUF[inx];

      
Serial_1 <<=8
;

   
}

   
for
(inx=4
; inx<8
; inx++)

   
{

      
Serial_2 += UNIQUE_ID_BUF[inx];

      
Serial_2 <<=8
;

   
}

   
Serial_1 += Serial_2;

   
for
(inx=8
; inx<12
; inx++)

   
{

      
Serial_1 += UNIQUE_ID_BUF[inx];

   
}
//--------------------------------------


   
SERIAL_NUM  
= Serial_1;

   
Serial_1 >>= 24
;

   
SERIAL_NUM &= 0xFFFFFF
;

   
SERIAL_NUM += Serial_1;

   
TELE_FRAME_BUF[0
] = (uint8_t) ((SERIAL_NUM &0xFF0000
) >> 16
);

   
TELE_FRAME_BUF[1
] = (uint8_t) ((SERIAL_NUM &0x00FF00
) >> 8
);

   
TELE_FRAME_BUF[2
] = (uint8_t) (SERIAL_NUM &0x0000FF
);
}

uint32_t Crc24Quick（uint32_t Crc，size_t Size，uint8_t * Buffer）
 
{
 static const uint32_t crctab [] = {
 0x00000000,0x01864CFB，0x038AD50D，0x020C99F6,0x0793E6E1,0x0615AA1A，0x041933EC，0x059F7F17，
 0x0FA18139,0x0E27CDC2,0x0C2B5434,0x0DAD18CF，0x083267D8,0x09B42B23,0x0BB8B2D5,0x0A3EFE2E};而（Size--）
 
 {
 Crc ^ =（uint32_t）* Buffer ++＆lt;＆lt; 16; Crc =（Crc  20）＆amp;为0x0F];
 
 Crc =（Crc  20）＆amp;为0x0F];
 } return（Crc＆amp; 0xFFFFFF）;
 
}



以下为原文




uint32_t Crc24Quick(uint32_t Crc, size_t Size, uint8_t *Buffer)

{
  static const uint32_t crctab[] = {
    0x00000000,0x01864CFB,0x038AD50D,0x020C99F6,0x0793E6E1,0x0615AA1A,0x041933EC,0x059F7F17,
    0x0FA18139,0x0E27CDC2,0x0C2B5434,0x0DAD18CF,0x083267D8,0x09B42B23,0x0BB8B2D5,0x0A3EFE2E };  while(Size--)

  {
    Crc ^= (uint32_t)*Buffer++ << 16;    Crc = (Crc << 4) ^ crctab[(Crc >> 20) & 0x0F];

    Crc = (Crc << 4) ^ crctab[(Crc >> 20) & 0x0F];
  }  return(Crc & 0xFFFFFF);

}

“
最后，这是我简单，经过测试的最终解决方案：'
没有乐趣，如果我们不能重新发明轮子，



以下为原文




'
At last, this is my simple, tested, final solution:'

no fun if we cannot re-invent the wheels,

是啊，没错！



以下为原文




Yeah ... that's right!