ADI Blackfin DSP处理器-BF533的开发详解67：PCM的播放（含源码）

news2025/1/18 21:05:40

硬件准备

ADSP-EDU-BF533：BF533开发板
AD-HP530ICE：ADI DSP仿真器

软件准备

Visual DSP++软件

硬件链接

在这里插入图片描述

代码实现功能

代码实现了打开代码工程目录下的“test.snd”文件，并读取 6MB 的数据到内存中，然后将内存中的数据进行循环播放，实现播放 PCM 音乐的功能。将耳机插入绿色的音频接口，可以听到正在播放的音乐。

代码使用说明

代码采用了 SPORT 接口的描述符 DMA 实现，通过 SPORT 口以 I2S 方式，将音频数据送给音频解码芯片，由音频解码芯片将数据转为音乐信号输出。

代码实验步骤

  1. 在代码工程目录下存放了一个名为 test.snd 的声音文件，该文件可以由提供的 MP3 解码代码生成，也可以由 GoldWave 软件生成，文件格式必须为立体声 44.1KHz128Kbps 格式。
  2. 将耳机接入开发板上绿色的音频接口，板卡连接 VDSP 软件，编译并运行代码。
  3. 等待文件系统加载 PCM 数据，待数据加载完后，通过耳机能听到音乐输出。

通过耳机听到 PCM 数据音乐输出。

程序源码

audio.c

#include “i2c.h”
#include “audio_regdef.h”
#include <cdefBF533.h>

#define AIC23B_ADDRESS 0x34

static i2c_device mcu_i2c;

void init_aic23b(void);
int aic23b_write(unsigned char addr, unsigned char dat);
int aic23b_read(unsigned char addr, unsigned char * buf);
/****************************************************************************

  • 名称 ：aic23b_write
  • 功能 ： 写aic23b寄存器函数
  • 入口参数 ：addr:寄存器偏移地址
    dat:寄存器配置值
  • 出口参数 ：返回0
    ****************************************************************************/
    int aic23b_write(unsigned char addr, unsigned char dat)
    {
    int ret = -1;
    i2c_start(&mcu_i2c);
    if(i2c_write(&mcu_i2c, AIC23B_ADDRESS, 1)){
    i2c_stop(&mcu_i2c);
    return ret;
    }
    if(i2c_write(&mcu_i2c, addr, 1)){
    i2c_stop(&mcu_i2c);
    return ret;
    }
    i2c_write(&mcu_i2c, dat, 1);
    i2c_stop(&mcu_i2c);
    return 0;
    }

/****************************************************************************

  • 名称 ：aic23b_read
  • 功能 ： 读aic23b寄存器函数
  • 入口参数 ：addr:寄存器偏移地址
    buf:寄存器读取数据缓存
  • 出口参数 ：返回0
    ****************************************************************************/
    int aic23b_read(unsigned char addr, unsigned char * buf)
    {
    unsigned char *p = buf;
    int ret = -1;
    i2c_start(&mcu_i2c);
    //send slave address
    if(i2c_write(&mcu_i2c, AIC23B_ADDRESS, 1)){
    i2c_stop(&mcu_i2c);
    return ret;
    }
    //send sub-address of slave
    if(i2c_write(&mcu_i2c, addr, 1)){
    i2c_stop(&mcu_i2c);
    return ret;
    }
    i2c_stop(&mcu_i2c);
    i2c_start(&mcu_i2c);
    // send slave address (+1 read mode)
    if(i2c_write(&mcu_i2c, AIC23B_ADDRESS+1, 1)){
    i2c_stop(&mcu_i2c);
    return ret;
    }
    if(i2c_wait_slave(&mcu_i2c, 1000)){
    i2c_stop(&mcu_i2c);
    return ret;
    }
    i2c_read(&mcu_i2c, p++, 1); // send ack
    i2c_stop(&mcu_i2c);
    return 0;
    }

