如何生成【随机数】

神*** · 发表于 2025-10-26 17:07:19

网友问，如何生成【随机数】
启动定时器，读计数值，启动 ADC, ADC转换的值 + 定时器计数值
www,STCAIMCU.com

_奶*** · 发表于 2025-10-27 13:20:23

欸 ADC数值可以理解，，，当引脚悬空的时候，读取的就是个随机值。。

这个计时器是个什么原理0.0

angm*** · 发表于 2025-11-8 19:36:20

_奶*** 发表于 2025-10-27 13:20
欸 ADC数值可以理解，，，当引脚悬空的时候，读取的就是个随机值。。

这个计时器是个什么原理0.0 ...

计时器原理详解

为什么定时器能产生随机性：

1. 时钟不确定性原理：

// 从启动定时器到读取值的时间是不确定的
TR0 = 1; // 启动定时器
// 这里的中断、代码执行时间都是变化的
val = TH0 << 8 | TL0; // 读取的值是随机的

2. 中断干扰：
- 其他中断可能在此期间发生
- 中断处理时间影响定时器计数值

3. 时钟抖动：
- 晶振本身的微小频率变化
- 电源噪声引起的时钟抖动

angm*** · 发表于 2025-11-8 19:41:12

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

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

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

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

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

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

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

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

#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
复制代码

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

_奶*** · 发表于 2025-11-10 10:23:48

angm*** 发表于 2025-11-8 19:36
计时器原理详解

为什么定时器能产生随机性：

emmm 假如一个极端的场景，我的产品就是一个生成随机数然后输出。没有使用任何中断。所有的程序均在主函数中运行。

按照你这里的解释是不是就不是个随机的值了。我可以这么理解么？

1. 从时钟启动到读取是确定的，确定的代码。
2.没有任何中断干扰。

个人理解3是错误的，晶振就算是有偏差，对于单片机来说是感受不到的。代码还是会按照固定的时钟数运行。只是或多或少在现实中有时间的偏差。但是我认为的是时钟数是一定的。

PS：您这里的详解应该不是AI生成的吧

我是很认真的在看在思考的。

angm*** · 发表于 2025-11-10 12:10:50

要是在这个极端的场景，就不是个随机的值了。你的理解是对的

要是你要做一个产品就是一个生成随机数然后输出。就不应该选用这种定时器方式来产生随机数。

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

_奶*** · 发表于 2025-11-12 10:39:15

angm*** 发表于 2025-11-10 12:10
要是在这个极端的场景，就不是个随机的值了。你的理解是对的

要是你要做一个产品就是一个生成随机数然后输 ...

受教了，，

除了专门的硬件的随机数生成器。其他的方法都有适合的场景，和不适用的情况

cjt*** · 发表于 2026-2-9 18:55:23

如何生成指定的某些端口随机一个出现高（或低）电平呢?比如P0口的P0.0/P0.1/P0.2/P0.3随机有一个引脚出现一个高电平。

hea*** · 发表于 2026-2-9 20:49:00

cjt*** 发表于 2026-2-9 18:55
如何生成指定的某些端口随机一个出现高（或低）电平呢?比如P0口的P0.0/P0.1/P0.2/P0.3随机有一个引脚出现一 ...

限定随机数的范围为0～3。
先产生一个随机数，然后%4。

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

如何生成 【随机数】

浏览过的版块

如何生成【随机数】