跟着冲哥学习单片机

CLis***

39. DS18B20

#include "pref.h"
#include "digital_display.h"
#include "timer.h"
#include "ntc.h"
#include "bee.h"
#include <STDIO.H>
#include "cmp.h"
#include "internal_eeprom.h"
#include "ds18b20.h"

bit B_1ms; // 1ms标志
u16 msecond;

void sys_init();
void init_usb();

void main()
{
    u16 temp;
    u8 digital_display_pos[8] = {DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK};

    sys_init();

    init_time0();
    digital_display_init();

    init_usb();

    EA = 1; // 打开总中断

    // (12*32768*WDT_PS) / MAIN_Fosc
    // WDT_PS = 128
    // 24M 系统时钟,看门狗计数器溢出时间大概为 2秒
    WDT_CONTR = 0x26;

    while (1)
    {
        WDT_CONTR = 0x36;
        if (B_1ms)
        {
            B_1ms = 0;
            if (++msecond >= 300)
            {
                msecond = 0;
                temp = ds18b20_read_temperature();
                
                if(ds18b20_is_minus())
                {
                    if(temp > 999)
                    {
                        digital_display_pos[3] = DIS_;
                        digital_display_pos[4] = temp / 1000;
                    }
                    else
                    {
                        digital_display_pos[3] = DIS_BLACK;
                        digital_display_pos[4] = DIS_;
                    }
                }
                else
                {
                    digital_display_pos[3] = DIS_BLACK;
                    if(temp > 999)
                    {
                        digital_display_pos[4] = temp / 1000;
                    }
                    else
                    {
                        digital_display_pos[4] = DIS_BLACK;
                    }
                }
                digital_display_pos[5] = (temp % 1000) / 100;
                digital_display_pos[6] = ((temp % 100) / 10) + DIS_DOT;
                digital_display_pos[7] = temp % 10;
                digital_display_set_pos(
                    digital_display_pos[0],
                    digital_display_pos[1],
                    digital_display_pos[2],
                    digital_display_pos[3],
                    digital_display_pos[4],
                    digital_display_pos[5],
                    digital_display_pos[6],
                    digital_display_pos[7]
                );
            }
        }
    }
}

void sys_init()
{
    WTST = 0;  // 设置程序指令延时参数，赋值为0可将CPU执行指令的速度设置为最快
    EAXFR = 1; // 扩展寄存器(XFR)访问使能
    CKCON = 0; // 提高访问XRAM速度

    {
        P0M1 = 0x30;
        P0M0 = 0x30; // 设置P0.4、P0.5为漏极开路(实验箱加了上拉电阻到3.3V)

        P1M1 = 0x30;
        P1M0 = 0x30; // 设置P1.4、P1.5为漏极开路(实验箱加了上拉电阻到3.3V)

        P2M1 = 0x3c;
        P2M0 = 0x3c; // 设置P2.2~P2.5为漏极开路(实验箱加了上拉电阻到3.3V)

        P3M1 = 0x50;
        P3M0 = 0x50; // 设置P3.4、P3.6为漏极开路(实验箱加了上拉电阻到3.3V)

        P4M1 = 0x3c;
        P4M0 = 0x3c; // 设置P4.2~P4.5为漏极开路(实验箱加了上拉电阻到3.3V)

        P5M1 = 0x0c;
        P5M0 = 0x0c; // 设置P5.2、P5.3为漏极开路(实验箱加了上拉电阻到3.3V)

        P6M1 = 0xff;
        P6M0 = 0xff; // 设置为漏极开路(实验箱加了上拉电阻到3.3V)

        P7M1 = 0x00;
        P7M0 = 0x00; // 设置为准双向口
    }
}

void init_usb()
{
    P3M0 &= ~0x03; // P30,P31 和 USB 的 D-,D+ 共用 PIN 脚
    P3M1 |= 0x03;  // 需要将 P30,P31 设置为高阻输入模式

    IRC48MCR = 0x80; // 使能内部 48M 的 USB 专用 IRC
    while (!(IRC48MCR & 0x01))
        ; // 等待震荡源稳定

    USBCLK = 0x00; // 设置 USB 时钟源为内部 48M 的 USB 专用 IRC
    USBCON = 0x09; // 使能 USB 功能

    usb_init(); // 调用 USB CDC 初始化库函数

    EUSB = 1; // 使能 USB 中断
}

/********************** Timer0 1ms中断函数 ************************/
void timer0(void) interrupt 1
{
    B_1ms = 1;     // 1ms标志
    DisplayScan(); // 1ms扫描显示一位
    bee_on_1ms();
}
复制代码

芯S***

推荐优先看的 printf_usb("Hello World !\r\n")及usb不停电下载, 演示视频链接

CLis***

39. DS18b20 功能扩展

#include "pref.h"
#include "digital_display.h"
#include "timer.h"
#include "ntc.h"
#include "bee.h"
#include <STDIO.H>
#include "cmp.h"
#include "internal_eeprom.h"
#include "ds18b20.h"

bit B_1ms; // 1ms标志
u16 msecond;

void sys_init();
void init_usb();

