4. Signalabstand einstellen mittels Code

Signalabstand einstellen mittels Code

  • B

    Hallo zusammen

    Ich habe ein weiteres Problem und zwar hoffe ich, dass ich mit den Erklärungen richtig anfange, sodass ihr nicht gleich erschlagen werdet. Lasst euch bitte vom Text nicht abschrecken.

    Ich habe vor ein Signal zu generieren, das zeitlich genau so ausgelegt ist, wie es im Datenblatt des Sensors verlangt ist. Das heisst, die Zeiten sollten annähernd gleich sein.

    Dies sieht so aus wie im Datenblatt in der Abbildung auf Seite 14.
    http://www.neumueller.com/datenblatt/epc/EPC_901.pdf
    Es geht um die Readpulse. Anfang ist ein LongPulse der Länge TRD_PULSE und danach folgen die short pulses.

    Was ich möchte ist ein LongPulse, der Länge TRD_PULSE, welcher von mir aus etwas länger andauern darf wie TRD_PULSE.
    Der EPC Sensor wird auf 32MHz getrimmt. Das heisst, dass TCDS etwa 1.2us lang ist (1156ns). (Zeiten sind der Seite 8 im epc Datenblatt zu entnehmen)

    Nach Ablauf des TCDs möchte ich sofort mit den ReadClocks starten.
    Irgendwie schafft das mein Code nicht und ich weiss nicht wo der Fehler steckt.
    Ich bekomme irgendwas mit 11us raus.. 😕 😕

    Der Ablauf der Interrupts ist so wie im state machine dargestellt.
    Ich erzeuge im DataRdy 1 einen 1. Longpulse und den Rest machen dann die Timer1 und Timer 7 Interrupts. Der Timer 7 Interrupt kommt immer wenn der Counter den Endwert erreicht (überläuft), der Timer 1 Interrupt, wenn der Repetition Counter von 1027 --> 0 erreicht, sprich am Ende der ReadClocks.

    state machine:
    https://picload.org/view/rppldill/state.png.html

    Hier der Code: (main und der interrupts)
    Beim Timer 7 Init habe ich als Periode TCDS angegeben, was ja stimmen sollte. Das ist im Main Programm fast ganz unten zu sehen, in der 3. letzten Zeile
    Ich messe aber 11us 😕

    Ich wäre um Hilfe sehr dankbar

    Hier ist die Messung

    gesamtbild:
    https://picload.org/view/rpplalow/signale.png.html

    einzelbild:
    https://picload.org/view/rpplallr/signale2.png.html

    Hier der Code: (main und interrupts)
    main:

    /* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32l4xx_hal.h"
#include "cmsis_os.h"

/* USER CODE BEGIN Includes */
#include "stdbool.h"
#include "tim15funct.h"
#include "alltimfunct.h"
#include "epc_constants.h"
#include "config.h"
#include "tim1funct.h"
#include "tim2funct.h"
#include "adc.h"
#include "dma.h"
#include "uart.h"
#include "epc.h"
#include "tim7funct.h"

/* USER CODE END Includes */

/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;

I2C_HandleTypeDef hi2c1;

SPI_HandleTypeDef hspi1;

SWPMI_HandleTypeDef hswpmi1;

TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim7;
TIM_HandleTypeDef htim15;
TIM_HandleTypeDef htim16;

UART_HandleTypeDef huart3;

osThreadId defaultTaskHandle;

/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/
osThreadId myTask02Handle;
osThreadId myTask_longHandle;                           

uint8_t buffer[BufferLength];

uint16_t adcValue;
uint32_t count;
bool readOutMemory = false;

uint16_t epcPinActive;

