STC什么时候出点带硬件随机数功能的呀

angm*** · 发表于 2023-12-8 10:47:29

STC什么时候出这样的单片机芯片带硬件随机数功能，有硬件随机数生成器，由硬件产生32位随机数。

电子硬件随机数生成器的主要应用是加密技术，它们用于生成随机加密密钥以安全地传输数据。它们广泛用于Internet加密协议，如Secure Sockets Layer（SSL）。

既然你们有规划，先解决【USB-HS-OTG】和【以太网外加 PHY】这2个有线的方向

加密技术的应用是要的，现在毕竟是万物互联的时代了。

晓*** · 发表于 2023-12-22 21:17:16

如果有多余的IO，配置成ADC输入，采集空间噪声能不能当成随机因子？

angm*** · 发表于 2023-12-22 22:10:38

晓*** 发表于 2023-12-22 21:17
如果有多余的IO，配置成ADC输入，采集空间噪声能不能当成随机因子？

事实上，从单片机上未连接的ADC模拟引脚读取值用于为软件伪随机数生成提供起始种子。
我不知道它在实践中连接到噪声发生器会有多随机。
输入 ADC 的噪声应产生随机数。它们的随机性可能会受到相对于 ADC 动态范围和采样频率的噪声幅度和频率的影响。
数字生成的随机数生成器不是随机的。当你处理大量样本时，模式就开始出现。

如果您想使用 ADC 作为随机数发生器的噪声源，最好、最简单的方法是使用基于雪崩二极管或齐纳二极管或基于反向偏置晶体管的噪声生成电路。

Snapd*** · 发表于 2023-12-23 18:18:04

可以使用ADC测量悬空引脚来产生随机数，不过可能范围较小，自己加点算法转换一下。

神*** · 发表于 2023-12-23 19:19:49

假定你几个定时器都开着，读过来，+，-， *， /
再 ADC去读外部输入，再运算，啥随机都有了

xxkj*** · 发表于 2023-12-24 09:05:40

神*** 发表于 2023-12-23 19:19
假定你几个定时器都开着，读过来，+，-， *， /
再 ADC去读外部输入，再运算，啥随机都有了 ...

好方法！点赞！

wppp*** · 发表于 2023-12-26 21:42:42

有没有一个实验过的方法。上传过来。

angm*** · 发表于 2025-11-9 11:37:55

wppp*** 发表于 2023-12-26 21:42
有没有一个实验过的方法。上传过来。

这种方法是利用硬件特性生成真随机数的经典技术。

我们使用AI8051U的定时器和ADC来生成随机数种子。具体方法如下：

启动定时器，让定时器自由运行。

启动ADC转换，读取一个悬空引脚的ADC值（由于悬空，读取的是噪声，具有随机性）。

同时读取定时器的计数值。

将ADC值和定时器计数值进行某种组合（比如相加或异或）作为随机数种子。

注意：由于定时器一直在运行，其计数值是随机的（因为程序运行点不确定），而ADC悬空引脚读取的也是随机噪声，因此组合起来可以作为较好的随机种子。

下面我们给出一个示例程序，使用定时器0和ADC来生成随机种子，然后使用线性同余生成器（LCG）生成随机数。

假设使用Keil C51编译器，单片机为STC8051U（但代码适用于大多数8051），ADC通道为0（P1.0悬空）。

步骤：

初始化定时器0，设置为16位定时器模式，自由运行。

初始化ADC，读取悬空引脚的ADC值。

结合定时器0的计数值和ADC值生成种子。

使用LCG算法生成随机数。

下面提供代码示例：

#include "config.h"                     //默认已包含stdio.h、intrins.h等头文件


//<<AICUBE_USER_INCLUDE_BEGIN>>
// 在此添加用户头文件包含  
unsigned int Get_Hardware_Entropy(void);
void Init_Random_Seed(void);
unsigned long LCG_Random(void);
unsigned long LCG_Random_Range(unsigned long min, unsigned long max);
unsigned long Enhanced_Random(void);

// LCG参数
#define LCG_A 1664525L
#define LCG_C 1013904223L
#define LCG_M 0xFFFFFFFFL

unsigned long lcg_seed = 0;

//<<AICUBE_USER_INCLUDE_END>>


//<<AICUBE_USER_GLOBAL_DEFINE_BEGIN>>
// 在此添加用户全局变量定义、用户宏定义以及函数声明  

//<<AICUBE_USER_GLOBAL_DEFINE_END>>