void main()
{
    u16 temp;
    u8 digital_display_pos[8] = {DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK, DIS_BLACK};

    u8 serial[8];
    u8 config[5];

    sys_init();

    init_time0();
    digital_display_init();

    init_usb();

    EA = 1; // 打开总中断

    ds18b20_read_serial(serial);
    ds18b20_read_cfg(serial, config);

    // 接收任意串口数据后继续执行, 方便调试
    while (!bUsbOutReady)
        ;

    printf_usb("\r\nserial: %X %X %X %X %X %X %X %X\r\n", serial[7], serial[6], serial[5], serial[4], serial[3], serial[2], serial[1], serial[0]);
    printf_usb("\r\nconfig: %X %X %X %X %X\r\n", config[4], config[3], config[2], config[1], config[0]);

    digital_display_black();

    // (12*32768*WDT_PS) / MAIN_Fosc
    // WDT_PS = 128
    // 24M 系统时钟,看门狗计数器溢出时间大概为 2秒
    WDT_CONTR = 0x26;

    while (1)
    {
        WDT_CONTR = 0x36;

        if (B_1ms)
        {
            B_1ms = 0;
            if (++msecond >= 500)
            {
                msecond = 0;

                temp = ds18b20_read_temperature_target(serial);
                printf_usb("%0.2f", ((float)temp / 100));

                if (ds18b20_is_minus())
                {
                    if (temp > 999)
                    {
                        digital_display_pos[3] = DIS_;
                        digital_display_pos[4] = temp / 1000;
                    }
                    else
                    {
                        digital_display_pos[3] = DIS_BLACK;
                        digital_display_pos[4] = DIS_;
                    }
                }
                else
                {
                    digital_display_pos[3] = DIS_BLACK;
                    if (temp > 999)
                    {
                        digital_display_pos[4] = temp / 1000;
                    }
                    else
                    {
                        digital_display_pos[4] = DIS_BLACK;
                    }
                }
                digital_display_pos[5] = (temp % 1000) / 100 + DIS_DOT;
                digital_display_pos[6] = ((temp % 100) / 10);
                digital_display_pos[7] = temp % 10;
                digital_display_set_pos(
                    digital_display_pos[0],
                    digital_display_pos[1],
                    digital_display_pos[2],
                    digital_display_pos[3],
                    digital_display_pos[4],
                    digital_display_pos[5],
                    digital_display_pos[6],
                    digital_display_pos[7]);
                usb_OUT_done();
            }

            if (!P34)
            {
                // 精度切换
                delay_ms(100);
                if (!P34)
                {
                    digital_display_set(12345678);
                    temp = (config[2] & 0x60) >> 5;
                    if (temp >= 3)
                    {
                        temp = 0;
                    }
                    else
                    {
                        temp++;
                    }
                    ds18b20_cfg_ratio(serial, temp);
                    ds18b20_read_cfg(serial, config);
                    printf_usb("\r\nconfig: %X %X %X %X %X\r\n", config[4], config[3], config[2], config[1], config[0]);

                    while (!P34)
                    {
                        WDT_CONTR = 0x36;
                    }
                    digital_display_black();
                }
            }
        }
    }
}

void sys_init()
{
    WTST = 0;  // 设置程序指令延时参数，赋值为0可将CPU执行指令的速度设置为最快
    EAXFR = 1; // 扩展寄存器(XFR)访问使能
    CKCON = 0; // 提高访问XRAM速度

    {
        P0M1 = 0x30;
        P0M0 = 0x30; // 设置P0.4、P0.5为漏极开路(实验箱加了上拉电阻到3.3V)

        P1M1 = 0x30;
        P1M0 = 0x30; // 设置P1.4、P1.5为漏极开路(实验箱加了上拉电阻到3.3V)

        P2M1 = 0x3c;
        P2M0 = 0x3c; // 设置P2.2~P2.5为漏极开路(实验箱加了上拉电阻到3.3V)

        P3M1 = 0x50;
        P3M0 = 0x50; // 设置P3.4、P3.6为漏极开路(实验箱加了上拉电阻到3.3V)

        P4M1 = 0x3c;
        P4M0 = 0x3c; // 设置P4.2~P4.5为漏极开路(实验箱加了上拉电阻到3.3V)

        P5M1 = 0x0c;
        P5M0 = 0x0c; // 设置P5.2、P5.3为漏极开路(实验箱加了上拉电阻到3.3V)

        P6M1 = 0xff;
        P6M0 = 0xff; // 设置为漏极开路(实验箱加了上拉电阻到3.3V)

        P7M1 = 0x00;
        P7M0 = 0x00; // 设置为准双向口
    }
}

void init_usb()
{
    P3M0 &= ~0x03; // P30,P31 和 USB 的 D-,D+ 共用 PIN 脚
    P3M1 |= 0x03;  // 需要将 P30,P31 设置为高阻输入模式

    IRC48MCR = 0x80; // 使能内部 48M 的 USB 专用 IRC
    while (!(IRC48MCR & 0x01))
        ; // 等待震荡源稳定

    USBCLK = 0x00; // 设置 USB 时钟源为内部 48M 的 USB 专用 IRC
    USBCON = 0x09; // 使能 USB 功能

    usb_init(); // 调用 USB CDC 初始化库函数

    EUSB = 1; // 使能 USB 中断
}

/********************** Timer0 1ms中断函数 ************************/
void timer0(void) interrupt 1
{
    B_1ms = 1;     // 1ms标志
    DisplayScan(); // 1ms扫描显示一位
    bee_on_1ms();
}
复制代码

#include "ds18b20.h"

sbit DQ = P3 ^ 3; // DS18B20的数据口
bit _MinusFlag;   // 负数标志，0：正数，1：负数

bit ds18b20_is_minus()
{
    return _MinusFlag;
}

void ds18b20_read_scratchpad(u8 *temperature, u8 *tHL, u8 *cfg, u8 *user, u8 *crc)
{
    ds18b20_writebyte(0xBE); // 读取暂存器

    temperature[0] = ds18b20_readbyte(); // 读温度低字节
    temperature[1] = ds18b20_readbyte(); // 读温度高字节

    tHL[0] = ds18b20_readbyte(); // T_H Reg
    tHL[1] = ds18b20_readbyte(); // T_L Reg

    *cfg = ds18b20_readbyte(); // Config Reg

    ds18b20_readbyte(); // FFh

    user[0] = ds18b20_readbyte(); // User byte
    user[1] = ds18b20_readbyte(); // User byte

    *crc = ds18b20_readbyte();
}

void ds18b20_write_scratchpad(u8 *config)
{
    ds18b20_writebyte(0x4E); // 写入暂存器

    ds18b20_writebyte(config[0]);
    ds18b20_writebyte(config[1]);
    ds18b20_writebyte(config[2]);

    ds18b20_reset();
}

void ds18b20_write_eeprom(u8 *serial)
{
    ds18b20_reset();
    ds18b20_match_serial(serial);
    ds18b20_writebyte(0x48); // 写入EEPROM
    while (!DQ)
        ;
}

u16 ds18b20_read_tempturature()
{
    u16 Temperature;
    u8 temp[2];

    ds18b20_read_scratchpad(temp, 0, 0, 0, 0);

    if (temp[1] & 0xf8) // 判断是否位负数
    {
        _MinusFlag = 1; // 设置负数标志
        Temperature = (temp[1] << 8) | temp[0];
        Temperature = ~Temperature + 1;
        Temperature *= 0.625; // 0.0625 * 10，保留1位小数点
    }
    else
    {
        _MinusFlag = 0;                                    // 清除负数标志
        Temperature = (((temp[1] << 8) | temp[0]) * 6.25); // 0.0625 * 100，保留2位小数点
    }

    return Temperature;
}

