关于OLED屏的笔记

news2024/11/24 20:49:58

OLED即有机发光管(Organic Light-Emitting Diode,OLED)。OLED显示技术具有自发光、广视角、几乎无穷高的对比度、较低功耗、极高反应速度、可用于绕曲性面板、使用温度范围广、构造及制程简单等有点，被认为是下一代的平面显示屏新兴应用技术。

OLED显示和传统的LCD显示不同，其可以自发光，所以不需要背光灯，这使得OLED显示屏相对于LCD显示屏尺寸更薄，同时显示效果更优。 常用的OLED屏幕有蓝色、黄色、白色等几种。屏的大小为0.96寸，像素点为 128*64，所以我们称为0.96oled屏或者12864屏。

------------------------------------------------------------------------------------

如何让字符显示在OLED屏幕上：

由于我们实际上是在和OLED的驱动IC通信，所以我们要选择驱动的相应时序8080时序。然后利用厂家给的初始化序列进行屏幕初始化。然后再进行画点读点的操作。

接下来介绍8080并行通信的读/写操作过程。

1、设置DC电平，选择写入类型（高电平为读写数据，低电平为读写命令）；

2、拉低片选，选中我们的操作设备；

3、设置RD(读)/WD(写)为低电平，选择操作方式，再拉高选择的操作位，使之产生一个上升沿触发信号，会将数据锁存/写入，等于是在这个上升沿之后命令有效。

接下来以写入为例进行示范：根据需求自行选择DC电平，比如说读写数据的时候我们选择高电平；接下来拉低CS选中相应OLED屏设备；然后拉低WR线，准备进行写入数据；接下来在数据线上进行数据准备；然后我们再拉高WR线，产生一个上升沿触发信号，此时我们的数据线上的数据会被读取；然后再分别释放CS和DC线。

接下来进行代码示范：

void oled_wr_byte(uint8_t data, uint_8 cmd){

    OLED_RS(cmd); //数据类型，有传参决定
    OLED_CS(0);
    OLED_WR(0);
    oled_data_out(data); //数据线准备
    OLED_WR(1);
    OLED_CS(0);
    OLED_RS(cmd); //释放，恢复默认

}

void oled_data_out(uint8_t data){

    GPIOC->ODR = (GPIOC->ODR & 0xFF00) | (data & 0x00FF); //D[7:0]使用的是PC0~7,前一段清空后8位的数据，，后一段传入数据
}

