基于环形缓冲区的按键中断读取

已于 2023-10-24 21:40:29 修改
阅读量236 收藏
点赞数 5
分类专栏： STM32_基于Hal库 文章标签： 单片机 嵌入式硬件 stm32 mcu 物联网 1024程序员节
于 2023-10-24 21:36:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1981613393/article/details/134019831
版权

1.目标

        通过以前的学习，学习到了基础的GPIO输入和输出以及串口，接下来，通过一个小demo来学习引入外部中断。也就是通过按键设置外部中断来进行按键状态的读取，按键按下，LED灯亮起，按键松开，LED熄灭。

2.中断

2.1什么是中断

        中断是指计算机运行过程中，出现某些意外情况需主机干预时，机器能自动停止正在运行的程序并转入处理新情况的程序，处理完毕后又返回原被暂停的程序继续运行。 

2.2中断的流程

        1.设置中断源，允许指定的中断发生；

        2.设置中断控制器，例如屏蔽指定中断，例如设置允许发生的中断的优先等级；

        3.设置CPU中断总开关，使能中断； 执行一般程序；

        4.产生中断，硬件将中断信号发送给中断控制器，中断控制器再发给CPU让CPU知道发生了什么中断；

        5.CPU每执行完一句指令，都会去检查有无异常中断产生； 如果发现有异常中断发生，那么就会去处理异常中断；

2.3ARM对中断的处理        

        1.保存现场：将一般程序的当前执行地址、变量等保存到栈中；

        2.处理异常：通过异常中断信号跳转到保存在异常向量表中的中断服务函数开始执行中断；

        3.恢复现场：执行完中断处理程序之后，从栈中读取之前保存的数据，跳转到原本的执行地址开始执行一般程序；

2.4 中断优先级

        1.优先级数值越低，被执行的优先等级就越高；

        2.优先级分为：抢占优先级和子优先级； 抢占优先级数值低的中断可以打断正在执行的抢占优先级数值高的中断；

        3.子优先级只能决定同一时间产生的多个相同抢占优先级中断的执行顺序；

        4.当两个优先级数值一样的（不管是抢占还是子优先级）中断同时产生，那么则根据在异常向量表中的位置决定执行先后，越靠前的中断先被执行；

3.分析

        首先，在这个demo里，需要涉及到的是LED和按键，按键涉及到外部中断，其中外部中断有多种模式，因为需要实现的目的是按下和松开都变化状态，所以采用双边沿触发，也就是上升沿和下降沿都触发。虽然这个demo里，单片机只处理了这一件事情，但是我们要想象当单片机的处理器在运行时，双边沿触发外部中断，外部中断有对应的回调函数，这个demo里要做的就是，触发中断，读取按键的状态，然后控制LED的亮灭，按键按下，LED亮，按键松开，LED灭。

4.创建工程     

4.1配置老三样
4.2配置LED和按键

        设置PA0-PA3为外部中断模式，然后双边沿触发，设置PB12-PB15为输出模式，默认输出高电平，也就是默认LED初始是熄灭的状态。

4.3配置NVIC

        使能外部中断。

5.代码

5.1重构按键的代码

        引入外部中断，所有我们需要重新写Read函数，将正常的按键Read函数修改成GPIODrvIrqRead函数，写一个全局变量state作为标志位。

#define K1          \
{                   \
    .name   = "K1", \
    .port   = GPIOA,\
    .pin    = GPIO_PIN_0,  \
    .Init   = GPIODrvInit,   \
    .Write  = NULL,  \
    .Read   = GPIODrvIrqRead,   \
    .next   = NULL  \
}


static GPIO_PinState state = 1;

static int GPIODrvIrqRead(struct GPIODev *ptdev)
{
    if(NULL == ptdev)   return -EINVAL;
    return state;
 
}
5.2回调函数

        在外部中断的函数里，所有的外部中断公用一个回调函数，但是是通过输入的GPIO_Pin来区分是哪个外部中断，以及执行什么样的中断处理。

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    switch(GPIO_Pin)
    {
        case GPIO_PIN_0:    // PA0--K1
        {
            state = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
            break;
        }
        case GPIO_PIN_1:    // PA1--K2
        {
            break;
        }
        case GPIO_PIN_2:    // PA2--K3
        {
            break;
        }
        case GPIO_PIN_3:    // PA3--K4
        {
            break;
        }
        default:break;
    }
}
5.3 测试函数
#include "devices.h"
#include "errno.h"
#include "mytype.h"