void ds18b20_reset()
{
    CY = 1;
    while (CY)
    {
        DQ = 0;        // 送出低电平复位信号
        delay_us(240); // 延时至少480us
        delay_us(240);
        DQ = 1;        // 释放数据线
        delay_us(60);  // 等待60us
        CY = DQ;       // 检测存在脉冲
        delay_us(240); // 等待设备释放数据线
        delay_us(180);
    }
}

void ds18b20_read_serial(u8 *dat)
{
    u8 i, j, tmp_u8;
    bit tmp_bit;

    ds18b20_reset();
    ds18b20_writebyte(0xF0); // Search ROM

    for (i = 0; i < 8; i++)
    {
        tmp_u8 = 0;
        for (j = 0; j < 8; j++)
        {
            tmp_bit = ds18b20_readbit();         // B20 TX bit
            while (ds18b20_readbit() == tmp_bit) // B20 TX !bit
                ;
            ds18b20_writebit(tmp_bit); // Master TX bit
            // printf_usb("%d", tmp_bit);
            tmp_u8 >>= 1;
            if (tmp_bit)
            {
                tmp_u8 |= 0x80;
            }
        }
        *dat++ = tmp_u8;
    }
}

void ds18b20_match_serial(u8 *dat)
{
    u8 i, j, tmp_u8;

    ds18b20_reset();
    ds18b20_writebyte(0x55); // Match ROM

    for (i = 0; i < 8; i++)
    {
        tmp_u8 = dat[i];
        for (j = 0; j < 8; j++)
        {
            ds18b20_writebit(tmp_u8 & 0x01); // Master TX bit
            tmp_u8 >>= 1;
        }
    }
}

void ds18b20_writebit(bit b)
{
    DQ = 0;      // 开始时间片
    delay_us(1); // 延时等待
    DQ = b;
    delay_us(60); // 等待时间片结束
    DQ = 1;       // 恢复数据线
    delay_us(1);  // 恢复延时
}

void ds18b20_writebyte(u8 dat)
{
    char i;

    for (i = 0; i < 8; i++) // 8位计数器
    {
        DQ = 0;      // 开始时间片
        delay_us(1); // 延时等待
        dat >>= 1;   // 送出数据
        DQ = CY;
        delay_us(60); // 等待时间片结束
        DQ = 1;       // 恢复数据线
        delay_us(1);  // 恢复延时
    }
}

bit ds18b20_readbit()
{
    bit i;
    DQ = 0;      // 开始时间片
    delay_us(1); // 延时等待
    DQ = 1;      // 准备接收
    delay_us(1); // 接收延时
    i = DQ;
    delay_us(60); // 等待时间片结束
    return i;
}

u8 ds18b20_readbyte()
{
    u8 i;
    u8 dat = 0;

    for (i = 0; i < 8; i++) // 8位计数器
    {
        dat >>= 1;
        DQ = 0;      // 开始时间片
        delay_us(1); // 延时等待
        DQ = 1;      // 准备接收
        delay_us(1); // 接收延时
        if (DQ)
            dat |= 0x80; // 读取数据
        delay_us(60);    // 等待时间片结束
    }

    return dat;
}

void ds18b20_read_cfg(u8 *serial, u8 *cfg)
{
    u8 t_threshold[2], _user[2];
    u8 _config;

    ds18b20_reset();
    ds18b20_match_serial(serial);
    ds18b20_read_scratchpad(0, t_threshold, &_config, _user, 0);

    cfg[0] = t_threshold[0];
    cfg[1] = t_threshold[1];
    cfg[2] = _config;
    cfg[3] = _user[0];
    cfg[4] = _user[1];
}

/**
 * 0 - 0.5
 * 1 - 0.25
 * 2 - 0.125
 * 3 - 0.0625
 */
void ds18b20_cfg_ratio(u8 *serial, u8 ratio)
{
    u8 config[5];
    ds18b20_read_cfg(serial, config);

    config[2] = ratio << 5;

    ds18b20_reset();
    ds18b20_match_serial(serial);
    ds18b20_write_scratchpad(config);
    ds18b20_write_eeprom(serial);
}

u16 ds18b20_read_temperature_target(u8 *serial)
{
    ds18b20_match_serial(serial); // 找指定设备
    ds18b20_writebyte(0x44);      // 写入转换命令
    while (!DQ)
        ; // 等待转换完成

    ds18b20_reset();              // 复位
    ds18b20_match_serial(serial); // 找指定设备
    return ds18b20_read_tempturature();
}

u16 ds18b20_read_temperature_any()
{
    ds18b20_reset();         // 设备复位
    ds18b20_writebyte(0xCC); // 跳过ROM命令
    ds18b20_writebyte(0x44); // 开始转换命令
    while (!DQ)
        ; // 等待转换完成

    ds18b20_reset();                    // 设备复位
    ds18b20_writebyte(0xCC);            // 跳过ROM命令
    return ds18b20_read_tempturature(); // 读暂存存储器命令
}
复制代码

CLis***

41. 软件模拟SPI

main.c

                spi_flash_writebyte(0xAB);
                // 3个字节无效数据
                spi_flash_readbyte();
                spi_flash_readbyte();
                spi_flash_readbyte();
                // 在 CS 拉高之前，flash会一直输出device id
                printf_usb("device id: 0x%X\r\n", spi_flash_readbyte());
                printf_usb("device id: 0x%X\r\n", spi_flash_readbyte());
                printf_usb("device id: 0x%X\r\n", spi_flash_readbyte());
                printf_usb("device id: 0x%X\r\n", spi_flash_readbyte());
                spi_flash_disable();

                spi_flash_writebyte(0x9F);
                printf_usb("JEDEC ID: ");
                printf_usb("%X ", spi_flash_readbyte());
                printf_usb("%X ", spi_flash_readbyte());
                printf_usb("%X \r\n", spi_flash_readbyte());
                spi_flash_disable();

                spi_flash_writebyte(0x4B);
                // 4个字节无效数据
                spi_flash_readbyte();
                spi_flash_readbyte();
                spi_flash_readbyte();
                spi_flash_readbyte();
                printf_usb("UniqueID: ");
                // 64位序列号
                printf_usb("%X ", spi_flash_readbyte());
                printf_usb("%X ", spi_flash_readbyte());
                printf_usb("%X ", spi_flash_readbyte());
                printf_usb("%X ", spi_flash_readbyte());
                printf_usb("%X ", spi_flash_readbyte());
                printf_usb("%X ", spi_flash_readbyte());
                printf_usb("%X ", spi_flash_readbyte());
                printf_usb("%X \r\n", spi_flash_readbyte());
                spi_flash_disable();
复制代码

spi.c

