OK Mégsem
Fórum témák

» Több friss téma
Fórum » STM32 Discovery Kit programozása
Lapozás: OK   6 / 7
(#) cimopata válasza vzoole hozzászólására (») Feb 12, 2016 /
 
Tovább írtam a programot de megint belefutottam egy érdekes dologba:
A beolvasott poti feszültségét szeretném kiírni 7 szegmenses kijelzőre.

Ha simán a 4096-ot írnám ki és nem játszok a leosztással akkor szépen mutatja a beolvasott értéket +/- 1 ingadozással ez normális is. Viszont amikor próbálom leosztani 0-3,30V kijelzésre (persze a tizedes pont egyenlőre még nincs a progiban) egyszer jó értéket mutat pl 0,63V a következő frissítésnél felugrik 1,32V-ra. Utána ismét vissza 0,63V-ra látszólag teljesen random időközönként.

Ha a cucc változóba fix értékeker töltök pl 322, 323... akkor semmi baj a kijelzéssel szépen kiírja hogy 0,26V ugrálás nélkül.

Teljesen mindegy milyen állásban van a poti mindig bevillan egy jóval nagyobb érték. Nem értem hol hibázik a program.

  1. sConfig.Channel = ADC_CHANNEL_0;
  2. HAL_ADC_ConfigChannel(&hadc, &sConfig);
  3. HAL_ADC_Start(&hadc);
  4. HAL_ADC_PollForConversion(&hadc,1);
  5. cucc = HAL_ADC_GetValue(&hadc);
  6. HAL_ADC_Stop(&hadc);
  7.        
  8.                 for(i=0;i<100;i++)
  9.                 {
  10.                         szam[0]=cucc/1240;  //első digit számolása
  11.                         szam[1]=cucc/124-(szam[0]*10);  //tizedes számolása
  12.                         szam[2]=(cucc*10)/124-(szam[0]*100)-(szam[1]*10); //százados
  13.                        
  14.                         for(int a=0;a<3;a++)
  15.                                 {
  16.                                         if(a==0)k=0x0600;
  17.                                         if(a==1)k=0x0500;
  18.                                         if(a==2)k=0x0300;
  19.                                        
  20.                                         switch(szam[a])
  21.                                                 {
  22.                         case(0): GPIOC->ODR = 0x007E^k; break;
  23.                         case(1): GPIOC->ODR = 0x0030^k; break;
  24.                         case(2): GPIOC->ODR = 0x006D^k; break;
  25.                         case(3): GPIOC->ODR = 0x0079^k; break;
  26.                         case(4): GPIOC->ODR = 0x0033^k; break;
  27.                         case(5): GPIOC->ODR = 0x005B^k; break;
  28.                         case(6): GPIOC->ODR = 0x005F^k; break;
  29.                         case(7): GPIOC->ODR = 0x0070^k; break;
  30.                         case(8): GPIOC->ODR = 0x007F^k; break;
  31.                         case(9): GPIOC->ODR = 0x007B^k; break;
  32.                                                 }
  33.                                                         HAL_Delay(1);
  34.                                 }
  35.                        
  36.                         }
A hozzászólás módosítva: Feb 12, 2016
(#) cimopata hozzászólása Feb 12, 2016 /
 
Közben rájöttem a baj az volt, hogy a main loop-on belül kellett volna deklarálnom a változót így már jól adja mindig az adatokat. Bár nem tudom ez miért van.

Csináltam 1-2 érdekes mérést kíváncsi voltam mennyire gyorsan végez az ADC.
Ha nem végzek figyelést hogy mikor van kész az átalakítás akkor 300ns alatt már kaphattam eredményt.
Visszarakva az EOC flag figyelését viszont 1,6us.
Adatlap 12 biten 1us-t ír kíváncsi lennék azt hogy mérték.

  1. ADC1->CR  = 5;//(1<<0 | 1<<2);    
  2.                 //while( !(ADC1->ISR & (1<<2)) );
  3.                 GPIOC->ODR = 0x0000;
  4.                 cucc = ADC1->DR;
A hozzászólás módosítva: Feb 12, 2016
(#) vzoole válasza cimopata hozzászólására (») Feb 12, 2016 /
 
EOC: End of conversion flag
This bit is set by hardware at the end of each conversion of a channel when a new data result is
available in the ADC_DR register. It is cleared by software writing 1 to it or by reading the ADC_DR
register.
0: Channel conversion not complete (or the flag event was already acknowledged and cleared by
software)
1: Channel conversion complete
(#) cimopata válasza vzoole hozzászólására (») Feb 12, 2016 /
 
Tudom ennek ellenére ha kihagytam akkor is megkaptam az eredményt a kijelzőn. Kérdés az mennyire pontos. Érdekes...
A hozzászólás módosítva: Feb 12, 2016
(#) vzoole válasza cimopata hozzászólására (») Feb 12, 2016 /
 
Amíg nem végez a konverzióval addig nem frissíti a DR-t.
Tehát kiolvashatod, csak felesleges, mert a régi érték lesz benne, amit már előtte kiolvastál.
(#) cimopata válasza vzoole hozzászólására (») Feb 12, 2016 /
 
Értem köszi, így akkor már más a helyzet.
(#) cimopata hozzászólása Feb 17, 2016 /
 
Lenne másik kérdésem. Összeállt a program nyáktervezésnél tartok és a referencia feszültséggel vagyok bajban. Előállítok +2,5V referenciafeszültséget de nem vagyok biztos hogy melyik lábra is kellene kössem. 64 lábú procinak van külön lába VREF bemenettel én viszont a TQFP32 -es STM32F030K6T-t választottam amiben van egy VDDA de VREF nek nem látok semmi mást.
VDDA itt most a ADC referenciája is egyben? Ha megtáplálom 2,5V referenciával akkor ahhoz mérten végzi az átalakítást?

Van egy ilyen hogy vrefint channel. Az micsoda?
A hozzászólás módosítva: Feb 17, 2016

32.jpg		    
(#) cimopata hozzászólása Ápr 13, 2016 /
 
Üdv.

Játszok ezzel a rossz, STM Studio-val de lehetetlen dolgokat írkál ki.
A regiszterek értékét szerettem volna kiolvasni de teljesen lehetetlen érték az összes.
Pl ott van a current_dis1 amit 0-ra írok és mégis hülyeségeket ír. Alatta a inic valójában 1 és arra is hülyeség.

Miért van ez? Nem értem én azt a programot a neten meg alig vagy nincs is infó róla.
A hozzászólás módosítva: Ápr 13, 2016

miez.jpg		    
(#) mdemcsik válasza vzoole hozzászólására (») Ápr 13, 2016 /
 
Nekem sose működött
(#) cimopata hozzászólása Ápr 28, 2016 /
 
Üdv.

ADC-vel szeretnék mérni értéket de egész nap ne jutottam semmire.
Az ADC folyamatos mintavételi módban megy. A timer3-at 10ms periódusidóval hívom meg ami egyben a 7 szegmenses kijelző frissítése is. Miért van az hogy ha a """aram = ADC1->DR; """ (19. sort) a megszakításba rakom be akkor nem jönnek az adatok viszont ha kirakom a main függvénybe akkor jól megy?


  1. while (1)
  2.   {
  3.        
  4.         szam[0]=aram/1240;
  5.         szam[1]=aram/124-(szam[0]*10);
  6.         szam[2]=((aram*10)/124)-(szam[0]*100)-(szam[1]*10);
  7.  
  8.   }
  9.   /* USER CODE END 3 */
  10.  
  11. }
  12.  
  13. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  14.         {
  15.                 if(htim->Instance==TIM3)
  16.                                 {      
  17.                        
  18.                                        
  19.                 aram = ADC1->DR;
  20.                 buffer= GPIOB->ODR | 0x70;
  21.                 if(digit==0)
  22.                         {
  23.                         GPIOB->ODR = buffer & 0x3F;} //A1       digit 0
  24.                         if(digit==1){GPIOB->ODR = buffer & 0x5F;} //A2 digit 0
  25.                         if(digit==2)
  26.                         {
  27.                         if(szam[0]==0){szam[0]=10;}//első digit sötét ha 0 a szám
  28.                         GPIOB->ODR = buffer & 0x6f;
  29.                         } //A3 digit 0
  30.                         buffer = GPIOA->ODR & 0x00FF; //7 szegmens bitek mask
  31.                         if(digit==1){buffer = buffer | 0x8000;}//tizedespont
  32.  
  33.                         switch(szam[digit])
  34.                                 {
  35.                                 case(0): GPIOA->ODR = buffer | 0x3F00; break;
  36.                                 case(1): GPIOA->ODR = buffer | 0x0600; break;
  37.                                 case(2): GPIOA->ODR = buffer | 0x5B00; break;
  38.                                 case(3): GPIOA->ODR = buffer | 0x4F00; break;
  39.                                 case(4): GPIOA->ODR = buffer | 0x6600; break;
  40.                                 case(5): GPIOA->ODR = buffer | 0x6D00; break;
  41.                                 case(6): GPIOA->ODR = buffer | 0x7D00; break;
  42.                                 case(7): GPIOA->ODR = buffer | 0x0700; break;
  43.                                 case(8): GPIOA->ODR = buffer | 0x7F00; break;
  44.                                 case(9): GPIOA->ODR = buffer | 0x6F00; break;
  45.                                 case(10): GPIOA->ODR = buffer | 0x0000; break;
  46.                                                 }              
  47.                                                
  48.                                         digit++;
  49.                                         if(digit==3){digit=0;}
  50.  
  51.                                        
  52.                                                                                
  53.                                    
  54.                                 }
  55.  
  56.  
  57.         }
A hozzászólás módosítva: Ápr 28, 2016
(#) vzoole válasza cimopata hozzászólására (») Ápr 28, 2016 /
 
Változó hol és hogy van deklarálva?
(#) mdemcsik válasza cimopata hozzászólására (») Ápr 28, 2016 /
 
Bár rég nem foglalkoztam vele így, de az ADC-t el kell indítani, megvárni amíg lefut és olvasni csak utána? Bár én DMA-val csináltattam szerintem.
(#) cimopata hozzászólása Ápr 28, 2016 /
 
Ezek után kezdődik a while(1). Igazából ha simán a main függvénybe teszem a aram = ADC1->DR; sort akkor működik szépen és adogatja az adatokat a kijelzőre viszont ha berakom a timer megszakításába ahol a kijelzőt is frissítgeti 10msec-el akkor nem jönnek az adatok hanem a kezdeti 0 értéket jelzi. Nem lenne szükségem minig ADC mintára így az adc-t úgy állítottam be hogy folyamatosan vegyen mintát egyenlőre csak erről az egy csatornáról és mindig írja felül az előző értéket.
  1. int digit=0;
  2. short szam[3];
  3. short buffer;
  4. short aram_dis=3625;
  5. short bemenet[5];
  6. short aram=0;
  7. short aram_sum=0;
  8. short minta=1;
  9.  
  10.  
  11.  
  12. int main(void)
  13. {
  14.  
  15.  
  16.  
  17.  
  18.   HAL_Init();
  19.  
  20.  
  21.   SystemClock_Config();
  22.  
  23.  
  24.   MX_GPIO_Init();
  25.   MX_ADC_Init();
  26.   MX_TIM3_Init();
  27.   MX_TIM14_Init();
  28.  
  29.   HAL_TIM_Base_Start(&htim14);
  30.   HAL_TIM_Base_Start_IT(&htim14);
  31.   HAL_TIM_Base_Start_IT(&htim3);
  32.   HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_1);
  33.         __HAL_TIM_SET_COMPARE(&htim3,TIM_CHANNEL_1,100);
  34.  
  35.         HAL_ADC_Start(&hadc);
A hozzászólás módosítva: Ápr 28, 2016
(#) cimopata hozzászólása Ápr 28, 2016 /
 
ADC inicializálás:
  1. ADC_ChannelConfTypeDef sConfig;
  2.  
  3.     /**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
  4.     */
  5.   hadc.Instance = ADC1;
  6.   hadc.Init.ClockPrescaler = ADC_CLOCK_ASYNC;
  7.   hadc.Init.Resolution = ADC_RESOLUTION12b;
  8.   hadc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  9.   hadc.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD;
  10.   hadc.Init.EOCSelection = EOC_SEQ_CONV;
  11.   hadc.Init.LowPowerAutoWait = DISABLE;
  12.   hadc.Init.LowPowerAutoPowerOff = DISABLE;
  13.   hadc.Init.ContinuousConvMode = ENABLE;
  14.   hadc.Init.DiscontinuousConvMode = DISABLE;
  15.   hadc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  16.   hadc.Init.DMAContinuousRequests = DISABLE;
  17.   hadc.Init.Overrun = OVR_DATA_OVERWRITTEN;
  18.   HAL_ADC_Init(&hadc);
  19.  
  20.     /**Configure for the selected ADC regular channel to be converted.
  21.     */
  22.   sConfig.Channel = ADC_CHANNEL_1;
  23.   sConfig.Rank = ADC_RANK_CHANNEL_NUMBER;
  24.   sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  25.   HAL_ADC_ConfigChannel(&hadc, &sConfig);
(#) mdemcsik válasza cimopata hozzászólására (») Ápr 29, 2016 /
 
Ha megszakításba teszed akkor törlöd a megszakítás bitet? Az ADC_FLAG_EOC-t megvárod?
(#) cimopata hozzászólása Máj 10, 2016 /
 
Üdv.

Sikerült megoldanom a problémát. Olyan kérdésem lenne, hogy egy felprogramozott procit, hogyan tudom lezárni hogy utána már ne tudják kiolvasni belőle a kódsort és esetlegesen sokszorosítani?

Esetemben pl a uVision 5.0 használok. be lehet ennél valahogy állítani ezt?

köszi
(#) kapu48 hozzászólása Aug 2, 2016 /
 
Lenne 1 véletlen szám generálás feladatom!
Tudnátok segíteni, megoldani?

Adott 1 STM32F103: 20bites, 72MHz-vel ketyegő SYSTICK számlálója.
SysTick interupt = 0.1ms, 10kHz

Ezzel hogyan lehetne véletlen számot generálni mondjuk 10ms-ként (100Hz) 0...7-ig?

Minél gyorsabban, mert timer megszakításban kellene elvégezni!

Köszi!
A hozzászólás módosítva: Aug 2, 2016
(#) kapu48 válasza kapu48 hozzászólására (») Aug 2, 2016 /
 
Igy próbáltam:

  1. void SysTickHandler(void)
  2. {                
  3.                
  4.         sysTick++;                                                              // ms számláló++
  5.  
  6. }
  7.  
  8. void TIM2_IRQHandler(void)
  9. {
  10.          if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
  11.   {  
  12.      TIM2->CNT = (timersVal[0] - (u16)(sysTick & 0x0007));
  13.      
  14.      TIM2->SR = (u16)~TIM_IT_Update;            // Clear TIM2 update Interrupt source          
  15.   }
  16. }

De állandóan csak 2 szám váltakozik!
A hozzászólás módosítva: Aug 2, 2016
(#) wbt válasza kapu48 hozzászólására (») Aug 2, 2016 /
 
Szia!
Csinálj gyűrűs számlálót. Mondjuk 8 bites értéket elrotálsz felfelé, a legalsó bit meg a byte.5 és byte.7 EXOR kapcsolata legyen. Aztán kiveszed magadnak valahonnan a 0-7 értéket. Valami kezdőértéket is adhatsz, arra kell vigyázni, hogy csupa 0 ne legyen, akkor a bejövő bit 1 legyen. Álmoskönyvek szerint pl. 5-bites regiszternél a 31 variációhoz a byte.2 és byte.4-et kell XOR-al visszavezetni a bemenetre, de hosszabb regiszterekkel is lehet próbálkozni, az a lényeg, hogy az utolsó és egy belső bit XOR menjen vissza.
(#) kapu48 válasza wbt hozzászólására (») Aug 2, 2016 /
 
Köszi!
Nem igazán értem, de próbálkozok!

Eddig van két számlálóm. Egyiket sem piszkálhatom, csak ki olvashatom!

HardWares, 20bites 72MHz-vel halytva: SysTick->VAL
Ami számol: 0 – 7200-ig.
SysTick_SetReload(7200); // SysTick interupt = 0.1ms, 10kHz

És van egy 32bites interupt számlálóm: „ sysTick” amit 0.1ms-ként növelek 1-el!

Akkor ezekkel kellene valami EXOR műveletet végezni?
A hozzászólás módosítva: Aug 2, 2016
(#) icserny válasza kapu48 hozzászólására (») Aug 2, 2016 /
 
Számlálókkal csak akkor van esély, ha különböző forrásból táplálod azokat (SysTick a rendszer órajel - a külső kristállyak satbilizálva, egy másik Timer pedig RC oszcillátorról járatva. A kettő közötti csúszkálás (jitter) többé-kevésbé véletlennek tekinthető.

Analóg jelforrások zajából is generálható valódi véletlenszám. Itt találsz egy érdekes társalgást a véletlenszám generálásról, benne ötletek és mintapélda is.
(#) kapu48 válasza icserny hozzászólására (») Aug 2, 2016 /
 
Köszi!
De az analog mérés túl sok órajel, és még bizonytalan is a hossza!

Össze hoztam egy ilyen rutint, a 2 számlálóból:
  1. // timersVal[0]  = a periódus hossza
  2. // tim2Cnt  az órajel költség mire sikerül frissíteni a számlálót
  3. sysTick[3] = (sysTick[3] ^= SysTick->VAL | sysTick[0]) & 0x0007;  //RND = (Az előző véletlen érték XOR ( SysTick->VAL  OR  sysTick)) AND 0x0007;
  4.  
  5. TIM2->CNT = timersVal[0] - (tim2Cnt + (u16)sysTick[3]);


És az eredmény, RND a +x:
  1. Tick- = 426+2
  2. Tick- = 426+3
  3. Tick- = 426+6
  4. Tick- = 426+7
  5. Tick- = 426+0
  6. Tick- = 426+7
  7. Tick- = 426+0
  8. Tick- = 426+7
  9. Tick- = 426+2
  10. Tick- = 426+5
  11. Tick- = 426+2
  12. Tick- = 426+1
  13. Tick- = 426+6
  14. Tick- = 426+7
  15. Tick- = 426+2
  16. Tick- = 426+5
  17. Tick- = 426+2
  18. Tick- = 426+5
  19. Tick- = 426+6
  20. Tick- = 426+1
  21. Tick- = 426+2
  22. Tick- = 426+5
  23. Tick- = 426+6
  24. Tick- = 426+1
  25. Tick- = 426+2
  26. Tick- = 426+5
  27. Tick- = 426+6
  28. Tick- = 426+1
  29. Tick- = 426+2
  30. Tick- = 426+5
  31. Tick- = 426+6
  32. Tick- = 426+1
  33. Tick- = 426+2
  34. Tick- = 426+5
  35. Tick- = 426+6
  36. Tick- = 426+1
  37. Tick- = 426+6
  38. Tick- = 426+5
  39. Tick- = 426+2
  40. Tick- = 426+1
  41. Tick- = 426+6
  42. Tick- = 426+5
  43. Tick- = 426+2
  44. Tick- = 426+1
  45. Tick- = 426+6
  46. Tick- = 426+1
  47. Tick- = 426+6
  48. Tick- = 426+1
  49. Tick- = 426+6
  50. Tick- = 426+5
  51. Tick- = 426+0
  52. Tick- = 426+7
  53. Tick- = 426+0
  54. Tick- = 426+5
  55. Tick- = 426+2
  56. Tick- = 426+5


Szerintem megfelelő!?
(#) wbt válasza kapu48 hozzászólására (») Aug 3, 2016 / 1
 
Van pár variánsa a véletlenszám e-módon előállítására, de az alap ugyan az, egy hosszú shiftregiszter kimenete és egy belső bit XOR kapcsolata lesz a bemeneten.
wiki RND
(#) kapu48 válasza wbt hozzászólására (») Aug 3, 2016 /
 
Köszi neked is! De!

Előzőleg már többször le írtam, hogy ez timer időzítésben fut.
Tehát fontos, hogy ismert legyen a müvelet hossza, és lehetőleg rövid legyen.

Ezért nem lehet benne while(?) Ciklus, aminek előre ismeretlen a hossza.
Úgy nem tudom kalkulálni a timer kezdőértékét.

timer 1 órajel= 72MHz-vel az 1/72= 0,0138888888888889 nanoSec
Ismernem kel a megszakítás kezdete és a timer újra töltése óta leketyeget órajeleket,
hogy ki tudjam vonni a számláló kezdő értékéből.
Különben kontrolálhatatlan lesz a véletlen szám értéke!

És így a timer megszakítások közötti impulzusok hossza is.
A hozzászólás módosítva: Aug 3, 2016
(#) wbt hozzászólása Aug 3, 2016 /
 
Ezt nem kell nX meghívni, csak minden Timer INT-kor 1x. (persze gondoskodni kell a regiszternek használt változó értékének megmaradásáról). Tehát annyi van Tint-ben, hogy rotálsz és 2 bit XOR eredményét beteszed a 0. helyre és kiolvasod a "regiszter" értékét, aztán mehetsz is vissza. Tehát ez a megoldás minden meghívásra ad egy véletlenszámot időtől függetlenül. Közben eszembe jutott a négyzetközép-összeg megoldás is, de vagy 15 éve használtam utoljára. Valami olyan, hogy a pl. 16-bites számot négyzetre emeled és jobb/bal 4 bitet hozzáadod a középső 8 bithez. Itt is figyelni kell a 0000 értékre, az tiltott. Mindkét megoldásnak kalkulálható a hossza, max 2 értékre (0000 kivétel teljesülése/nem teljesülése okoz pár utasítás eltérést)
(#) wbt válasza kapu48 hozzászólására (») Aug 3, 2016 /
 
Várjunk csak! STMF103 tartalmaz belső hőmérőt. Rémlik valami olyan, hogy a belső hőmérő (ADC) XOR Systick timer. Valami 5-6.5 bit entrópiáról beszéltek, így egész kiegyenlített volt a véletlen számok spektruma. Bár nem tudom, mi a konkrét feladat, számít-e a statisztikai egyenletesség vagy ugrások is lehetnek benne... Szóval ha nem esik ki az ADC-vel való mérés, akkor talán segít. (ha, ahogy írtad, túl sok órajel, a mérést el lehet ám kezdeni valahol máskor, az a lényeg, hogy neked INT-nél már legyen eredményed...valami).
Na, most már bogarat tettél a fülembe, mi is lesz ez
(#) kapu48 válasza wbt hozzászólására (») Aug 3, 2016 /
 
Köszi, a türelmedet!
Az este már fáradt lehettem, hogy jobban bele gondoljak a tanácsodba!
Ki fogom próbálni!

Az RND ellőre gyártása már nekem is be ugrott!
Illetve a timer elindítása után már van időm a következő jel feldolgozásáig.


(Ez fény sebesség mérő akar lenni!)
(#) kapu48 válasza wbt hozzászólására (») Aug 4, 2016 /
 
Végül ezt szedtem ki a Wikiböl:
  1. bit  = ((lfsr[0] >> 0) ^ (lfsr[0] >> 2) ^ (lfsr[0] >> lfsr[1]) ^ (lfsr[0] >> 12) );    
  2. lfsr[0] =  ((lfsr[0] >> 1) | (bit << 15));     
  3. lfsr[1] =  (lfsr[0] & 0x0007);

És ez tényleg jobb eredményt produkált:
  1. Tick- = 320+7
  2. Tick- = 320+5
  3. Tick- = 320+6
  4. Tick- = 320+6
  5. Tick- = 320+5
  6. Tick- = 320+5
  7. Tick- = 320+6
  8. Tick- = 320+5
  9. Tick- = 320+0
  10. Tick- = 320+7
  11. Tick- = 320+1
  12. Tick- = 320+3
  13. Tick- = 320+5
  14. Tick- = 320+4
  15. Tick- = 320+7
  16. Tick- = 320+3
  17. Tick- = 320+3
  18. Tick- = 320+6
  19. Tick- = 320+5
  20. Tick- = 320+4
  21. Tick- = 320+7
  22. Tick- = 320+6
  23. Tick- = 320+6
  24. Tick- = 320+7
  25. Tick- = 320+2
  26. Tick- = 320+4
  27. Tick- = 320+7
  28. Tick- = 320+2
  29. Tick- = 320+4
  30. Tick- = 320+7
  31. Tick- = 320+3
  32. Tick- = 320+7
  33. Tick- = 320+6
  34. Tick- = 320+3
  35. Tick- = 320+4
  36. Tick- = 320+5
  37. Tick- = 320+1
  38. Tick- = 320+3
  39. Tick- = 320+4
  40. Tick- = 320+7
  41. Tick- = 320+5
  42. Tick- = 320+5
  43. Tick- = 320+6
  44. Tick- = 320+2
  45. Tick- = 320+0
  46. Tick- = 320+1
  47. Tick- = 320+5
  48. Tick- = 320+5
  49. Tick- = 320+4
  50. Tick- = 320+7
  51. Tick- = 320+3
  52. Tick- = 320+7
  53. Tick- = 320+5
  54. Tick- = 320+5
  55. Tick- = 320+6
  56. Tick- = 320+5
  57. Tick- = 320+0

Még egyszer Köszönöm a segítséget!
(#) elektros90 hozzászólása Szept 20, 2016 /
 
Sziasztok!
Hobbi szinten foglalkozok STM32 programozással. STM32F429 boardon játszadozok az ST-s framework használatával. Amit szeretnék az egy egyszerű program amivel az ADC-t szeretném a TIM2 időzítővel triggerelni bizonyos időközönként. Mondjuk 1ms-onként. Van valakinek erre működő kódja, megoldása, segítsége? Nézegettem neten kódokat, de nekem nem működik. Jelenleg olvasgatom az ST-s függvényeket + regisztereket. Pár dolog még nem világos. Nagy segítség lenne a működő kód. Bárminemű segítséget köszönök.
(#) kapu48 válasza elektros90 hozzászólására (») Szept 20, 2016 /
 
Letöltöd:
STSW-STM32138

Csak 1 regisztrácio!
És megtalálsz mindent!
A hozzászólás módosítva: Szept 20, 2016
Ezekre szükség lehet! - HESTORE.HU

STM32F103-MS
STM32F429I-DISC1
STM32F030C6T6
36 K 5%
PG13.5-WH
Következő: »»   6 / 7
Bejelentkezés

Belépés
Hirdetés
Lapoda.hu     XDT.hu     HEStore.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem