关于DMA到存储器发送数据速率的一道题。。。 30C

一台计算机包括一个CPU和一台I/O设备D,通过一条共享总线连接到主存储器M,数据总线的宽度为1个字。CPU每秒最多可执行106条指令,平均每条指令需要5个机器周期,其中3个周期需要使用存储器总线。存储器读/写操作使用1个机器周期。假设CPU正在连续不断地执行后台程序,并且需要保证95%的指令执行速度,但没有任何I/O指令。假设1个处理器周期等于1个总线周期,现在要在M和D之间传送大块数据。
a.若使用程序控制I/O,I/O每传送1个字需要CPU执行两条指令。请估计通过D的I/O数据传送的最大可能速度。
b.如果使用DMA传送,请估计传送速度。
答案:a.处理器只能分配5%的时间给I/O.所以最大的I/O指令传送速度是10e6×0.05=50000条指令/秒。因此I/O的传送速率是25000字/秒。
b.使用DMA控制时,可用的机器周期下的数量是
10e6(0.05×5+0.95×2)=2.15×10e6
如果我们假设DMA模块可以使用所有这些周期,并且忽略任何设置和状态检查时间,那么这个值就是最大的I/O传输速率。

我很是不明白b的答案是怎么得到的...

1个回答

CPU每秒最多可执行106条指令
排版的问题,应该是10e6(10的6次方)
5%的情况下,5个时钟,95%的情况下,异步,2个时钟,读写各一个

sinat_30787967
wenxiao li 还是不懂,5个时钟?可其中有3个是使用的存储器总线,并没有写操作啊?能详细解释下吗?
4 年多之前 回复
sinat_30787967
wenxiao li 还是不懂,5个时钟?可其中有3个是使用的存储器总线,并没有写操作啊?能详细解释下吗?
4 年多之前 回复
sinat_30787967
wenxiao li 还是不懂,5个时钟?可其中有3个是使用的存储器总线,并没有写操作啊?能详细解释下吗?
4 年多之前 回复
sinat_30787967
wenxiao li 还是不懂,5个时钟?可其中有3个是使用的存储器总线,并没有写操作啊?能详细解释下吗?
4 年多之前 回复
sinat_30787967
wenxiao li 还是不懂,5个时钟?可其中有3个是使用的存储器总线,并没有写操作啊?能详细解释下吗?
4 年多之前 回复
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
如何用DMA方式发送数据(网络发送)

如何使DMA方式获得的数据通过lwip直接发送出去?中间不仅过别的软件

stm32f407 DMA接收、发送问题

进行串口收发时,可以发送数据,但是DMA无法读取数据,配置看了好几遍,不知道哪里出现了问题,特意贴个代码,希望大家帮忙看看 #include "stm32f4xx.h" #include "myconst.h" #include "myfunction.h" #include <stdio.h> #include "eeprom.h" extern uint8_t uploaddata[10]; extern uint8_t usart1_dma_received[55]; extern uint8_t usart1_dma_flag; //Óë´«¸ÐÐÅÏ¢°åͨÐŵĴ®¿Ú£ºPA9---TX; PA10---RX //½ÓÊÕ´«¸Ð°å·¢À´µÄ59¸ö×Ö½Ú£º3A+A3+±ÚÕÏ2¸ö×Ö½Ú+µçÁ¿2¸ö×Ö½Ú+¹ßµ¼12¸ö×Ö½Ú+GPS39¸ö×Ö½Ú+Éî¶È2¸ö×Ö½Ú //Ïò´«¸Ð°å·¢ËÍË®ÖÊÐÅÏ¢£º10¸ö×Ö½Ú£ºA4+phÖµ2¸ö×Ö½Ú+µçµ¼ÂÊ3¸ö×Ö½Ú+ζÈ2¸ö×Ö½Ú+0A+0D; void USART1_Configuration(void) { USART_InitTypeDef USART_InitStructure; GPIO_InitTypeDef GPIO_InitStructure; DMA_InitTypeDef DMA_InitStructure; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1); GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1); USART_InitStructure.USART_BaudRate = 115200; USART_InitStructure.USART_WordLength = USART_WordLength_8b; USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_Init(USART1, &USART_InitStructure); USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); USART_ClearFlag(USART1, USART_FLAG_TC); USART_Cmd(USART1, ENABLE); /*DMA·¢ËÍÅäÖÃ*/ DMA_DeInit(DMA2_Stream7); DMA_StructInit( &DMA_InitStructure); DMA_InitStructure.DMA_Channel = DMA_Channel_4; DMA_InitStructure.DMA_PeripheralBaseAddr =USART1_DR_Base; DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)0; DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; DMA_InitStructure.DMA_BufferSize = 8; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(DMA2_Stream7, &DMA_InitStructure); DMA_ITConfig(DMA2_Stream7, DMA_IT_TC, ENABLE); USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE); DMA_ClearITPendingBit(DMA2_Stream7, DMA_IT_TCIF7); /*DMA ½ÓÊÕÊý¾ÝÉèÖÃ*/ DMA_DeInit(DMA2_Stream5); DMA_StructInit(&DMA_InitStructure); DMA_InitStructure.DMA_Channel = DMA_Channel_4; //Ñ¡ÔñChannel_5 DMA_InitStructure.DMA_PeripheralBaseAddr =USART1_DR_Base; //Êý¾Ý´«ÊäµÄÍâÉèÊ×µØÖ·£¬Ïê½â¼ûÉÏ DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)(&usart1_dma_received[0]); //×Ô¼º¶¨Òå´ý·¢ËÍÊý×éµÄÊ×µØÖ·£¬ÒªÇ¿ÖÆת»»Îª32λ DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory; //Êý¾Ý´«Êä·½ÏòÑ¡ÔñΪÄÚ´æ<-ÍâÉè DMA_InitStructure.DMA_BufferSize =8; //´«ÊäÊý¾Ý´óСΪ8£¬µ¥Î»ÓÉÒÔÏÂÈ·¶¨£¬´óСҪÅäºÏ¶¨ÒåµÄÊý×éÀàÐͺÍÍâÉèÊý¾ÝÀàÐÍ DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //ÍâÉèµØÖ·¼Ä´æÆ÷×Ô¶¯Ôö¼Ó½ûÖ¹£¬ÒòΪÕâÀïÖ»Óõ½ÁËDRÊý¾Ý¼Ä´æÆ÷ DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //ÄÚ´æµØÖ·×ÔÔöÔÊÐí£¬ÒòΪҪ¶ÁÈ¡Ò»¸öÊý×é DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //ÍâÉèµÄÊý¾Ý´óС£¬ÒòΪUSART6_DRÊý¾Ý¼Ä´æÆ÷Ϊ8Ϊ£¬¹ÊÑ¡Byte DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //ÕâÀïҲѡByte DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //DMA´«ÊäģʽΪNormal£¬Èç¹ûΪCircular,½«»áÑ­»·´«Êä DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; //ÓÅÏȼ¶ÎªHigh DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(DMA2_Stream5, &DMA_InitStructure); //DMA_ITConfig(DMA2_Stream5, DMA_IT_TC, ENABLE); DMA_ClearITPendingBit(DMA2_Stream5, DMA_IT_TCIF5); USART_DMACmd(USART1,USART_DMAReq_Rx, ENABLE); DMA_Cmd(DMA2_Stream5, ENABLE); } /*dma ½ÓÊÕÖжÏ*/ void DMA2_Stream5_IRQHandler(void) { if (DMA_GetITStatus(DMA2_Stream5, DMA_IT_TCIF5) != RESET) { DMA_Cmd(DMA2_Stream5, DISABLE); DMA_ClearITPendingBit(DMA2_Stream5, DMA_IT_TCIF5); USART_DMACmd(USART1, USART_DMAReq_Rx, DISABLE); usart1_dma_flag=1; } } //USART1 DMA ·¢ËÍÖÐ¶Ï void DMA2_Stream7_IRQHandler(void) { if (DMA_GetITStatus(DMA2_Stream7, DMA_IT_TCIF7) != RESET) //·¢ËÍÍê³É { DMA_ClearITPendingBit(DMA2_Stream7, DMA_IT_TCIF7); USART_DMACmd(USART1, USART_DMAReq_Tx, DISABLE); DMA_Cmd(DMA2_Stream7, DISABLE); } } void UASRT1_DMA_Senddata(u32 par,u16 ndtr) { DMA_Cmd(DMA2_Stream7, DISABLE); DMA2_Stream7->M0AR = (uint32_t)(par); DMA2_Stream7->NDTR = ndtr; DMA_Cmd(DMA2_Stream7, ENABLE); USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE); } void USART1_IRQHandler(void) { if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //ÅжÏΪ½ÓÊÕÖÐ¶Ï { // uint8_t Received; // float angle_temp=0; // Received = USART_ReceiveData(USART1); // USART_SendData(USART1,Received); // usart1_dma_flag=1; USART_ClearITPendingBit(USART1,USART_IT_RXNE); } } int main(void) { while(1) if(usart1_dma_flag==1)//Êý¾Ý½ÓÊÜ { //......... DMA_Cmd(DMA2_Stream5, ENABLE); USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE); } } void NVIC_Config() { NVIC_InitTypeDef NVIC_InitStructure; /* Enable the USARTx Interrupt */ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); ////// NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); ////// NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); ////// NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //ǶÌ×ÓÅÏȼ¶·Ö×éΪ 1 NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream5_IRQn; //ǶÌ×ͨµÀΪDMA2_Stream7_IRQn NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; //ÇÀÕ¼ÓÅÏȼ¶Îª 1 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //ÏìÓ¦ÓÅÏȼ¶Îª 0 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //ͨµÀÖжÏʹÄÜ NVIC_Init(&NVIC_InitStructure); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //ǶÌ×ÓÅÏȼ¶·Ö×éΪ 1 NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream7_IRQn; //ǶÌ×ͨµÀΪDMA2_Stream7_IRQn NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; //ÇÀÕ¼ÓÅÏȼ¶Îª 1 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 4; //ÏìÓ¦ÓÅÏȼ¶Îª 0 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //ͨµÀÖжÏʹÄÜ NVIC_Init(&NVIC_InitStructure); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); ////// NVIC_InitStructure.NVIC_IRQChannel = USART6_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 5; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); //ǶÌ×ÓÅÏȼ¶·Ö×éΪ 1 NVIC_InitStructure.NVIC_IRQChannel = DMA2_Stream1_IRQn; //ǶÌ×ͨµÀΪDMA2_Stream7_IRQn NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; //ÇÀÕ¼ÓÅÏȼ¶Îª 1 NVIC_InitStructure.NVIC_IRQChannelSubPriority = 6; //ÏìÓ¦ÓÅÏȼ¶Îª 0 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //ͨµÀÖжÏʹÄÜ NVIC_Init(&NVIC_InitStructure); // // NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); // ÇÀռʽÓÅÏȼ¶±ð // NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;//Ö¸¶¨ÖжÏÔ´ // NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; // NVIC_InitStructure.NVIC_IRQChannelSubPriority = 7;// Ö¸¶¨ÏìÓ¦ÓÅÏȼ¶±ð1 // NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // NVIC_Init(&NVIC_InitStructure); // NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); // ÇÀռʽÓÅÏȼ¶±ð NVIC_InitStructure.NVIC_IRQChannel = TIM1_UP_TIM10_IRQn;//Ö¸¶¨ÖжÏÔ´ NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 7;// Ö¸¶¨ÏìÓ¦ÓÅÏȼ¶±ð1 NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); // ÇÀռʽÓÅÏȼ¶±ð NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); }