#define SCLK P25
#define MISO P24
#define MOSI P23
#define CS P22
#define WP P53

void spi_flash_reset()
{
    SCLK = 0;
    WP = 1;
    MISO = 1;
    MOSI = 1;
    CS = 0;
}

void spi_flash_disable()
{
    CS = 1;
}

void spi_flash_writebyte(u8 dat)
{
    u8 i;
    spi_flash_reset();
    for (i = 0; i < 8; i++)
    {
        if (dat & 0x80)
        {
            MOSI = 1;
        }
        else
        {
            MOSI = 0;
        }
        SCLK = 0;
        SCLK = 1;
        dat <<= 1;
    }
}

u8 spi_flash_readbyte()
{
    u8 dat, i;
    spi_flash_reset();
    for (i = 0; i < 8; i++)
    {
        dat <<= 1;
        SCLK = 0;
        SCLK = 1;
        dat |= MISO;
    }
    return dat;
}
复制代码

CLis***

42. 硬件SPI

SPI

#include "spi_flash.h"

#define CS P22
#define MOSI P23
#define MISO P24
#define SCLK P25
#define WP P53

void init_spi_flash()
{
    P_SW1 &= 0xF3;  // 清除 SPI 功能脚选择位
    P_SW1 |= 0x04;  // SS=P22 MOSI=P23 MISO=P24 SCLK=P25

    SPSTAT = 0xC0;  // 清除 SPI 状态寄存器

    SSIG = 1;   // 忽略 SS 引脚功能，使用 MSTR 确定主、从
    DORD = 0;   // 从最高位开始传输 SPI 数据
    MSTR = 1;   // 主机模式

    CPOL = 1;   // SCLK 空闲为高电平，前时钟沿为下降沿
    CPHA = 1;   // 数据在 SCLK 的前时钟沿驱动，后时钟沿采样

    SPR1 = 0;   // SPI 时钟频率
    SPR0 = 0;   //      SPI 输入时钟/4

    SPEN = 1;   // 使能 SPI
}

void spi_flash_enable()
{
    CS = 0;
}

void spi_flash_disable()
{
    CS = 1;
}

void spi_flash_writebyte(u8 dat)
{
    SPDAT = dat;
    while(SPIF == 0);
    SPIF = 1;
    WCOL = 1;
}

u8 spi_flash_readbyte()
{
    SPDAT = 0xFF;
    while(SPIF == 0);
    SPIF = 1;
    WCOL = 1;
    return (SPDAT);
}
复制代码

USART2-SPI

#include "spi_flash.h"

#define CS P22
#define MOSI P23
#define MISO P24
#define SCLK P25
#define WP P53

void init_spi_flash()
{
    S2SPI_S1 = 0;
    S2SPI_S0 = 1;

    S2SM0 = 0;
    S2SM1 = 0;

    S2REN = 1;

    USART2CR1 = 0x10;

    USART2CR4 = 0x00;

    USART2CR1 |= 0x08;

    S2TI = 0;
    S2RI = 0;
}

void spi_flash_enable()
{
    CS = 0;
}

void spi_flash_disable()
{
    CS = 1;
}

void spi_flash_writebyte(u8 dat)
{
    S2TI = 0;
    S2BUF = dat;
    while (!S2TI)
        ;
}

u8 spi_flash_readbyte()
{
    S2TI = 0;
    S2BUF = 0xFF;
    while (!S2TI)
        ;
    return S2BUF;
}
复制代码

CLis***

43. SPI 读写 FLASH 芯片

读取device id
读取 jedec id
读取 unique id
记录开关机次数

            printf_usb("device ID: 0x%X\r\n", spi_flash_load_DEVICE_ID());

            printf_usb("JEDEC ID: %lX\r\n", spi_flash_load_JEDEC_ID());

            spi_flash_load_UNIQUE_ID(tmp);
            printf_usb("Unique ID: %lX%lX\n", tmp[1], tmp[0]);

            printf_usb("busy: %d\r\n", spi_flash_check_busy());

            spi_flash_read(DAT_ADDR, buf, 2);
            printf_usb("%X %d\r\n", buf[0], buf[1]);
            if (buf[0] == 0x8F)
            {
                printf_usb("found data\r\n");
                spi_flash_erase(DAT_ADDR);
                buf[1]++;
            }
            else
            {
                printf_usb("erase page\r\n");
                spi_flash_erase(DAT_ADDR);
                buf[0] = 0x8F;
                buf[1] = 1;
            }
            spi_flash_write(DAT_ADDR, buf, 2);
            printf_usb("%X %d\r\n", buf[0], buf[1]);
            digital_display_set(buf[1]);
            
            usb_OUT_done();
复制代码

NTC采集温度并存储最近10次温度数值存储到flash芯片

void clear_temperature()
{
    spi_flash_erase(DAT_ADDR);
    printf_usb("CLEAR TEMPERATURE DATA!");
}

void print_temperature(u8 *buf, u8 cnt)
{
    u8 i;
    u16 tmp_u16;
    printf_usb(">>>>>>>>>>>>>>>>>>>>>>\r\n");
    printf_usb("TEMPERTURE DATA:\r\n");
    for (i = 1; i <= cnt; i++)
    {
        // 高8位地址
        tmp_u16 = buf[(i * 2 + 1)] << 8;
        // 低8位地址
        tmp_u16 |= buf[(i * 2)];

        if (tmp_u16 >= 400)
            F0 = 0, tmp_u16 -= 400; // 温度 >= 0度
        else
            F0 = 1, tmp_u16 = 400 - tmp_u16; // 温度 <  0度

        printf_usb("%2d :  %5.1f\r\n", i, ((float)tmp_u16) / 10);
    }
    printf_usb("<<<<<<<<<<<<<<<<<<<<<<\r\n");
}