/****************************************************************************

  • 名称 ：Init_aic23b
  • 功能 ： 音频模块的内部初始化
  • 入口参数 ：无
  • 出口参数 ：无
    ****************************************************************************/

void init_aic23b(void)
{
unsigned char i;

mcu_i2c.sclk = PF0;         //时钟PF脚
mcu_i2c.sdata = PF1;        //数据PF脚
mcu_i2c.low_ns = 7000;      //低电平延时 ns
mcu_i2c.high_ns = 6000;     //高电平延时 ns	   
       
i2c_init(&mcu_i2c);	
aic23b_write(PWDC,0x000FF);   
aic23b_write(LLVC,0x1d);    
aic23b_write(RLVC,0x1d);    
aic23b_write(LHVC,0x73);   
aic23b_write(RHVC,0x73);  
aic23b_read(RHVC, i);   
aic23b_write(AAPC,DAC);
aic23b_write(DAPC,0);    
aic23b_write(PWDC,0);
aic23b_write(DAIF,MS|FOR|LRP);   
aic23b_write(SARC,0x23);        
aic23b_write(DIAC,ACT|RES);

}

cpu.c

#include <cdefBF533.h>

void Set_PLL(int pmsel,int pssel)
{
int new_PLL_CTL;
*pPLL_DIV = pssel;
asm(“ssync;”);
new_PLL_CTL = (pmsel & 0x3f) << 9;
*pSIC_IWR |= 0xffffffff;
if (new_PLL_CTL != *pPLL_CTL)
{
*pPLL_CTL = new_PLL_CTL;
asm(“ssync;”);
asm(“idle;”);
}
}

void Init_SDRAM(void)
{
*pEBIU_SDRRC = 0x00000817;
*pEBIU_SDBCTL = 0x00000013;
*pEBIU_SDGCTL = 0x0091998d;
ssync();
}

void Init_EBIU(void)
{
*pEBIU_AMBCTL0 = 0x7bb07bb0;
*pEBIU_AMBCTL1 = 0x7bb07bb0;
*pEBIU_AMGCTL = 0x000f;
}

void Setup_Flags(void)
{
*pFIO_INEN = 0x0020;
*pFIO_DIR = 0x001f;
*pFIO_EDGE = 0x0000;
*pFIO_MASKA_S = 0x0020;
*pFIO_POLAR = 0x0020;
}

i2c.c

#include <cdefBF533.h>
#include “i2c.h”

#define CORE_CLK_IN 24 * 1000 * 1000

#define SET_PF(pf)
do{
*pFIO_FLAG_S = (pf);
ssync();
}while(0)

#define CLR_PF(pf)
do{
*pFIO_FLAG_C = (pf);
ssync();
}while(0)

#define SET_PF_OUTPUT(pf)
do{
*pFIO_INEN &= ~(pf);
*pFIO_DIR |= (pf);
ssync();
}while(0)

#define SET_PF_INPUT(pf)
do{
*pFIO_DIR &= ~(pf);
*pFIO_INEN |= (pf);
ssync();
}while(0)

int get_core_clk(void)
{
int tempPLLCTL;
int _DF;
int VCO;
int MSEL1;

tempPLLCTL = *pPLL_CTL;


MSEL1 = ((tempPLLCTL & 0x7E00) >> 9);
_DF   =  tempPLLCTL & 0x0001;

VCO  = MSEL1 * __CORE_CLK_IN__;
if(_DF == 1)
	VCO /= 2;

return  VCO;

}
void delay_ns(unsigned int core_clock, unsigned long long count)
{
count *= core_clock;
count /= 1000000000;
while(count–);

}

int _get_sdata(i2c_device * dev)
{
return ((*pFIO_FLAG_D & dev->sdata) ? 1 : 0);
}