野火 RTT 改的 三个串口 dma 接收 接收后处理数据,但是串口一直不能正常发送数据

野火 RTT 改的 三个串口 dma 接收 接收后处理数据,但是串口一直不能正常发送数据 Uart2 Uart3 都有问题,请赐教,确实没有分了 ** 调用 ** RS485_SEND_EN(ON); rt_thread_delay(200); Usart_SendString(RS485_USARTx,Uart3Send); Usart_SendCharCount(RS485_USARTx,Uart3Send,10); **一直停在这里 while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)**

DMA传输后,拷贝DMA缓冲区数据时出错

Windows下 WDM 驱动 应用程序需要读取PCI卡(PCI9054)的数据 在驱动的读请求处理例程中 1、启动DMA传输将卡中的数据读取到驱动的缓冲区A中, 2、然后将数据复制到读请求的缓冲区B, 3、并将缓冲区A中的最后四个字节记录到缓冲区C中。 为了调试方便,我将缓冲区A初始化为“#” 现在的问题是: 读请求处理完成后,缓冲区B中的数据有时候会是“#”,而缓冲区C中的数据是对的 在第2步之前加1ms的延时,出错的概率会减小

关于pcie dma传输的问题

小弟最近在做pcie dma传输的程序,现在碰到一个很奇怪的问题。程序要实现对dma传输 12m的数据。程序轮训传输12m数据,但程序传输了几次12m数据后,dma传输函数会返回ApiDmaInProgress dma。 程序: int Dma(PLX_DEVICE_OBJECT *pDevice, char *pUserBuffer, int UserBufferLen, int wr_addr) { U8 DmaChannel; U16 ChannelInput; PLX_STATUS rc; PLX_DMA_PROP DmaProp; PLX_DMA_PARAMS DmaParams; PLX_PHYSICAL_MEM PciBuffer; int count = 0; int len = 0; int cpld_idea = 0; int data_value = 0; int dma_count = 0; int retry_times = 0; int ret = 0; char *buffer = NULL; int j = 0; int offset = 0; ChannelInput = 0; DmaChannel = (U8)ChannelInput; buffer = (char *)malloc(4096); if(buffer == NULL) { Cons_printf("xbuffer malloc memory err\n"); return ERR_MALLOC_MEM_ERR; } count = UserBufferLen / 4096; offset = UserBufferLen % 4096; // Get DMA buffer parameters //ret = Read_Cpld_Idea(pDevice, &cpld_idea); rc = PlxPci_DeviceReset(pDevice); if (rc != ApiSuccess) { Cons_printf("*ERROR* - API failed to reset\n"); ret = ERR_OPEN_DMA_FAIL; } //cpld_idea = 0; //ret = Read_Cpld_Idea(pDevice, &cpld_idea); rc = PlxPci_CommonBufferProperties(pDevice,&PciBuffer); if (rc != ApiSuccess) { Cons_printf("*ERROR* - API failed\n"); ret = ERR_OPEN_DMA_FAIL; } // Clear DMA structure memset(&DmaProp, 0, sizeof(PLX_DMA_PROP)); // Initialize the DMA channel DmaProp.LocalBusWidth = 3; // 32-bit DmaProp.ReadyInput = 1; DmaProp.ConstAddrLocal = 1; rc =PlxPci_DmaChannelOpen(pDevice,DmaChannel,&DmaProp); if (rc != ApiSuccess) { Cons_printf("*ERROR* - API failed\n"); ret = ERR_OPEN_DMA_FAIL; } // Clear DMA data for(j = 0; j < count + 1; j++) { Delay_Us(50); if(j == count) { len = offset; } else { len = 4096; } memset(buffer, 0, 4096); memcpy(buffer, pUserBuffer + j * 4096, 4096); memset(&DmaParams, 0, sizeof(PLX_DMA_PARAMS)); // Clear DMA data memset(&DmaParams, 0, sizeof(PLX_DMA_PARAMS)); DmaParams.UserVa = (PLX_UINT_PTR)buffer; DmaParams.LocalAddr = wr_addr; DmaParams.ByteCount = len; DmaParams.Direction = PLX_DMA_PCI_TO_LOC; // Specify a timeout to let API perform wait //ASCIIToHex(buffer, len); rc =PlxPci_DmaTransferUserBuffer(pDevice,DmaChannel,&DmaParams,0); while(1) { do { rc = PlxPci_DmaStatus(pDevice, 0); retry_times++; } while (rc == ApiDmaInProgress && retry_times <= 1000000); switch (rc) { case ApiDmaDone: //Cons_printf("Ok (DMA ApiDmaDone)\n"); ret = 0; break; case ApiDmaInProgress: Cons_printf("*ERROR* -DMA ApiDmaInProgress\n"); ret = ERR_DMA_ALWAYS_INPROGESS; goto FAIL; default: Cons_printf("*ERROR* - API failed\n"); ret = ERR_DMA_OTHER_ERR; goto FAIL ; } break; } ret = Read_Dma_Count(pDevice, &dma_count); if(ret) { Cons_printf("Read_Dma_Count\n"); goto FAIL; } //cpld_idea = 0; //ret = Read_Cpld_Idea(pDevice, &cpld_idea); ret = Read_Dma_To_Fpga_Data(pDevice, &data_value); if(ret) { Cons_printf("Read_Dma_Count\n"); goto FAIL; } } if(UserBufferLen != dma_count) { Cons_printf("UserBufferLen = %d, count = %d\n", UserBufferLen, dma_count); ret = ERR_DMA_TRANSLATE_ERR; goto FAIL; } FAIL: // Close DMA Channel //Cons_printf(" Close DMA Channel.............. "); rc =PlxPci_DmaChannelClose(pDevice,DmaChannel); if (rc != ApiSuccess) { Cons_printf("*ERROR* - API failed\n"); PlxPci_DeviceReset(pDevice); ret = ERR_CLOSE_DMA_FAIL; } PlxPci_DmaChannelClose(pDevice,DmaChannel); free(buffer); return ret; }

STM32 SPI2使用DMA接收,DMA接收完成后不进DMA中断???

//Configuration SPI2 of CCPU2MCU RCC_AHB1PeriphClockCmd(PROTOCOL_SPI_PORT_CLK,ENABLE); //使能GPIO B口的时钟 RCC_APB1PeriphClockCmd(PROTOCOL_SPI_CLK, ENABLE); //使能SPI2 时钟 GPIO_PinAFConfig(PROTOCOL_SPI_CS_PORT, PROTOCOL_SPI_CS_PIN_SRC, GPIO_AF_SPI2); GPIO_PinAFConfig(PROTOCOL_SPI_SCK_PORT, PROTOCOL_SPI_SCK_PIN_SRC, GPIO_AF_SPI2); GPIO_PinAFConfig(PROTOCOL_SPI_MISO_PORT, PROTOCOL_SPI_MISO_PIN_SRC, GPIO_AF_SPI2); GPIO_PinAFConfig(PROTOCOL_SPI_MOSI_PORT, PROTOCOL_SPI_MOSI_PIN_SRC, GPIO_AF_SPI2); GPIO_InitStructure.GPIO_Pin = PROTOCOL_SPI_CS_PIN; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(PROTOCOL_SPI_CS_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = PROTOCOL_SPI_SCK_PIN; GPIO_Init(PROTOCOL_SPI_SCK_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = PROTOCOL_SPI_MOSI_PIN; GPIO_Init(PROTOCOL_SPI_MOSI_PORT, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Pin = PROTOCOL_SPI_MISO_PIN; GPIO_Init(PROTOCOL_SPI_MISO_PORT, &GPIO_InitStructure); SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; SPI_InitStructure.SPI_Mode = SPI_Mode_Slave; SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; SPI_InitStructure.SPI_NSS = SPI_NSS_Hard; SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4; SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; SPI_InitStructure.SPI_CRCPolynomial = 0x07; SPI_Init(SPI2, &SPI_InitStructure); SPI_Cmd(SPI2, ENABLE); // Configuration DMA1 DMA_InitTypeDef DMA_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE); DMA_DeInit(DMA1_Stream3); //SPI2 Rx DMA_InitStructure.DMA_Channel = DMA_Channel_0; DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)(&(SPI2->DR)); DMA_InitStructure.DMA_Memory0BaseAddr = (u32)(&USART_RX_DMA_Buf[0]); DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory; DMA_InitStructure.DMA_BufferSize = 16384+6; //32768+6; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull; DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(DMA1_Stream3, &DMA_InitStructure); SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE); DMA_ClearITPendingBit(DMA1_Stream3,DMA_IT_TCIF3); DMA_ITConfig(DMA1_Stream3,DMA_IT_TC,ENABLE); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannel = ENABLE; NVIC_Init(&NVIC_InitStructure); DMA_Cmd(DMA1_Stream3, ENABLE); // DMA Interrupt void DMA1_Stream3_IRQHandler(void) { unsigned int len; len = 0; if(DMA_GetITStatus(DMA1_Stream3, DMA_IT_TCIF3) != RESET) { DMA_ClearITPendingBit(DMA1_Stream3,DMA_IT_TCIF3); DMA_Cmd(DMA1_Stream3,DISABLE); spiRxFlag = 1; DMA_SetCurrDataCounter(DMA1_Stream3, 16384+6); DMA_Cmd(DMA1_Stream3, ENABLE); } }

stm32adc配置问题应用到adc+dma+tim+usart

我将adc配置后读出的数一直为0,怀疑是否adc没有运作。下面是我写的程序,请大神们帮我指点一下,看看哪出了问题。 **********************************************************************************/ #include "adc.h" vu16 AD_Value[N][M]; //用来存放ADC转换结果,也是DMA的目标地址 vu16 After_filter[M]; //用来存放求平均值之后的结果 u16 AD_Data_Ram[N]; u16 Get_RF_Data[N]; extern u16 RF_ADC1_Value_Count[ADRF_Arr_Count]; extern u16 V_ADC1_Value[ADRF_Arr_Count]; //存储采集电池电压缓存 /* * 函数名:ADC1_GPIO_Config * 描述 :使能ADC1和DMA1的时钟,初始化PC.01 * 输入 : 无 * 输出 :无 * 调用 :内部调用 */ static void ADC1_GPIO_Config(void) { GPIO_InitTypeDef GPIO_InitStructure; /* Enable ADC1 and GPIOC clock */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB, ENABLE); /*PB0-RF_AD输入 PB1-电压检测输入*/ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOB, &GPIO_InitStructure); } /* 函数名:ADC1_Mode_Config * 描述 :配置ADC1的工作模式为DMA模式 * 输入 : 无 * 输出 :无 * 调用 :内部调用 */ static void ADC1_Mode_Config(void) { ADC_InitTypeDef ADC_InitStructure; // ADC_DMARequestModeConfig(ADC1, ADC_DMAMode_Circular); /* ADC1 configuration */ ADC_DeInit(ADC1); //复位ADC ADC_StructInit(&ADC_InitStructure); //初始化ADC结构体 ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; //独立ADC模式 ADC_InitStructure.ADC_ScanConvMode = ENABLE; //扫描模式用于多通道采集 ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; //ENABLE 开启连续转换模式,即不停地进行ADC转换 ADC_InitStructure.ADC_ExternalTrigConv =ADC_ExternalTrigConv_None; //ADC_ExternalTrigConv_T2_CC2;//外部触发设置为TIM2 //(ADC_ExternalTrigConv_None; //不使用外部触发转换 (ADC_ExternalTrigConv_Ext_IT11_TIM8_TRGO; )//使用外部中断线11作为转换外部触发 ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; //采集数据右对齐 ADC_InitStructure.ADC_NbrOfChannel = M; //要转换的通道数目2 ADC_Init(ADC1, &ADC_InitStructure); /*配置ADC时钟,为PCLK2的8分频,即9MHz*/ RCC_ADCCLKConfig(RCC_PCLK2_Div8); /*配置ADC1的通道8为55.5个采样周期,序列为1 */ /*配置ADC1的通道9为55.5个采样周期,序列为2 */ // ADC_SampleTime_55Cycles5 ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 1, ADC_SampleTime_7Cycles5); ADC_RegularChannelConfig(ADC1, ADC_Channel_9, 2, ADC_SampleTime_7Cycles5); // ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 1, ADC_SampleTime_239Cycles5); // ADC_RegularChannelConfig(ADC1, ADC_Channel_9, 2, ADC_SampleTime_239Cycles5); /* Enable ADC1 external trigger */ // ADC_ExternalTrigConvCmd(ADC1, ENABLE); /* Enable ADC1 DMA */ ADC_DMACmd(ADC1, ENABLE); /* Enable ADC1 */ ADC_Cmd(ADC1, ENABLE); /*复位校准寄存器 */ ADC_ResetCalibration(ADC1); /*等待校准寄存器复位完成 */ while(ADC_GetResetCalibrationStatus(ADC1)); /* ADC校准 */ ADC_StartCalibration(ADC1); /* 等待校准完成*/ while(ADC_GetCalibrationStatus(ADC1)); /* 由于没有采用外部触发,所以使用软件触发ADC转换 */ ADC_SoftwareStartConvCmd(ADC1, ENABLE); // DMA_Cmd(DMA1_Channel1, ENABLE);//使能DMA } void DMA_AD_Init(void) { DMA_InitTypeDef DMA_InitStructure; /* Enable DMA clock */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); /* DMA channel1 configuration */ DMA_DeInit(DMA1_Channel1); DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address; //ADC地址 DMA_InitStructure.DMA_MemoryBaseAddr = (u32)&AD_Value;//内存地址 DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; //内存作为数据传输的目的地 DMA_InitStructure.DMA_BufferSize = N*M; //DMA通道的DMA缓存的大小 DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//外设地址固定 DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //内存地址递增 DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; //半字 DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; //循环传输 DMA_InitStructure.DMA_Priority = DMA_Priority_High; //DMA通道拥有高优先级 DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; //DMA通道没有设置为内存到内存传输 DMA_Init(DMA1_Channel1, &DMA_InitStructure); //开启DMA传输完成中断 // DMA_ITConfig(DMA1_Channel1,DMA_IT_TC,ENABLE); // DMA_ClearITPendingBit(DMA_IT_TC); //清除一次DMA中断标志 DMA_Cmd(DMA1_Channel1, ENABLE); //Enable DMA channel1 } /* * 函数名:ADC1_Init * 描述 :无 * 输入 :无 * 输出 :无 * 调用 :外部调用 */ void ADC1_Init(void) { ADC1_GPIO_Config(); DMA_AD_Init(); ADC1_Mode_Config(); }

STM32 HAL库DMA第二次输入不能从buffer头存储

现在STM32的DMA成功的将接受所得的字符存入buffer,并通过IDIE中断保证了接受数据能够处理,但是当第二次输入的时候,DMA默认将数据存储在第一次输入的数据后面。请问有什么函数能让DMA将第二次(及以后)的输入从buffer头开始存储? 下面是我的代码 main.c ``` uint8_t uart2Rx[UART2_BUF_MAX]; uint16_t uart2RxLength; int main(void) { /* USER CODE BEGIN 1 */ int i; /* USER CODE END 1 */ /* MCU Configuration----------------------------------------------------------*/ /* Reset of all peripherals, Initializes the Flash interface and the Systick. */ HAL_Init(); /* USER CODE BEGIN Init */ /* USER CODE END Init */ /* Configure the system clock */ SystemClock_Config(); /* USER CODE BEGIN SysInit */ /* USER CODE END SysInit */ /* Initialize all configured peripherals */ MX_GPIO_Init(); MX_DMA_Init(); MX_USART1_UART_Init(); MX_USART2_UART_Init(); /* USER CODE BEGIN 2 */ USR_UartInit(); /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { /* USER CODE END WHILE */ /* USER CODE BEGIN 3 */ HAL_Delay(1000); HAL_UART_Transmit(&huart1, (uint8_t*)"UART1\r\n", 9, 1000); for(i=0;i<uart1RxLength;i++) { HAL_UART_Transmit(&huart1, &uart1Rx[i], 1, 100); } HAL_Delay(1000); HAL_UART_Transmit(&huart1, (uint8_t*)"UART2\r\n", 9, 1000); for(i=0;i<uart2RxLength;i++) { HAL_UART_Transmit(&huart1, &uart2Rx[i], 1, 100); } } /* USER CODE END 3 */ } void USR_UartInit(void) { uart1RxLength = 0; HAL_UART_Receive_DMA(&huart1, uart1Rx, UART1_BUF_MAX); __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); uart2RxLength = 0; HAL_UART_Receive_DMA(&huart2, uart2Rx, UART2_BUF_MAX); __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE); } ``` st32_f1xxit.c ``` void USART1_IRQHandler(void) { /* USER CODE BEGIN USART1_IRQn 0 */ /* USER CODE END USART1_IRQn 0 */ HAL_UART_IRQHandler(&huart1); /* USER CODE BEGIN USART1_IRQn 1 */ if((__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!=RESET)) { __HAL_UART_DISABLE_IT(&huart1,UART_IT_IDLE); HAL_UART_DMAStop(&huart1); uart1RxLength = UART1_BUF_MAX-__HAL_DMA_GET_COUNTER(&hdma_usart1_rx); __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); HAL_UART_Receive_DMA(&huart1, uart1Rx, UART1_BUF_MAX); } /* USER CODE END USART1_IRQn 1 */ } ```

请问:其它外设是否使用DMA?

我能够理解IDE硬盘使用DMA的方式,我也知道使用DMA需要主板、操作系统和硬盘的三者配合。从相关资料来看,很多外设或单片机内部也使用DMA。 但我无法理解:1、除了IDE接口设备使用主板DMA外,其它接口的外设是否使用主板DMA(如果有如何查看)?(SATA硬盘应该也使用主板DMA) 2、问:硬盘使用主板DMA,是仅需要驱动的支持,还是同时需要硬盘芯片的支持? 3、问:使用DMA,是否必须要达到某个传输速度? 4、问:使用主板DMA与接口有关吗?USB、并行接口、火线接口等是否使用主板DMA? 5、问:移动硬盘的盘体支持DMA,那么硬盘转USB后还使用主板DAM吗? 请各位大侠不吝赐教! 请讲的通俗,这些问题已困扰我多日!

stm32串口发送可以进入中断但没有数据显示

程序功能是:若接收到数据0x55,则发送接收到的数据(0x55)。 但现在问题是:通过串口助手发送0x55,已经进入接收中断接受到数据,然后通过SendData函数发送数据,能进入发送中断,但是串口助手却没有显示0x55(好像是数据并没有发送出去) /*头文件*/ #ifndef __HEAD_H__ #define __HEAD_H__ #include <misc.h> #include <stm32f10x_usart.h> #include <stm32f10x_gpio.h> #include <STM32F10x_rcc.h> #include <stdint.h> #include "stm32f10x_flash.h" //#include <stm32100e_eval.h> //#include <stm32_eval.h> void NVIC_Configuration(void); void RCC_Configuration(void); void Usart_Initial(void); void gpio_Init(void); void Delayms(uint16_t ms); extern uint16_t rece; #endif /*函数*/ #include "head.h" void NVIC_Configuration(void){ //ÖжÏÓÅÏȼ¶ÉèÖà NVIC_InitTypeDef NVIC_InitStruc; NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); NVIC_InitStruc.NVIC_IRQChannel = USART1_IRQn; NVIC_InitStruc.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStruc.NVIC_IRQChannelSubPriority = 0; NVIC_InitStruc.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStruc); } void RCC_Configuration(void){ ErrorStatus HSEStartUpStatus; RCC_DeInit(); RCC_HSEConfig(RCC_HSE_ON); HSEStartUpStatus = RCC_WaitForHSEStartUp(); if(RCC_WaitForHSEStartUp() == SUCCESS) { FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable); FLASH_SetLatency(FLASH_Latency_2); RCC_HCLKConfig(RCC_SYSCLK_Div1); RCC_PCLK2Config(RCC_HCLK_Div1); RCC_PCLK1Config(RCC_HCLK_Div2); RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9); RCC_PLLCmd(ENABLE); while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY==RESET)) {} RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); while(RCC_GetSYSCLKSource()!=0x08){} } RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE); } void Usart_Initial(void){ USART_InitTypeDef USART_InitStructure; USART_ClockInitTypeDef USART_ClockStructure; USART_InitStructure.USART_BaudRate = 115200; USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_InitStructure.USART_Parity = USART_Parity_No; USART_InitStructure.USART_StopBits = USART_StopBits_1; USART_InitStructure.USART_WordLength = USART_WordLength_8b; // USART_ClockStructure.USART_Clock = USART_Clock_Disable; // USART_ClockStructure.USART_CPHA = USART_CPHA_2Edge; // USART_ClockStructure.USART_CPOL = USART_CPOL_Low; // USART_ClockStructure.USART_LastBit = USART_LastBit_Disable; USART_ClockStructInit(&USART_ClockStructure); USART_Init(USART1,&USART_InitStructure); USART_ClockInit(USART1,&USART_ClockStructure); RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE); // USART_ITConfig(USART1,USART_IT_TXE,ENABLE); // USART_ITConfig(USART1, USART_IT_RXNE,ENABLE); // USART_WakeUpConfig(USART1, USART_WakeUp_IdleLine); USART_Cmd(USART1,ENABLE); } void gpio_Init(void){ GPIO_InitTypeDef GPIO_InitSTA; GPIO_InitTypeDef GPIO_InitSTB; /* GPIO_PinLockConfig(GPIOB,GPIO_Pin_12);*/ RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOB,ENABLE); GPIO_InitSTA.GPIO_Mode = GPIO_Mode_Out_PP; //TxD1 GPIO_InitSTA.GPIO_Pin = GPIO_Pin_9; GPIO_InitSTA.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA,&GPIO_InitSTA); GPIO_InitSTA.GPIO_Mode = GPIO_Mode_IN_FLOATING; //RxD1 GPIO_InitSTA.GPIO_Pin = GPIO_Pin_10; // GPIO_InitSTA.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA,&GPIO_InitSTA); GPIO_InitSTB.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_InitSTB.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13; GPIO_InitSTB.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOB,&GPIO_InitSTB); GPIO_SetBits(GPIOA,GPIO_Pin_9 | GPIO_Pin_10); GPIO_SetBits(GPIOB,GPIO_Pin_12 | GPIO_Pin_13); } void Delayms(uint16_t ms){ uint16_t i = 0; uint16_t j = 0; for(j = 0;j < ms;j ++){ for(i = 0;i < 12000;i ++){ } } } /*主程序,串口usart1中断函数*/ #include "head.h" #include "stdio.h" #include "stm32f10x_it.h" uint16_t rece = 0; int main(void){ NVIC_Configuration(); RCC_Configuration(); Usart_Initial(); gpio_Init(); USART_ITConfig(USART1,USART_IT_TXE,ENABLE); USART_ITConfig(USART1,USART_IT_RXNE,ENABLE); GPIO_WriteBit(GPIOB,GPIO_Pin_12 | GPIO_Pin_13,Bit_RESET); while(1){ // GPIO_WriteBit(GPIOB,GPIO_Pin_12 | GPIO_Pin_13,Bit_SET); // Delayms(1000); GPIO_WriteBit(GPIOB,GPIO_Pin_12 | GPIO_Pin_13,Bit_RESET); Delayms(1000); // USART_SendData(USART1,0x55); // Delayms(1000); // while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET){}; } } void USART1_IRQHandler(void) { /* if(USART_GetITStatus(USART1, USART_IT_PE) != RESET) { USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); rece = USART_ReceiveData(USART1); } */ if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) { GPIO_WriteBit(GPIOB,GPIO_Pin_12,Bit_SET); //若发送0x55,引脚电平会变 // USART_SendData(USART1, 0xff); // while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET){}; USART_ClearFlag(USART1,USART_FLAG_TC); USART_ITConfig(USART1, USART_IT_TXE, DISABLE); } if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) { /* Disable USART1 RXNE Interrupt */ rece = USART_ReceiveData(USART1); USART_ClearFlag(USART1,USART_IT_RXNE); // USART_ITConfig(USART1, USART_IT_RXNE, DISABLE); if(rece == 0x55){ // GPIO_WriteBit(GPIOB,GPIO_Pin_12,Bit_SET); USART_ITConfig(USART1,USART_IT_TXE,ENABLE); USART_SendData(USART1,rece); while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET){}; // printf("hello"); } } }

STM32串口接收数据有时候会出错

void USART_Config(void) { GPIO_InitTypeDef GPIO_InitStruct ; USART_InitTypeDef USART_InitStruct ; NVIC_InitTypeDef NVIC_InitStruct ; #ifdef DMA_EN DMA_InitTypeDef DMA_InitStructure ; RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); //DMA1通道5配置 DMA_DeInit(DMA1_Channel6); //USART2_RX DMA1 channel 6 //外设地址 DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART2->DR); //内存地址 DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)USART_Rev_Buffer; //dma传输方向单向 DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; //设置DMA在传输时缓冲区的长度 DMA_InitStructure.DMA_BufferSize = 40 ;//UART_RX_LEN; //设置DMA的外设递增模式,一个外设 DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //设置DMA的内存递增模式 DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //外设数据字长 DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //内存数据字长 DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //设置DMA的传输模式 DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //设置DMA的优先级别 DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; //设置DMA的2个memory中的变量互相访问 DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; DMA_Init(DMA1_Channel6,&DMA_InitStructure); //使能通道6 DMA_Cmd(DMA1_Channel6,ENABLE); #endif RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE); USART_DeInit(USART2) ; GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2 ; //USART1-TX GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz ; GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP ; GPIO_Init(GPIOA,&GPIO_InitStruct); GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3 ; //USART1-RX GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz ; GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING ; GPIO_Init(GPIOA,&GPIO_InitStruct); USART_InitStruct.USART_BaudRate = 115200 ; USART_InitStruct.USART_WordLength = USART_WordLength_8b ; USART_InitStruct.USART_StopBits = USART_StopBits_1 ; USART_InitStruct.USART_Parity = USART_Parity_No ; USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx ; USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None ; USART_Init(USART2,&USART_InitStruct) ; NVIC_InitStruct.NVIC_IRQChannel = USART2_IRQn; NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority=0 ; //抢占优先级 3 NVIC_InitStruct.NVIC_IRQChannelSubPriority = 3; //子优先级 3 NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE; //IRQ 通道使能 NVIC_Init(&NVIC_InitStruct); USART_ITConfig(USART2,USART_IT_IDLE,ENABLE) ; /* CPU的小缺陷:串口配置好,如果直接Send,则第1个字节发送不出去 如下语句解决第1个字节无法正确发送出去的问题 */ //USART_ClearFlag(USART2, USART_FLAG_TC); /* 清发送外城标志,Transmission Complete*/ USART_DMACmd(USART2, USART_DMAReq_Rx, ENABLE); // 开启串口DMA接收 USART_Cmd(USART2, ENABLE); } void USART2_IRQHandler(void) { uint8_t temp = 0; uint8_t i = 0; if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET) { //USART_ClearFlag(USART1,USART_IT_IDLE); temp = USART2->SR; temp = USART2->DR; //清USART_IT_IDLE标志 DMA_Cmd(DMA1_Channel6,DISABLE); temp = 40 - DMA_GetCurrDataCounter(DMA1_Channel6); //接收到数据的长度 for(i=0;i<temp;i++) { printf(" %x ",USART_Rev_Buffer[i]); } printf("\r\n"); printf("\r\n"); //if(temp == USART_Rev_Buffer[4]+5) //{ // USART_FLAG_RX = 1 ; //标志位置1 //USART_TX = 0 ; //} //设置传输数据长度 DMA_SetCurrDataCounter(DMA1_Channel6,40); //打开DMA DMA_Cmd(DMA1_Channel6,ENABLE); } __nop(); } ![图片说明](https://img-ask.csdn.net/upload/201704/13/1492079684_720557.png)

Xilinx开发板利用SPI与铁电存储器FM25H20通信问题

刚刚开始学习。想利用SPI与铁电存储器FM25H20进行通信,不使用中断。铁电存储器的写保护线没有连接。我的步骤是:初始化SPI,清空RXFIFO,配置初始参数为0x0002f019,建立一个数组含有128个数,前五个分别是铁电存储器的写使能,写命令和地址指令,由于ZYNQ-7000系列的板子SPI是先输出地位,FM25H20是先处理高位,所以我把数组中的数进行了倒序,用for循环把数组中的数写到TXFIFO后,将Man_Start_com置1,通过寄存器Intr_Status_reg0中看TXFIFO是否空,RXFIFO是否满来看是不是发送完成。我理解是TXFIFO每发送一位相应的RXFIFO就接收一位。Man_Start_com位清0,读RXFIFO128次将其清空,再建立一个128数组,前四个数是铁电的读指令和地址,写进TXFIFO后Man_Start_com置1,写地址和读地址是一样的,理论上来讲我把RXFIFO中的数挪到一个数组中后应该有123位是我第一个数组中的,但实际上所有的数全是255,求一位大神解答为什么,以及我应该怎么处理

DMA传送方式中,是DMA控制器发出DMA请求还是外部设备呢?

DMA传送方式中,是DMA控制器发出DMA请求还是外部设备呢?

ARM+Linux DMA API使用

最近项目接手一个项目:为了加快LCD液晶刷新高清图片的速率,采用DMA将显存中的数据传输给液晶模块,各位大神有没有做过这方面的项目。

关于pc机dma传输的问题

大神能不能帮我解答一下,现在要做一个pci通信,用的是9030,没有dma控制器,想用pc机上的南桥上的dma主动发起传输,这样实现可能吗?

当串口通信波特率大于信道传输速率时会怎么样?

最近买了一款lora传输模块,上面参数显示空中通信速率为2.4bps,我的串口设备波特率为115200,应该就等于比特率了吧?(2400小于115200) ,那意思是不是都没法正常传输了,求科普解惑

windows PCI驱动Block DMA使用问题

最近在修改一份基于DriverStudio的PCI视频采集卡驱动代码,遇到了关于DMA的使用上的疑惑。 其OnStartDevice初始化了相关资源,代码如下: ``` PCM_RESOURCE_LIST pResListRaw = I.AllocatedResources(); // Get the list of translated resources from the IRP PCM_RESOURCE_LIST pResListTranslated = I.TranslatedResources(); // Initialize the device descriptor for the DMA object using the assigned resource DEVICE_DESCRIPTION dd; RtlZeroMemory(&dd, sizeof(dd)); dd.Version = DEVICE_DESCRIPTION_VERSION; dd.Master = TRUE; dd.ScatterGather = FALSE; dd.DemandMode = TRUE; dd.AutoInitialize = FALSE; dd.Dma32BitAddresses = TRUE; dd.IgnoreCount = FALSE; dd.DmaChannel = 3; dd.InterfaceType = PCIBus; dd.DmaWidth = Width32Bits; // PCI default width dd.DmaSpeed = MaximumDmaSpeed; dd.MaximumLength = m_nDmaBufferSize; // Initialize the DMA adapter object m_Dma.Initialize(&dd, m_Lower.TopOfStack()); m_DmaBuffer.Initialize(&m_Dma,m_nDmaBufferSize,true); // Create an instance of KPciConfiguration so we can map Base Address // Register indicies to ordinals for memory or I/O port ranges. KPciConfiguration PciConfig(m_Lower.TopOfStack()); // For each I/O port mapped region, initialize the I/O port range using // the resources provided by NT. Once initialized, use member functions such as // inb/outb, or the array element operator to access the ports range. status = m_IoPortRange0.Initialize( pResListTranslated, pResListRaw, PciConfig.BaseAddressIndexToOrdinal(0) ); status = m_Irq.InitializeAndConnect( pResListTranslated, LinkTo(Isr_Irq), this ); if (!NT_SUCCESS(status)) { Invalidate(); return status; } // Setup the DPC to be used for interrupt processing m_DpcFor_Irq.Setup(LinkTo(DpcFor_Irq), this); ``` 这里初始化了DMA,但是没有绑定PCI设备物理地址与驱动空间地址的相关代码。然而在IoControl中却有以下操作 ``` //写 UCHAR* pDMA = (UCHAR*)m_DmaBuffer.pVirtualAddress() + pCapInfo->nCode*pCapInfo->nSize + pCapInfo->nOffset; memcpy(pDMA,pCapInfo->pData,pCapInfo->nSize); //读 UCHAR* pDMA = (UCHAR*)m_DmaBuffer.pVirtualAddress() + pCapInfo->nCode*pCapInfo->nSize + pCapInfo->nOffset; memcpy(pCapInfo->pData,pDMA,pCapInfo->nSize); ``` 从代码可以看出,直接将m_DmaBuffer当做PCI的内存进行了访问。简单阅读了DriverStudio的封装源代码,初始化过程实际上调用了IoGetDmaAdapter与AllocateCommonBuffer,也就是说m_DmaBuffer.pVirtualAddress()实际上是AllocateCommonBuffer分配的公用缓冲区,而实际上并没有任何地方将该地址与PCI实际的物理地址进行绑定。查阅相关资料,AllocateCommonBuffer一般用于ScatterGather模式,这里使用的是block DMA模式。难道是IoGetDmaAdapter或者AllocateCommonBuffer自动将pVirtualAddress()与PCI的物理地址空间进行了绑定?查询相关资料,也没有这种解释。那究竟为什么能直接通过m_DmaBuffer.pVirtualAddress()操作PCI的物理地址空间呢? 求各位大神解答。

DMA通道是什么,请大神赐教

请教大神: DMA中的通道 是什么意思,一直不理解,请赐教,感激涕零!

64位LINUX X86关于DMA API的一些问题, 求高手不吝赐教,急急急!

pSendDmaPool = dma_pool_create("DmaPool",pci_dev->dev), (size_t)(512 * 64*1024+1024), (size_t)(64*1024), (size_t)0); pDmaBuf = (unsigned char*)dma_pool_alloc(pSendDmaPool, GFP_KERNEL, &dma_handle); 我的平台是64位X86,我执行完dma_pool_create后,再执行dma_pool_alloc,就崩溃了,然后打印信息是: ------------[ cut here ]------------ WARNING: at mm/page_alloc.c:2139 __alloc_pages_nodemask+0x7a8/0x8d0() (Not tainted) Hardware name: All Series Modules linked in: fh130drv(U) ebtable_nat ebtables ipt_MASQUERADE iptable_nat nf_nat xt_CHECKSUM iptable_mangle bridge autofs4 8021q garp stp llc cpufreq_ondemand acpi_cpufreq freq_table mperf ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables ipv6 vhost_net macvtap macvlan tun kvm uinput ppdev iTCO_wdt iTCO_vendor_support microcode parport_pc parport r8169 mii sg serio_raw lpc_ich mfd_core i2c_i801 shpchp snd_hda_codec_realtek snd_hda_codec_hdmi snd_hda_intel snd_hda_codec snd_hwdep snd_seq snd_seq_device snd_pcm snd_timer snd soundcore snd_page_alloc ext4 jbd2 mbcache sd_mod crc_t10dif ahci xhci_hcd i915 drm_kms_helper drm i2c_algo_bit i2c_core video output dm_mirror dm_region_hash dm_log dm_mod [last unloaded: scsi_wait_scan] Pid: 3725, comm: fh130demo Not tainted 2.6.32-504.el6.x86_64 #1 Call Trace: [<ffffffff81074df7>] ? warn_slowpath_common+0x87/0xc0 [<ffffffff81074e4a>] ? warn_slowpath_null+0x1a/0x20 [<ffffffff811343e8>] ? __alloc_pages_nodemask+0x7a8/0x8d0 [<ffffffff815300da>] ? atomic_notifier_call_chain+0x1a/0x20 [<ffffffff813429ae>] ? notify_update+0x2e/0x30 [<ffffffff813443b0>] ? vt_console_print+0x260/0x330 [<ffffffff810a4c2f>] ? up+0x2f/0x50 [<ffffffff81074ffa>] ? _call_console_drivers+0x4a/0x80 [<ffffffff81012fe6>] ? dma_generic_alloc_coherent+0xa6/0x160 [<ffffffff8100bb8e>] ? apic_timer_interrupt+0xe/0x20 [<ffffffff81041fd1>] ? x86_swiotlb_alloc_coherent+0x31/0x70 [<ffffffff81164f5c>] ? dma_pool_alloc+0xfc/0x2a0 [<ffffffff815293c5>] ? printk+0x41/0x44 [<ffffffffa0546b36>] ? hbaDevAllocDmaBuffers+0x2f6/0x8f0 [fh130drv] [<ffffffffa0547298>] ? hbaDevInitialize+0x168/0x1b0 [fh130drv] [<ffffffffa053fd44>] ? Hba_FC_ASM_LoadConfig+0x54/0xa0 [fh130drv] [<ffffffffa053e532>] ? hba_dev_ioctl+0x1e2/0xbd0 [fh130drv] [<ffffffff81234be1>] ? avc_has_perm+0x71/0x90 [<ffffffff8133a483>] ? pty_write+0x73/0x80 [<ffffffff812369d4>] ? inode_has_perm+0x54/0xa0 [<ffffffff8109eefc>] ? remove_wait_queue+0x3c/0x50 [<ffffffff8105bd23>] ? __wake_up+0x53/0x70 [<ffffffff811a3752>] ? vfs_ioctl+0x22/0xa0 [<ffffffff811a38f4>] ? do_vfs_ioctl+0x84/0x580 [<ffffffff811a3e71>] ? sys_ioctl+0x81/0xa0 [<ffffffff810e5a7e>] ? __audit_syscall_exit+0x25e/0x290 [<ffffffff8100b072>] ? system_call_fastpath+0x16/0x1b ---[ end trace 03df1cd6b697aafa ]--- 求高手解答这个是怎么回事? 然后我想问一下,我可以分配 512 * 64*1024+1024这么大的DMA内存吗?并且对齐方式是64*1024? 然后我alloc的时候,每一块是多大呢? 谢谢了,没有金币了,不好意思!

Java基础知识面试题(2020最新版)

文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的主类有何不同?Java应用程序与小程序之间有那些差别?Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...

软件测试入门、SQL、性能测试、测试管理工具

软件测试2小时入门,让您快速了解软件测试基本知识,有系统的了解; SQL一小时,让您快速理解和掌握SQL基本语法 jmeter性能测试 ,让您快速了解主流来源性能测试工具jmeter 测试管理工具-禅道,让您快速学会禅道的使用,学会测试项目、用例、缺陷的管理、

基于西门子S7—1200的单部六层电梯设计程序,1部6层电梯

基于西门子S7—1200的单部六层电梯设计程序,1部6层电梯。 本系统控制六层电梯, 采用集选控制方式。 为了完成设定的控制任务, 主要根据电梯输入/输出点数确定PLC 的机型。 根据电梯控制的要求,

捷联惯导仿真matlab

捷联惯导的仿真(包括轨迹仿真,惯性器件模拟输出,捷联解算),标了详细的注释捷联惯导的仿真(包括轨迹仿真,惯性器件模拟输出,捷联解算),标了详细的注释

深度学习原理+项目实战+算法详解+主流框架(套餐)

深度学习系列课程从深度学习基础知识点开始讲解一步步进入神经网络的世界再到卷积和递归神经网络,详解各大经典网络架构。实战部分选择当下最火爆深度学习框架PyTorch与Tensorflow/Keras,全程实战演示框架核心使用与建模方法。项目实战部分选择计算机视觉与自然语言处理领域经典项目,从零开始详解算法原理,debug模式逐行代码解读。适合准备就业和转行的同学们加入学习! 建议按照下列课程顺序来进行学习 (1)掌握深度学习必备经典网络架构 (2)深度框架实战方法 (3)计算机视觉与自然语言处理项目实战。(按照课程排列顺序即可)

图书管理系统(Java + Mysql)我的第一个完全自己做的实训项目

图书管理系统 Java + MySQL 完整实训代码,MVC三层架构组织,包含所有用到的图片资源以及数据库文件,大三上学期实训,注释很详细,按照阿里巴巴Java编程规范编写

玩转Linux:常用命令实例指南

人工智能、物联网、大数据时代,Linux正有着一统天下的趋势,几乎每个程序员岗位,都要求掌握Linux。本课程零基础也能轻松入门。 本课程以简洁易懂的语言手把手教你系统掌握日常所需的Linux知识,每个知识点都会配合案例实战让你融汇贯通。课程通俗易懂,简洁流畅,适合0基础以及对Linux掌握不熟练的人学习; 【限时福利】 1)购课后按提示添加小助手,进答疑群,还可获得价值300元的编程大礼包! 2)本月购买此套餐加入老师答疑交流群,可参加老师的免费分享活动,学习最新技术项目经验。 --------------------------------------------------------------- 29元=掌握Linux必修知识+社群答疑+讲师社群分享会+700元编程礼包。 &nbsp;