void refresh_temperature(BOOL is_print)
{
    // W25X40CL
    // 1K = 512byte * 2 = 1024byte
    // 4KB = 4096byte
    // 1页 = 256byte
    // 4KB = 16页
    // 地址格式（24 位）：A23 A22 ... A8 A7 A6 ... A0
    // 高 16 位（A23~A8）：决定 “哪一页”（比如 A23~A8=0000h，就是第 0 页；A23~A8=0001h，就是第 1 页）；
    // 低 8 位（A7~A0）：决定 “页内的哪个字节”（00h~FFh，对应页内第 0 字节到第 255 字节）。
    u8 buf[22], cnt_temperature, flag; // temperture_9, temperture_8, ... , temperture_0, count, flag
    u8 i, tmp_H, tmp_L;
    u16 tmp_u16;
    spi_flash_read(DAT_ADDR, buf, 22);
    printf_usb("read  buf: 0x%X  %d\r\n", buf[0], buf[1]);
    flag = buf[0];
    if (flag == 0x80)
    {
        cnt_temperature = buf[1];
    }
    else
    {
        cnt_temperature = 1;
    }
    if (is_print)
    {
        if (flag == 0x80)
        {
            print_temperature(buf, cnt_temperature);
            return;
        }
        else
        {
            printf_usb("not found temperture data");
            return;
        }
    }
    if (cnt_temperature >= MAX_TEMP_COUNT)
    {
        cnt_temperature = MAX_TEMP_COUNT;
        // 滚动记录
        for (i = 1; i < MAX_TEMP_COUNT; i++)
        {
            buf[i * 2] = buf[(i + 1) * 2];
            buf[i * 2 + 1] = buf[(i + 1) * 2 + 1];
        }
    }
    tmp_u16 = Get_ADC12bitResult(ADC_CHANNEL_NTC);
    printf_usb("adc: %d\r\n", tmp_u16);
    if (tmp_u16 < 4096)
    {
        if (flag == 0x80 && cnt_temperature < MAX_TEMP_COUNT)
        {
            cnt_temperature += 1;
        }

        tmp_u16 = get_temperature(tmp_u16);
        tmp_H = (u8)(tmp_u16 >> 8);
        tmp_L = (u8)(tmp_u16 & 0xFF);
        // 高8位地址
        buf[(cnt_temperature * 2 + 1)] = tmp_H;
        // 低8位地址
        buf[(cnt_temperature * 2)] = tmp_L;
        buf[0] = 0x80;
        buf[1] = cnt_temperature;

        spi_flash_erase(DAT_ADDR);
        printf_usb("write  buf: 0x%X  %d\r\n", buf[0], buf[1]);
        spi_flash_write(DAT_ADDR, buf, 22);
    }
    else
    {
        printf_usb("invalid adc data, skip sample");
        return;
    }
}
复制代码

CLis***

47. USB-CDC串口读写 FLASH

读取FLASH芯片地址