整个OLED屏幕分成了八页，说白了就是把OLED的屏幕把宽平均分成了八份。比如想要在第0列第三行的开头显示一个点那就是按位来配置，0000 0100（0x08）。在对GRAM进行操作的时候，列地址指针自动递增，当列地址指针达到列结束地址的时候，重置开始地址，但页指针不变。用户必须设置新的页和列地址，才能访问下一页GRAM内容。

 

 STM32内部建立一个缓存(共128*8个字节），每次修改的时候，只是修改STM32上的缓存(实际上就是SRAM)，修改完后一次性把STM32上的缓存数据写入到OLED的GRAM。

代码实现如下：

static uint8_t g_oled_gram[128][8]; //OLED的显存，前面是列数，后面是页数

void oled_refresh_gram(void){

    unit8_t i,n;

    for(i=0;i<8;i++){
        oled_wr_byte(0xB0 + i, OLED_CMD); //设置页地址
        oled_wr_byte(0x00, OLED_CMD);     //设置列低地址
        oled_wr_byte(0x10, OLED_CMD);     //设置列高地址

        for(n=0;n<128;n++){
            oled_wr_byte(g_oled_gram[n][i], OLED_DATA);
        }
    }
}

一个通用的置1表达式为OLED_GRAM[x][y/8] |= 1<< y%8;

然后给出标准画点的代码：

void oled_draw_point(uint8_t x, uint8_t y, uint8_t dot){

    uint8_t pos, bx, temp = 0;
    if(x > 127 || y > 63) return;

    pos = y / 8;    //页地址
    bx = y % 8;     //在页中纵坐标的位置
    temp = 1 << bx; //转换后y对应的bit位置
    
    if(dot)
        g_oled_gram[x][pos] |= temp;
    else
        g_oled_gram[x][pos] |= ~temp;

}

接下来介绍字符显示原理：

1、显示字符必须有相应的点阵数据，点阵数据的集合叫做字库；

2、单片机根据点阵数据按取模放进行描点还原，从而显示字符；

3、ASCII字符宽度 = 汉字宽度的一半。

画点遵循原则：从上到下，从左到右，高位在前。

如图中的字符，我们对应的数据是

0x00, 0x04, 0x00, 0x3C, 0x03, 0xC4, 0x1C, 0x40。 

接下来给出字符显示代码：

void oled_show_chara(){

    uint8_t temp, t1, t;
    uint8_t y0 = y; //保存y的初值
    uint8_t mode = 1;

    for(t1=0;t1<16;t1++){
        temp = oled_ascii_1608[t];

        for(t=0;t<8;t++){
            if(temp & 0x80) //用最高位判断，如果这个点有效，则画出来
                oled_draw_point(x, y, mode);
            else
                oled_draw_point(x, y, !mode);

            temp <<= 1; //进行移位操作，直接丢弃最高位，以下一位为最高位进行判断
            y++; //纵坐标自增

            if((y-y0) == 16){ //显示完了一列
                y=y0;  //纵坐标复位
                x++;   //横坐标自增
                break; 
            }
        }
    }
}

接下来用代码实现OLED基本驱动：

先写函数头文件oled.h：

#ifndef __OLED_H
#define __OLED_H

#include "stdlib.h"
#include "./SYSTEM/sys/sys.h"

#define OLED_MODE       1


//引脚定义和时钟开启
#define OLED_SPI_RST_PORT               GPIOG
#define OLED_SPI_RST_PIN                GPIO_PIN_15
#define OLED_SPI_RST_CLK_ENABLE()       do{ __HAL_RCC_GPIOG_CLK_ENABLE(); }while(0)

#define OLED_SPI_CS_PORT                GPIOD
#define OLED_SPI_CS_PIN                 GPIO_PIN_6
#define OLED_SPI_CS_CLK_ENABLE()        do{ __HAL_RCC_GPIOD_CLK_ENABLE(); }while(0)   

#define OLED_SPI_RS_PORT                GPIOD
#define OLED_SPI_RS_PIN                 GPIO_PIN_3
#define OLED_SPI_RS_CLK_ENABLE()        do{ __HAL_RCC_GPIOD_CLK_ENABLE(); }while(0)

#define OLED_SPI_SCLK_PORT              GPIOC
#define OLED_SPI_SCLK_PIN               GPIO_PIN_0
#define OLED_SPI_SCLK_CLK_ENABLE()      do{ __HAL_RCC_GPIOC_CLK_ENABLE(); }while(0)

#define OLED_SPI_SDIN_PORT              GPIOC
#define OLED_SPI_SDIN_PIN               GPIO_PIN_1
#define OLED_SPI_SDIN_CLK_ENABLE()      do{ __HAL_RCC_GPIOC_CLK_ENABLE(); }while(0)



//端口函数启动
#define OLED_RST(x)     do{ x ? \
                                  HAL_GPIO_WritePin(OLED_SPI_RST_PORT, OLED_SPI_RST_PIN, GPIO_PIN_SET) : \
                                  HAL_GPIO_WritePin(OLED_SPI_RST_PORT, OLED_SPI_RST_PIN, GPIO_PIN_RESET); \
                        }while(0)       /* ÉèÖÃRSTÒý½Å */

#define OLED_CS(x)      do{ x ? \
                                  HAL_GPIO_WritePin(OLED_SPI_CS_PORT, OLED_SPI_CS_PIN, GPIO_PIN_SET) : \
                                  HAL_GPIO_WritePin(OLED_SPI_CS_PORT, OLED_SPI_CS_PIN, GPIO_PIN_RESET); \
                        }while(0)       /* ÉèÖÃCSÒý½Å */