网络工程师小白入门--【思科CCNA、华为HCNA等网络工程师认证】

本课程适合CCNA或HCNA网络小白同志,高手请绕道,可以直接学习进价课程。通过本预科课程的学习,为学习网络工程师、思科CCNA、华为HCNA这些认证打下坚实的基础! 重要!思科认证2020年2月24日起,已启用新版认证和考试,包括题库都会更新,由于疫情原因,请关注官网和本地考点信息。题库网络上很容易下载到。

C++语言基础视频教程

C++语言基础视频培训课程:本课与主讲者在大学开出的程序设计课程直接对接,准确把握知识点,注重教学视频与实践体系的结合,帮助初学者有效学习。本教程详细介绍C++语言中的封装、数据隐藏、继承、多态的实现等入门知识;主要包括类的声明、对象定义、构造函数和析构函数、运算符重载、继承和派生、多态性实现等。 课程需要有C语言程序设计的基础(可以利用本人开出的《C语言与程序设计》系列课学习)。学习者能够通过实践的方式,学会利用C++语言解决问题,具备进一步学习利用C++开发应用程序的基础。

微信小程序 实例汇总 完整项目源代码

微信小程序 实例汇总 完整项目源代码

Python数据挖掘简易入门

&nbsp; &nbsp; &nbsp; &nbsp; 本课程为Python数据挖掘方向的入门课程,课程主要以真实数据为基础,详细介绍数据挖掘入门的流程和使用Python实现pandas与numpy在数据挖掘方向的运用,并深入学习如何运用scikit-learn调用常用的数据挖掘算法解决数据挖掘问题,为进一步深入学习数据挖掘打下扎实的基础。