// TIM2 variable
uint16_t pulseArray[4];
/* Dies sind Werte, die von der RS485 Schnittstelle vorgegeben werden und im Center-aligned mode immer halbiert werden müssen.
   Die Werte sollten später deshalb immer durch 2 geteilt werden.
*/
uint16_t led1_Pulse = 150;                                     // später zu Variablen definieren, die per Schnittstelle eingelesen werden
uint16_t led2_Pulse = 150;                                     // später zu Variablen definieren, die per Schnittstelle eingelesen werden
uint16_t led3_Pulse = 150;                                     // war zuvor 75 - später zu Variablen definieren, die per Schnittstelle eingelesen werden
uint16_t led4_Pulse = 150;                                     // später zu Variablen definieren, die per Schnittstelle eingelesen werden
uint16_t ledMaxWidth = 0;

// epc1-4 adresses writte and read
uint8_t ep1_address_write = 0x20;
uint8_t ep2_address_write = 0x26;
uint8_t ep3_address_write = 0x38;
uint8_t ep4_address_write = 0x3E;
uint8_t ep1_address_read = 0x21;
uint8_t ep2_address_read = 0x27;
uint8_t ep3_address_read = 0x39;
uint8_t ep4_address_read = 0x3F;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);

void StartDefaultTask(void const * argument);

void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);

/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/
void StartTask02(void const * argument); 
//void StartTask1_LongPulse(void const * argument); 

/* USER CODE END PFP */

/* USER CODE BEGIN 0 */

void ReadOutIntArray()
{   
    for (uint16_t j = 0; j < EPC_QUANTITY; j++)
    {
      for (uint16_t i = 0; i < DATALENGTH; i++)
      {             
        adcValue = dmaBuffer[j][i];
        USART_Transmit_Int(adcValue);
        USART_sendChar('\n');
        for (count = 0; count <= 50000; count++);
      } 
    }
}

/* USER CODE END 0 */

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();                                                         // enthält später nur die SystemClock Konfigurationen

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();                                                               // sollte später entfernt werden/sein

  /* USER CODE BEGIN 2 */

/* USER Inits*/

/*
            ##### UART config #####
  ==============================================================================   
*/    
   Init_USART3_RS485(115200);                                   

/*
            ##### TIM15 config #####
  ==============================================================================   
*/
   Init_Timer15(500);                                        
   Enable_Shutter_TIM15();                                                      // Schaltet den Kanal 2 von Timer 15 ein (Shuttersignal)

/*
            ##### TIM2 config #####
  ==============================================================================   
*/

   Init_Timer2(500);                                                            

  // Led Pulse werden in das Array pulseArray geschrieben
	pulseArray[0] = led1_Pulse;
	pulseArray[1] = led2_Pulse;
	pulseArray[2] = led3_Pulse;
	pulseArray[3] = led4_Pulse;
   LEDsFlashEnable(pulseArray);                                                 // Alle LED-Flashsignale werden zur gleichen Zeit eingeschaltet

/*
            ##### TIM1 config #####
  ==============================================================================   
*/ 
   InitReadCLKTimer(TRD_CLOCK, READ_CLK_TIM1_REPETITION_COUNT_VALUE);

   // Alle Kanäle werden vorsichtshalber ausgeschaltet
   Disable_EPCReadCLK_CH(EN_EPC1_CH | EN_EPC2_CH | EN_EPC3_CH
                      | EN_EPC4_CH | EN_ADC_TRG_CH);           

/*
            ##### DMA config #####
  ==============================================================================   
*/  
   /******** Konfiguration der DMA für den ADC - um korrekte Funktionalität zu 
   gewähren muss die Konfiguration der DMA nach der TIM1 Konfiguration sein ***/

   Init_DMA_ADC1(DMA_DATA_LEN, &dmaBuffer[0][0]);                                            
   __HAL_DMA_ENABLE(&hdma_adc1);

/*
            ##### ADC config #####
  ==============================================================================   
*/ 
   Init_ADC1();                                                                  
   select_ADC_Channel_to_Convert(1);
   Reset_ADC_from_DEEP_PWR_DOWN();

   HAL_ADCEx_Calibration_Start(&hadc1, ADC_SINGLE_ENDED);                      /* Nur notwendig, wenn die MCU im deep power modus war. Vor der Kalibration 
                                                                                  sollten die Bits auf jeden Fall --> DEEPPWD=0, ADVREGEN=1 sein und dass der ADC voltage 
                                                                                  regulator startup Zeit vorüber ist, bevor weitere Aktionen vorgenommen werden(tADCVREG_STUP = 20us) */
   ADC_Enable(&hadc1);
   Start_ADC();    