void app_key_test(void)
{
    IODevicesRegister();
    
    GPIODevice *pK1 = IODeviceFind("K1");
    if(NULLDEV == pK1) return;
    GPIODevice *pD1 = IODeviceFind("D1");
    if(NULLDEV == pD1) return;
    
    if(pK1->Init(pK1) != ESUCCESS)  return;
    if(pD1->Init(pD1) != ESUCCESS)  return;
    while(1)
    {
        int status = pK1->Read(pK1);
        pD1->Write(pD1, status);
        
    }
}
5.4 main函数
#include "main.h"
#include "usart.h"
#include "gpio.h"

void SystemClock_Config(void);

extern void app_key_test(void);

int main(void)
{
  
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART1_UART_Init();

  app_key_test();

  while (1)
  {
  }
}
5.5逻辑分析

        首先初始化HAL库，初始化系统时钟，初始化GPIO，初始化串口（可以忽略不计）。然后调用app_key_test()，在app_key_test()函数中，首先寻找K1和D1设备，也就是按键1和LED1，接着对D1和K1进行初始化，然后轮询读取K1的状态，写一个全局变量state作为标志位，默认为1，也就是LED熄灭，当按键按下的时候，PA0口的状态为0，则LED亮，当按键松开的时候，PA0口的状态为1，则LED熄灭。

6.环形缓冲区

6.1什么是环形缓冲区

        环形缓冲区是一个先进先出（FIFO）的闭环的存储空间。通俗的理解为，在内存中规划了一块“圆形”的地，将该“圆形”进行N（Ring Buffer的大小）等分。

6.2 ring_buffer.c
#include "errno.h"
#include "libs.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

static int RingBufferWrite(struct RingBuffer *ptbuf, const unsigned char *src, unsigned int length);
static int RingBufferRead(struct RingBuffer *ptbuf, unsigned char *dst, unsigned int length);
static int RingBufferClear(struct RingBuffer *ptbuf);
static int RingBufferFree(struct RingBuffer *ptbuf);

/*
    函数名：RingBufferNew
    功能：初始化一个指定的环形缓冲区
    输入参数：ength->表示缓冲区分配的内存大小，单位是字节
    输出参数：无
    返回值：NULL->表示错误；ptbuf->表示成功得到一个buffer
*/
struct RingBuffer *RingBufferNew(unsigned int length)
{
    struct RingBuffer *ptbuf;
    if(0 == length)     return NULL;
    
    ptbuf = (struct RingBuffer*)malloc(sizeof(struct RingBuffer));
    if(NULL == ptbuf)   return NULL;
    if(NULL != ptbuf->info.pHead)
    {
        free(ptbuf->info.pHead);
    }
    ptbuf->info.pHead = (unsigned char*)malloc(length);
    if(NULL == ptbuf->info.pHead) 
    {
        xprintf("Error. Malloc %d bytes failed.\r\n", length);
        return NULL;
    }
    ptbuf->info.pValid = ptbuf->info.pValidEnd = ptbuf->info.pHead;
    ptbuf->info.pEnd = ptbuf->info.pHead + length;
    ptbuf->info.nValidLength = 0;
    ptbuf->info.nBufferLength = length;
    
    ptbuf->Write = RingBufferWrite;
    ptbuf->Read = RingBufferRead;
    ptbuf->Clear = RingBufferClear;
    ptbuf->Free = RingBufferFree;
    
    return ptbuf;
}

static int RingBufferFree(struct RingBuffer *ptbuf)
{
    if(ptbuf == NULL)           return -EINVAL;
    if(ptbuf->info.pHead==NULL) return -EINVAL;
    
    free((unsigned char*)ptbuf->info.pHead);
    
    ptbuf->info.pHead = NULL;
    ptbuf->info.pValid = NULL;
    ptbuf->info.pValidEnd = NULL;
    ptbuf->info.pEnd = NULL;
    ptbuf->info.nValidLength = 0;
    
    free((struct RingBuffer *)ptbuf);
    return ESUCCESS;
}