2020-五一数学建模大赛C类问题饲料加工配比及优化.pdf

2020年,“51”数学建模C类问题,关于饲料配比问题以及加工优化方案。论文采用统计分析,建立了关于饲料加工的多目标优化模型。并利用蒙特卡罗算法对目标函数进行优化,解决了饲料加工质量最优配比问题并进行

MySQL数据库从入门到实战应用

限时福利1:购课进答疑群专享柳峰(刘运强)老师答疑服务 限时福利2:购课后添加学习助手(微信号:csdn590),按消息提示即可领取编程大礼包! 为什么说每一个程序员都应该学习MySQL? 根据《2019-2020年中国开发者调查报告》显示,超83%的开发者都在使用MySQL数据库。 使用量大同时,掌握MySQL早已是运维、DBA的必备技能,甚至部分IT开发岗位也要求对数据库使用和原理有深入的了解和掌握。 学习编程,你可能会犹豫选择 C++ 还是 Java;入门数据科学,你可能会纠结于选择 Python 还是 R;但无论如何, MySQL 都是 IT 从业人员不可或缺的技能! 【课程设计】 在本课程中,刘运强老师会结合自己十多年来对MySQL的心得体会,通过课程给你分享一条高效的MySQL入门捷径,让学员少走弯路,彻底搞懂MySQL。 本课程包含3大模块:&nbsp; 一、基础篇: 主要以最新的MySQL8.0安装为例帮助学员解决安装与配置MySQL的问题,并对MySQL8.0的新特性做一定介绍,为后续的课程展开做好环境部署。 二、SQL语言篇: 本篇主要讲解SQL语言的四大部分数据查询语言DQL,数据操纵语言DML,数据定义语言DDL,数据控制语言DCL,学会熟练对库表进行增删改查等必备技能。 三、MySQL进阶篇: 本篇可以帮助学员更加高效的管理线上的MySQL数据库;具备MySQL的日常运维能力,语句调优、备份恢复等思路。 &nbsp;

