面包芯语

一个环形缓冲区的实现

嵌入式大杂烩 2022-03-19 21:57
迈来芯新一代经济型热成像技术 一场让你秒懂实时频谱分析的直播

这是一个模仿kfifo实现的环形缓冲区，Github仓库：

https://github.com/XinLiGitHub/RingBuffer

API 

RingBuffer *RingBuffer_Malloc(uint32_t size);
void RingBuffer_Free(RingBuffer *fifo);
uint32_t RingBuffer_In(RingBuffer *fifo, const void *in, uint32_t len);
uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
void RingBuffer_Reset(RingBuffer *fifo);
uint32_t RingBuffer_Size(RingBuffer *fifo);
uint32_t RingBuffer_Len(RingBuffer *fifo);
uint32_t RingBuffer_Avail(RingBuffer *fifo);
bool RingBuffer_IsEmpty(RingBuffer *fifo);
bool RingBuffer_IsFull(RingBuffer *fifo);

测试

main.c文件:

左右滑动查看全部代码>>>

/**
  ******************************************************************************
  * @file    main.c
  * @author  XinLi
  * @version v1.0
  * @date    15-January-2018
  * @brief   Main program body.
  ******************************************************************************
  * @attention
  *
  * 
Copyright © 2018 XinLi

  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see .
  *
  ******************************************************************************
  */
 
/* Header includes -----------------------------------------------------------*/
#include "RingBuffer.h"
#include 
#include 
 
/* Macro definitions ---------------------------------------------------------*/
/* Type definitions ----------------------------------------------------------*/
/* Variable declarations -----------------------------------------------------*/
/* Variable definitions ------------------------------------------------------*/
/* Function declarations -----------------------------------------------------*/
/* Function definitions ------------------------------------------------------*/
 
/**
  * @brief  Main program.
  * @param  None.
  * @return None.
  */