/*
            ##### DATARDY1 Interrupt config #####
  ==============================================================================   
*/ 

   Init_EXTI_H0_DATARDY_epc1();   

/*
            ##### TIM7 config #####
  ==============================================================================   
*/ 
   uint8_t tcds =  TCDS >> 1;                                                   // Definition der Periode des Timer 7, TCDS durch 3 geteilt, um 1us zu erreichen
   Init_TIM7(tcds);

/*
            ##### Global variable definition - Read out process #####
  ==============================================================================   
*/ 
  epcPinActive = 0;

    Interrupts:

    /* Includes ------------------------------------------------------------------*/
#include "stm32l4xx_hal.h"
#include "stm32l4xx.h"
#include "stm32l4xx_it.h"
#include "cmsis_os.h"

/* USER CODE BEGIN 0 */
#include "stdbool.h"
#include "tim1funct.h"
#include "tim15funct.h"
#include "config.h"
#include "alltimfunct.h"
#include "epc_constants.h"
#include "uart.h"
#include "tim7funct.h"
#include "adc.h"
#include "dma.h"

uint16_t zaehler = 1;

extern UART_HandleTypeDef huart2;
extern ADC_HandleTypeDef hadc1;
extern TIM_HandleTypeDef htim1;

extern uint16_t epcPinActive;
extern bool readOutMemory;

typedef struct _readout_t
{
   uint16_t pin;
   uint16_t tim_ch;
   uint8_t adc_ch;
} chReadOutInfo_t;

const chReadOutInfo_t epcInfo[] = {
   {
      .pin = EPC_READ_CLK_CH1_PIN,
      .tim_ch = EN_EPC1_CH,
      .adc_ch = 1,
   },
   {
      .pin = EPC_READ_CLK_CH2_PIN,
      .tim_ch = EN_EPC2_CH,
      .adc_ch = 3,
   },
   {
      .pin = EPC_READ_CLK_CH3_PIN,
      .tim_ch = EN_EPC3_CH,
      .adc_ch = 7,
   },
   {
      .pin = EPC_READ_CLK_CH4_PIN,
      .tim_ch = EN_EPC4_CH,
      .adc_ch = 9,
   },
};

/* USER CODE END 0 */

/* External variables --------------------------------------------------------*/
extern DMA_HandleTypeDef hdma_adc1;

extern TIM_HandleTypeDef htim6;

/******************************************************************************/
/* STM32L4xx Peripheral Interrupt Handlers                                    */
/* Add here the Interrupt Handlers for the used peripherals.                  */
/* For the available peripheral interrupt handler names,                      */
/* please refer to the startup file (startup_stm32l4xx.s).                    */
/******************************************************************************/

/**
* @brief This function handles DMA1 channel1 global interrupt.
*/
void DMA1_Channel1_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel1_IRQn 0 */

  /* USER CODE END DMA1_Channel1_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_adc1);
  /* USER CODE BEGIN DMA1_Channel1_IRQn 1 */

  /* USER CODE END DMA1_Channel1_IRQn 1 */
}

/**
* @brief This function handles TIM6 global interrupt, DAC channel1 and channel2 underrun error interrupts.
*/
void TIM6_DAC_IRQHandler(void)
{
  /* USER CODE BEGIN TIM6_DAC_IRQn 0 */

  /* USER CODE END TIM6_DAC_IRQn 0 */
  HAL_TIM_IRQHandler(&htim6);
  /* USER CODE BEGIN TIM6_DAC_IRQn 1 */

  /* USER CODE END TIM6_DAC_IRQn 1 */
}

/* USER CODE BEGIN 1 */