navicat简体中文版 绿色版 (64位)

解压后安装navicat,打开navicat执行PatchNavicat即破解成功。可以正常使用啦。

linux“开发工具三剑客”速成攻略

工欲善其事,必先利其器。Vim+Git+Makefile是Linux环境下嵌入式开发常用的工具。本专题主要面向初次接触Linux的新手,熟练掌握工作中常用的工具,在以后的学习和工作中提高效率。

机器学习初学者必会的案例精讲

通过六个实际的编码项目,带领同学入门人工智能。这些项目涉及机器学习(回归,分类,聚类),深度学习(神经网络),底层数学算法,Weka数据挖掘,利用Git开源项目实战等。

Python代码实现飞机大战

文章目录经典飞机大战一.游戏设定二.我方飞机三.敌方飞机四.发射子弹五.发放补给包六.主模块 经典飞机大战 源代码以及素材资料(图片,音频)可从下面的github中下载: 飞机大战源代码以及素材资料github项目地址链接 ————————————————————————————————————————————————————————— 不知道大家有没有打过飞机,喜不喜欢打飞机。当我第一次接触这个东西的时候,我的内心是被震撼到的。第一次接触打飞机的时候作者本人是身心愉悦的,因为周边的朋友都在打飞机, 每

java jdk 8 帮助文档 中文 文档 chm 谷歌翻译