void i2c_init(i2c_device * dev)
{
dev->core_clock = get_core_clk();
dev->delay_ns = delay_ns;
*pFIO_DIR |= dev->sclk | dev->sdata;
ssync();
}

void i2c_deinit(i2c_device * dev)
{
dev->sclk = 0;
dev->sdata = 0;

*pFIO_DIR &=  ~(dev->sclk | dev->sdata);
ssync();

}

void i2c_start(i2c_device * dev)
{
SET_PF_OUTPUT(dev->sdata);
SET_PF_OUTPUT(dev->sclk);

SET_PF(dev->sdata);
SET_PF(dev->sclk);
delay_ns(dev->core_clock, dev->high_ns);

CLR_PF(dev->sdata);
delay_ns(dev->core_clock, dev->low_ns);

CLR_PF(dev->sclk);
delay_ns(dev->core_clock, dev->low_ns);

}

void i2c_stop(i2c_device * dev)
{
CLR_PF(dev->sclk);
delay_ns(dev->core_clock, dev->low_ns);

SET_PF_OUTPUT(dev->sdata);
CLR_PF(dev->sdata);
delay_ns(dev->core_clock, dev->low_ns);

SET_PF_INPUT(dev->sclk);
delay_ns(dev->core_clock, dev->high_ns);

SET_PF_INPUT(dev->sdata);
delay_ns(dev->core_clock, dev->high_ns);

}

int i2c_read_ack(i2c_device * dev)
{
int ret = 0;

SET_PF_INPUT(dev->sdata);
delay_ns(dev->core_clock, dev->high_ns/3);

SET_PF(dev->sclk);
delay_ns(dev->core_clock, dev->high_ns/3);

ret = _get_sdata(dev);

delay_ns(dev->core_clock, dev->high_ns/3);
CLR_PF(dev->sclk);

delay_ns(dev->core_clock, dev->low_ns);

SET_PF_OUTPUT(dev->sdata);
return ret;

}

int i2c_wait_slave(i2c_device * dev, unsigned int time_out)
{
int ret;
int count = time_out * 2 / dev->high_ns;

SET_PF_INPUT(dev->sclk);
delay_ns(dev->core_clock, dev->high_ns/2);

do{
	ret = *pFIO_FLAG_D & dev->sclk;
	if(ret)
	   break;
	delay_ns(dev->core_clock, dev->high_ns/2);
}while(count--);

SET_PF_OUTPUT(dev->sclk);
return !ret;

}

void i2c_write_ack(i2c_device * dev)
{
SET_PF_OUTPUT(dev->sdata);
CLR_PF(dev->sdata);
delay_ns(dev->core_clock, dev->high_ns/2);
SET_PF(dev->sclk);
delay_ns(dev->core_clock, dev->high_ns);

CLR_PF(dev->sclk);
delay_ns(dev->core_clock, dev->low_ns);

}

int i2c_write(i2c_device * dev, unsigned char value, int need_ack)
{
int ret = -1;
unsigned char index;

SET_PF_OUTPUT(dev->sdata);

//send 8 bits to slave
for(index = 0; index < 8; index++){
	//send one bit to the i2c bus
	if((value<<index) & 0x80){
		SET_PF(dev->sdata);
	} else {
		CLR_PF(dev->sdata);
	}
	
	delay_ns(dev->core_clock, dev->low_ns/2);
	
	SET_PF(dev->sclk);
	delay_ns(dev->core_clock, dev->high_ns);
	
	CLR_PF(dev->sclk);
	delay_ns(dev->core_clock, dev->low_ns/2);
}

if(need_ack){
	ret = i2c_read_ack(dev);
}
return ret;

}

