Partage
  • Partager sur Facebook
  • Partager sur Twitter

SPI+DMA sur microphones (STM32)

Sujet résolu
    15 juin 2020 à 16:20:34

    Bonjour,

    J'essaye de mettre en place une lecture de microphones MEMS par DMA avec le SPI d'un STM32WB nucleo.

    Je suis en mode receive only master et je lance une lecture de mon buffer avec la fonction HAL_SPI_Receive_DMA().

    Seulement, mon buffer sensé se remplir avec les valeurs reçues reste à 0 et après vérification avec mon analyseur de trames, effectivement rien n'est envoyé.

    voici mon code main :

    /* USER CODE BEGIN Header */
    /**
      ******************************************************************************
      * @file           : main.c
      * @brief          : Main program body
      ******************************************************************************
      * @attention
      *
      * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
      * All rights reserved.</center></h2>
      *
      * This software component is licensed by ST under BSD 3-Clause license,
      * the "License"; You may not use this file except in compliance with the
      * License. You may obtain a copy of the License at:
      *                        opensource.org/licenses/BSD-3-Clause
      *
      ******************************************************************************
      */
    /* USER CODE END Header */
    
    /* Includes ------------------------------------------------------------------*/
    #include "main.h"
    
    /* Private includes ----------------------------------------------------------*/
    /* USER CODE BEGIN Includes */
    #include "stdio.h"
    #include "bsp_microphone.h"
    /* USER CODE END Includes */
    
    /* Private typedef -----------------------------------------------------------*/
    /* USER CODE BEGIN PTD */
    
    /* USER CODE END PTD */
    
    /* Private define ------------------------------------------------------------*/
    /* USER CODE BEGIN PD */
    /* USER CODE END PD */
    
    /* Private macro -------------------------------------------------------------*/
    /* USER CODE BEGIN PM */
    
    /* USER CODE END PM */
    
    /* Private variables ---------------------------------------------------------*/
    SPI_HandleTypeDef hspi1;
    DMA_HandleTypeDef hdma_spi1_rx;
    
    UART_HandleTypeDef huart1;
    
    PCD_HandleTypeDef hpcd_USB_FS;
    
    /* USER CODE BEGIN PV */
    
    /* USER CODE END PV */
    
    /* Private function prototypes -----------------------------------------------*/
    void SystemClock_Config(void);
    static void MX_GPIO_Init(void);
    static void MX_DMA_Init(void);
    static void MX_USART1_UART_Init(void);
    static void MX_USB_PCD_Init(void);
    static void MX_SPI1_Init(void);
    /* USER CODE BEGIN PFP */
    
    /* USER CODE END PFP */
    
    /* Private user code ---------------------------------------------------------*/
    /* USER CODE BEGIN 0 */
    extern uint16_t PCM_Buffer[((AUDIO_IN_CHANNELS*AUDIO_IN_SAMPLING_FREQUENCY)/1000)  * N_MS_PER_INTERRUPT ];
    /* USER CODE END 0 */
    
    /**
      * @brief  The application entry point.
      * @retval int
      */
    int main(void)
    {
      /* USER CODE BEGIN 1 */
    
      /* 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_USB_PCD_Init();
      MX_SPI1_Init();
      /* USER CODE BEGIN 2 */
    
      /* USER CODE END 2 */
    
      /* Infinite loop */
      /* USER CODE BEGIN WHILE */
      while (1)
      {
    	  bsp_microphone();
    	  HAL_Delay(1);
        /* USER CODE END WHILE */
    
        /* USER CODE BEGIN 3 */
      }
      /* USER CODE END 3 */
    }
    
    /**
      * @brief System Clock Configuration
      * @retval None
      */
    void SystemClock_Config(void)
    {
      RCC_OscInitTypeDef RCC_OscInitStruct = {0};
      RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
      RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
    
      /** Macro to configure the PLL multiplication factor 
      */
      __HAL_RCC_PLL_PLLM_CONFIG(RCC_PLLM_DIV1);
      /** Macro to configure the PLL clock source 
      */
      __HAL_RCC_PLL_PLLSOURCE_CONFIG(RCC_PLLSOURCE_MSI);
      /** Configure LSE Drive Capability 
      */
      HAL_PWR_EnableBkUpAccess();
      __HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_LOW);
      /** Configure the main internal regulator output voltage 
      */
      __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
      /** Initializes the CPU, AHB and APB busses clocks 
      */
      RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI|RCC_OSCILLATORTYPE_HSE
                                  |RCC_OSCILLATORTYPE_LSE|RCC_OSCILLATORTYPE_MSI;
      RCC_OscInitStruct.HSEState = RCC_HSE_ON;
      RCC_OscInitStruct.LSEState = RCC_LSE_ON;
      RCC_OscInitStruct.HSIState = RCC_HSI_ON;
      RCC_OscInitStruct.MSIState = RCC_MSI_ON;
      RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
      RCC_OscInitStruct.MSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
      RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_6;
      RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
      if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
      {
        Error_Handler();
      }
      /** Configure the SYSCLKSource, HCLK, PCLK1 and PCLK2 clocks dividers 
      */
      RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK4|RCC_CLOCKTYPE_HCLK2
                                  |RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                                  |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
      RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;
      RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
      RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
      RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
      RCC_ClkInitStruct.AHBCLK2Divider = RCC_SYSCLK_DIV1;
      RCC_ClkInitStruct.AHBCLK4Divider = RCC_SYSCLK_DIV1;
    
      if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
      {
        Error_Handler();
      }
      /** Initializes the peripherals clocks 
      */
      PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SMPS|RCC_PERIPHCLK_USART1
                                  |RCC_PERIPHCLK_USB;
      PeriphClkInitStruct.PLLSAI1.PLLN = 24;
      PeriphClkInitStruct.PLLSAI1.PLLP = RCC_PLLP_DIV2;
      PeriphClkInitStruct.PLLSAI1.PLLQ = RCC_PLLQ_DIV2;
      PeriphClkInitStruct.PLLSAI1.PLLR = RCC_PLLR_DIV2;
      PeriphClkInitStruct.PLLSAI1.PLLSAI1ClockOut = RCC_PLLSAI1_USBCLK;
      PeriphClkInitStruct.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
      PeriphClkInitStruct.UsbClockSelection = RCC_USBCLKSOURCE_PLLSAI1;
      PeriphClkInitStruct.SmpsClockSelection = RCC_SMPSCLKSOURCE_HSI;
      PeriphClkInitStruct.SmpsDivSelection = RCC_SMPSCLKDIV_RANGE0;
      if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
      {
        Error_Handler();
      }
      /* USER CODE BEGIN Smps */
    
      /* USER CODE END Smps */
      /** Enable MSI Auto calibration 
      */
      HAL_RCCEx_EnableMSIPLLMode();
    }
    
    /**
      * @brief SPI1 Initialization Function
      * @param None
      * @retval None
      */
    static void MX_SPI1_Init(void)
    {
    
      /* USER CODE BEGIN SPI1_Init 0 */
    
      /* USER CODE END SPI1_Init 0 */
    
      /* USER CODE BEGIN SPI1_Init 1 */
    
      /* USER CODE END SPI1_Init 1 */
      /* SPI1 parameter configuration*/
      hspi1.Instance = SPI1;
      hspi1.Init.Mode = SPI_MODE_MASTER;
      hspi1.Init.Direction = SPI_DIRECTION_2LINES_RXONLY;
      hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
      hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
      hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
      hspi1.Init.NSS = SPI_NSS_SOFT;
      hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
      hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
      hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
      hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
      hspi1.Init.CRCPolynomial = 7;
      hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
      hspi1.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
      if (HAL_SPI_Init(&hspi1) != HAL_OK)
      {
        Error_Handler();
      }
      /* USER CODE BEGIN SPI1_Init 2 */
    
      /* USER CODE END SPI1_Init 2 */
    
    }
    
    
    /** 
      * Enable DMA controller clock
      */
    static void MX_DMA_Init(void) 
    {
    
      /* DMA controller clock enable */
      __HAL_RCC_DMAMUX1_CLK_ENABLE();
      __HAL_RCC_DMA1_CLK_ENABLE();
    
      /* DMA interrupt init */
      /* DMA1_Channel1_IRQn interrupt configuration */
      HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
      HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
      /* DMAMUX1_OVR_IRQn interrupt configuration */
      HAL_NVIC_SetPriority(DMAMUX1_OVR_IRQn, 0, 0);
      HAL_NVIC_EnableIRQ(DMAMUX1_OVR_IRQn);
    
    }
    
    

    et voici le code de récupération des données sonores :

         
     /* Includes ------------------------------------------------------------------*/
    #include "bsp_microphone.h"
    //#include "app_common.h"
    #include "stm32wbxx_hal.h"
    
    enum
    {
    	TRANSFER_WAIT,
    	TRANSFER_COMPLETE,
    	TRANSFER_ERROR
    };
    
    uint32_t TransferState = TRANSFER_WAIT;
    
    extern SPI_HandleTypeDef hspi1;
         
    void bsp_microphone(void);
    
    
    uint16_t PDM_Buffer[((((AUDIO_IN_CHANNELS * AUDIO_IN_SAMPLING_FREQUENCY) / 1000) * MAX_DECIMATION_FACTOR) / 16)* N_MS_PER_INTERRUPT ];
    uint16_t PCM_Buffer[((AUDIO_IN_CHANNELS*AUDIO_IN_SAMPLING_FREQUENCY)/1000)  * N_MS_PER_INTERRUPT ];
         
    
    void bsp_microphone(void)
    {
      int i;
      i=0;
      while (i < ((((AUDIO_IN_CHANNELS * AUDIO_IN_SAMPLING_FREQUENCY) / 1000) * MAX_DECIMATION_FACTOR) / 16)* N_MS_PER_INTERRUPT)
      {
      	PDM_Buffer[i] = 0x4445;
      	PDM_Buffer[i+1] = 0x4044;
      	PDM_Buffer[i+2] = 0x424F;
      	PDM_Buffer[i+3] = 0x4445;
      	i=i+4;
      }
      HAL_GPIO_WritePin(GPIOC, SENSOR_MIC_LR_Pin, GPIO_PIN_RESET);
      
      if (HAL_SPI_Receive_DMA(&hspi1, (uint8_t *) &PDM_Buffer, 128) != HAL_OK)
      {
    	  HAL_Delay(1);
      }
      while (TransferState != TRANSFER_COMPLETE)
      {
    	  HAL_Delay(1);
      }
    
      TransferState = TRANSFER_WAIT;
    
    }
    
    
    void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi1)
    {
    	TransferState = TRANSFER_COMPLETE;
    }
    
    void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi1)
    {
    	TransferState = TRANSFER_COMPLETE;
    }
    
    void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi1)
    {
    	TransferState = TRANSFER_ERROR;
    }
    

    J'ai tenté diverses configurations de SPI et DMA mais rien ne semble fonctionner, je ne sais pas ce que j'ai pu oublier...


    -
    Edité par Sidka 15 juin 2020 à 16:28:23

    • Partager sur Facebook
    • Partager sur Twitter
      16 juin 2020 à 14:59:33

      Bonjour,

      Si ton microphone a une broche de sélection de canal (souvent nommée "LR"), il faut vérifiée qu'elle est configurée correctement, en fonction de la datasheet du micro, pour qu'elle renvoie les données sur le même font que celui attendu par le mode SPI que tu as choisi (ici sur le front montant de l'horloge)

      Si ce n'est pas un problème de câblage, que la fréquence d'horloge est bien dans la fourchette supportée par le micro mems et que l'entrée LR n'est pas flottante, tu devais pouvoir changer le front d'horloge sur lequel le SPI lit les données en remplaçant:

      hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;

      par

      hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;





      • Partager sur Facebook
      • Partager sur Twitter
        16 juin 2020 à 15:15:55

        Bonjour,

        Pour mon microphone, j'utilise la carte annexe CCA02M1 sur laquelle la pin LR du micro que j'utilise est branché sur la masse.

        De plus j'ai bien une fréquence comprise dans ma fourchette.

        J'ai même testé la configuration recommandée par ce document : https://www.st.com/resource/en/application_note/dm00380469-interfacing-pdm-digital-microphones-using-stm32-mcus-and-mpus-stmicroelectronics.pdf , sans succès.

        J'ai changé le front d'horloge avec la commande que tu m'as conseillé mais rien n'a changé. Le code s'effectue sans erreur mais j'ai toujours des 0.

        • Partager sur Facebook
        • Partager sur Twitter
          16 juin 2020 à 20:45:43

          Comment connectes tu les 2 cartes ? En les enfichant ou avec des câbles ?

          Parce que la configuration par défaut des ponts de soudure de la carte CCA02M1, ne correspond pas à l'emplacement des broches SPI de la carte P-NUCLEO-WB55.

          Rien que l'horloge, il faudrait, je crois, couper SB7 et SB13 et connecter SB14 et SB8, ou si tu ne veux pas modifier la carte, mettre un cable entre les broches 11 et 29 du connecteur CN10 (qui correspondent respectivement à SPI1_SCLK et MIC_CLK_NUCLEO). Pour SPI1_MISO, je ne vois pas de possibilité de le connecter à MIC_PDM12 ou MIC_PDM34 avec les ponts de soudure, donc il faudrait le faire avec des fils entre la broche PDM par défaut du micro utilisé et MISO. 

          • Partager sur Facebook
          • Partager sur Twitter
            17 juin 2020 à 9:19:05

            Effectivement,  en connectant directement les deux cartes c'est impossible d'avoir les configurations que je veux, du coup je les ai connectées avec des fils.

            Concrètement j'ai connectées les cartes de la manière suivante :

            • la pin 5 de CN5 de la nucléo est reliée à la pin 4 de CN5 de la board du micro
            • la pin 6 de CN5 de la nucléo est reliée à la pin 6 de CN5 de la board du micro
            • la pin 5 de CN7 de la nucléo est reliée à la pin 2 de CN6 de la board du micro
            • la pin 8 de CN7 de la nucléo est reliée à la pin 6 de CN6 de la board du micro

            De plus , sur la board du micro, SB8 et SB10 ont été fermées et J3 est en position 12.

            Du coup niveau branchement normalement je suis bon.

            -
            Edité par Sidka 17 juin 2020 à 18:04:17

            • Partager sur Facebook
            • Partager sur Twitter
              18 juin 2020 à 3:10:03

              Sidka a écrit:

              De plus , sur la board du micro, SB8 et SB10 ont été fermées et J3 est en position 12.

              Et SB14 ? Parce que MIC_CLK_x2 n'est pas connecté à MIC_CLK si SB14 n'est pas fermé. Sinon, il faut déplacer sur la carte du micro, le cable de la broche 6 de CN5 sur la broche 5 de CN9.

              Du coup niveau branchement normalement je suis bon.

              Tu peux quand même vérifier avec un multimètre qu'il y a bien continuité entre l'horloge qui sort de la carte Nucleo et la broche n°3 du micro utilisé.

              D'après ton code, l'horloge SPI semble être à 2MHz (crystal de 32MHz, source d'horloge HSE, et tous les prescaleurs à 1, sauf celui du SPI qui est à 16), l'analyseur logique montre qu'il y a bien un signal d'horloge qui sort de la carte nucleo, la sortie du micro devrait être correctement connectée à l'analyseur logique, d'après les ponts de soudure que tu indiques comme étant fermés (il y a toujours la possibilité que MOSI ne soit pas configuré sur la bonne broche, mais ça ne devrait pas jouer au niveau du signal de l'analyseur), donc je ne vois pas d'autre possibilité que le fait qu'il y a toujours un mauvais branchement entre l'horloge SPI et l'horloge du micro.

              PS: En fait, la raison pour laquelle MISO est accessible en changeant les ponts de soudure et pas MOSI pour la sortie du micro, est que dans les codes d'exemple, le SPI est utilisé en mode esclave et l'horloge est généré par un des timers sur la broche SPI1_SCLK.

              • Partager sur Facebook
              • Partager sur Twitter
                18 juin 2020 à 12:52:52

                Oh oui effectivement je n'avais pas remarqué merci!

                Du coup j'ai fait cette modification ainsi que d'autres sur mes paramètres :

                static void MX_SPI1_Init(void)
                {
                
                  /* USER CODE BEGIN SPI1_Init 0 */
                
                  /* USER CODE END SPI1_Init 0 */
                
                  /* USER CODE BEGIN SPI1_Init 1 */
                
                  /* USER CODE END SPI1_Init 1 */
                  /* SPI1 parameter configuration*/
                  hspi1.Instance = SPI1;
                  hspi1.Init.Mode = SPI_MODE_MASTER;
                  hspi1.Init.Direction = SPI_DIRECTION_2LINES_RXONLY;
                  hspi1.Init.DataSize = SPI_DATASIZE_16BIT;
                  hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
                  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
                  hspi1.Init.NSS = SPI_NSS_SOFT;
                  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
                  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
                  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
                  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
                  hspi1.Init.CRCPolynomial = 7;
                  hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
                  hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
                  if (HAL_SPI_Init(&hspi1) != HAL_OK)
                  {
                    Error_Handler();
                  }
                  /* USER CODE BEGIN SPI1_Init 2 */
                
                  /* USER CODE END SPI1_Init 2 */
                
                }

                et j'ai enfin des trames :



                Par contre j'ai l'impression qu'elles sont étranges...

                Aussi, je n'ai pas l'impression que les datas remontées évoluent beaucoup lorsque je change le niveau sonore de la pièce...

                -
                Edité par Sidka 18 juin 2020 à 12:53:49

                • Partager sur Facebook
                • Partager sur Twitter
                  18 juin 2020 à 15:55:29

                  Pourquoi as tu changé la fréquence du SPI et de capture de l'analyseur ? Le micro attend entre 1 et 3.25MHz, donc les 2MHz semblaient corrects.

                  Si tu n'as pas changé la fréquence du microcontrôleur, SPI_BAUDRATEPRESCALER_4 passe la fréquence d'horloge du SPI à 32MHz/4 = 8MHz. Normalement cette fréquence est indiqué dans STM32Cube, juste en dessous du paramètre du prescaleur.

                  Et sur l'analyseur logique, tu dois avoir une fréquence au moins double de la fréquence du signal à capturer (théorème de Shannon), donc au minimum 4MHz pour un signal à 2MHz. Ca permet de capturer chaque état du signal sur au moins 1 période complète de la fréquence d’échantillonnage.

                  • Partager sur Facebook
                  • Partager sur Twitter
                    18 juin 2020 à 16:51:02

                    alexisdm a écrit:

                    Pourquoi as tu changé la fréquence du SPI et de capture de l'analyseur ? Le micro attend entre 1 et 3.25MHz, donc les 2MHz semblaient corrects.

                    Justement je ne comprends pas comment je peux avoir des données du coup.

                    De plus avec une fréquence de 2KHz j'ai une clock qui ressemble à ça :

                    On est d'accord pour dire que c'est pas beau non?

                    • Partager sur Facebook
                    • Partager sur Twitter
                      18 juin 2020 à 23:36:56

                      Je ne comprends pas comment tu passes de 2MHz à 2KHz. Ce micro MEMS a besoin d'une fréquence d'horloge de 1MHz minimum, en dessous, son comportement est indéfini. Ca ne veut pas dire qu'il ne va rien renvoyer en dessous de 1MHz, juste que tu risques de ne pas avoir de données valides. La doc de la puce précise juste qu'en dessous d'une certaine fréquence, le micro se met en mode basse consommation.

                      Si l'horloge globale du nucleo est toujours à 32MHz, tu n'as que 2 valeurs possibles pour le prescaleur SPI (hspi1.Init.BaudRatePrescale): SPI_BAUDRATEPRESCALER_16 ou SPI_BAUDRATEPRESCALER_32, pour avoir respectivement 1MHz et 2MHz (il y a d'autres solutions pour utiliser d'autres fréquences, mais c'est juste pour vérifier que ça fonctionne).

                      Dans ton logiciel de capture (Digilent Waveforms ?), ne peux tu pas fixer la fréquence d'échantillonnage à 4MHz ? D'après la doc, il y a un bouton "Config" où tu peux préciser la fréquence dans "Rate" et la durée en secondes ou en nombre d'échantillons.

                      • Partager sur Facebook
                      • Partager sur Twitter
                        19 juin 2020 à 9:22:24

                        C'est juste que je suis stupide, je voulais dire 2MHz pas 2kHz...

                        Oui j'utilise Digilent Waveforms et j'ai mis l'échantillonage à 4MHz mais j'ai pas l'impression que ça change grand chose :

                        • Partager sur Facebook
                        • Partager sur Twitter
                          19 juin 2020 à 23:41:39

                          Si, au moins ça montre que la sortie du micro passe. Tu peux encore augmenter la fréquence d'échantillonnage et/ou baisser la fréquence de l'horloge SPI à 1MHz pour avoir un signal plus carré, avec seulement 2x la fréquence du signal, tu n'as souvent qu'un seul point à l'état haut ou à l'état bas d'où la forme triangulaire du signal (avec d'autres analyseurs, ça ne fait pas forcément ça).

                          Par contre, il y visiblement une pause tous les 16 fronts d'horloge, qui est probablement due à l'option SPI_NSS_PULSE_ENABLE qui comme son nom l'indique envoie une impulsion sur la broche slave select entre chaque trame SPI (ici de 16 bits) en arrêtant l'horloge pendant cette impulsion.

                          -
                          Edité par alexisdm 22 juin 2020 à 13:02:51

                          • Partager sur Facebook
                          • Partager sur Twitter
                            22 juin 2020 à 9:47:36

                            Effectivement c'est bien mieux comme ça merci beaucoup!

                            • Partager sur Facebook
                            • Partager sur Twitter

                            SPI+DMA sur microphones (STM32)

                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                            • Editeur
                            • Markdown