#define OLED_RS(x)      do{ x ? \
                                  HAL_GPIO_WritePin(OLED_SPI_RS_PORT, OLED_SPI_RS_PIN, GPIO_PIN_SET) : \
                                  HAL_GPIO_WritePin(OLED_SPI_RS_PORT, OLED_SPI_RS_PIN, GPIO_PIN_RESET); \
                        }while(0)       /* ÉèÖÃRSÒý½Å */
                              
#define OLED_SCLK(x)    do{ x ? \
                                  HAL_GPIO_WritePin(OLED_SPI_SCLK_PORT, OLED_SPI_SCLK_PIN, GPIO_PIN_SET) : \
                                  HAL_GPIO_WritePin(OLED_SPI_SCLK_PORT, OLED_SPI_SCLK_PIN, GPIO_PIN_RESET); \
                        }while(0)       /* ÉèÖÃSCLKÒý½Å */
#define OLED_SDIN(x)    do{ x ? \
                                  HAL_GPIO_WritePin(OLED_SPI_SDIN_PORT, OLED_SPI_SDIN_PIN, GPIO_PIN_SET) : \
                                  HAL_GPIO_WritePin(OLED_SPI_SDIN_PORT, OLED_SPI_SDIN_PIN, GPIO_PIN_RESET); \
                        }while(0)       /* ÉèÖÃSDINÒý½Å */


#define OLED_WR(x)      do{ x ? \
                                  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET) :  \
                                  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET); \
                        } while (0)     
#define OLED_RD(x)      do{ x ? \
                                  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET) : \
                                  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET); \
                        }while(0)       



#define OLED_CMD        0 //CS脚写命令
#define OLED_DATA       1 //CS脚写数据


    
static void oled_wr_byte(uint8_t data, uint8_t cmd);   //写一个字节到OLED
static uint32_t oled_pow(uint8_t m, uint8_t n);        //求平方函数 


void oled_init(void);           
void oled_clear(void);          
void oled_display_on(void);     
void oled_display_off(void);   
void oled_refresh_gram(void);   
void oled_draw_point(uint8_t x, uint8_t y, uint8_t dot);    
void oled_fill(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t dot);        
void oled_show_char(uint8_t x, uint8_t y, uint8_t chr, uint8_t size, uint8_t mode);
void oled_show_num(uint8_t x, uint8_t y, uint32_t num, uint8_t len, uint8_t size);
void oled_show_string(uint8_t x, uint8_t y, const char *p, uint8_t size);


#endif

接下来写函数文件代码：

#include "stdlib.h"
#include "./BSP/OLED/oled.h"
#include "./BSP/OLED/oledfont.h"
#include "./SYSTEM/delay/delay.h"

static uint8_t g_oled_gram[128][8];

void oled_refresh_gram(void)
{
    uint8_t i, n;

    for (i = 0; i < 8; i++)
    {
        oled_wr_byte (0xb0 + i, OLED_CMD); //设置页地址
        oled_wr_byte (0x00, OLED_CMD);     //设置列低地址
        oled_wr_byte (0x10, OLED_CMD);     //设置列高地址

        for (n = 0; n < 128; n++)
        {
            oled_wr_byte(g_oled_gram[n][i], OLED_DATA);
        }
    }
}

#if OLED_MODE == 1    //使用8080并口通信驱动OLED

static void oled_data_out(uint8_t data) //数据线准备
{
    GPIOC->ODR = (GPIOC->ODR & 0XFF00) | (data & 0X00FF);
}


static void oled_wr_byte(uint8_t data, uint8_t cmd) //OLED读写操作
{
    oled_data_out(data);
    OLED_RS(cmd);
    OLED_CS(0);
    OLED_WR(0);
    OLED_WR(1);
    OLED_CS(1);
    OLED_RS(1);
}

