Är en STM32 bra att använda som USB I/O-modul?

[Rick81]

Ja det finns exempelkod i halbiblioteket för PWM och ADC, timer interupt för stm32f4. Använder man PWM perihperals så belastas inte processorn alls.

[AndLi]

Och det går med dessa att skapa pulståg med precision i 1uS skalan... det bör räcka...

[Icecap]

Det är sällan att PWM-hårdvara kan ha så pass låga PWM-frekvenser som 100mHz. I det läge använder man ju oftast en timer-interrupt och en räknare som fixar biffen med en enkel jämförelse.

Tiden som går åt till att ta hand om detta bör vara ytterst försumbar - men kanske Al kan få varje interrupt till att vara en månresa som det programmeringsgeni h*n är.

[Rick81]

Osäker på hur prescaler och timer är då jag aldrig gjort så långsamma PWM, men som sagt timer interupt exempel finns i hal biblioteket också.

Sen var väl grundfrågan om en PC eller Raspberry var snabbast? Frågan borde väl ha varit "räcker en raspberry pi till för de beräkningar jag vill göra?". Det gäller att välja den processor som är lämplig för tillämpningen inte den som är snabbast. Hade ju varit lite dyrt med en Intel i7 i varje fjärrkontroll till tvn....

[Micke_s]

STM32 kan du förvisso koppla ihop två timers och använda den första som prescaler.
Gissar på att du kan få väldigt långa PWM tider med dessa.

[Al_Bundy]

Tja, använder du en uC så är det ju bara att skicka procent-värdet till den, och låta C-programmet i din uC hantera resten

Fast den ska ju beräkna med systemidentifiering och kvadratisk programmering.

Men snälla - att göra den PWM-funktion med en timer-interupt tillhör ju basal programmering. I övrigt har den beskrivits ett antal gångar så det är väl bara att leta lite.

Men som det geni du är med linjär och kvadratisk programmering borde det vara som att stjäla godis från barn för dig - eller hittar du ingen klippa-och-klistra exempel?

Tack. Då ska jag lägga fokus på detta.

Jag har hittat några filmklipp som visar hur man styr en STM32.

Vad är minst prestandakrävande om man vill pulsera PWM i långa sekunder?

Får man fråga exakt vad du pysslar med om du måste ta hänsyn till tidsdilatation?
För oss vanliga dödliga finns det inga långa eller korta sekunder, bara sekunder. Men med dina omnipotenta kunskaper är jag inte förvånad att du fått kontrakt åt någon rymdmyndighet.

Jag jobbar mycket åt uppfinnare och dem har märkliga krav. Märkliga menar jag att utvecklingstiden är kort, samt hårdvaran ska vara billig också.
Jag jobbar mycket åt processindustrin och hydrauliken.

3. Ställa ned PWM frekvensen på en analog utgång så att dessa har en cykeltid mellan 0 till 10 sekunder.

är PWM frekvensen 0 - 0.1 Hz,
det vill inte jag kalla PWM...

vill du minimera tiden för att utföra uppgifter som rör 0.1Hz "PWM"

2. Skicka dessa tre analoga värden via UART.

är det dessa data du skriver om i en tidigare tråd där du får med en massa nollor vid avläsningen?

Japp. Vi säger att jag har en PWM på t.ex 8 bit. Då är 255 100% duty call och 0 är 0% duty call. Men jag vill ändra frekvensen så att t.ex. 1 är t.ex. 10 Hz.

Detta har inget med min andra tråd att göra.

Rotar du runt lite djupare i ditt favotool(cube) från st så är jag rätt säkert på att det finns exempel på pwm där.

Ditt exempel borde gå att implementera med en tom while(1) i Main och låta interupt och dma ta hand om det hela.

Men det kräver lite av dig som programmerare...
Men extern hårdvara är defenetivt inte nödvändigt..
Och ett rtos äter ju mest klockcykler...

Jag ska titta på detta. OK. Rtos är då uteslutet.

STM32 kan du förvisso koppla ihop två timers och använda den första som prescaler.
Gissar på att du kan få väldigt långa PWM tider med dessa.

Jag tror det också får bli som du och andra säger. Timers och prescaler för at pulsera med en digital utgång.

[Al_Bundy]

STM32 kan du förvisso koppla ihop två timers och använda den första som prescaler.
Gissar på att du kan få väldigt långa PWM tider med dessa.

Jag testade att dra ned min clocka till 1 Mhz. Den är på 84 Mhz normal. Men jag kunde inte komma längre ned än 100 Hz på en PWM.
Då kanske man får använda sig av en 555 timers och styra den via en digital 10 kOhm potentiometer.

Sådan hastighet skulle jag vilja ha

[AndLi]

Eftersom det är så väldigt långsamma förlopp du jobbar mot kan ju upplösningen knappt ens behöva vara i ms?

Sätt upp en timer som skickar ett interrupt en gång i ms, däri implementerar du sen en enkel liten mjukvaru pwm.

En 555 får inte din konstruktion att framstå som så bleeding edge, risken finns att någon tom kan tolka det som inkompetens...