static int RingBufferWrite(struct RingBuffer *ptbuf, const unsigned char *src, unsigned int length)
{
    unsigned int len1 = 0, len2 = 0;
    unsigned int move_len = 0;
    
    if(length > ptbuf->info.nBufferLength)
    {
        return -EINVAL;
    }
    if(ptbuf->info.pHead==NULL)
    {
        return -EINVAL;
    }
    
    // copy buffer to pValidEnd
    if( (ptbuf->info.pValidEnd + length) > ptbuf->info.pEnd )  // 超过了Buffer范围需要分为两段
    {
        len1 = (unsigned)(ptbuf->info.pEnd - ptbuf->info.pValidEnd);
        len2 = length - len1;
        
        memcpy((unsigned char*)ptbuf->info.pValidEnd, src, len1);
        memcpy((unsigned char*)ptbuf->info.pHead, src + len1, len2);
        
        ptbuf->info.pValidEnd = ptbuf->info.pHead + len2;   // 更新有效数据区尾地址
    }
    else
    {
        memcpy((unsigned char*)ptbuf->info.pValidEnd, src, length);
        ptbuf->info.pValidEnd = ptbuf->info.pValidEnd + length;
    }
    
    // 重新计算已使用区的起始位置
    if( (ptbuf->info.nValidLength + length) > ptbuf->info.nBufferLength )     // 要写入的数据超过了缓冲区总长度，分为两段写
    {
        move_len = ptbuf->info.nValidLength + length - ptbuf->info.nBufferLength;
        if( (ptbuf->info.pValid + move_len) > ptbuf->info.pEnd )
        {
            len1 = (unsigned)(ptbuf->info.pEnd - ptbuf->info.pValid);
            len2 = move_len - len1;
            
            ptbuf->info.pValid = ptbuf->info.pHead + len2;
        }
        else
        {
            ptbuf->info.pValid = ptbuf->info.pValid + move_len;
        }
        
        ptbuf->info.nValidLength = ptbuf->info.nBufferLength;
    }
    else
    {
        ptbuf->info.nValidLength = ptbuf->info.nValidLength + length;
    }
    
    return (int)length;
}

static int RingBufferRead(struct RingBuffer *ptbuf, unsigned char *dst, unsigned int length)
{
    unsigned int len1 = 0, len2 = 0;
    if(ptbuf->info.pHead==NULL)     return -EINVAL;
    if(ptbuf->info.nValidLength==0) return -ENOMEM;
    
    if(length > ptbuf->info.nValidLength)
    {
        length = ptbuf->info.nValidLength;
    }
    
    if( (ptbuf->info.pValid + length) > ptbuf->info.pEnd )
    {
        len1 = (unsigned int)(ptbuf->info.pEnd - ptbuf->info.pValid);
        len2 = length - len1;
        
        memcpy(dst, (unsigned char*)ptbuf->info.pValid, len1);
        memcpy(dst + len1, (unsigned char*)ptbuf->info.pHead, len2);
        
        ptbuf->info.pValid = ptbuf->info.pHead + len2;
    }
    else
    {
        memcpy(dst, (unsigned char*)ptbuf->info.pValid, length);
        ptbuf->info.pValid = ptbuf->info.pValid + length;
    }
    
    ptbuf->info.nValidLength -= length;
    
    return (int)length;
}

static int RingBufferClear(struct RingBuffer *ptbuf)
{
    if(ptbuf == NULL)           return -EINVAL;
    if(ptbuf->info.pHead==NULL) return -EINVAL;
    if(ptbuf->info.pHead != NULL)
    {
        memset(ptbuf->info.pHead, 0, ptbuf->info.nBufferLength);
    }
    
    ptbuf->info.pValid = ptbuf->info.pValidEnd = ptbuf->info.pHead;
    ptbuf->info.nValidLength = 0;
    return ESUCCESS;
}
 6.2 ring_buffer.h
#ifndef __RING_BUFFER_H
#define __RING_BUFFER_H

typedef struct RingBuffInfo{
    unsigned char *pHead;
    unsigned char *pEnd;    
    unsigned char *pValid;    
    unsigned char *pValidEnd; 
    unsigned int  nBufferLength;
    unsigned int  nValidLength;   
}RingBuffInfo;

typedef struct RingBuffer{
    RingBuffInfo info;
    int         (*Write)(struct RingBuffer *ptbuf, const unsigned char *src, unsigned int length);
    int         (*Read)(struct RingBuffer *ptbuf, unsigned char *dst, unsigned int length);
    int         (*Clear)(struct RingBuffer *ptbuf);
    int         (*Free)(struct RingBuffer *ptbuf);
    struct RingBuffer *next;
}RingBuffer;