JDK1.8 API 中文谷歌翻译版 java帮助文档 JDK API java 帮助文档 谷歌翻译 JDK1.8 API 中文 谷歌翻译版 java帮助文档 Java最新帮助文档 本帮助文档是使用谷

Qt5.10 GUI完全参考手册(强烈推荐)

本书是Qt中文版的参考手册,内容详尽易懂,详细介绍了Qt实现的各种内部原理,是一本不可多得的参考文献

Python可以这样学(第四季:数据分析与科学计算可视化)

董付国老师系列教材《Python程序设计(第2版)》(ISBN:9787302436515)、《Python可以这样学》(ISBN:9787302456469)配套视频,在教材基础上又增加了大量内容,通过实例讲解numpy、scipy、pandas、statistics、matplotlib等标准库和扩展库用法。

设计模式(JAVA语言实现)--20种设计模式附带源码

课程亮点: 课程培训详细的笔记以及实例代码,让学员开始掌握设计模式知识点 课程内容: 工厂模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式、原型模型、代理模式、单例模式、适配器模式 策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式 课程特色: 笔记设计模式,用笔记串连所有知识点,让学员从一点一滴积累,学习过程无压力 笔记标题采用关键字标识法,帮助学员更加容易记住知识点 笔记以超链接形式让知识点关联起来,形式知识体系 采用先概念后实例再应用方式,知识点深入浅出 提供授课内容笔记作为课后复习以及工作备查工具 部分图表(电脑PC端查看):