#else       //使用SPI驱动

static void oled_wr_byte(uint8_t data, uint8_t cmd)
{
    uint8_t i;
    OLED_RS(cmd);   /* дÃüÁî */
    OLED_CS(0);

    for (i = 0; i < 8; i++)
    {
        OLED_SCLK(0);

        if (data & 0x80)
        {
            OLED_SDIN(1);
        }
        else
        {
            OLED_SDIN(0);
        }

        OLED_SCLK(1);
        data <<= 1;
    }

    OLED_CS(1);
    OLED_RS(1);
}

#endif

//开启OLED显示
void oled_display_on(void)
{
    oled_wr_byte(0X8D, OLED_CMD);   /* SET DCDCÃüÁî */
    oled_wr_byte(0X14, OLED_CMD);   /* DCDC ON */
    oled_wr_byte(0XAF, OLED_CMD);   /* DISPLAY ON */
}

//关闭OLED显示
void oled_display_off(void)
{
    oled_wr_byte(0X8D, OLED_CMD);   /* SET DCDCÃüÁî */
    oled_wr_byte(0X10, OLED_CMD);   /* DCDC OFF */
    oled_wr_byte(0XAE, OLED_CMD);   /* DISPLAY OFF */
}

//清屏
void oled_clear(void)
{
    uint8_t i, n;

    for (i = 0; i < 8; i++)for (n = 0; n < 128; n++)g_oled_gram[n][i] = 0X00;

    oled_refresh_gram();    
}

画点
void oled_draw_point(uint8_t x, uint8_t y, uint8_t dot)
{
    uint8_t pos, bx, temp = 0;

    if (x > 127 || y > 63) return;  

    pos = y / 8;            

    bx = y % 8;             
    temp = 1 << bx;         

    if (dot)    
    {
        g_oled_gram[x][pos] |= temp;
    }
    else        
    {
        g_oled_gram[x][pos] &= ~temp;
    }
}

//OLED区域填充
void oled_fill(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t dot)
{
    uint8_t x, y;

    for (x = x1; x <= x2; x++)
    {
        for (y = y1; y <= y2; y++)oled_draw_point(x, y, dot);
    }

    oled_refresh_gram();    
}

//在指定位置显示字符
void oled_show_char(uint8_t x, uint8_t y, uint8_t chr, uint8_t size, uint8_t mode)
{
    uint8_t temp, t, t1;
    uint8_t y0 = y;
    uint8_t *pfont = 0;
    uint8_t csize = (size / 8 + ((size % 8) ? 1 : 0)) * (size / 2); //得到一个字符对应点阵所占字节数
    chr = chr - ' ';        //得到偏移后的值，因为是从空格开始记录的

    if (size == 12)         /* 1206字体*/
    {
        pfont = (uint8_t *)oled_asc2_1206[chr];
    }
    else if (size == 16)     /* 1608字体 */
    {
        pfont = (uint8_t *)oled_asc2_1608[chr];
    }
    else if (size == 24)     /* 2412字库 */
    {
        pfont = (uint8_t *)oled_asc2_2412[chr];
    }
    else                    /* 不存在相应字库 */
    {
        return;
    }

    for (t = 0; t < csize; t++)
    {
        temp = pfont[t];

        for (t1 = 0; t1 < 8; t1++)
        {
            if (temp & 0x80)oled_draw_point(x, y, mode);
            else oled_draw_point(x, y, !mode);

            temp <<= 1;
            y++;

            if ((y - y0) == size)
            {
                y = y0;
                x++;
                break;
            }
        }
    }
}

//平方函数
static uint32_t oled_pow(uint8_t m, uint8_t n)
{
    uint32_t result = 1;

    while (n--)
    {
        result *= m;
    }

    return result;
}