int i2c_read(i2c_device * dev, unsigned char * value, int send_ack)
{
unsigned char index;
*value = 0x00;

SET_PF_INPUT(dev->sdata);
delay_ns(dev->core_clock, dev->high_ns/2);

//get 8 bits from the device
for(index = 0; index < 8; index++){
	SET_PF(dev->sclk);
	delay_ns(dev->core_clock, dev->high_ns/2);
	
	*value <<= 1;
	*value |= _get_sdata(dev);
	
	delay_ns(dev->core_clock, dev->high_ns/2);
	
	CLR_PF(dev->sclk);
	delay_ns(dev->core_clock, dev->low_ns);
}

// send ack to slave
if(send_ack){
	i2c_write_ack(dev);
}
return *value;

}

main.c

#include “sport.h”
#include <cdefBF533.h>

#define LIST_NUM 20

typedef struct
{
unsigned short NDPL; // next descriptor pointer (lower 16-bits)
unsigned short NDPH; // next descriptor pointer (upper 16-bits)
unsigned short SAL; // start address (lower 16-bits)
unsigned short SAH; // start address (upper 16-bits)
unsigned short CFG; // DMA config
unsigned short XCNT; // X Count
unsigned short XMOD; // X Mod
unsigned short YCNT; // Y Count
unsigned short YMOD; // Y Mod
} sDMA_Descriptor_Long;

extern sDMA_Descriptor_Long current_des[2];

unsigned char buffer[102410246];
extern volatile int current_play_buffer;
extern int current_play_index;
extern int current_addr;

typedef struct
{
int flag;
void * next;
sDMA_Descriptor_Long des;
} audio_list_t;
extern audio_list_t sport_output[LIST_NUM];
extern void * sport_output_ptr;
extern void * sport_input_ptr;

FILE *fp;

void main(void)
{
unsigned char* ptr;
Set_PLL(16,4);
Init_SDRAM();
Init_EBIU();

IIC_Enable();
init_aic23b();

printf("initialization is ok!\n");
fp = fopen("../test.snd", "rb");
printf("open pcm file!\n");
printf("read pcm data!\n");
fread(buffer, 1, 1024*1024*6, fp);
fclose(fp);
printf("read pcm data ok!\n");
Init_Interrupts();	
Init_Sport0_TX();			
Init_DMA2_Sport0_TX();			
Enable_DMA2_Sport0_TX();

ptr = buffer;
while(1)
{
	while(current_play_buffer > 15)
	{
	}
	((audio_list_t *)sport_input_ptr)->des.SAL = (unsigned long)ptr;
	((audio_list_t *)sport_input_ptr)->des.SAH = ((unsigned long)ptr)>>16;
	((audio_list_t *)sport_input_ptr)->des.CFG = 0x7900 | WDSIZE_16|DMAEN|DI_EN;
	((audio_list_t *)sport_input_ptr)->des.XCNT = 1024*16;
	((audio_list_t *)sport_input_ptr)->des.XMOD = 2;
	((audio_list_t *)sport_input_ptr)->flag = 1;
	sport_input_ptr = ((audio_list_t *)sport_input_ptr)->next;
	current_play_buffer ++;
	
	ptr += 1024*16*2;
	if(ptr==buffer+1024*1024*6)
		ptr = buffer;
};

}

sports.c

#include “sport.h”

typedef struct
{
unsigned short NDPL; // next descriptor pointer (lower 16-bits)
unsigned short NDPH; // next descriptor pointer (upper 16-bits)
unsigned short SAL; // start address (lower 16-bits)
unsigned short SAH; // start address (upper 16-bits)
unsigned short CFG; // DMA config
unsigned short XCNT; // X Count
unsigned short XMOD; // X Mod
unsigned short YCNT; // Y Count
unsigned short YMOD; // Y Mod
} sDMA_Descriptor_Long;

#define LINE_COUNT 1024*16
#define LIST_NUM 20

unsigned char mute_buffer[LINE_COUNT*2];

sDMA_Descriptor_Long des1;
sDMA_Descriptor_Long des2;