/*
  ******************************************************************************
  * ACHTUNG: Interrupt -> TIM1_BRK_TIM15_IRQHandler (void)  
  *
  * Dieser Interrupt ist für den TIM15 (Shutter) um den TIM2 Counter im PWM Mode
  * stoppen zu können. 
  * Wenn der ARR Wert des Timer 15 erreicht wurde, stoppt der Interrupt das 
  * laufende PWM Signal so, dass nach dem ersten Led-Flashpuls die PWM
  * abgeschaltet wird. Damit wird künstlich ein One Pulse Mode erzeugt, welcher
  * zentriert ist, da im OC Mode keine Möglichkeit besteht, die Signale 
  * center-aligned, sprich zueinander (CH 1-4) zentriert zu gestalten.  
  *
  *   1. Dieser Interrupt wird nur benötigt, wenn der PWM Modus genutzt werden 
         soll

    Entkommentiere den folgenden Interrupt, falls der PWM Modus genutzt wird
  ******************************************************************************  
  */

/*************** Entkommentiere hier !!!!!!! TIM1_BRK_TIM15_IRQHandler (void) *******/

//void TIM1_BRK_TIM15_IRQHandler (void)                                                  
//{                                              
//   
//  if (TIM15->SR & TIM_SR_UIF) 
//  {
//    TIM15->SR &= ~TIM_SR_UIF;
//     
//    Disable_Timerx_Counter(TIM2); 
//  }
//}

/*********** Ende Entkommentiere hier!!!!!!! TIM1_BRK_TIM15_IRQHandler (void) *******/

/*
  ******************************************************************************
  * INFORMATION ZU DER INTERAKTION DER FOLGENDEN 3 INTERRUPTS:
  *       1. EXTI15_10_IRQHandler (void) 
  *       2. TIM7_IRQHandler(void)
  *       3. TIM1_UP_TIM16_IRQHandler (void)  
  * Der DATARDY1 Interrupt EXTI15_10_IRQHandler (void) kommt lediglich einmal und
  * erzeugt nur den ersten LongPulse.
  * Der Interrupt TIM7_IRQHandler(void) erzeugt anschliessend immer die
  * ShortPulses und der Interrupt TIM1_UP_TIM16_IRQHandler (void) den LongPulse
  * Diese Interaktion dauert so lange an, bis der epcPinActive = 4 ist
  * Dann wird erneut auf das DATARDY1 Signal gewartet.
  ******************************************************************************  
  */

/*
  ******************************************************************************
  * ACHTUNG: Interrupt -> EXTI15_10_IRQHandler (void)
  *
  * Dies ist der DATARDY1 Interrupt auf PIN PC10
  * Wenn das Shuttersignal low geht, geht das DATARDY1 Signal nach der Zeit 
  * T_SHIFT high. Dann wird der Interrupt aktiv
  ******************************************************************************  
  */

  /*
  ******************************************************************************
  * Aufgabe: Interrupt -> EXTI15_10_IRQHandler (void)
  *
  * Der Interrupt DATARDY1 kommt lediglich einmal pro Auslesesequenz. In diesem
  * Interrupt wird lediglich der erste LongPulse per CPU generiert und der
  * Timer 7 gestartet, um die Interaktion zwischen Timer 7 und Timer 1 zu starten,
  * die für das serielle Auslesen der EPC Sensoren verantwortlich sind. 

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

void EXTI15_10_IRQHandler (void) {                                             

  if (__HAL_GPIO_EXTI_GET_IT(DataRdy1.pin) != RESET)                             // Wenn DATARDY1 aktiv bzw. high
  {
    __HAL_GPIO_EXTI_CLEAR_IT(DataRdy1.pin);                                      // Lösche die Interrupt Flag

    epcPinActive = 0;                                                            // Setze die Variable 0
    Disable_Shutter_TIM15();                                                     // Shutter ausschalten, damit die Zeitüberlappungen laut epc datasheet vermieden werden

    TIM7->DIER |= TIM_DIER_UIE;                                                  // Den Timer 7 Interrupt einschalten
    configChannelsTim1_AsOP();                                                   // Den Timer 1 als Output konfigurieren, um den Pin schreiben zu können (LongPulse mittels CPU)

    /* Dieser Abschnitt erzeugt genau einen LongPuls der im epc Datasheet 
       benötigten Länge */
    #pragma push                                                                 /* Speicher den aktuellen Optimierungslevel */
    #pragma O0                                                                   /* Optimierungslevel ist auf O0 gesetzt */
       EPC_READ_CLK_PORT->BSRR = (uint32_t)epcInfo[epcPinActive].pin;            // Setze Pin high
       __asm {NOP}                                                               // keine Aktion
       EPC_READ_CLK_PORT->BRR = (uint32_t)epcInfo[epcPinActive].pin;             // Setze Pin low
    #pragma pop                                                                  /* Stelle den original Optimierungslevel wieder her */

    TIM1->SR &= ~TIM_SR_UIF;                                                     // Lösche den Timer overflow interrupt flag                 
    TIM1->DIER |= TIM_DIER_UIE;                                                  // Schalte den Interrupt ein
    Start_Timerx_Counter(TIM7);                                                  // Starte Timer 7 Counter
  }
}