////////////////////////////////////////
// 项目主函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void main(void)
{
    //<<AICUBE_USER_MAIN_INITIAL_BEGIN>>
    // 在此添加用户主函数初始化代码  
    unsigned long random_num;
    int i;
    unsigned int test_count = 0;
        
    //<<AICUBE_USER_MAIN_INITIAL_END>>

    SYS_Init();

    //<<AICUBE_USER_MAIN_CODE_BEGIN>>
    // 在此添加主函数中运行一次的用户代码  
//    printf("Hello World !\n");
          printf("Random Number Generator Test\n");
    printf("Initial Seed: %lu\n", lcg_seed);
    random_num = Enhanced_Random();
          printf("LCG Random: %lu\n", random_num);
    //<<AICUBE_USER_MAIN_CODE_END>>

    while (1)
    {
        //<<AICUBE_USER_MAIN_LOOP_BEGIN>>
        // 在此添加主函数中用户主循环代码  
        // 两种方式生成随机数
        random_num = LCG_Random();
        printf("LCG Random: %lu\n", random_num);
        
        // 测试范围限制的随机数
        if(test_count % 10 == 0) {
            printf("Range[1-100]: %lu\n", LCG_Random_Range(1, 100));
            printf("Range[1000-2000]: %lu\n", LCG_Random_Range(1000, 2000));
        }
        
        test_count++;
        
        // 可变延时，增加随机性
        for(i = 0; i < (20000 + (LCG_Random() % 10000)); i++) {
            _nop_();
        }
        
        // 每100次重新初始化种子
        if(test_count % 100 == 0) {
            Init_Random_Seed();
            printf("Reseeded! New Seed: %lu\n", lcg_seed);
        }
                        
        //<<AICUBE_USER_MAIN_LOOP_END>>
    }
}

////////////////////////////////////////
// 系统初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void SYS_Init(void)
{
    EnableAccessXFR();                  //使能访问扩展XFR
    AccessCodeFastest();                //设置最快速度访问程序代码
    AccessIXramFastest();               //设置最快速度访问内部XDATA
    IAP_SetTimeBase();                  //设置IAP等待参数,产生1us时基

    //<<AICUBE_USER_PREINITIAL_CODE_BEGIN>>
    // 在此添加用户预初始化代码  
    //<<AICUBE_USER_PREINITIAL_CODE_END>>

    P0M0 = 0x00; P0M1 = 0x00;           //初始化P0口为准双向口模式
    P1M0 = 0x00; P1M1 = 0x00;           //初始化P1口为准双向口模式
    P2M0 = 0x00; P2M1 = 0x00;           //初始化P2口为准双向口模式
    P3M0 = 0x00; P3M1 = 0x00;           //初始化P3口为准双向口模式
    P4M0 = 0x00; P4M1 = 0x00;           //初始化P4口为准双向口模式
    P5M0 = 0x00; P5M1 = 0x00;           //初始化P5口为准双向口模式
    P6M0 = 0x00; P6M1 = 0x00;           //初始化P6口为准双向口模式
    P7M0 = 0x00; P7M1 = 0x00;           //初始化P7口为准双向口模式

    TIMER0_Init();                      //定时器0初始化
    UART1_Init();                       //串口1初始化
    ADC_Init();                         //ADC初始化
    SPI_Init();                         //SPI初始化

    //<<AICUBE_USER_INITIAL_CODE_BEGIN>>
    // 在此添加用户初始化代码  
                Init_Random_Seed();
    //<<AICUBE_USER_INITIAL_CODE_END>>
}

////////////////////////////////////////
// 微秒延时函数
// 入口参数: us (设置延时的微秒值)
// 函数返回: 无
////////////////////////////////////////
void delay_us(uint16_t us)
{
    do
    {
        NOP(34);                        //(MAIN_Fosc + 500000) / 1000000 - 6
    } while (--us);
}


////////////////////////////////////////
// 毫秒延时函数
// 入口参数: ms (设置延时的毫秒值)
// 函数返回: 无
////////////////////////////////////////
void delay_ms(uint16_t ms)
{
    uint16_t i;

    do
    {
        i = MAIN_Fosc / 6000;
        while (--i);
    } while (--ms);
}

////////////////////////////////////////
// 定时器0初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void TIMER0_Init(void)
{
#define T0_PSCR                 (3)
#define T0_RELOAD               (65536 - (float)SYSCLK / 12 / (T0_PSCR + 1) * 65535 / 1000000)

    TIMER0_TimerMode();                 //设置定时器0为定时模式
    TIMER0_12TMode();                   //设置定时器0为12T模式
    TIMER0_Mode0();                     //设置定时器0为模式0 (16位自动重载模式)
    TIMER0_DisableGateINT0();           //禁止定时器0门控
    TIMER0_SetPrescale(T0_PSCR);        //设置定时器0的8位预分频
    TIMER0_SetReload16(T0_RELOAD);      //设置定时器0的16位重载值
    TIMER0_Run();                       //定时器0开始运行

    //<<AICUBE_USER_TIMER0_INITIAL_BEGIN>>
    // 在此添加用户初始化代码  
    //<<AICUBE_USER_TIMER0_INITIAL_END>>
}