typedef struct
{
int flag;
void * next;
sDMA_Descriptor_Long des;
} audio_list_t;
audio_list_t sport_output[LIST_NUM];
void* sport_output_ptr, *sport_input_ptr;
sDMA_Descriptor_Long current_des[2], mute_des;
volatile int current_play_buffer = 0;
int current_play_index = 0;
int current_addr;

void Init_Interrupts(void)
{
register_handler(ik_ivg9, Sport0_TX_ISR);
*pSIC_IMASK = (*pSIC_IMASK | 0x00000400);
}

void Init_Sport0_TX()
{
*pSPORT0_TCR1 = TFSR |TCKFE ;
*pSPORT0_TCR2 = 15| TSFSE;
}

/
void Init_DMA2_Sport0_TX(void)
{
int i;
current_play_buffer = 0;
for(i=0; i<LINE_COUNT4; i++)
{
mute_buffer[i] = 0;
}
sport_output_ptr = (void)&sport_output[0];
sport_input_ptr = (void*)&sport_output[0];
sport_output[LIST_NUM-1].next = (void*)&sport_output[0];
for(i=0; i<LIST_NUM-1; i++)
{
sport_output[i].next = (void*)&sport_output[i+1];
sport_output[i].des.NDPL = (unsigned int)&sport_output[i].des;
sport_output[i].des.NDPH = (unsigned int)(&sport_output[i].des)>>16;
}
for(i=0; i<LIST_NUM; i++)
{
sport_output[i].flag = 0;
sport_output[i].des.SAL = (unsigned int)&mute_buffer;
sport_output[i].des.SAH = (unsigned int)(&mute_buffer)>>16;
sport_output[i].des.CFG = 0x7900 | WDSIZE_16|DMAEN|DI_EN;
sport_output[i].des.XCNT = LINE_COUNT;
sport_output[i].des.XMOD = 2;
}

mute_des.SAL = (unsigned int)&mute_buffer;
mute_des.SAH = (unsigned int)(&mute_buffer)>>16;
mute_des.CFG = 0x7900 | WDSIZE_16|DMAEN|DI_EN;
mute_des.XCNT = LINE_COUNT;
mute_des.XMOD = 2;

des1.NDPL = (unsigned int)&des2;
des1.NDPH = (unsigned int)(&des2)>>16;
des1.SAL = (unsigned int)&mute_buffer;
des1.SAH = (unsigned int)(&mute_buffer)>>16;
des1.CFG = 0x7900 | WDSIZE_16|DMAEN|DI_EN;
des1.XCNT = LINE_COUNT;
des1.XMOD = 2;

des2.NDPL = (unsigned int)&des1;
des2.NDPH = (unsigned int)(&des1)>>16;
des2.SAL = (unsigned int)&mute_buffer;
des2.SAH = (unsigned int)(&mute_buffer)>>16;
des2.CFG = 0x7900 | WDSIZE_16|DMAEN|DI_EN;
des2.XCNT = LINE_COUNT;
des2.XMOD = 2;

*pDMA2_NEXT_DESC_PTR = &des1;
asm("ssync;");
*pDMA2_CONFIG = 0x7900 | WDSIZE_16 | 0x20;
asm("ssync;");

}

void Enable_DMA2_Sport0_TX()
{
*pDMA2_CONFIG = (*pDMA2_CONFIG | DMAEN);
asm(“ssync;”);
*pSPORT0_TCR1 |= TSPEN;
asm(“ssync;”);
}

void Stop_DMA2_Sport0_TX(void)
{
*pDMA2_CONFIG &= ~DMAEN;
*pSPORT0_TCR1 &= ~TSPEN;

}