/*
  ******************************************************************************
  * ACHTUNG: Interrupt -> TIM7_IRQHandler(void)
  *
  * Wenn der Timer 7 gestartet wurde, wird nach dem Erreichen des Counter 
  * Endwertes (ARR-Wert) in die Interrupt Routine gesprungen.
  ******************************************************************************  
  */

  /*
  ******************************************************************************
  * Aufgabe: Interrupt -> TIM7_IRQHandler(void)
  *
  * Der Interrupt des Timer 7 ist für die Generierung der ShortPulses zuständig.
  * Nach dem DATARDY1 Interrupt wird dieser solange aufgerufen, bis alle vier
  * EPC Sensoren ausgelesen sind. Der Ganze Prozess hat sein Ende, sobald die 
  * Variable epcPinActive den Wert 4 erreicht hat. 

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

void TIM7_IRQHandler(void)
{

    __HAL_TIM_CLEAR_IT(&htim7, TIM_FLAG_UPDATE);                                // Lösche den Interrupt Flag

    Stop_Timerx_Counter(TIM7);                                                  // Stoppe den Timer 7 Counter

    TIM1->CCER |= epcInfo[epcPinActive].tim_ch | EN_ADC_TRG_CH;                 // Schalte den aktiven Kanal und den ADC Triggerkanal ein
    configChannelsTim1_AsAF();                                                  // Den Timer 1 als alternate Function konfigurieren, um die Timer 1 Short Pulses auf den Kanal legen zu können

    select_ADC_Channel_to_Convert(epcInfo[epcPinActive].adc_ch);                // Wähle den aktuellen ADC Kanal 

    Start_Timerx_Counter(TIM1);                                                 // Starte den Timer 1 Counter

}

/*
  ******************************************************************************
  * ACHTUNG: Interrupt -> TIM1_UP_TIM16_IRQHandler (void) 
  *
  * Wenn der Timer 1 gestartet wurde, wird nach dem Erreichen des Repetition- 
  * Counterwerts = 0 ein Interrupt ausgelöst. Dann wird in die Interrupt 
  * Routine gesprungen. 
  ******************************************************************************  
  */

  /*
  ******************************************************************************
  * Aufgabe: Interrupt -> TIM1_UP_TIM16_IRQHandler (void) 
  *
  * Der Interrupt des Timer 1 ist für die Generierung des LongPulse zuständig.
  * Nach dem DATARDY1 Interrupt wird dieser solange aufgerufen, bis alle vier
  * EPC Sensoren ausgelesen sind. Der Ganze Prozess hat sein Ende, sobald die 
  * Variable epcPinActive den Wert 4 erreicht hat. 

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

void TIM1_UP_TIM16_IRQHandler (void)                                            
{ 
   TIM1->SR &= ~TIM_SR_UIF;                                                     // Lösche den Timer overflow interrupt flag  
   TIM1->CCER &= ~(epcInfo[epcPinActive].tim_ch | EN_ADC_TRG_CH);               // Schalte den aktiven Kanal und den ADC Triggerkanal ein
   Stop_Timerx_Counter(TIM1);                                                   // Stoppe den Timer 1 Counter
   epcPinActive++;                                                              // Inkrementiere den Variablenwert

   if (epcPinActive < 4 )
   {  

      configChannelsTim1_AsOP();                                                // Den Timer 1 als Output konfigurieren, um den Pin schreiben zu können (LongPulse mittels CPU)

      /* Dieser Abschnitt erzeugt genau einen LongPuls der im epc Datasheet 
         benötigten Länge */
      #pragma push                                                              /* Speicher den aktuellen Optimierungslevel */
      #pragma O0                                                                /* Optimierungslevel ist auf O0 gesetzt */
          EPC_READ_CLK_PORT->BSRR = (uint32_t)epcInfo[epcPinActive].pin;        // Setze Pin high
          __asm {NOP}                                                           // keine Aktion
          EPC_READ_CLK_PORT->BRR = (uint32_t)epcInfo[epcPinActive].pin;         // Setze Pin low
      #pragma pop                                                               /* Stelle den original Optimierungslevel wieder her */

      Start_Timerx_Counter(TIM7);                                               // Starte Timer 7 Counter

   }
   else
   {
      Stop_Timerx_Counter(TIM1);
      Stop_Timerx_Counter(TIM7);
      Enable_Shutter_TIM15();                                                   // Aktiviere wieder den Timer 15 Kanal 2 (Shuttersignal)
      epcPinActive = 0;                                                         // Setze den Variablenwert zurück auf 0
      readOutMemory=true;
   }

}
    0
  • B

    Habe ich euch erschlagen mit meiner Schreiberei?

    Ich wäre um Hilfe wirklich dankbar.

    Ich denke, ich habe auch einen kleinen Fehler herausgefunden, welcher aber nicht das Problem löst.
    Im Interrupt DataRdy, sprich EXTI15_10_IRQHandler (void) generiere ich den LongPulse mit

    #pragma push                                                              /* Speicher den aktuellen Optimierungslevel */ 
       #pragma O0                                                                /* Optimierungslevel ist auf O0 gesetzt */ 
           EPC_READ_CLK_PORT->BSRR = (uint32_t)epcInfo[epcPinActive].pin;        // Setze Pin high 
           __asm {NOP}                                                           // keine Aktion 
           EPC_READ_CLK_PORT->BRR = (uint32_t)epcInfo[epcPinActive].pin;         // Setze Pin low 
       #pragma pop

    Danach müsste ich beim Start von Timer 7 (TCDS - LongPulse Länge) als Periode angeben und nicht TCDS direkt. Aber dennoch müsste doch so maximal 1us zwischen dem LongPulse und den Shortpulses sein und nich 11us-LongPulse..

    Der Timer startet erst nach diesen 2 Befehlen.

    TIM1->SR &= ~TIM_SR_UIF;
    TIM1->DIER |= TIM_DIER_UIE;

    Zudem ruft der Start des Timer 7 die Funktion:
    Start_Timerx_Counter(TIM7);
    auf.
    Kann es sein, dass diese Befehle vor allem mit dem Aufrufen der Funktion Start_Timerx_Counter noch sooo viel Zeit benötigt??

    0
  • F

    buell schrieb:

    Habe ich euch erschlagen mit meiner Schreiberei?

    Du bist eher im falschen Board gelandet. Die Burschen hier können Standard-C, aber von speziellen Toolchains und Controllern haben die keinen Schimmer.

    Frag besser in einem Forum, wo sich die Leute mit deiner MCU befassen, oder den Distributor deines Chips. Im Idealfall vermittelt er dir einen FAE, der mit dir zusammen da Problem löst. Die sind schließlich daran interessiert, möglichst viel von ihrem Zeug zu verkaufen. 🙂

    0
Anmelden zum Antworten