struct RingBuffer *RingBufferNew(unsigned int length);

#endif /* __DRV_BUFFER_H */

7.采用了环形缓冲区后的代码

7.1重构代码

        在GPIODev里加入value代表GPIO当时的状态。

typedef struct GPIODev{
    char *name;
    void *port;
    unsigned int pin;
    unsigned char value;
    int (*Init)(struct GPIODev *ptdev);
    int (*Write)(struct GPIODev *ptdev, unsigned char status);
    int (*Read)(struct GPIODev *ptdev);
    struct GPIODev *next;
}GPIODevice;
static RingBuffer *gK1Buffer = NULL;

static int GPIODrvInit(struct GPIODev *ptdev)
{
    if(NULL == ptdev)   return -EINVAL;
    
    if(strstr(ptdev->name, "K1"))
    {
        gK1Buffer = RingBufferNew(sizeof(unsigned char) * 10);
        if(NULL == gK1Buffer)   return -EIO;
    }
    
    return ESUCCESS;
}
static int GPIODrvIrqRead(struct GPIODev *ptdev)
{
    if(NULL == ptdev)   return -EINVAL;

    if(strstr(ptdev->name, "K1"))
    {
        if(NULL != gK1Buffer)
        {
            int ret = gK1Buffer->Read(gK1Buffer, (unsigned char*)&ptdev->value, 1);
            if(ret != 1)    return -EIO;
        }
    }
    
    return ESUCCESS;
}
7.2 回调函数
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    switch(GPIO_Pin)
    {
        case GPIO_PIN_0:    // PA0--K1
        {
            GPIO_PinState state = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
            if(NULL != gK1Buffer)
                gK1Buffer->Write(gK1Buffer, (unsigned char*)&state, 1);
            break;
        }
        case GPIO_PIN_1:    // PA1--K2
        {
           
        }
        case GPIO_PIN_2:    // PA2--K3
        {
            
        }
        case GPIO_PIN_3:    // PA3--K4
        {
           
        }
        default:break;
    }
}
7.3 测试函数
#include "devices.h"
#include "errno.h"
#include "mytype.h"

void app_key_test(void)
{
    IODevicesRegister();
    
    GPIODevice *pK1 = IODeviceFind("K1");
    if(NULLDEV == pK1) return;
    GPIODevice *pD1 = IODeviceFind("D1");
    if(NULLDEV == pD1) return;
    
    if(pK1->Init(pK1) != ESUCCESS)  return;
    if(pD1->Init(pD1) != ESUCCESS)  return;
    while(1)
    {
        int status = pK1->Read(pK1);
        if(ESUCCESS == status)
            pD1->Write(pD1, pK1->value);
    }
}