int mute_flag = 0;
//发送的中断程序
EX_INTERRUPT_HANDLER(Sport0_TX_ISR)
{
*pDMA2_IRQ_STATUS = 0x0001;

if(current_play_buffer == 0)
{
	if(mute_flag==1)
		printf("mute\n");
	if(*pDMA2_NEXT_DESC_PTR == &des1)
	{
		des1.SAL = mute_des.SAL;
		des1.SAH = mute_des.SAH;
		des1.CFG = mute_des.CFG;
		des1.XCNT = mute_des.XCNT;
		des1.XMOD = mute_des.XMOD;
	}else
	{
		des2.SAL = mute_des.SAL;
		des2.SAH = mute_des.SAH;
		des2.CFG = mute_des.CFG;
		des2.XCNT = mute_des.XCNT;
		des2.XMOD = mute_des.XMOD;
	}		
}else
{
	mute_flag = 1;
	if(*pDMA2_NEXT_DESC_PTR == &des1)
	{
		des1.SAL = ((audio_list_t *)sport_output_ptr)->des.SAL;
		des1.SAH = ((audio_list_t *)sport_output_ptr)->des.SAH;
		des1.CFG = ((audio_list_t *)sport_output_ptr)->des.CFG;
		des1.XCNT = ((audio_list_t *)sport_output_ptr)->des.XCNT;
		des1.XMOD = ((audio_list_t *)sport_output_ptr)->des.XMOD;
		((audio_list_t *)sport_output_ptr)->flag = 0;
	}else
	{
		des2.SAL = ((audio_list_t *)sport_output_ptr)->des.SAL;
		des2.SAH = ((audio_list_t *)sport_output_ptr)->des.SAH;
		des2.CFG = ((audio_list_t *)sport_output_ptr)->des.CFG;
		des2.XCNT = ((audio_list_t *)sport_output_ptr)->des.XCNT;
		des2.XMOD = ((audio_list_t *)sport_output_ptr)->des.XMOD;
		((audio_list_t *)sport_output_ptr)->flag = 0;
	}
	current_play_buffer --;
	sport_output_ptr = ((audio_list_t *)sport_output_ptr)->next;
}

}

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

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

相关文章

C语言重点解剖第17课笔记

C语言重点解剖第17课笔记

1.预处理阶段&#xff0c;先去注释&#xff0c;再宏替换。所以宏替换不能用于去注释。 #define bsc //就变成了一个空的宏。(//在这里面本来就是注释&#xff0c;只是注释后面的内容为空) 2.宏定义并不是简单的无脑替换。 printf(" ")中&#xff0c;双引号里面的东…
阅读更多...
uniCloud云开发----3、uniApp中文件上传（通过插件(uniFilePicker)或者 uniCloud.uploadFile实现方案）

uniCloud云开发----3、uniApp中文件上传（通过插件(uniFilePicker)或者 uniCloud.uploadFile实现方案）

uniApp中文件上传前言效果图1、使用unifilePicker插件&#xff08;1&#xff09;安装unifilePicker插件&#xff08;2&#xff09;简单案例2、通过原生的 uniCloud.uploadFile来实现共同成长共同进步前言 uniapp图片上传插件unifilePicker 在开发uniapp的时候上传文件是必不可…
阅读更多...
从月入5千到现在的月入1W+，会计转程序员，“谁说女的不适合学编程？”

从月入5千到现在的月入1W+，会计转程序员，“谁说女的不适合学编程？”

前言 我毕业五年了&#xff0c;但与技术和 Python 相关的工作经验也就两年。今天我想跟大家分享自己转行的故事&#xff0c;希望能够鼓励那些跟我一样的朋友共同前行。 我们将会聊到我个人的经历和入行故事&#xff0c;讨论快速学习的方法&#xff0c;最后推荐一些学习资源。…
阅读更多...
“互联网+”获奖项目专访 | 阿尔兹海默症患者辅助诊断研究分享

“互联网+”获奖项目专访 | 阿尔兹海默症患者辅助诊断研究分享