[Al_Bundy]

Nej. Upplösningen kan vara 0.1 sekundvis. Vi säger att jag har 16 bits PWM, vilket jag har.

Men borde jag inte spara mer tid på att låta SPI'n sköta styrningen av en 555 timer, jämfört med att ha en timer som skickar ett uppehåll varje 0.1 sekund och sedan lite C-kod för att få till så att en digital utgång blir en "långvarig" PWM?

Tänk på att det är tre stycken digitala utgångar jag ska styra med långa pulser. Sedan ska jag ha UART kommunikation också, samt läsa analoga värden.

Jag undviker att programmera "krånglig kod" för det är dålig praktik. Kod ska vara strikt och flödet ska vara logiskt. Jag använder exempelvis aldrig globala variabler när jag programmerar i Java eller i andra programmeringsspråk. Jag följer alltid OOP. Men nu kör jag C och då får jag anpassa mig efter dess struktur.

Jag ska ta och titta på interrupts.

[Glattnos]

Vad är anledningen till att inte använda ett timer interrupt i detta fall? Behövs precision och lång puls-tid är det väl bara att låta timer-avbrottet räkna upp en räknare?
Man bör väl till och med kunna räkna varje gång som timern rullar runt och när rätt antal "rullningar" uppnåtts så sätter man timern att generera avbrott på exakt rätt ställe inom timerns spann? Då kan man väl i princip ha timerns fulla upplösning och ändå räkna "hur långt som helst"?

Kan ju bara var jag som inte fattar också

Edit: Med klocka på 84 MHz och 1024 prescaler på en 16-bits timer så genereras overflow-interrupt ca var 0,8 s (0,7989 s) och precisionen blir ca 0,012 ms. Om jag räknat rätt

[AndLi]

Spara tid?

Om vi nu säger att interruptet går var 10 ms, och du vill ha 10 sekunder periodtid..

Tre 16 bitars variabler har värdet 0-1000 som börvärde för pulslängden, det är dessa du ställer din på tid med.

I interruptet har du en static räknare som räknar till 1000,
När den är 1000, resetar du den till 0 och stäng av alla dina utgångar.
Vid varje interrupt kollar du om något av dina tre börvärde matchar din räknare.
Om sant sätt på motsvarande utgång.

Klart.
Som överkurs kan man ju ha tre värden för när de ska sätta lågt med, om man inte vill att påslaget ska vara i fas.

[Al_Bundy]

Okej! Nu försöker jag implementera en räknare.

Jag har följt denna "manual" där talaren har just startat sitt timerobjekt &htim2. Alltså han skickar adressen från en struct till en funktion bara.


Sedan så klipper han in en annan kod och lägger till denna i Main. Men hur vet jag att jag ska göra så där? Finner ingen logik.
Finns det ett annat sätt för att "återställa timer"?

Här är den generade koden. Nu måste jag kunna använda denna räknare så att den kan räkna till ett värde? Eller hur gör jag?

Kod: Markera allt

static void MX_TIM3_Init(void)
{

  /* USER CODE BEGIN TIM3_Init 0 */

  /* USER CODE END TIM3_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM3_Init 1 */

  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 16000;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 1000;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */
  HAL_TIM_Base_Start_IT(&htim3); <--- Denna har jag gjort för att starta räknaren.

  /* USER CODE END TIM3_Init 2 */

}

Löste detta nu!

Kod: Markera allt

while (1)
  {
    /* USER CODE END WHILE */
	  int value = htim3.Instance->CNT;
	  if (value == 400){
		  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
	  }else if (value == 500){
		  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
	  }else{

	  }
    /* USER CODE BEGIN 3 */
  }

Ok! En 555 timer var en dålig ide

[Al_Bundy]

Vad är anledningen till att inte använda ett timer interrupt i detta fall? Behövs precision och lång puls-tid är det väl bara att låta timer-avbrottet räkna upp en räknare?
Man bör väl till och med kunna räkna varje gång som timern rullar runt och när rätt antal "rullningar" uppnåtts så sätter man timern att generera avbrott på exakt rätt ställe inom timerns spann? Då kan man väl i princip ha timerns fulla upplösning och ändå räkna "hur långt som helst"?

Kan ju bara var jag som inte fattar också

Edit: Med klocka på 84 MHz och 1024 prescaler på en 16-bits timer så genereras overflow-interrupt ca var 0,8 s (0,7989 s) och precisionen blir ca 0,012 ms. Om jag räknat rätt

10000000000 = 1024 binärt
84*10^6/10000000000= 0.0084 Hz

FÖr att få Hz i period 1/0.0084 = 119.047619048 om jag har tolkat dig rätt.

[Glattnos]

Jag bara räknade ut hur "sällan" det blir ett timer-interrupt och hur "hög" precision man får med 1024 prescaler. Man kan ta vilka värden man vill som passar det man ska göra.

Jag tycker det ser ut som du blandar binära och decimala tal i din uträkning

[Al_Bundy]

Japp. Det gjorde jag.