进程监控软件 Performance Monitor中文版

告诉你每个程序现在在做什么,还可以根据你的要求过滤无关的内容。

八数码的深度优先算法c++实现

人工智能的八数码的深度优先算法c++实现

2021考研数学张宇基础30讲.pdf

张宇:博士,全国著名考研数学辅导专家,教育部“国家精品课程建设骨干教师”,全国畅销书《张宇高等数学18讲》《张宇线性代数9讲》《张宇概率论与数理统计9讲》《张宇考研数学题源探析经典1000题》《张宇考

2019 Python开发者日-培训

本次活动将秉承“只讲技术,拒绝空谈”的理念,邀请十余位身处一线的Python技术专家,重点围绕Web开发、自动化运维、数据分析、人工智能等技术模块,分享真实生产环境中使用Python应对IT挑战的真知灼见。此外,针对不同层次的开发者,大会还安排了深度培训实操环节,为开发者们带来更多深度实战的机会。

C/C++跨平台研发从基础到高阶实战系列套餐

一 专题从基础的C语言核心到c++ 和stl完成基础强化; 二 再到数据结构,设计模式完成专业计算机技能强化; 三 通过跨平台网络编程,linux编程,qt界面编程,mfc编程,windows编程,c++与lua联合编程来完成应用强化 四 最后通过基于ffmpeg的音视频播放器,直播推流,屏幕录像,