在本届“互联网”创新创业大赛中 昇思MindSpore群英荟萃团队荣获全国总决赛铜奖 本期有幸邀请到 团队负责人李鹏和指导老师胡悦进行采访 一起来看看夺奖背后的故事吧 PART ONE 团队介绍 群英荟萃团队 1. 项目成员 李鹏、周晨、邹静、纪雨萍、李晓迪、张英豪 2. 指导老…
阅读更多...
Insight Enterprises EDI 850 采购订单报文详解

Insight Enterprises EDI 850 采购订单报文详解

Insight Enterprises 是一家世界 500 强解决方案集成商&#xff0c;在全球拥有 11,500 多名员工&#xff0c;帮助企业加速数字化转型。Insight为管理其庞大的供应链建立了EDI&#xff08;Electronic Data Interchange&#xff0c;中文名称是电子数据交换&#xff09;系统&#…
阅读更多...
Android 进阶——Framework 核心之Touch事件分发机制详细攻略（一）

Android 进阶——Framework 核心之Touch事件分发机制详细攻略（一）

文章大纲引言一、Android 事件分发概述二、Touch事件分发的对象MotionEvent三、分发事件的核心对象及方法1、分发事件的核心对象2、事件分发的核心方法四、Touch事件分发的流程1、Activity的事件处理流程2、ViewGroup&View的事件分发流程五、事件分发的应用1、事件拦截2、响…
阅读更多...
刨根问底Kafka 40问，看看你能坚持到第几问

刨根问底Kafka 40问，看看你能坚持到第几问

Kafka最初是由Linkedin公司开发的&#xff0c;是一个分布式的、可扩展的、容错的、支持分区的&#xff08;Partition&#xff09;、多副本的&#xff08;replica&#xff09;、基于Zookeeper框架的发布-订阅消息系统&#xff0c;Kafka适合离线和在线消息消费。它是分布式应用系…
阅读更多...
【JavaSE】内部类

【JavaSE】内部类

目录 前言&#xff1a; 内部类 什么是内部类&#xff1f; 内部类的分类 1、静态内部类 1、静态内部类&#xff0c;不能直接被实例化 2、 静态内部类当中&#xff0c;不能直接访问外部类的非静态成员&#xff0c;但是可以直接访问外部类的静态成员。 3、外部类可以访问静…
阅读更多...
java -数据结构 - 集合框架及背后的数据结构

java -数据结构 - 集合框架及背后的数据结构

什么是集合框架 数据结构&#xff0c;我们知道数据结构就是组织数据的一种方式&#xff0c;比如所链表&#xff0c;就是将数据存储在链表的value域中&#xff0c;next域就是存储下一个节点的地址&#xff0c;通过这样的方式将数据组织起来。 在我们学习中&#xff0c;所知道 的…
阅读更多...
接口幂等实现基于注解(适用于分布式系统中支持spEl动态过滤)

接口幂等实现基于注解(适用于分布式系统中支持spEl动态过滤)

在网络卡顿时,容易出现在极短的时间内产生重复请求,或重复支付,一般我们会在数据操作时先通过数据查询是否存在,然后再进行业务逻辑操作的方式来进行避免,但是这种方式并不是原子性,很容易出现第一次请求未进行落表,第二次重复的请求就已经通过了数据库查询,可通过设置唯一索引…
阅读更多...
用于开发语音 AI 应用程序的 GPU 加速 SDK

用于开发语音 AI 应用程序的 GPU 加速 SDK

NVIDIA Riva 简介&#xff1a;用于开发语音 AI 应用程序的 GPU 加速 SDK 语音 AI 用于多种应用&#xff0c;包括联络中心的座席助理以增强人类座席的能力、智能虚拟助理 (IVA) 的语音界面以及视频会议中的实时字幕。 为了支持这些功能&#xff0c;语音 AI 技术包括自动语音识别…
阅读更多...
基于springboot的社区团购管理系统的设计与实现

基于springboot的社区团购管理系统的设计与实现