林奇老师
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
串口接收应用——环形缓冲buffer
李肖遥的专栏
07-28 670
在单片机开发过程中，如串口通讯中，大家往往会遇到数据传输有时候并发量很大，处理不过来导致数据丢失。实际如何确保数据不丢失？估计有点经验的朋友都会想到缓冲存储。对的，先将数据存储起来，再慢慢对数据做处理。...
ringbuff | 通用FIFO环形缓冲区实现库
Mculover666的博客（嵌入式）
06-06 6658
嵌入式开源项目精选专栏 本专栏由Mculover666创建，主要内容为寻找嵌入式领域内的优质开源项目，一是帮助开发者使用开源项目实现更多的功能，二是通过这些开源项目，学习大佬的代码及背后的实现思想，提升自己的代码水平，和其它专栏相比，本专栏的优势在于： 不会单纯的介绍分享项目，还会包含作者亲自实践的过程分享，甚至还会有对它背后的设计思想解读。 目前本专栏包含的开源项目有： cJSON | 一个轻量级C语言JSON解析器 paho | 支持10种语言编写mqtt客户端，总有一款适合你！ MultiButt.
STM32单片机采用环形缓冲区实现串口中断数据接收管理
10-13 1386
在嵌入式系统开发中，与上位机进行串口通信是非常常见的场景。上位机可以通过串口发送指令或者数据给嵌入式设备，而嵌入式设备需要可靠地接收并解析这些数据，以执行相应的操作。然而，在串口通信过程中，上位机发送数据的速率往往与嵌入式设备接收和处理数据的速率不一致，这就可能导致数据的丢失或者误解析。 为了解决这个问题，决定设计并实现一个环形缓冲区来进行数据接收管理。环形缓冲区是一种高效的数据结构，适用于数据产生速率快于消费速率的场景。它具有固定大小的缓冲区，并且可以循环利用空间，保证数据的连续存储和有效利用。
[缓存] RingBuff 环形队列、环形缓冲区及有锁无锁实现
小田的专栏
02-20 1684
由于自旋锁不需要进行线程切换，所以它完全在用户态下实现，加锁开销低，但是由于其采用忙等待的策略，对于短期加锁来说没问题，但是长期锁定的时候就会导致CPU资源的大量消耗。如果读取数据的速度跟不上写入数据的速度，旧的数据将被新写入的数据覆盖。所以当互斥锁加锁失败的时候，就伴随着两次上下文切换的开销，而如果我们锁定的时间较短，可能上下文切换的时间会比锁定的时间还要长。由于自旋锁和互斥锁的失败策略不同，自旋锁采用忙等待的策略，而互斥锁采用线程切换的策略，由于策略不同，它们的应用场景也不同。
STM32/GD32学习指南-踩坑之（三）环形buffer使用方法，环形缓存区的读取操作方法
qq_38584212的博客
07-14 1331
例如：现在有一个串口，接收到外部发来的数据，将其存入到环形buffer中，然后再从该环形buffer中将数据读取出来，进行一些帧格式、数据校验的操作，再从该串口发送出去。在处理接收数据时，经常使用到环形buffer存储数据进行处理，尤其是单片机中，内存本来就小，就需要节约内存的使用。Head：当前队列头部，也就是下次数据读取时的首地址，根据数据的存取状态，是动态变化的。Tail：当前队列尾，也就是下次数据写入时的首地址，根据数据的存取状态，是动态变化的。3. 读取环形buffer中的数据。
环形缓冲区(ring buffer)，环形队列(ring queue) 原理
wabil的专栏
12-23 1万+
1. 序言 环形缓冲区(ring buffer)，环形队列(ring queue) 多用于2个线程之间传递数据，是标准的先入先出(FIFO)模型。一般来说，对于多线程共享数据，需要使用mutex来同步，这样共享数据才不至于发生不可预测的修改/读取，然而，mutex的使用也带来了额外的系统开销，ring buffer/queue 的引入，就是为了有效地解决这个问题，因其特殊的结构及算法，可以用
GD32零基础教程第五节（使用环形缓冲区解决按键数据丢失问题）
m0_49476241的博客
04-09 572
本篇文章来讲解环形缓冲区，我们在这里会使用到环形缓冲区解决按键数据丢失的问题。环形缓冲区（Circular Buffer），也称为循环缓冲区或环形队列，是一种用于在计算机程序中临时存储数据的数据结构。它通常由一个固定大小的数组和两个指针组成，用于表示缓冲区的读取位置和写入位置。环形缓冲区可以循环利用内存空间，使得数据在缓冲区中被重复使用，而无需移动数据。固定大小的数组：环形缓冲区由一个固定大小的数组构成，该数组在内存中被分配一块连续的空间。这个数组的大小通常在初始化时确定，并且在整个生命周期中不会改变。
七、输入输出系统：用锁实现输出、编写键盘驱动程序、环形输入缓冲区
zhangyang249的博客
12-02 682
锁 多线程调度中出现了字符乱象，本质是访问公共资源需要很多步操作，但是这些操作不具备原子性，它被任务调度器给断开了，从而让其他线程有机会去破坏显存和光标寄存器这两类公共资源。 公共资源：公共内存、公共文件、公共硬件等，我们这里的是显存和光标寄存器 临界区：各个任务中访问公共资源的指令代码组成的区域就是临界区，，强调一下，临界区是指程序中那些访问公共资源的代码，即临界区是指令代码。 互斥：指
嵌入式学习——中断及串口通信进阶
qq_66144143的博客
10-22 949
定义：指处理机处理程序运行中出现的紧急事件的整个过程.程序运行过程中，系统外部、系统内部或者现行程序本身若出现紧急事件，处理机立即中止现行程序的运行，自动转入相应的处理程序(中断服务程序)，待处理完后，再返回原来的程序运行，这整个过程称为程序中断。定义：DMA，全称Direct Memory Access，即直接存储器访问。功能：DMA用来提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。无须CPU的干预，通过DMA数据可以快速地移动。这就节省了CPU的资源来做其他操作，
stm32f103_LL_key_FIFO.rar
07-19
3. 创建按键队列：可以使用环形缓冲区或者标准库提供的队列功能，确保队列的大小能够容纳预期的最大按键数量。 4. 中断服务程序：当检测到GPIO中断时，将按键事件加入队列，并清除中断标志。 5. 主循环或滴答定时器...
环形缓冲区（ringbuffer）
热门推荐
loveliu928的博客
03-29 1万+
环形缓冲区（ringbuffer） 环形缓冲区是嵌入式系统中十分重要的一种数据结构，比如在串口处理中，串口中断接收数据直接往环形缓冲区丢数据，而应用可以从环形缓冲区取数据进行处理，这样数据在读取和写入的时候都可以在这个缓冲区里循环进行，程序员可以根据自己需要的数据大小来决定自己使用的缓冲区大小。 环形缓冲区，顾名思义这个缓冲区是环形的，那么何谓环形这个意思也很好理解，就是用一个指针去访问该缓冲区的最后一个内存位置的的后一位置时回到环形缓冲区的起点。类似一个环一样 在此之前，我们来回顾一下队列的基本概念
基于单片机的智能防盗窗户的设计
lantiandianzi的博客
08-27 251
本设计是一种基于单片机的智能防盗窗户，采用STC89C52单片机作为核心控制器，配合DHT11温湿度传感器和MQ-2烟雾传感器等传感器和模块，用于收集室内环境数据，并通过单片机进行数据处理和控制。实现窗户状态的智能监测和防盗报警，能够自动识别窗户开启、关闭以及异常情况，并及时发出警报信号。
【STM32】BKP备份寄存器与RTC实时时钟
m0_75090944的博客
08-27 1040
BKP备份寄存器与RTC实时时钟代码
05：【江科大stm32】：定时器输出比较功能（PWM）
qq_51284092的博客
08-27 406
使用的是TB6612模块驱动电机。
NFC射频--天线设计
STM89C56的博客
08-27 537
如图3.3所示，13.56Mhz读卡器电路又两部分组成，其中引脚RX到引脚AGND部分区域是信号接收电路；引脚TX1到引脚TX2之间区域是信号发射电路。
嵌入式和单片机有什么区别？
weixin_61944480的博客
08-21 4313
嵌入式系统通常由电源、时基、数字处理、内存、软件和固件、专用集成电路、来自环境的输入、输出到环境、网络通信这几个元素组成。是：以应用为中心、以计算机技术为基础，软件硬件可裁剪，适应应用系统对功能、可靠性、成本、体积、功耗严格要求的专用计算机系统。嵌入式系统： 可以非常复杂，包括多个处理器、多个设备、多个软件组件等，用于执行复杂的任务，如汽车控制系统、医疗设备等。虽然有这些共同点，但嵌入式系统是一个更广泛的概念，可以包括各种形式的硬件和软件，而单片机是其中一种特定的实现形式。
分享推荐用于工业物联网单片机主控芯片
EVERSPIN的博客
08-27 345
1个12位ADC、2个比较器，1个I2C接口、1个I3C从机接口，2个SPI或I2S接口、4个UART接口、1个低功耗UART，1个USB接口，1个FlexCAN-FD接口，工作电压为2.0V∼5.5V，环境温度-40℃∼+85℃，工业级-40℃∼+105℃的扩展工业级（尾缀V），采用LQFP64、LQFP48和QFN32封装。该工业物联网单片机主控方案具有网络数据实时传输、支持丰富的通信端口、高可靠性，保证在工业复杂环境下能正常运行等应用特色。方案及技术支持洽RAMSUN。
基于CW2217B的库仑计硬件设计
最新发布
corlin6688的博客
08-30 330
CW2217B是一款适用于穿戴设备的超低功耗锂电池电量计芯片。芯片监测电池在充放电状态下的电压，电流和温度，运行专利“FastCali”电量计算法，结合电池建模信息，可准确计算电池的剩余电量。CW2217B适用于包括锂锰，锂钴和聚合物等多种类型的锂电池应用。• 14-bit模数转换器进行温度和电压检测。• 16-bit模数转换器进行电流检测。• 休眠模式 0.5μA。• 工作模式 12μA。• 应用于系统侧或电池包内。• 支持低至1mΩ的检流电阻。
【CanMV K230】外接传感器
咸鱼菌
08-27 1055
外接按键
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值