stm32 timers synchronisieren in encoder mode

[Navid M. (Firma: mori) (navidmo198)]

Hallo zusammen,

Ich muss 8 Timer von 2 Stm32f7 Nucleo Board im Encoder-Modus verwenden, 
um Encoder-Daten zu speichern. Aber ich muss die Timer synchronisieren. 
Dafür gibt es zwei Methoden: 1. Externe Clock 2. Master/Slave-Modus.

Aber in diesen 2 Modi kann man keine Timer im Encoder-Modus verwenden. 
Kann  jemand mir bitte helfen? Wie kann ich den Timer im Encoder-Modus 
synchronisieren?

[Uwe Bonnes (Gast)]

Was soll "synchronisieren in encoder mode" bedeuten. Takt fuer die Timer 
kommt vom Encoder, da kannst Du nichts synchronisieren. Nur das Auslesen 
sollte moeglichst schnell hintereinander erfolgen, aber wenn Du die 
Timer zuegig hintereinander ausliest sehe ich da auch keine grosse 
Chance fuer  Jitter. Evt waehrend der Auslese Interrupts deaktivieren...

[Navid M. (Firma: mori) (navidmo198)]

Danke für deine Antwort.

Ich habe 8 Timers von 2 Stm32F7 boards in encoder mode benutzt um die 
encoderinkremente zu lesen. Die 2 Boards und mein Programm funktionieren 
richtig, aber es gibt immer +/- 1ms Verzogerung zwischen Timers. (Z.B 
eine encoder zeigt die Werte 2000 in miliseconde 500 und die andere 
zeigt das in 501ms und die andere in 499ms)

Ich muss die Timers synchronisieren. Timers kann man mit external clock 
oder in Master slave mode synchronisieren, aber so man kann nicht mehr 
Timers in encoder mode benutzen.

[Jan H. (jan_h74)]

Wen ich das richtig verstehen :
Sie haben 2 STM32 F7 µ-controller
Jeden F7 µ ist verbunden mit ein motor-encoder mit A/B pulsen.
Sie wollen jetzt das beide µ-controller das gleiche Ergebnis von pulsen 
zaehlen (es geht um nur ein motor) ?

[Navid M. (Firma: mori) (navidmo198)]

Ja genau. Die beiden Boards zeigen richtig. Aber es gibt eine 
Verzögerung zwischen boards. ein Stm32 zeigt das Ergebnis 1 ms früher 
oder später im Vergleich mit dem anderen.

[Jan H. (jan_h74)]

Ich siehe 2 mogliche Fehlerquellen :
1. Die counter in beide F7 werden nicht auf den identische moment auf 
"0" gezetst. Hier soll ich ueber eine GPIO und ISR die counter auf 0 
setzen. Damit ist eine synchronisierung in µs bereich machbar.
2. Wie werden die counter ausgelesen (usart, display)? Irgendwo muss die 
countervalue nach aussen kommen und interpretiert werden. Falls moglich 
auch hier mit ein GPIO und ISR die beide countervalues kopieren und den 
kopie nach aussen bringen.

[Navid M. (Firma: mori) (navidmo198)]

Ich habe CubeMx benutz. Timer habe ich in Encoder Mode eingestellt.
Dann habe ich die Channel A und B aktiviert:
HAL_TIM_Encoder_Start(&htim1, TIM_CHANNEL_1);
HAL_TIM_Encoder_Start(&htim1, TIM_CHANNEL_2);

Und die Encoderswerte ausgelesen mit:
encoder_count = __HAL_TIM_GET_COUNTER(&htim1);

Wie kann man Über eine GPIO und ISR die counter auf 0 setzen?
Sorry für viele Fragen. Ich habe nicht zu viele Erfahrungen.

[Jan H. (jan_h74)]

An jeden GPIO pin kann ein "Interrupt Service Routine" gekuppelt werden. 
Das ist ein Routine die unabhangig von den normale Ablauf ("loop") 
activiert werd wen ein GPIO-pin von Zustand wechselt. Das gleiche Signal 
muss naturlich an beide µ verbunden werden. Auch in cube kann das 
gemacht werden.
Werden die Zaehler jetzt genullt bei booten von  µ ? Steht en Motor dan, 
oder kann er schon drehen ? Wie werden den __HAL_TIM_GET_COUNTER(&htim1) 
sichtbar gemacht ? Wen das in der loop ist, sind die naturlich nicht 
synchronisiert. Beide loops laufen komplett unabhangig von ein ander.

[Navid M. (Firma: mori) (navidmo198)]

Du meinst ich muss Die Werte nach einem Interrupt auslesen?
Also ich muss encoder_count = __HAL_TIM_GET_COUNTER(&htim1);  nach 
Interrupt machen? Dann wie kann ich Interrupts in jedem Mikro 
miteinander und mit anderem Mikro synchronisieren?
Bei booten Encoderswerte wird null, deswegen ich denke ja die Zähler 
werden genullt.
Motor ist unabhängig von diesem Projekt. Also es gibt ein Motor, der 
sich dreht. Der hat einen Inkrementalen Enkoder und ich muss die 
Inkremente vom Motor nur lesen.
Das ist mein Programm:

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 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 */