项目描述 临近学期结束&#xff0c;还是毕业设计&#xff0c;你还在做java程序网络编程&#xff0c;期末作业&#xff0c;老师的作业要求觉得大了吗?不知道毕业设计该怎么办?网页功能的数量是否太多?没有合适的类型或系统?等等。这里根据疫情当下&#xff0c;你想解决的问…
阅读更多...
FineReport企业报表工具-JS根据条件显示参数控件

FineReport企业报表工具-JS根据条件显示参数控件

1. 概述 1.1 版本 报表服务器版本 功能变更 11.0 -- 1.2 问题描述 在使用参数控件时&#xff0c;有时我们希望部分参数控件在没满足条件时不显示&#xff0c;满足条件后再显示&#xff0c;如下图效果&#xff0c;只有前面的下拉框选择了内容之后&#xff0c;后一层下拉框控…
阅读更多...
【C语言】重要函数qsort函数的用法

【C语言】重要函数qsort函数的用法

目录 一、qsort函数的介绍 1、整形数组 2、字符数组 3、字符串 4、结构体 二、qsort函数的使用 一、qsort函数的介绍 qsort函数是一种底层快速排序的函数&#xff0c;它的特点就是可以排序任意类型的数据&#xff0c;比如&#xff1a;整形、字符串、浮点型、以及结构体类型。 …
阅读更多...
VUE3-组件之间传值《四》

VUE3-组件之间传值《四》

目录 一.父传子&#xff0c;父组件向子组件传值 二.子传父&#xff0c;子组件向父组件传值 三.兄弟组件之间互传&#xff0c;2个组件之间是平级关系&#xff0c;互相传值 组件之间的传值&#xff0c;分为3种方式 一.父传子&#xff0c;父组件向子组件传值 1.建立一个默认的…
阅读更多...
零信任深入理解--概念，架构和实现方案

零信任深入理解--概念，架构和实现方案

1. 零信任究竟解决了什么问题&#xff1f; 很多人在初步了解“零信任”概念&#xff0c;乃至进一步研究一些技术和产品方案之后&#xff0c;会有种“不过如此”的感觉。 毕竟&#xff0c; IAM&#xff08;Identity and Access Management&#xff0c;身份识别与访问管理&…
阅读更多...
6. 【gRPC系列学习】Balance原理详解

6. 【gRPC系列学习】Balance原理详解

本节开始分析Balance执行原理，通过上面流程可知，Balance Build的创建来自于Resolver的解析完成后调用updateResolverState方法，我们从updateResolverState方法开始分析Balance执行流程。 1. Balance调用流程 1）updateResolverState(s resolver.State, err error) error 方…
阅读更多...
Java培训MySQL之全局序列

Java培训MySQL之全局序列

1.本地文件 不推荐&#xff0c;存在宕机序列丢失问题。 2.数据库方式 数据库序列方式原理 利用数据库一个表 来进行计数累加。但是并不是每次生成序列都读写数据库&#xff0c;这样效率太低。 mycat会预加载一部分号段到mycat的内存中&#xff0c;这样大部分读写序列都是在…
阅读更多...
第二章：Linux的目录结构-[基础篇]

第二章：Linux的目录结构-[基础篇]

一&#xff1a;基础介绍 linux的文件系统是采用级层式的数状目录结构&#xff0c;在此结构中的最上层是根目录“/”&#xff0c;然后在此目录下再创建其他的目录。 深刻理解linux树状文件目录是非常重要的&#xff0c;这里我给大家说明一下。 记住一句经典的话&#xff1a;在Li…
阅读更多...
通信原理循环码

通信原理循环码

目录 码多项式 码多项式的按模运算 循环码的码多项式 循环码的生成矩阵 如何寻求任一循环码循环码的生成多项式​ 码多项式 一个长度为的码组可表示成如下多项式形式&#xff1a; 多项式的系数就是码组中的各码元&#xff0c;仅是码元位置标记 。 n7 时&#xff1a; 例&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023