u8 i2c_24Cxx_load_device_addr()
{
  u8 a2a1a0; // A2/A1/A0 地址位，000~111 共有7钟组合
  u8 tmp;
  u8 heigh_addr = 0xA0; // 高位地址固定为 1010
  for (a2a1a0 = 0; a2a1a0 < 8; a2a1a0++)
  {
    tmp = heigh_addr | (a2a1a0 << 1);
    i2c_24Cxx_start();
    if (!i2c_24Cxx_send_byte(tmp & 0xFE)) // 发送器件地址+写选择位
    {
      i2c_24Cxx_stop();
      // 接收到器件 ACK
      printf_usb("device addr: 0x%X\r\n", tmp);
      return tmp;
    }
    i2c_24Cxx_stop();
  }
复制代码

CLis***

50. PWM

//<<AICUBE_USER_HEADER_REMARK_BEGIN>>
////////////////////////////////////////
// 在此添加用户文件头说明信息
// 文件名称: main.c
// 文件描述:
// 文件版本: V1.0
// 修改记录:
//   1. (2025-11-24) 创建文件
////////////////////////////////////////
//<<AICUBE_USER_HEADER_REMARK_END>>


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


//<<AICUBE_USER_INCLUDE_BEGIN>>
// 在此添加用户头文件包含
//<<AICUBE_USER_INCLUDE_END>>


//<<AICUBE_USER_GLOBAL_DEFINE_BEGIN>>
// 在此添加用户全局变量定义、用户宏定义以及函数声明
#define PWM_PERIOD 999 // 设置周期值

u16 PWM1_Duty;
u16 PWM2_Duty;
u16 PWM3_Duty;
u16 PWM4_Duty;

bit PWM1_Flag;
bit PWM2_Flag;
bit PWM3_Flag;
bit PWM4_Flag;

void UpdatePwm(void);
//<<AICUBE_USER_GLOBAL_DEFINE_END>>




////////////////////////////////////////
// 项目主函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void main(void)
{
    //<<AICUBE_USER_MAIN_INITIAL_BEGIN>>
    // 在此添加用户主函数初始化代码
    //<<AICUBE_USER_MAIN_INITIAL_END>>

    SYS_Init();

    //<<AICUBE_USER_MAIN_CODE_BEGIN>>
    // 在此添加主函数中运行一次的用户代码
    //<<AICUBE_USER_MAIN_CODE_END>>

    while (1)
    {
        USBLIB_OUT_Done();              //查询方式处理USB接收的数据

        //<<AICUBE_USER_MAIN_LOOP_BEGIN>>
        // 在此添加主函数中用户主循环代码
        //<<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口为准双向口模式

    PORT0_Init();                       //P0口初始化
    PORT6_Init();                       //P6口初始化
    PORT7_Init();                       //P7口初始化
    TIMER0_Init();                      //定时器0初始化
    PWMA_Init();                        //高级PWMA初始化
    delay_ms(1);
    USBLIB_Init();                      //USB库初始化
    delay_ms(1);

    //<<AICUBE_USER_INITIAL_CODE_BEGIN>>
    // 在此添加用户初始化代码
    P40 = 0;
    P7 = 0x00;
    PWM1_Duty = 249;
    PWM2_Duty = 249 * 2;
    PWM3_Duty = 249 * 3;
    PWM4_Duty = 249 * 4;
    UpdatePwm();
    //<<AICUBE_USER_INITIAL_CODE_END>>

    EnableGlobalInt();                  //使能全局中断
    USBLIB_WaitConfiged();              //等待USB完成配置
}

////////////////////////////////////////
// 微秒延时函数
// 入口参数: us (设置延时的微秒值)
// 函数返回: 无
////////////////////////////////////////
void delay_us(uint16_t us)
{
    do
    {
        NOP(18);                        //(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);
}

////////////////////////////////////////
// P0口初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void PORT0_Init(void)
{
    SetP0nInitLevelHigh(PIN_ALL);       //设置P0初始化电平
    SetP0nQuasiMode(PIN_ALL);           //设置P0为准双向口模式

    DisableP0nPullUp(PIN_ALL);          //关闭P0内部上拉电阻
    DisableP0nSchmitt(PIN_ALL);         //使能P0施密特触发
    SetP0nSlewRateNormal(PIN_ALL);      //设置P0一般翻转速度
    SetP0nDrivingNormal(PIN_ALL);       //设置P0一般驱动能力
    SetP0nDigitalInput(PIN_ALL);        //使能P0数字信号输入功能

    //<<AICUBE_USER_PORT0_INITIAL_BEGIN>>
    // 在此添加用户初始化代码
    //<<AICUBE_USER_PORT0_INITIAL_END>>
}

////////////////////////////////////////
// P6口初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void PORT6_Init(void)
{
    SetP6nInitLevelHigh(PIN_ALL);       //设置P6初始化电平
    SetP6nQuasiMode(PIN_ALL);           //设置P6为准双向口模式

    DisableP6nPullUp(PIN_ALL);          //关闭P6内部上拉电阻
    DisableP6nSchmitt(PIN_ALL);         //使能P6施密特触发
    SetP6nSlewRateNormal(PIN_ALL);      //设置P6一般翻转速度
    SetP6nDrivingNormal(PIN_ALL);       //设置P6一般驱动能力
    SetP6nDigitalInput(PIN_ALL);        //使能P6数字信号输入功能

    //<<AICUBE_USER_PORT6_INITIAL_BEGIN>>
    // 在此添加用户初始化代码
    //<<AICUBE_USER_PORT6_INITIAL_END>>
}

////////////////////////////////////////
// P7口初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void PORT7_Init(void)
{
    SetP7nInitLevelHigh(PIN_ALL);       //设置P7初始化电平
    SetP7nQuasiMode(PIN_ALL);           //设置P7为准双向口模式

    DisableP7nPullUp(PIN_ALL);          //关闭P7内部上拉电阻
    DisableP7nSchmitt(PIN_ALL);         //使能P7施密特触发
    SetP7nSlewRateNormal(PIN_ALL);      //设置P7一般翻转速度
    SetP7nDrivingNormal(PIN_ALL);       //设置P7一般驱动能力
    SetP7nDigitalInput(PIN_ALL);        //使能P7数字信号输入功能

    //<<AICUBE_USER_PORT7_INITIAL_BEGIN>>
    // 在此添加用户初始化代码
    //<<AICUBE_USER_PORT7_INITIAL_END>>
}

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

    TIMER0_TimerMode();                 //设置定时器0为定时模式
    TIMER0_1TMode();                    //设置定时器0为1T模式
    TIMER0_Mode0();                     //设置定时器0为模式0 (16位自动重载模式)
    TIMER0_DisableGateINT0();           //禁止定时器0门控
    TIMER0_SetIntPriority(0);           //设置中断为最低优先级
    TIMER0_EnableInt();                 //使能定时器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>>
}

////////////////////////////////////////
// PWMA初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void PWMA_Init(void)
{
    PWMA_C1SwitchP6061();               //设置PWMA通道1数据端口: PWM1P (P6.1), PWM3N (P6.2)
    PWMA_C2SwitchP6263();               //设置PWMA通道2数据端口: PWM2P (P6.3), PWM3N (P6.4)
    PWMA_C3SwitchP6465();               //设置PWMA通道3数据端口: PWM3P (P6.4), PWM3N (P6.5)
    PWMA_C4SwitchP6667();               //设置PWMA通道4数据端口: PWM4P (P6.6), PWM4N (P6.7)

    HSPWMA_Disable();                   //关闭高速模式，使用同步方式进行初始化
    PWMA_InternalClockMode();           //选择内部时钟模式
    PWMA_SetClockDivider(0);            //设置16位预分频
    PWMA_SetReload16(PWM_PERIOD);       //设置16位重载值
    PWMA_BufferARR();                   //使能重载值寄存器预装载功能
    PWMA_SetCounter(0);                 //初始化计数值

    PWMA_CC1PDisable();                 //关闭通道
    PWMA_CC1Output();                   //使能通道输出功能
    PWMA_CC1PEnable();                  //打开通道
    PWM_UpdateDuty(PWMA_CH1, 500);      //设置通道的PWM占空比
    PWMA_OC1REFPWMMode1();              //设置通道输出参考信号为PWM模式1信号
    PWMA_BufferCCR1();                  //使能CCRn预装载功能
    PWMA_CC1PNonInverted();             //设置正极通道输出高电平有效
    PWMA_EnablePWM1POutput();           //使能正极通道输出
    PWMA_CC1NEnable();                  //打开负极通道
    PWMA_CC1NNonInverted();             //设置负极通道输出高电平有效
    PWMA_EnablePWM1NOutput();           //使能负极通道输出

    PWMA_CC2PDisable();                 //关闭通道
    PWMA_CC2Output();                   //使能通道输出功能
    PWMA_CC2PEnable();                  //打开通道
    PWM_UpdateDuty(PWMA_CH2, 500);      //设置通道的PWM占空比
    PWMA_OC2REFPWMMode1();              //设置通道输出参考信号为PWM模式1信号
    PWMA_BufferCCR2();                  //使能CCRn预装载功能
    PWMA_CC2PNonInverted();             //设置正极通道输出高电平有效
    PWMA_EnablePWM2POutput();           //使能正极通道输出
    PWMA_CC2NEnable();                  //打开负极通道
    PWMA_CC2NNonInverted();             //设置负极通道输出高电平有效
    PWMA_EnablePWM2NOutput();           //使能负极通道输出

    PWMA_CC3PDisable();                 //关闭通道
    PWMA_CC3Output();                   //使能通道输出功能
    PWMA_CC3PEnable();                  //打开通道
    PWM_UpdateDuty(PWMA_CH3, 500);      //设置通道的PWM占空比
    PWMA_OC3REFPWMMode1();              //设置通道输出参考信号为PWM模式1信号
    PWMA_BufferCCR3();                  //使能CCRn预装载功能
    PWMA_CC3PNonInverted();             //设置正极通道输出高电平有效
    PWMA_EnablePWM3POutput();           //使能正极通道输出
    PWMA_CC3NEnable();                  //打开负极通道
    PWMA_CC3NNonInverted();             //设置负极通道输出高电平有效
    PWMA_EnablePWM3NOutput();           //使能负极通道输出

    PWMA_CC4PDisable();                 //关闭通道
    PWMA_CC4Output();                   //使能通道输出功能
    PWMA_CC4PEnable();                  //打开通道
    PWM_UpdateDuty(PWMA_CH4, 500);      //设置通道的PWM占空比
    PWMA_OC4REFPWMMode1();              //设置通道输出参考信号为PWM模式1信号
    PWMA_BufferCCR4();                  //使能CCRn预装载功能
    PWMA_CC4PNonInverted();             //设置正极通道输出高电平有效
    PWMA_EnablePWM4POutput();           //使能正极通道输出
    PWMA_CC4NEnable();                  //打开负极通道
    PWMA_CC4NNonInverted();             //设置负极通道输出高电平有效
    PWMA_EnablePWM4NOutput();           //使能负极通道输出

    PWMA_EnableMainOutput();            //使能PWM主输出

    PWMA_Run();                         //PWMA开始运行

    //<<AICUBE_USER_PWM0_INITIAL_BEGIN>>
    // 在此添加用户初始化代码
    //<<AICUBE_USER_PWM0_INITIAL_END>>
}

////////////////////////////////////////
// 设置PWM通道输出占空比
// 入口参数: PWMx: (目标PWM组和通道索引)
//           nCompare: (PWM占空比值)
//           iMode: (PWM输出模式：PWM_MODE1/PWM_MODE2)
// 函数返回: 无
////////////////////////////////////////
void PWM_UpdateDuty(uint8_t PWMx, uint16_t nCompare)
{
    switch (PWMx)
    {
    case PWMA_CH1:
        PWMA_SetCCR1Value(nCompare);    //设置通道比较值
        break;
    case PWMA_CH2:
        PWMA_SetCCR2Value(nCompare);    //设置通道比较值
        break;
    case PWMA_CH3:
        PWMA_SetCCR3Value(nCompare);    //设置通道比较值
        break;
    case PWMA_CH4:
        PWMA_SetCCR4Value(nCompare);    //设置通道比较值
        break;
    case PWMB_CH5:
        PWMB_SetCCR5Value(nCompare);    //设置通道比较值
        break;
    case PWMB_CH6:
        PWMB_SetCCR6Value(nCompare);    //设置通道比较值
        break;
    case PWMB_CH7:
        PWMB_SetCCR7Value(nCompare);    //设置通道比较值
        break;
    case PWMB_CH8:
        PWMB_SetCCR8Value(nCompare);    //设置通道比较值
        break;
    }
}

////////////////////////////////////////
// 读取PWM通道捕获值
// 入口参数: PWMx: (目标PWM组和通道索引)
// 函数返回: 捕获值
////////////////////////////////////////
uint16_t PWM_ReadCapture(uint8_t PWMx)
{
    uint16_t cap;

    switch (PWMx)
    {
    case PWMA_CH1:  cap = PWMA_ReadCCR1Value(); break;
    case PWMA_CH2:  cap = PWMA_ReadCCR2Value(); break;
    case PWMA_CH3:  cap = PWMA_ReadCCR3Value(); break;
    case PWMA_CH4:  cap = PWMA_ReadCCR4Value(); break;
    case PWMB_CH5:  cap = PWMB_ReadCCR5Value(); break;
    case PWMB_CH6:  cap = PWMB_ReadCCR6Value(); break;
    case PWMB_CH7:  cap = PWMB_ReadCCR7Value(); break;
    case PWMB_CH8:  cap = PWMB_ReadCCR8Value(); break;
    default: cap = 0;
    }

    return cap;
}

////////////////////////////////////////
// 设置高速模式PWM通道输出占空比
// 入口参数: PWMx: (目标PWM组和通道索引)
//           nCompare: (PWM占空比值)
// 函数返回: 无
////////////////////////////////////////
void HSPWM_UpdateDuty(uint8_t PWMx, uint16_t nCompare)
{
    switch (PWMx)
    {
    case PWMA_CH1:
        HSPWMA_SetCCR1Value(nCompare);  //设置通道比较值
        break;
    case PWMA_CH2:
        HSPWMA_SetCCR2Value(nCompare);  //设置通道比较值
        break;
    case PWMA_CH3:
        HSPWMA_SetCCR3Value(nCompare);  //设置通道比较值
        break;
    case PWMA_CH4:
        HSPWMA_SetCCR4Value(nCompare);  //设置通道比较值
        break;
    case PWMB_CH5:
        HSPWMB_SetCCR5Value(nCompare);  //设置通道比较值
        break;
    case PWMB_CH6:
        HSPWMB_SetCCR6Value(nCompare);  //设置通道比较值
        break;
    case PWMB_CH7:
        HSPWMB_SetCCR7Value(nCompare);  //设置通道比较值
        break;
    case PWMB_CH8:
        HSPWMB_SetCCR8Value(nCompare);  //设置通道比较值
        break;
    }
}

////////////////////////////////////////
// 读取高速模式PWM通道捕获值
// 入口参数: PWMx: (目标PWM组和通道索引)
// 函数返回: 捕获值
////////////////////////////////////////
uint16_t HSPWM_ReadCapture(uint8_t PWMx)
{
    uint16_t cap;

    switch (PWMx)
    {
    case PWMA_CH1:  cap = HSPWMA_ReadCCR1Value();   break;
    case PWMA_CH2:  cap = HSPWMA_ReadCCR2Value();   break;
    case PWMA_CH3:  cap = HSPWMA_ReadCCR3Value();   break;
    case PWMA_CH4:  cap = HSPWMA_ReadCCR4Value();   break;
    case PWMB_CH5:  cap = HSPWMB_ReadCCR5Value();   break;
    case PWMB_CH6:  cap = HSPWMB_ReadCCR6Value();   break;
    case PWMB_CH7:  cap = HSPWMB_ReadCCR7Value();   break;
    case PWMB_CH8:  cap = HSPWMB_ReadCCR8Value();   break;
    default: cap = 0;
    }

    return cap;
}

////////////////////////////////////////
// 异步方式读取PWMA特殊功能寄存器
// 入口参数: addr: (PWMA特殊功能寄存器的低7位)
// 函数返回: 寄存器的值
////////////////////////////////////////;
uint8_t HSPWMA_ReadReg(uint8_t addr)
{
    uint8_t dat;

    while (HSPWMA_CheckBusy());         //等待前一个异步读写完成
    HSPWMA_AsyncRead(addr, dat);        //触发异步方式读取寄存器

    return dat;
}

////////////////////////////////////////
// 异步方式写PWMA特殊功能寄存器
// 入口参数: addr: (PWMA特殊功能寄存器的低7位)
//           dat: (待写入的数据)
// 函数返回: 无
////////////////////////////////////////;
void HSPWMA_WriteReg(uint8_t addr, uint8_t dat)
{
    while (HSPWMA_CheckBusy());         //等待前一个异步读写完成
    HSPWMA_AsyncWrite(addr, dat);       //触发异步方式写寄存器
}

////////////////////////////////////////
// 异步方式读取PWMB特殊功能寄存器
// 入口参数: addr: (PWMB特殊功能寄存器的低7位)
// 函数返回: 寄存器的值
////////////////////////////////////////;
uint8_t HSPWMB_ReadReg(uint8_t addr)
{
    uint8_t dat;

    while (HSPWMB_CheckBusy());         //等待前一个异步读写完成
    HSPWMB_AsyncRead(addr, dat);        //触发异步方式读取寄存器

    return dat;
}

////////////////////////////////////////
// 异步方式写PWMB特殊功能寄存器
// 入口参数: addr: (PWMB特殊功能寄存器的低7位)
//           dat: (待写入的数据)
// 函数返回: 无
////////////////////////////////////////;
void HSPWMB_WriteReg(uint8_t addr, uint8_t dat)
{
    while (HSPWMB_CheckBusy());         //等待前一个异步读写完成
    HSPWMB_AsyncWrite(addr, dat);       //触发异步方式写寄存器
}

////////////////////////////////////////
// USB库初始化函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void USBLIB_Init(void)
{
    usb_init();                         //初始化USB模块
    USB_SetIntPriority(0);              //设置中断为最低优先级
    set_usb_ispcmd("@STCISP#");         //设置USB不停电下载命令

    //<<AICUBE_USER_USBLIB_INITIAL_BEGIN>>
    // 在此添加用户初始化代码
    //<<AICUBE_USER_USBLIB_INITIAL_END>>
}

////////////////////////////////////////
// 等待USB配置完成函数
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void USBLIB_WaitConfiged(void)
{
    while (DeviceState != DEVSTATE_CONFIGURED) //等待USB完成配置
        WDT_Clear();                    //清看门狗定时器 (防止硬件自动使能看门狗)
}

////////////////////////////////////////
// USB设备接收数据处理程序
// 入口参数: 无
// 函数返回: 无
// bUsbOutReady：USB设备接收数据标志位
// OutNumber：USB设备接收到的数据长度
// UsbOutBuffer：保存USB设备接收到的数据
////////////////////////////////////////
void USBLIB_OUT_Done(void)
{
    if (bUsbOutReady)                   //查询是否有接收到USB主机发送数据
    {
        //<<AICUBE_USER_USBLIB_ISR_CODE1_BEGIN>>
        // 在此添加中断函数用户代码
        USB_SendData(UsbOutBuffer, OutNumber); // 原路返回, 用于测试
        // 在此处添加用户处理接收数据的代码
        //<<AICUBE_USER_USBLIB_ISR_CODE1_END>>
        usb_OUT_done();                 //当前包的数据处理完成,通知USB主机可以发送下一包数据
    }
}


////////////////////////////////////////
// 定时器0中断服务程序
// 入口参数: 无
// 函数返回: 无
////////////////////////////////////////
void TIMER0_ISR(void) interrupt TMR0_VECTOR
{
    //<<AICUBE_USER_TIMER0_ISR_CODE1_BEGIN>>
    // 在此添加中断函数用户代码
    if (!PWM1_Flag)
    {
        PWM1_Duty++;
        if (PWM1_Duty > PWM_PERIOD)
            PWM1_Flag = 1;
    }
    else
    {
        PWM1_Duty--;
        if (PWM1_Duty <= 0)
            PWM1_Flag = 0;
    }

    if (!PWM2_Flag)
    {
        PWM2_Duty++;
        if (PWM2_Duty > PWM_PERIOD)
            PWM2_Flag = 1;
    }
    else
    {
        PWM2_Duty--;
        if (PWM2_Duty <= 0)
            PWM2_Flag = 0;
    }

    if (!PWM3_Flag)
    {
        PWM3_Duty++;
        if (PWM3_Duty > PWM_PERIOD)
            PWM3_Flag = 1;
    }
    else
    {
        PWM3_Duty--;
        if (PWM3_Duty <= 0)
            PWM3_Flag = 0;
    }

    if (!PWM4_Flag)
    {
        PWM4_Duty++;
        if (PWM4_Duty > PWM_PERIOD)
            PWM4_Flag = 1;
    }
    else
    {
        PWM4_Duty--;
        if (PWM4_Duty <= 0)
            PWM4_Flag = 0;
    }

    UpdatePwm();
    //<<AICUBE_USER_TIMER0_ISR_CODE1_END>>
}


//<<AICUBE_USER_FUNCTION_IMPLEMENT_BEGIN>>
// 在此添加用户函数实现代码

//========================================================================
// 函数: UpdatePwm(void)
// 描述: 更新PWM占空比. 
// 参数: none.
// 返回: none.
// 版本: V1.0, 2012-11-22
//========================================================================
void UpdatePwm(void)
{
    PWM_UpdateDuty(PWMA_CH1, PWM1_Duty);
    PWM_UpdateDuty(PWMA_CH2, PWM2_Duty);
    PWM_UpdateDuty(PWMA_CH3, PWM3_Duty);
    PWM_UpdateDuty(PWMA_CH4, PWM4_Duty);
}

//<<AICUBE_USER_FUNCTION_IMPLEMENT_END>>


复制代码

CLis***

最后一课

CDC串口控制PWM（使用led灯模拟电机）

tmp_16 = atoi(UsbOutBuffer);
        printf_usb("tmp_16: %d\r\n", tmp_16);
        if (tmp_16 < 0)
        {
            // 反转
            PWM4_Duty = -tmp_16;
        }
        else
        {
            // 正转
            PWM4_Duty = tmp_16;
        }
        if (PWM4_Duty > PWM_RELOAD + 1)
        {
            PWM4_Duty = PWM_RELOAD + 1;
        }
        printf_usb("PWM4_Duty: %d\r\n", PWM4_Duty);
        if (PWM4_Duty == 0)
        {
            // 停止
            PWMA_DisablePWM4NOutput();
            PWMA_DisablePWM4POutput();
            P66 = 1;
            P67 = 1;
        }
        else if (tmp_16 > 0)
        {
            // 正转
            PWMA_EnablePWM4POutput();
            PWMA_DisablePWM4NOutput();
            PWMA_CC4PInverted(); // 开发板上led低电平导通
            P67 = 1;
        }
        else if (tmp_16 < 0)
        {
            // 反转
            PWMA_DisablePWM4POutput();
            PWMA_EnablePWM4NOutput();
            PWMA_CC4NInverted(); // 开发板上led低电平导通
            P66 = 1;
        }
        memset(UsbOutBuffer, 0, OutNumber);
复制代码