/显示len个数字
void oled_show_num(uint8_t x, uint8_t y, uint32_t num, uint8_t len, uint8_t size)
{
    uint8_t t, temp;
    uint8_t enshow = 0;

    for (t = 0; t < len; t++)   /* °´×ÜÏÔʾλÊýÑ­»· */
    {
        temp = (num / oled_pow(10, len - t - 1)) % 10;  /* »ñÈ¡¶ÔӦλµÄÊý×Ö */

        if (enshow == 0 && t < (len - 1))   /* ûÓÐʹÄÜÏÔʾ,ÇÒ»¹ÓÐλҪÏÔʾ */
        {
            if (temp == 0)
            {
                oled_show_char(x + (size / 2)*t, y, ' ', size, 1); /* ÏÔʾ¿Õ¸ñ,վλ */
                continue;       /* ¼ÌÐøϸöһλ */
            }
            else
            {
                enshow = 1;     /* ʹÄÜÏÔʾ */
            }
        }

        oled_show_char(x + (size / 2)*t, y, temp + '0', size, 1);    /* ÏÔʾ×Ö·û */
    }
}

//显示字符串
void oled_show_string(uint8_t x, uint8_t y, const char *p, uint8_t size)
{
    while ((*p <= '~') && (*p >= ' '))   
    {
        if (x > (128 - (size / 2)))     
        {
            x = 0;
            y += size;                  
        }

        if (y > (64 - size))            
        {
            y = x = 0;
            oled_clear();
        }

        oled_show_char(x, y, *p, size, 1);   
        x += size / 2;      
        p++;
    }
}