2020_五一数学建模_C题_整理后的数据.zip

该数据是我的程序读取的数据,仅供参考,问题的解决方案:https://blog.csdn.net/qq_41228463/article/details/105993051

机器学习实战系列套餐(必备基础+经典算法+案例实战)

机器学习实战系列套餐以实战为出发点,帮助同学们快速掌握机器学习领域必备经典算法原理并结合Python工具包进行实战应用。建议学习顺序:1.Python必备工具包:掌握实战工具 2.机器学习算法与实战应用:数学原理与应用方法都是必备技能 3.数据挖掘实战:通过真实数据集进行项目实战。按照下列课程顺序学习即可! 课程风格通俗易懂,用最接地气的方式带领大家轻松进军机器学习!提供所有课程代码,PPT与实战数据,有任何问题欢迎随时与我讨论。

实用主义学Python(小白也容易上手的Python实用案例)

原价169,限时立减100元! 系统掌握Python核心语法16点,轻松应对工作中80%以上的Python使用场景! 69元=72讲+源码+社群答疑+讲师社群分享会&nbsp; 【哪些人适合学习这门课程?】 1)大学生,平时只学习了Python理论,并未接触Python实战问题; 2)对Python实用技能掌握薄弱的人,自动化、爬虫、数据分析能让你快速提高工作效率; 3)想学习新技术,如:人工智能、机器学习、深度学习等,这门课程是你的必修课程; 4)想修炼更好的编程内功,优秀的工程师肯定不能只会一门语言,Python语言功能强大、使用高效、简单易学。 【超实用技能】 从零开始 自动生成工作周报 职场升级 豆瓣电影数据爬取 实用案例 奥运冠军数据分析 自动化办公:通过Python自动化分析Excel数据并自动操作Word文档,最终获得一份基于Excel表格的数据分析报告。 豆瓣电影爬虫:通过Python自动爬取豆瓣电影信息并将电影图片保存到本地。 奥运会数据分析实战 简介:通过Python分析120年间奥运会的数据,从不同角度入手分析,从而得出一些有趣的结论。 【超人气老师】 二两 中国人工智能协会高级会员 生成对抗神经网络研究者 《深入浅出生成对抗网络:原理剖析与TensorFlow实现》一书作者 阿里云大学云学院导师 前大型游戏公司后端工程师 【超丰富实用案例】 0)图片背景去除案例 1)自动生成工作周报案例 2)豆瓣电影数据爬取案例 3)奥运会数据分析案例 4)自动处理邮件案例 5)github信息爬取/更新提醒案例 6)B站百大UP信息爬取与分析案例 7)构建自己的论文网站案例

相关热词 c#分级显示数据 c# 不区分大小写替换 c#中调用就java c#正则表达式 验证小数 c# vscode 配置 c#三维数组能存多少数据 c# 新建excel c#多个文本框 c#怎么创建tcp通讯 c# mvc 电子病例
立即提问