////////////////////////////////////////
// 串口1初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void UART1_Init(void)
{
#ifdef BAUDRATE
#undef BAUDRATE
#endif
#define BAUDRATE                (115200)
#define T2_RELOAD               (65536 - (SYSCLK / BAUDRATE + 2) / 4)

    UART1_SwitchP3031();                //设置串口数据端口: RxD (P3.0), TxD (P3.1)

    UART1_Timer2BRT();                  //选择定时器2作为串口1波特率发生器
    TIMER2_TimerMode();                 //设置定时器2为定时模式
    TIMER2_1TMode();                    //设置定时器2为1T模式
    TIMER2_SetPrescale(0);              //设置定时器2的8位预分频
    TIMER2_SetReload16(T2_RELOAD);      //设置定时器2的16位重载值
    TIMER2_Run();                       //定时器2开始运行

    UART1_EnableRx();                   //使能串口1接收数据
    UART1_Mode1();                      //设置串口1为模式1 (8位数据可变波特率)

    UART1_SetTxFlag();                  //设置发送标志以配合printf函数

    //<<AICUBE_USER_UART1_INITIAL_BEGIN>>
    // 在此添加用户初始化代码  
    //<<AICUBE_USER_UART1_INITIAL_END>>
}

////////////////////////////////////////
// 重写printf字符发送重定向函数
// 入口参数: dat (printf函数待打印的字符)
// 函数返回: 需要返回入口参数的数据
////////////////////////////////////////
char putchar (char dat)                 //将串口1和printf函数绑定
{
    while (!UART1_CheckTxFlag());
    UART1_ClearTxFlag();
    UART1_SendData(dat);

    return dat;
}

////////////////////////////////////////
// ADC初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void ADC_Init(void)
{
    ADC_SetClockDivider(0);             //设置ADC时钟
    ADC_ResultRightAlign();             //设置ADC结果右对齐(12位结果)
    ADC_SetRepeat2Times();              //ADC自动重复转换2次并取平均值

    ADC_SetCSSetupCycles(0);            //设置ADC通道选择建立时间
    ADC_SetCSHoldCycles(1);             //设置ADC通道选择保持时间
    ADC_SetSampleDutyCycles(9);         //设置ADC通道采样时间

    ADC_DisableETR();                   //禁止ADC外部触发功能

    ADC_ActiveChannel(8);               //选择ADC通道
    ADC_Enable();                       //使能ADC功能

    //<<AICUBE_USER_ADC_INITIAL_BEGIN>>
    // 在此添加用户初始化代码  
    //<<AICUBE_USER_ADC_INITIAL_END>>
}

////////////////////////////////////////
// 获取ADC转换结果函数
// 入口参数: ch (ADC通道选择)
// 函数返回: ADC转换结果
////////////////////////////////////////
uint16_t ADC_Convert(uint8_t ch)
{
    uint16_t res;                       //定义保存ADC结果的变量

    ADC_ActiveChannel(ch);              //选择ADC通道
    ADC_Start();                        //开始ADC转换
    while (!ADC_CheckFlag());           //等待ADC转换完成
    ADC_ClearFlag();                    //清除ADC转换完成中断标志
    res = ADC_ReadResult();             //读取ADC转换结果

    return res;                         //返回ADC结果
}

////////////////////////////////////////
// SPI初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void SPI_Init(void)
{
    SPI_SwitchP2n();                    //选择SPI数据口: SS(P2.4), MOSI(P2.5), MISO(P2.6), SCLK(P2.7)

    SPI_MasterMode();                   //设置SPI为主机模式
    SPI_IgnoreSS();                     //忽略SS脚
    SPI_DataMSB();                      //设置SPI数据顺序为MSB (高位在前)
    SPI_SetMode0();                     //设置SPI工作模式0 (CPOL=0, CPHA=0)
    SPI_SetClockDivider4();             //设置SPI时钟分频

    HSSPI_Disable();                    //关闭SPI高速模式

    SPI_Enable();                       //使能SPI功能

    //<<AICUBE_USER_SPI_INITIAL_BEGIN>>
    // 在此添加用户初始化代码  
    //<<AICUBE_USER_SPI_INITIAL_END>>
}

////////////////////////////////////////
// SPI主机模式发送字节函数
// 入口参数: dat (待发送的字节数据)
// 函数返回: 无
////////////////////////////////////////
void SPI_WriteByte(uint8_t dat)
{
    SPI_SendData(dat);                  //触发主机发送数据
    while (!SPI_CheckFlag());           //等待发送完成
    SPI_ClearFlag();                    //清除中断标志
}