//初始化OLED
void oled_init(void)
{
    GPIO_InitTypeDef gpio_init_struct;
    __HAL_RCC_GPIOC_CLK_ENABLE();     
    __HAL_RCC_GPIOD_CLK_ENABLE();     
    __HAL_RCC_GPIOG_CLK_ENABLE();     

#if OLED_MODE==1    /* 使用8080并口通信 */

    /* PC0 ~ 7 设置 */
    gpio_init_struct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;                
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽输出 */
    gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_MEDIUM;        /* 中速 */
    HAL_GPIO_Init(GPIOC, &gpio_init_struct);                /* PC0 ~ 7 设置 */

    gpio_init_struct.Pin = GPIO_PIN_3|GPIO_PIN_6;           /* PD3, PD6 设置 */
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽输出 */
    gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_MEDIUM;        /* 中速 */
    HAL_GPIO_Init(GPIOD, &gpio_init_struct);                /* PD3, PD6 设置 */
    
    gpio_init_struct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽输出 */
    gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_MEDIUM;        /* 中速 */
    HAL_GPIO_Init(GPIOG, &gpio_init_struct);                /* WR/RD/RST引脚模式设置 */

    OLED_WR(1);
    OLED_RD(1);

#else               /* SPI串口通信模式 */

    gpio_init_struct.Pin = OLED_SPI_RST_PIN;                /* RST引脚 */
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽 */
    gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉­ */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_MEDIUM;        /* 中速 */
    HAL_GPIO_Init(OLED_SPI_RST_PORT, &gpio_init_struct);    

    gpio_init_struct.Pin = OLED_SPI_CS_PIN;                 /* CS引脚 */
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽 */
    gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉*/
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_MEDIUM;        /* 中速 */
    HAL_GPIO_Init(OLED_SPI_CS_PORT, &gpio_init_struct);     

    gpio_init_struct.Pin = OLED_SPI_RS_PIN;                 /* RS引脚 */
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽 */
    gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_MEDIUM;        /* 中速 */
    HAL_GPIO_Init(OLED_SPI_RS_PORT, &gpio_init_struct);     

    gpio_init_struct.Pin = OLED_SPI_SCLK_PIN;                /* SCLK引脚 */
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;             /* 推挽 */
    gpio_init_struct.Pull = GPIO_PULLUP;                     /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_MEDIUM;         /* 中速 */
    HAL_GPIO_Init(OLED_SPI_SCLK_PORT, &gpio_init_struct);    

    gpio_init_struct.Pin = OLED_SPI_SDIN_PIN;               /* SDIN引脚 */
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;            /* 推挽 */
    gpio_init_struct.Pull = GPIO_PULLUP;                    /* 上拉 */
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_MEDIUM;        /* 中速 */
    HAL_GPIO_Init(OLED_SPI_SDIN_PORT, &gpio_init_struct);   

    OLED_SDIN(1);
    OLED_SCLK(1);
#endif
    OLED_CS(1);
    OLED_RS(1);

    OLED_RST(0);
    delay_ms(100);
    OLED_RST(1);

    oled_wr_byte(0xAE, OLED_CMD);   
    oled_wr_byte(0xD5, OLED_CMD);   
    oled_wr_byte(80, OLED_CMD);     
    oled_wr_byte(0xA8, OLED_CMD);   
    oled_wr_byte(0X3F, OLED_CMD);   
    oled_wr_byte(0xD3, OLED_CMD);   
    oled_wr_byte(0X00, OLED_CMD);   

    oled_wr_byte(0x40, OLED_CMD);   

    oled_wr_byte(0x8D, OLED_CMD);   
    oled_wr_byte(0x14, OLED_CMD);   
    oled_wr_byte(0x20, OLED_CMD);   
    oled_wr_byte(0x02, OLED_CMD);   
    oled_wr_byte(0xA1, OLED_CMD);   
    oled_wr_byte(0xC8, OLED_CMD);   
    oled_wr_byte(0xDA, OLED_CMD);   
    oled_wr_byte(0x12, OLED_CMD);   

    oled_wr_byte(0x81, OLED_CMD);   
    oled_wr_byte(0xEF, OLED_CMD);   
    oled_wr_byte(0xD9, OLED_CMD);   
    oled_wr_byte(0xf1, OLED_CMD);   
    oled_wr_byte(0xDB, OLED_CMD);   
    oled_wr_byte(0x30, OLED_CMD);   

    oled_wr_byte(0xA4, OLED_CMD);   
    oled_wr_byte(0xA6, OLED_CMD);   
    oled_wr_byte(0xAF, OLED_CMD);   
    oled_clear();
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/489481.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

英文论文（sci）解读复现【NO.6】ASFF-YOLOv5：基于多尺度特征融合的无人机图像道路交通多元检测方法

英文论文（sci）解读复现【NO.6】ASFF-YOLOv5：基于多尺度特征融合的无人机图像道路交通多元检测方法

此前出了目标检测算法改进专栏&#xff0c;但是对于应用于什么场景&#xff0c;需要什么改进方法对应与自己的应用场景有效果&#xff0c;并且多少改进点能发什么水平的文章&#xff0c;为解决大家的困惑&#xff0c;此系列文章旨在给大家解读发表高水平学术期刊中的 SCI论文&a…
阅读更多...
Xceed Ultimate Suite 22.3 Crack

Xceed Ultimate Suite 22.3 Crack

Xceed Ultimate Suite 22.3 Crack　 Xceed Ultimate Suite是最完整的包括所有用户的工具&#xff0c;并设置所有Xceed和计算机连接以生成书面数据。Xceed Ultimate Suite还为用户提供了140多个预先编写的比较。 Xceed Ultimate Suite公司的功能和特点&#xff1a; -包括.NET在内…
阅读更多...
Linux shell脚本 扩展补充示例

Linux shell脚本 扩展补充示例

通过变量切片、获取变量长度、产生随机数、合并字符串 最后生成随机密码 变量切片、获取变量长度 [xuexue ~]$ a1234567890 [xuexue ~]$ echo $a [xuexue ~]$ echo ${a} [xuexue ~]$ echo ${#a} #获取变量长度 [xuexue ~]$ echo ${a:3:3} #切片&#xff0c;第4个开始获取三个…
阅读更多...
力扣题库刷题笔记646-最长数对链

力扣题库刷题笔记646-最长数对链

1、题目如下&#xff1a; 2、题解思路代码实现&#xff1a; 本题算是到目前为止&#xff0c;代码能读懂&#xff0c;但是思路并不能完全理解的代码&#xff08;大概能理解&#xff0c;但是无法完全描述&#xff0c;不看题解不能做出&#xff09;&#xff0c;涉及到贪心和排序。…
阅读更多...
07_Uboot顶层Makefile分析_make xxx_defconfig

07_Uboot顶层Makefile分析_make xxx_defconfig

目录 make xxx_defconfig 过程 Makefile.build 脚本分析 scripts_basic 目标对应的命令 %config 目标对应的命令 make xxx_defconfig 过程 在编译uboot之前要使用"make xxx_defconfig"命令来配置uboot,那么这个配置过程是如何运行的呢?在顶层Makefile中有如下代…
阅读更多...
C++类模板

C++类模板

类模板和函数模板语法相似&#xff0c;在声明模板template后面加类&#xff0c;此类称为类模板. 类模板作用&#xff1a; 建立一个通用类&#xff0c;类中的成员 数据类型可以不具体制定&#xff0c;用一个虚拟的类型来代表。 语法&#xff1a; template<typename T> …
阅读更多...
深入解析PyTorch中的模型定义：原理、代码示例及应用

深入解析PyTorch中的模型定义：原理、代码示例及应用

❤️觉得内容不错的话&#xff0c;欢迎点赞收藏加关注&#x1f60a;&#x1f60a;&#x1f60a;&#xff0c;后续会继续输入更多优质内容❤️ &#x1f449;有问题欢迎大家加关注私戳或者评论&#xff08;包括但不限于NLP算法相关&#xff0c;linux学习相关&#xff0c;读研读博…
阅读更多...
【基础算法】大数运算问题

【基础算法】大数运算问题

&#x1f339;作者:云小逸 &#x1f4dd;个人主页:云小逸的主页 &#x1f4dd;Github:云小逸的Github &#x1f91f;motto:要敢于一个人默默的面对自己&#xff0c;强大自己才是核心。不要等到什么都没有了&#xff0c;才下定决心去做。种一颗树&#xff0c;最好的时间是十年前…
阅读更多...
Python高光谱遥感数据处理与机器学习（最新的技术突破讲解和复现代码）

Python高光谱遥感数据处理与机器学习（最新的技术突破讲解和复现代码）

将高光谱技术与Python编程工具结合起来&#xff0c;聚焦高频技术难点&#xff0c;明确开发要点&#xff0c;快速复现高光谱数据处理和分析过程&#xff0c;并对每一行代码进行解析&#xff0c;对学习到的理论和方法进行高效反馈。实践篇&#xff0c;通过高光谱矿物识别&#xf…
阅读更多...
了解这个项目进度跟踪管理工具，轻松掌握项目进度

了解这个项目进度跟踪管理工具，轻松掌握项目进度

白天开会晚上干活的PM和战场上的将军没有区别&#xff0c;产品研发如同组团杀敌&#xff0c;团队配合最为重要。Zoho Projects项目管理工具&#xff0c;适用于各种规模和需求的公司。 一、需求管理 在项目中&#xff0c;我们使用它Zoho收集整理各方反馈&#xff0c;快速处理工单…
阅读更多...
自媒体达人养成计划（ChatGPT+new bing）

自媒体达人养成计划（ChatGPT+new bing）

本节课我们来探索如何使用GPT帮助我们成为自媒体达人&#xff0c;快速赚到一个小目标&#xff01;在此之前&#xff0c;我们需要先做些准备工作~ 首先是平台选取&#xff0c;写文章第一件事就是要保证内容的有效性和准确性&#xff0c;不然就成为营销号了嘛&#xff0c;所以我…
阅读更多...
5---最长回文字串

5---最长回文字串

给你一个字符串 s&#xff0c;找到 s 中最长的回文子串。 如果字符串的反序与原始字符串相同&#xff0c;则该字符串称为回文字符串。 示例 1&#xff1a; 输入&#xff1a;s “babad” 输出&#xff1a;“bab” 解释&#xff1a;“aba” 同样是符合题意的答案。 示例 2&…
阅读更多...
改进沙猫群优化算法(ISCSO)-附代码

改进沙猫群优化算法(ISCSO)-附代码

改进沙猫群优化算法(ISCSO) 文章目录 改进沙猫群优化算法(ISCSO)1.沙猫群优化算法2. 改进沙猫群优化算法2.1 混沌映射初始化2.2 引入互利共生策略2.3 引入莱维飞行策略 3.实验结果4.参考文献5.Matlab代码6.Python代码 摘要&#xff1a;对沙猫群优化算法进行改进。在改进的沙猫群…
阅读更多...
Vue.js 教程---菜鸟教程

Vue.js 教程---菜鸟教程

文章目录 Vue.js 教程Vue.js 安装Vue.js 起步Vue.js 模板语法插值指令用户输入过滤器缩写 Vue.js 条件语句Vue.js 循环语句Vue.js 计算属性Vue.js 监听属性Vue.js样式绑定 Vue.js 教程 本教程主要介绍了 Vue2.x 版本的使用 第一个实例&#xff1a; <body> <div id&…
阅读更多...
Linux 信号学习

Linux 信号学习

Linux 信号学习 信号量的基本概念信号产生的条件信号如何被处理信号的异步特质 信号的分类可靠信号/不可靠信号实时信号/非实时信号 常见信号与默认行为信号处理signal() 函数sigaction()函数 向进程发送信号kill() 函数raise() 函数 alarm()和pause()函数alarm() 定时函数paus…
阅读更多...
玩转传感器----理解时序和数据采集（DHT11）

玩转传感器----理解时序和数据采集（DHT11）

该文章以DHT11模块进行分析 目录 1.模块复位&#xff08;时序图&#xff09; 2.DHT11的应答信号 3.读取1bit数值&#xff08;比较高电平的时间是否大于40us&#xff09; 4.读取一个字节 5.把读取的字节放入单片机 6. 寄存器设置IO口方向 1.模块复位&#xff08;时序图&a…
阅读更多...
22.Java多线程

22.Java多线程

Java多线程 一、进程和线程 进程是程序的一次动态执行过程&#xff0c;它需要经历从代码加载&#xff0c;代码执行到执行完毕的一个完整的过程&#xff0c;这个过程也是进程本身从产生&#xff0c;发展到最终消亡的过程。多进程操作系统能同时达运行多个进程&#xff08;程序…
阅读更多...
使用Python接口自动化测试post请求和get请求，获取请求返回值

使用Python接口自动化测试post请求和get请求，获取请求返回值

目录 引言 请求接口为Post时&#xff0c;传参方法 获取接口请求响应数据 引言 我们在做python接口自动化测试时&#xff0c;接口的请求方法有get,post等&#xff1b;get和post请求传参&#xff0c;和获取接口响应数据的方法&#xff1b; 请求接口为Post时&#xff0c;传参方法…
阅读更多...
C++系列二：数据类型

C++系列二：数据类型

C数据类型 1. 原始类型2. 复合类型3. 类型转换3.1 隐式类型转换3.2 显式类型转换 4. 总结&#xff08;手稿版&#xff09; 1. 原始类型 C 中的原始类型包括整型&#xff08;integral types&#xff09;、浮点型&#xff08;floating-point types&#xff09;、字符型&#xff…
阅读更多...
涨薪60%，从小厂逆袭，坐上美团技术专家（面经+心得）

涨薪60%，从小厂逆袭，坐上美团技术专家（面经+心得）

前言 大多数情况下&#xff0c;程序员的个人技能成长速度&#xff0c;远远大于公司规模或业务的成长速度。所以&#xff0c;跳槽成为了这个行业里最常见的一个词汇。 实际上&#xff0c;跳槽的目的无非是为了涨薪或是职业发展&#xff0c;我也不例外。普通本科毕业后&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023