int main(void)
{
  uint8_t data[256] = {0};
 
  for(int i = 0; i < sizeof(data); i++)
  {
    data[i] = i;
  }
 
  RingBuffer *fifo = RingBuffer_Malloc(sizeof(data));
 
  if(fifo != NULL)
  {
    printf("FIFO创建成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
           RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
 
    if(RingBuffer_IsFull(fifo) == true)
    {
      printf("FIFO满了！！！\n");
    }
    else
    {
      printf("FIFO没满！！！\n");
    }
 
    if(RingBuffer_IsEmpty(fifo) == true)
    {
      printf("FIFO空了！！！\n");
    }
    else
    {
      printf("FIFO没空！！！\n");
    }
 
    printf("\n");
 
    for(;;)
    {
      {
        if(RingBuffer_In(fifo, data, sizeof(data) / 2) > 0)
        {
          printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
        else
        {
          printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
 
        if(RingBuffer_IsFull(fifo) == true)
        {
          printf("FIFO满了！！！\n");
        }
        else
        {
          printf("FIFO没满！！！\n");
        }
 
        if(RingBuffer_IsEmpty(fifo) == true)
        {
          printf("FIFO空了！！！\n");
        }
        else
        {
          printf("FIFO没空！！！\n");
        }
      }
 
      printf("\n");
 
      {
        uint8_t rdata[64] = {0};
        uint8_t len       = RingBuffer_Out(fifo, rdata, sizeof(rdata));
 
        if(len > 0)
        {
          printf("从FIFO中读出的数据，长度：%d\n", len);
 
          for(int i = 0; i < len; i++)
          {
            printf("%d ", rdata[i]);
          }
 
          printf("\n");
 
          printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
        else
        {
          printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
 
        if(RingBuffer_IsFull(fifo) == true)
        {
          printf("FIFO满了！！！\n");
        }
        else
        {
          printf("FIFO没满！！！\n");
        }
 
        if(RingBuffer_IsEmpty(fifo) == true)
        {
          printf("FIFO空了！！！\n");
        }
        else
        {
          printf("FIFO没空！！！\n");
        }
      }
 
      printf("\n");
 
      {
        RingBuffer_Reset(fifo);
        printf("FIFO清空成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
               RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
 
        if(RingBuffer_IsFull(fifo) == true)
        {
          printf("FIFO满了！！！\n");
        }
        else
        {
          printf("FIFO没满！！！\n");
        }
 
        if(RingBuffer_IsEmpty(fifo) == true)
        {
          printf("FIFO空了！！！\n");
        }
        else
        {
          printf("FIFO没空！！！\n");
        }
      }
 
      printf("\n");
 
      {
        if(RingBuffer_In(fifo, data, sizeof(data)) > 0)
        {
          printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
        else
        {
          printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
 
        if(RingBuffer_IsFull(fifo) == true)
        {
          printf("FIFO满了！！！\n");
        }
        else
        {
          printf("FIFO没满！！！\n");
        }
 
        if(RingBuffer_IsEmpty(fifo) == true)
        {
          printf("FIFO空了！！！\n");
        }
        else
        {
          printf("FIFO没空！！！\n");
        }
      }
 
      printf("\n");
 
      {
        if(RingBuffer_In(fifo, data, sizeof(data)) > 0)
        {
          printf("FIFO写入成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
        else
        {
          printf("FIFO写入失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
 
        if(RingBuffer_IsFull(fifo) == true)
        {
          printf("FIFO满了！！！\n");
        }
        else
        {
          printf("FIFO没满！！！\n");
        }
 
        if(RingBuffer_IsEmpty(fifo) == true)
        {
          printf("FIFO空了！！！\n");
        }
        else
        {
          printf("FIFO没空！！！\n");
        }
      }
 
      printf("\n");
 
      {
        uint8_t  rdata[256] = {0};
        uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
 
        if(len > 0)
        {
          printf("从FIFO中读出的数据，长度：%d\n", len);
 
          for(int i = 0; i < len; i++)
          {
            printf("%d ", rdata[i]);
          }
 
          printf("\n");
 
          printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
        else
        {
          printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
 
        if(RingBuffer_IsFull(fifo) == true)
        {
          printf("FIFO满了！！！\n");
        }
        else
        {
          printf("FIFO没满！！！\n");
        }
 
        if(RingBuffer_IsEmpty(fifo) == true)
        {
          printf("FIFO空了！！！\n");
        }
        else
        {
          printf("FIFO没空！！！\n");
        }
      }
 
      printf("\n");
 
      {
        uint8_t  rdata[256] = {0};
        uint16_t len        = RingBuffer_Out(fifo, rdata, sizeof(rdata));
 
        if(len > 0)
        {
          printf("从FIFO中读出的数据，长度：%d\n", len);
 
          for(int i = 0; i < len; i++)
          {
            printf("%d ", rdata[i]);
          }
 
          printf("\n");
 
          printf("FIFO读取成功，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
        else
        {
          printf("FIFO读取失败，FIFO大小：%d，使用大小：%d，剩余大小：%d\n",
                 RingBuffer_Size(fifo), RingBuffer_Len(fifo), RingBuffer_Avail(fifo));
        }
 
        if(RingBuffer_IsFull(fifo) == true)
        {
          printf("FIFO满了！！！\n");
        }
        else
        {
          printf("FIFO没满！！！\n");
        }
 
        if(RingBuffer_IsEmpty(fifo) == true)
        {
          printf("FIFO空了！！！\n");
        }
        else
        {
          printf("FIFO没空！！！\n");
        }
      }
 
      printf("\n\n\n");
      Sleep(5000);
    }
  }
  else
  {
    printf("FIFO创建失败\n");
  }
 
  for(;;)
  {
 
  }
}

运行结果：


程序源码

RingBuffer.h文件：

左右滑动查看全部代码>>>

/**
  ******************************************************************************
  * @file    RingBuffer.h
  * @author  XinLi
  * @version v1.0
  * @date    15-January-2018
  * @brief   Header file for RingBuffer.c module.
  ******************************************************************************
  * @attention
  *
  * 
Copyright © 2018 XinLi

  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see .
  *
  ******************************************************************************
  */
 
#ifndef __RINGBUFFER_H
#define __RINGBUFFER_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Header includes -----------------------------------------------------------*/
#include 
#include 
 
/* Macro definitions ---------------------------------------------------------*/
#define RING_BUFFER_MALLOC(size)  malloc(size)
#define RING_BUFFER_FREE(block)   free(block)
 
/* Type definitions ----------------------------------------------------------*/
typedef struct
{
  uint8_t *buffer;
  uint32_t size;
  uint32_t in;
  uint32_t out;
}RingBuffer;
 
/* Variable declarations -----------------------------------------------------*/
/* Variable definitions ------------------------------------------------------*/
/* Function declarations -----------------------------------------------------*/
RingBuffer *RingBuffer_Malloc(uint32_t size);
void RingBuffer_Free(RingBuffer *fifo);
uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
 
/* Function definitions ------------------------------------------------------*/
 
/**
  * @brief  Removes the entire FIFO contents.
  * @param  [in] fifo: The fifo to be emptied.
  * @return None.
  */
static inline void RingBuffer_Reset(RingBuffer *fifo)
{
  fifo->in = fifo->out = 0;
}
 
/**
  * @brief  Returns the size of the FIFO in bytes.
  * @param  [in] fifo: The fifo to be used.
  * @return The size of the FIFO.
  */
static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
{
  return fifo->size;
}
 
/**
  * @brief  Returns the number of used bytes in the FIFO.
  * @param  [in] fifo: The fifo to be used.
  * @return The number of used bytes.
  */
static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
{
  return fifo->in - fifo->out;
}
 
/**
  * @brief  Returns the number of bytes available in the FIFO.
  * @param  [in] fifo: The fifo to be used.
  * @return The number of bytes available.
  */
static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
{
  return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
}
 
/**
  * @brief  Is the FIFO empty?
  * @param  [in] fifo: The fifo to be used.
  * @retval true:      Yes.
  * @retval false:     No.
  */
static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
{
  return RingBuffer_Len(fifo) == 0;
}
 
/**
  * @brief  Is the FIFO full?
  * @param  [in] fifo: The fifo to be used.
  * @retval true:      Yes.
  * @retval false:     No.
  */
static inline bool RingBuffer_IsFull(RingBuffer *fifo)
{
  return RingBuffer_Avail(fifo) == 0;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* __RINGBUFFER_H */


RingBuffer.c文件：

左右滑动查看全部代码>>>

/**
  ******************************************************************************
  * @file    RingBuffer.c
  * @author  XinLi
  * @version v1.0
  * @date    15-January-2018
  * @brief   Ring buffer module source file.
  ******************************************************************************
  * @attention
  *
  * 
Copyright © 2018 XinLi

  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see .
  *
  ******************************************************************************
  */
 
/* Header includes -----------------------------------------------------------*/
#include "RingBuffer.h"
#include 
#include 
 
/* Macro definitions ---------------------------------------------------------*/
/* Type definitions ----------------------------------------------------------*/
/* Variable declarations -----------------------------------------------------*/
/* Variable definitions ------------------------------------------------------*/
/* Function declarations -----------------------------------------------------*/
static bool is_power_of_2(uint32_t x);
static uint32_t roundup_pow_of_two(uint32_t x);
 
/* Function definitions ------------------------------------------------------*/
 
/**
  * @brief  Allocates a new FIFO and its internal buffer.
  * @param  [in] size: The size of the internal buffer to be allocated.
  * @note   The size will be rounded-up to a power of 2.
  * @return RingBuffer pointer.
  */
RingBuffer *RingBuffer_Malloc(uint32_t size)
{
  RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
 
  if(fifo != NULL)
  {
    if(is_power_of_2(size) != true)
    {
      if(size > 0x80000000UL)
      {
        RING_BUFFER_FREE(fifo);
        fifo = NULL;
        return fifo;
      }
 
      size = roundup_pow_of_two(size);
    }
 
    fifo->size   = size;
    fifo->in     = 0;
    fifo->out    = 0;
    fifo->buffer = RING_BUFFER_MALLOC(fifo->size);
 
    if(fifo->buffer == NULL)
    {
      RING_BUFFER_FREE(fifo);
      fifo = NULL;
      return fifo;
    }
  }
 
  return fifo;
}
 
/**
  * @brief  Frees the FIFO.
  * @param  [in] fifo: The fifo to be freed.
  * @return None.
  */
void RingBuffer_Free(RingBuffer *fifo)
{
  RING_BUFFER_FREE(fifo->buffer);
  RING_BUFFER_FREE(fifo);
  fifo = NULL;
}
 
/**
  * @brief  Puts some data into the FIFO.
  * @param  [in] fifo: The fifo to be used.
  * @param  [in] in:   The data to be added.
  * @param  [in] len:  The length of the data to be added.
  * @return The number of bytes copied.
  * @note   This function copies at most @len bytes from the @in into
  *         the FIFO depending on the free space, and returns the number
  *         of bytes copied.
  */
uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
{
  len = min(len, RingBuffer_Avail(fifo));
 
  /* First put the data starting from fifo->in to buffer end. */
  uint32_t l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
  memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l);
 
  /* Then put the rest (if any) at the beginning of the buffer. */
  memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
 
  fifo->in += len;
 
  return len;
}
 
/**
  * @brief  Gets some data from the FIFO.
  * @param  [in] fifo: The fifo to be used.
  * @param  [in] out:  Where the data must be copied.
  * @param  [in] len:  The size of the destination buffer.
  * @return The number of copied bytes.
  * @note   This function copies at most @len bytes from the FIFO into
  *         the @out and returns the number of copied bytes.
  */
uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
{
  len = min(len, RingBuffer_Len(fifo));
 
  /* First get the data from fifo->out until the end of the buffer. */
  uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
  memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
 
  /* Then get the rest (if any) from the beginning of the buffer. */
  memcpy((uint8_t *)out + l, fifo->buffer, len - l);
 
  fifo->out += len;
 
  return len;
}
 
/**
  * @brief  Determine whether some value is a power of two.
  * @param  [in] x: The number to be confirmed.
  * @retval true:   Yes.
  * @retval false:  No.
  * @note   Where zero is not considered a power of two.
  */
static bool is_power_of_2(uint32_t x)
{
  return (x != 0) && ((x & (x - 1)) == 0);
}
 
/**
  * @brief  Round the given value up to nearest power of two.
  * @param  [in] x: The number to be converted.
  * @return The power of two.
  */
static uint32_t roundup_pow_of_two(uint32_t x)
{
  uint32_t b = 0;
 
  for(int i = 0; i < 32; i++)
  {
    b = 1UL << i;
 
    if(x <= b)
    {
      break;
    }
  }
 
  return b;
}


版权声明：本文来源网络，免费传达知识，版权归原作者所有。如涉及作品版权问题，请联系我进行删除。


猜你喜欢：

一个300多行代码实现的多任务管理的OS

一个实用的、可应用于单片机的内存管理模块

一个高效的界面开发解决方案

一个小巧好用的代码对比工具

 一个高性能通信库的简单使用分享

一个实用的头文件

一份嵌入式软件工具清单！

一组通用的Ｃ基础库

在公众号聊天界面回复1024，可获取嵌入式资源；回复 m ，可查看文章汇总。

点击阅读原文，查看更多分享。


登录阅读全文
免责声明： 该内容由专栏作者授权发布或作者转载，目的在于传递更多信息，并不代表本网赞同其观点，本站亦不保证或承诺内容真实性等。若内容或图片侵犯您的权益，请及时联系本站删除。侵权投诉联系：  nick.zong@aspencore.com！
嵌入式大杂烩 专注于嵌入式技术，包括但不限于C/C++、嵌入式、物联网、Linux等编程学习笔记，同时，内包含大量的学习资源。欢迎关注，一同交流学习，共同进步！
评论 （0）
  • 物质扩散与污染物监测系统全面解析
    　　物质扩散与污染物监测系统：环境守护的关键拼图 　　一、物质扩散原理剖析 　　物质扩散，本质上是物质在浓度梯度、温度梯度或者压力梯度等驱动力的作用下，从高浓度区域向低浓度区域迁移的过程。在环境科学范畴，物质扩散作为污染物在大气、水体以及土壤中迁移的关键机制，对污染物的分布态势、浓度动态变化以及环境风险程度有着直接且重大的影响。 　　应用案例 　　目前，已有多个物质扩散与污染物监测系统在实际应用中取得了显著成效。例如，北京华盛恒辉和北京五木恒润物质扩散与污染物监测系统。这些成功案例为物质
    华盛恒辉l58ll334744 2025-04-09 11:24 47浏览
  • 协议标准第009篇 瞬态过电压 Transient Voltage
        根据 IEC术语，瞬态过电压是指持续时间几个毫秒及以下的过高电压，通常是以高阻尼（快速衰减）形式出现，波形可以是振荡的，也可以是非振荡的。    瞬态过电压的成因和机理，IEC 60664-1给出了以下四种：    1. 自然放电，最典型的例子是雷击，感应到电力线路上，并通过电网配电系统传输，抵达用户端；        2. 电网中非特定感性负载通断。例如热处理工厂、机加工工厂对
    电子知识打边炉 2025-04-07 22:59 142浏览
  • 工业自动化中电磁兼容与接地系统软件全面解析
    　　工业自动化领域电磁兼容与接地系统深度剖析 　　一、电磁兼容(EMC)基础认知 　　定义及关键意义 　　电磁兼容性(EMC)，指的是设备或者系统在既定的电磁环境里，不但能按预期功能正常运转，而且不会对周边其他设备或系统造成难以承受的电磁干扰。在工业自动化不断发展的当下，大功率电机、变频器等设备被大量应用，现场总线、工业网络等技术也日益普及，致使工业自动化系统所处的电磁环境变得愈发复杂，电磁兼容(EMC)问题也越发严峻。 　　​电磁兼容三大核心要素 　　屏蔽：屏蔽旨在切断电磁波的传播路
    北京华盛恒辉软件开发 2025-04-07 22:55 230浏览
  • 全球化开启之年，周建掌舵的圆通出海业务折戟
    文/郭楚妤编辑/cc孙聪颖‍伴随贸易全球化的持续深入，跨境电商迎来蓬勃发展期，物流行业 “出海” 成为不可阻挡的必然趋势。加之国内快递市场渐趋饱和，存量竞争愈发激烈。在此背景下，国内头部快递企业为突破发展瓶颈，寻求新的增长曲线，纷纷将战略目光投向海外市场。2024 年，堪称中国物流企业出海进程中的关键节点，众多企业纷纷扬帆起航，开启海外拓展之旅。然而，在一片向好的行业发展表象下，部分跨境物流企业的经营状况却不容乐观。它们受困于激烈的市场竞争、不断攀升的运营成本，以及复杂的国际物流环境，陷入了微利
    华尔街科技眼 2025-04-09 15:15 74浏览
  • 智能语音新风尚：WTK6900语音识别芯片赋能未来家居，让凉爽触“声”可及
    在人工智能技术飞速发展的今天，语音交互正以颠覆性的方式重塑我们的生活体验。WTK6900系列语音识别芯片凭借其离线高性能、抗噪远场识别、毫秒级响应的核心优势，为智能家居领域注入全新活力。以智能风扇为起点，我们开启一场“解放双手”的科技革命，让每一缕凉风都随“声”而至。一、核心技术：精准识别，无惧环境挑战自适应降噪，听懂你的每一句话WTK6900系列芯片搭载前沿信号处理技术，通过自适应降噪算法，可智能过滤环境噪声干扰。无论是家中电视声、户外虫鸣声，还是厨房烹饪的嘈杂声，芯片均能精准提取有效指令，识
    广州唯创电子 2025-04-08 08:40 182浏览
  • HDMI2.1向下兼容设计
    HDMI从2.1版本开始采用FRL传输模式，和2.0及之前的版本不同。两者在物理层信号上有所区别，这就需要在一些2.1版本的电路设计上增加匹配电路，使得2.1版本的电路能够向下兼容2.0及之前版本。2.1版本的信号特性下面截取自2.1版本规范定义，可以看到2.1版本支持直流耦合和交流耦合，其共模电压和AVCC相关，信号摆幅在400mV-1200mV2.0及之前版本的信号特性HDMI2.0及之前版本采用TMDS信号物理层，其结构和参数如下：兼容设计根据以上规范定义，可以看出TMDS信号的共模电压范
    durid 2025-04-08 19:01 154浏览
  • 余承东卸任华为车BU董事长，曾直播说“智驾时可以睡觉”
    文/Leon编辑/侯煜‍就在小米SU7因高速交通事故、智驾性能受到质疑的时候，另一家中国领先的智驾解决方案供应商华为，低调地进行了一场重大人事变动。（详情见：雷军熬过黑夜，寄望小米SU7成为及时雨）4月4日上午，有网友发现余承东的职务发生了变化，华为官网、其个人微博认证信息为“常务董事，终端BG董事长”，不再包括“智能汽车解决方案BU董事长”。余承东的确不再兼任华为车BU董事长，但并非完全脱离华为的汽车业务，而是聚焦鸿蒙智行。据悉，华为方面寻求将车BU独立出去，但鸿蒙智行仍留在华为终端BG部门。
    华尔街科技眼 2025-04-09 15:28 68浏览
  • 网关对接DLT645电表开发记录
    ## DL/T645-2007* 帧格式：* 帧起始字符：68H* 地址域：A0 A1 A2 A3 A4 A5* 帧起始字符：68H* 控制码：1字节* 主站：* 13H：请求读电能表通信地址* 11H：请求读电能表数据* 1CH：请求跳闸、合闸* 从站：* 91H：正常应答读电能表* 9CH：正常应答跳闸、合闸* 数据域长度：1字节* 数据域：DI0 DI1 DI2 DI3* 发送方：每字节+33H* 接收方：每字节-33H* 数据标识：* 电能量* 最大需量及发生时间* 变量* 事件记录*
    四毛打印店 2025-04-09 10:53 49浏览
  • 4G智能报警器：WT2003H-16S低功耗语音芯片方案，实时音频上传
    在万物互联时代，智能化安防需求持续升级，传统报警系统已难以满足实时性、可靠性与安全性并重的要求。WT2003H-16S低功耗语音芯片方案，以4G实时音频传输、超低功耗设计、端云加密交互为核心，重新定义智能报警设备的性能边界，为家庭、工业、公共安防等领域提供高效、稳定的安全守护。一、技术内核：五大核心突破，构建全场景安防基座1. 双模音频传输，灵活应对复杂场景实时音频流传输：内置高灵敏度MIC，支持环境音实时采集，通过4G模块直接上传至云端服务器，响应速度低至毫秒级，适用于火灾警报、紧急呼救等需即
    广州唯创电子 2025-04-08 08:59 143浏览
  • 物质扩散与污染物监测系统软件：多领域环境守护的智能中枢
    　　物质扩散与污染物监测系统软件：多领域环境守护的智能中枢 　　北京华盛恒辉物质扩散与污染物监测系统软件，作为一款融合了物质扩散模拟、污染物监测、数据分析以及可视化等多元功能的综合性工具，致力于为环境科学、公共安全、工业生产等诸多领域给予强有力的技术支撑。接下来，将从功能特性、应用场景、技术实现途径、未来发展趋势等多个维度对这类软件展开详尽介绍。 　　应用案例 　　目前，已有多个物质扩散与污染物监测系统在实际应用中取得了显著成效。例如，北京华盛恒辉和北京五木恒润物质扩散与污染物监测系统。这
    华盛恒辉l58ll334744 2025-04-09 14:54 83浏览
  • 卫星图像智能测绘系统：地理空间数据处理的创新引擎
    　　卫星图像智能测绘系统：地理空间数据处理的创新引擎 　　卫星图像智能测绘系统作为融合卫星遥感、地理信息系统(GIS)、人工智能(AI)以及大数据分析等前沿技术的综合性平台，致力于达成高精度、高效率的地理空间数据采集、处理与应用目标。借助自动化、智能化的技术路径，该系统为国土资源管理、城市规划、灾害监测、环境保护等诸多领域输送关键数据支撑。 　　应用案例 　　目前，已有多个卫星图像智能测绘系统在实际应用中取得了显著成效。例如，北京华盛恒辉北京五木恒润卫星图像智能测绘系统。这些成功案例为卫星
    华盛恒辉l58ll334744 2025-04-08 16:19 77浏览
  • 卫星图像智能测绘系统软件全面解析
    　　卫星图像智能测绘系统全面解析 　　一、系统概述 　　卫星图像智能测绘系统是基于卫星遥感技术、图像处理算法与人工智能(AI)技术的综合应用平台，旨在实现高精度、高效率的地理空间数据获取、处理与分析。该系统通过融合多源卫星数据(如光学、雷达、高光谱等)，结合AI驱动的智能算法，实现自动化、智能化的测绘流程，广泛应用于城市规划、自然资源调查、灾害监测等领域。 　　应用案例 　　目前，已有多个卫星图像智能测绘系统在实际应用中取得了显著成效。例如，北京华盛恒辉和北京五木恒润卫星图像智能测绘系统
    华盛恒辉l58ll334744 2025-04-08 15:04 90浏览
我要评论
0
0
点击右上角，分享到朋友圈 我知道啦
请使用浏览器分享功能 我知道啦