////////////////////////////////////////
// SPI主机模式读取字节函数
// 入口参数: 无
// 函数返回: 读取的字节数据
////////////////////////////////////////
uint8_t SPI_ReadByte(void)
{
    SPI_SendData(0xff);                 //触发主机读取数据（主机发送时钟信号）
    while (!SPI_CheckFlag());           //等待读取完成
    SPI_ClearFlag();                    //清除中断标志
    return SPI_ReadData();
}



//<<AICUBE_USER_FUNCTION_IMPLEMENT_BEGIN>>
// 在此添加用户函数实现代码  
// 获取硬件熵源
unsigned int Get_Hardware_Entropy(void)
{
    unsigned int timer_val, adc_val;
    
    // 增加一些随机延迟
    _nop_();
    _nop_();
    _nop_();
    _nop_();
    _nop_();
    
    // 读取自由运行的定时器值
    timer_val = (TH0 << 8) | TL0;
    
    // 读取ADC悬空引脚的噪声
//    ADC_CONTR = 0x80 | 0x08;  // 启动ADC，选择通道8
    _nop_();  // 等待ADC稳定
    _nop_();
          _nop_();
//    while (!(ADC_CONTR & 0x10)); // 等待转换完成
//    adc_val = ADC_RES;
    adc_val = ADC_Convert(8);
    // 使用异或组合，增强随机性
    return (timer_val ^ adc_val);
}

// 初始化随机种子
void Init_Random_Seed(void)
{
    unsigned int hw_entropy1, hw_entropy2;
    
    // 获取两次硬件熵源来组成32位种子
    hw_entropy1 = Get_Hardware_Entropy();
    hw_entropy2 = Get_Hardware_Entropy();
    
    // 组合成32位种子
    lcg_seed = ((unsigned long)hw_entropy1 << 16) | hw_entropy2;
    
    // 如果种子为0，设置一个默认值（避免LCG失效）
    if(lcg_seed == 0) {
        lcg_seed = 0x31415926;
    }
}

// LCG伪随机数生成器  使用线性同余生成器（LCG）来生成随机数
//Linear Congruential Generator
unsigned long LCG_Random(void)
{
    lcg_seed = (LCG_A * lcg_seed + LCG_C) & LCG_M;
    return lcg_seed;
}

// 生成指定范围的随机数
unsigned long LCG_Random_Range(unsigned long min, unsigned long max)
{
    if(min >= max) {
        return min; // 防止除零错误
    }
    return min + (LCG_Random() % (max - min + 1));
}

// 增强的随机数生成（混合多个熵源）
unsigned long Enhanced_Random(void)
{
    static unsigned long counter = 0;
    unsigned int hw_entropy;
    
    // 定期重新注入硬件熵源
    if((counter++ % 256) == 0) {
        hw_entropy = Get_Hardware_Entropy();
        lcg_seed ^= ((unsigned long)hw_entropy << (counter & 0x0F));
    }
    
    return LCG_Random();
}
//<<AICUBE_USER_FUNCTION_IMPLEMENT_END>>

复制代码

输出打印

Random Number Generator Test
Initial Seed: 660284920
LCG Random: 3443013915
LCG Random: 2729286590
Range[1-100]: 38
Range[1000-2000]: 1598
LCG Random: 564213955
LCG Random: 666725036
LCG Random: 194310281
LCG Random: 2743846433
LCG Random: 3386965645
LCG Random: 952165558
LCG Random: 211779192
LCG Random: 3122220471
LCG Random: 566241984
LCG Random: 3779303736
Range[1-100]: 36
Range[1000-2000]: 1119
LCG Random: 1101102993
LCG Random: 3202722746
LCG Random: 1715571906
LCG Random: 2435360859
LCG Random: 744749997
LCG Random: 2400021725
LCG Random: 3050508810
LCG Random: 1782846440
LCG Random: 1970156876
LCG Random: 2113421365
Reseeded! New Seed: 2505545078
LCG Random: 1341427293
Range[1-100]: 41
Range[1000-2000]: 1436
复制代码

PRNG002.zip (187.04 KB, 下载次数: 0)

angm*** · 发表于 2025-11-15 21:15:37

最好、最简单的方法是使用基于雪崩二极管或齐纳二极管或基于反向偏置晶体管的噪声生成电路硬件随机数。

梁*** · 发表于 2025-11-17 16:35:36

angm*** 发表于 2025-11-15 21:15
最好、最简单的方法是使用基于雪崩二极管或齐纳二极管或基于反向偏置晶体管的噪声生成电路硬件随机数。

我也支持这种方法，多年前做真随机数发生器就是这样实现的，三极管BE反向击穿得到噪声，再将噪声电压放大到ADC的量程，做ADC，如果是16位ADC则取用相邻2次ADC值组成32位数，如果是12位的ADC，则取相邻3次ADC值转换成32位的，得到32位的随机数。

		自动登录	找回密码
密码			立即注册

STC什么时候出点带硬件随机数功能的呀

点评

点评