/* 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 ---------------------------------------------------------*/

TIM_HandleTypeDef htim1;

/* USER CODE BEGIN PV */
int32_t encoder_count;


/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM1_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* 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_TIM1_Init();
  /* USER CODE BEGIN 2 */

 // HAL_TIM_Encoder_Start(&htim3, TIM_CHANNEL_1);
//  HAL_TIM_Encoder_Start(&htim3, TIM_CHANNEL_2);

  HAL_TIM_Encoder_Start(&htim1, TIM_CHANNEL_1);
    HAL_TIM_Encoder_Start(&htim1, TIM_CHANNEL_2);




  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

    encoder_count = __HAL_TIM_GET_COUNTER(&htim1);
    //encoder3 = __HAL_TIM_GET_COUNTER(&htim3);
   // encoder4 = __HAL_TIM_GET_COUNTER(&htim4);

  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 192;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Activate the Over-Drive mode
  */
  if (HAL_PWREx_EnableOverDrive() != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief TIM1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM1_Init(void)
{

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_Encoder_InitTypeDef sConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 0;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 65535;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  sConfig.EncoderMode = TIM_ENCODERMODE_TI1;
  sConfig.IC1Polarity = TIM_ICPOLARITY_RISING;
  sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI;
  sConfig.IC1Prescaler = TIM_ICPSC_DIV1;
  sConfig.IC1Filter = 0;
  sConfig.IC2Polarity = TIM_ICPOLARITY_RISING;
  sConfig.IC2Selection = TIM_ICSELECTION_DIRECTTI;
  sConfig.IC2Prescaler = TIM_ICPSC_DIV1;
  sConfig.IC2Filter = 0;
  if (HAL_TIM_Encoder_Init(&htim1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, LD1_Pin|LD3_Pin|LD2_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_6, GPIO_PIN_RESET);

  /*Configure GPIO pin : USER_Btn_Pin */
  GPIO_InitStruct.Pin = USER_Btn_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(USER_Btn_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : RMII_MDC_Pin RMII_RXD0_Pin RMII_RXD1_Pin */
  GPIO_InitStruct.Pin = RMII_MDC_Pin|RMII_RXD0_Pin|RMII_RXD1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pins : RMII_REF_CLK_Pin RMII_MDIO_Pin RMII_CRS_DV_Pin */
  GPIO_InitStruct.Pin = RMII_REF_CLK_Pin|RMII_MDIO_Pin|RMII_CRS_DV_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pins : LD1_Pin LD3_Pin LD2_Pin */
  GPIO_InitStruct.Pin = LD1_Pin|LD3_Pin|LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : RMII_TXD1_Pin */
  GPIO_InitStruct.Pin = RMII_TXD1_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  HAL_GPIO_Init(RMII_TXD1_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : STLK_RX_Pin STLK_TX_Pin */
  GPIO_InitStruct.Pin = STLK_RX_Pin|STLK_TX_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

  /*Configure GPIO pin : PG6 */
  GPIO_InitStruct.Pin = GPIO_PIN_6;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

  /*Configure GPIO pin : USB_OverCurrent_Pin */
  GPIO_InitStruct.Pin = USB_OverCurrent_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(USB_OverCurrent_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : USB_SOF_Pin USB_ID_Pin USB_DM_Pin USB_DP_Pin */
  GPIO_InitStruct.Pin = USB_SOF_Pin|USB_ID_Pin|USB_DM_Pin|USB_DP_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : USB_VBUS_Pin */
  GPIO_InitStruct.Pin = USB_VBUS_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(USB_VBUS_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : RMII_TX_EN_Pin RMII_TXD0_Pin */
  GPIO_InitStruct.Pin = RMII_TX_EN_Pin|RMII_TXD0_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

[Jan H. (jan_h74)]

Es ist mir immer noch unklar wie die Counter werte nach "aussen" gehen. 
In der main loop steht nur "encoder_count = 
__HAL_TIM_GET_COUNTER(&htim1);" Wie wissen sie dan das encouder_count 
verschiedene Werte haben in die 2 µ ?

[Navid M. (Firma: mori) (navidmo198)]

Ich habe Cube Monitor benutzt die Daten zu speichern. Das gibt ein CSV. 
File. Darin kann man gut die Werte und Zeit sehen.
im Foto die erste Spalte ist die Anzahl von Inkremente.
2. und 3. Spalte ist die Zeit für Encoder1 und Encoder2.
Wie im Foto zu sehen ist Anzahl der Inkremente 88 ist für der erster 
Encoder in der Zeit 32ms but für zweiter Encoder in der 33ms.
Manchmal das ist gleich manchmal das hat +-1ms Differenz.

[Jan H. (jan_h74)]

Eigenlich ist ihre problem das Cube Monitor diese 1ms nicht immer 
einhalt ?
Da fehlen ab und zu eine Daten satz. Ich glaube nicht das dieses 
Verfahren auf millisecunden genau die Daten speichert ! Können sie nicht 
einfach mal die Motor stoppen, beide µ-controller resetten (counter =0), 
motor starten, motor wieder stoppen, und dan die erste und letzte 
Zaehlerstanden vergleichen ? Wen diese gleich sind, ist das encoder 
auswerten doch IO ?

[Peter D. (peda)]

Timer im Zählermode werden nicht genullt. Beim Nullen könnte ein 
gleichzeitiger Zählimpuls verloren gehen. Daher merkt man sich immer nur 
den vorherigen Zählerwert und bildet die Differenz zum aktuellen 
Zählerwert. Der Zählerwert ist quasi read-only.
Will man an einer Referenzmarke den Zählerstand als Nullwert speichern, 
dann liest man ihn genau an der Referenzmarke aus.

Die 1ms Unterschiede liegen an der Erstellung der CSV-Datei. Stehen die 
Encoder still, sollten die Differenzen zum Startwert wieder exakt gleich 
sein.

[Navid M. (Firma: mori) (navidmo198)]

Danke für Ihre Antwort.
Aber ich denke Stm32 kann nicht die schnelle Änderungen synchron zeigen. 
Ich habe den gleichen Encoder an 4 Timers angeschlossen. Theoretisch 
müssen die Werte immer gleich sein. Aber wie im Foto zu sehen ist bei 
der Änderung gibt es immer Unterschied. Aber wenn der Encoder in 
Standstill ist zeigen alle Timers richtig und gleiche Werte.

[Peter D. (peda)]

Ich vermute mal, das Debuggen erfolgt über USB und die 1ms Unterschied 
sind einfach die Pollingzeit des USB. Der Debugger kann daher nicht 
kleiner als 1ms auflösen.

[Navid M. (Firma: mori) (navidmo198)]

Kann man irgendwie die Daten in Mikro speichern? So die Aufzeichnung der 
Daten ist unabhängig von USB.

[Jan H. (jan_h74)]

Ja, das geht. Dan wird das problem verschoben nach "Diese Daten mussen 
ms genau auf beide µ gespeichert werden".
Diese Zeitpunkt kann ueber eine GPIO "synchronisiert" werden ! Ein µ 
wird master, und gibt jeden secunde / milli secunde ein puls (GPIOpin 
High/Low)an die andere µ. Diese µ reagiert auf diesen puls mit eine 
interrupt. In die interrupt wird dan die zaehler wert gespeichert.
Damit erreichen sie locker eine synchronisierung von 100 µsec.

volatile int encodercounter[1000];
Interrupt_GPIO{
encodercounter[count]=zaehler;
count++;
if (count>998)count=0;
}

[Gerald M. (gerald_m17)]

Hallo Navid,

vielleicht erklärst du Mal was genau du erreichen willst.
Gehe einfach davon aus, dass die Encoder Counter in beiden 
Mikrocontrollern das gleiche anzeigen. Zumindest sofern beim einschalten 
der Controller der Encoder stillsteht.
Das was du gerade hast, ist ein Ausleseproblem. Ist das in deinem Fall 
überhaupt ein wirkliches Problem? Was machst du später mit den Werten?

[Navid M. (Firma: mori) (navidmo198)]

Hallo Gerald,
Ich will die Encoderwerte messen. Ich habe 2 Stm32f7 Board benutzt.
Mein Problem ist das, dass ich mit gleichem Encoder unterschiedliche 
Werte mit Mikro Boards auslese.
Die Werte sind richtig aber ein Board zeigt die Werte mit +-1ms 
Verzögerung.
Ich habe ein external Clock auch benutzt um Clock zu synchronisieren 
aber das Problem gibt es noch.

[Stefan F. (Gast)]

Navid M. schrieb:
> Ich will die Encoderwerte messen.

Das kann alles und nichts bedeuten. "Ich will Würfel messen" sagt genau 
so wenig aus.

[Peter D. (peda)]

Navid M. schrieb:
> Ich will die Encoderwerte messen.

Was willst Du denn messen?

Um die Encoderauswertung zu überprüfen, fährt man eine Strecke hin und 
dann 10 Teilstrecken zurück. Danach muß man wieder beim gleichen 
Zählerstand angekommen sein, sonst stimmt was nicht.

[Gerald M. (gerald_m17)]

Hallo Navid, das ist kein Problem einer nicht synchronen Clock. Das ist 
ein Problem wie du die Werte ausliest.

Wenn du dir einmal Mühe bei deiner Antwort auf die Frage gibst, was du 
machen willst, sage ich dir, wie man das typischerweise richtig macht 
(dazu gehört beispielsweise kein Cube Monitor). Ich gebe dir dann sogar 
ein Beispiel dafür, wann und warum eine Clock synchronisiert sein muss.