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

» Több friss téma
Fórum » ARM - Miértek hogyanok
ARM - Miértek hogyanok
 
Témaindító: gtk, idő: Jún 26, 2007
Témakörök:
Lapozás: OK   67 / 177
(#) don_peter válasza icserny hozzászólására (») Ápr 27, 2016 /
 
Köszi, le is mentettem..
Remélem segítségemre lesz..
(#) cpt.zoltan.simon válasza don_peter hozzászólására (») Ápr 27, 2016 /
 
Van: Csak a powermcu cuccait használom. Hibátlanok.
NOR Flash-nek ott a helye alul. Csak nincs beforrasztva. Az én 2xx-es panelemen A22-ig vannak a cím lábak. Nem valamelyik Port-ra hanem kb az egyetlen lehetséges lábra ami fogadni tudja.
Az STM-nek nagyon jó a dokumentációja. Annál jobb nem kell. Én mondjuk Bare-Metal-ba progizom, számomra egyszerűbb mint külön még CMSIS-t tanulni.
A JTAG neked ott ki van építve, szerintem használd azt. Persze lehet SWD-ben is programozni, de jelenleg nem használ(hat)sz annyi lábat hogy már onnan is bogarászni kelljen.
Esetleg töltsd már fel a kapcsolási rajzát amit kaptál kérlek mert nekem csak 2xx és 4xx van.
Íme az enyém mellékletben. Ja és azért is csodálkozom a hiányázó NOR Flash lábaidról, mert a 2xx is 144 lábú ugyan ezen a board-on és ahogy írtam A22-ig vannak a cím lábak betervezve.
Másik tanács. Használj SD kártyát a gyorsabb SDIO módban. Inicializálás, olvasás már megy tökéletesen. Írásával még nem volt időm foglalkozni.

HY-STM32F2xx...pdf		    
(#) don_peter válasza cpt.zoltan.simon hozzászólására (») Ápr 27, 2016 /
 
A 100lábúnál (STM32F103VCT6) nincs meg az alsó fix 16cím bit kivezetése.
A 144-lábúnál meg van (56lábú NOR-t fel is forrasztottam), de én a kész projektemnél nem ezt a 144-est, hanem a az STM32F103VCT6 100 lábú kisebb MCU-t akarom használni.

Nem teljesen ez van nekem a fejlesztő panelen, de ennél nem találtam jobb rajzot.
A hozzászólás módosítva: Ápr 27, 2016

HY-STM32F1xx...pdf		    
(#) cpt.zoltan.simon válasza don_peter hozzászólására (») Ápr 27, 2016 /
 
Vágom. Oks, én csak 144 lábúakat használtam, vagy nagyobbakat.
Ha sikerül megcsinálni a NAND Driver-t az érdekelne engem is. De nem CMSIS-el.
Egyesek itt a MikroE cuccot használják, én speciel Keil-re esküszöm.
SRAM-ot a Keil gyári file-okkal életre keltheted egy sorral.

  1. #define DATA_IN_ExtSRAM


Ez aktivál egy külön részt a system_stm32f2xx.c file-ban.

Én 512k SRAM-ot használtam/használok, arra figyelj hogy a file csak A17-ig inicializálja az address lábakat (256k-ig), így nekem külön kellett még hozzátennem az A18-at.
(#) don_peter válasza cpt.zoltan.simon hozzászólására (») Ápr 27, 2016 /
 
Nem igazán értem egyelőre mit írsz, de a NOR Flash-re már rég kész a program.
Alapból ismeri az IAR környezet.
128Mbit-et ken vág 2-3utasítással.
Csak gondolom a 100lábú kisebb ARM-nél az alsó 16 címbitet majd nekem kell konfigurálnom.
(#) cpt.zoltan.simon válasza don_peter hozzászólására (») Ápr 27, 2016 /
 
Az hogy ismeri, és az hogy működik az két külön dolog. Kipróbáltad már?
Én mindent az alapoktól írok, nem használok beépített rutinokat. Nem ismerem az IAR környezetet.
(#) don_peter válasza cpt.zoltan.simon hozzászólására (») Ápr 27, 2016 /
 
Persze, élesben tesztelgetem.
USB-vel csatlakozom és írom Flasht.
Az olvasás sokkal gyorsabban megy.
Én még csak most kezdtem el pár napja nézegetni, szóval még tanulnom kell..

AVR_sebesseg...jpg		    
(#) cpt.zoltan.simon válasza don_peter hozzászólására (») Ápr 27, 2016 /
 
Értem. És ebben hol van IAR, meg Cortex-M akárhány?
Ez konzolba épített NOR flash chip hekkeléséhez van. Mert nem látom a kapcsolatot.
(#) don_peter válasza cpt.zoltan.simon hozzászólására (») Ápr 27, 2016 /
 
Ez csak a teszt ami a sebességet és a beírást mutatja..
Vagy mit szeretnél még látni?

IAR.JPG		    
(#) cpt.zoltan.simon válasza don_peter hozzászólására (») Ápr 28, 2016 /
 
Semmit. Láttam ott egy 5 betűs rövidítést amit mindennél jobban utálok: CMSIS.
(#) don_peter válasza cpt.zoltan.simon hozzászólására (») Ápr 28, 2016 /
 
Sajnos én még ennyire nem értek hozzá, nem tudom egyelőre mi mit jelent pontosan.
Pár nap alatt ezeket a dolgokat nehéz kitapasztalni..
Nekem ezt mondták, hogy ez az egyik legjobb fejlesztő, persze nem ingyenes.
(#) cpt.zoltan.simon válasza don_peter hozzászólására (») Ápr 28, 2016 /
 
Majd belejössz!
(#) don_peter válasza cpt.zoltan.simon hozzászólására (») Ápr 28, 2016 /
 
Vagy nem
Lehet maradok PIC-nél, mert abban már van tapasztalatom..
Ez az ARM dolog meg még várat magára, majd talán ha lesz valaki akivel tudok róla beszélgetni, lehet majd előveszem megint..
A hozzászólás módosítva: Ápr 28, 2016
(#) cpt.zoltan.simon válasza don_peter hozzászólására (») Ápr 28, 2016 /
 
Felejtsd el a PIC-et.
Kezdésképp villants fel egy led-et.
Ha jól emlékszem a tiéden is a PF6 porton figyel a LED ott az USB csati mellett:

  1. //Init the STATUS LED PF6
  2. RCC->AHB1ENR |= (1<<5); //Enable PortF if still not
  3. GPIOF->MODER |= (1<<12); //Output: PF[6]
  4. GPIOF->BSRRL |= (1<<6); //PF6 ON
(#) don_peter válasza cpt.zoltan.simon hozzászólására (») Ápr 28, 2016 /
 
Jaa ezeken túl vagyok.
Most jönne az, hogy át kellene ültetnem a programot a kistestvérre, STM32F103VCT6-ra.
A gond ott kezdődik, hogy még nem tudtam kihámozni, hogy NOR flash alsó 16címbiteket, hogy tudom megoldani, mivel az hiányzik a kisebb lábszám miatt.. (bár gondolom más lábakra kell átkonfigurálni, de nincs olyan PORT amelyen elférne a hiányzó 16bit)
Aztán jönne az interrupt, wake-up funkció és SPI.
Nem is kevés dolog ez
Arról nem is beszélve, hogy még soha nem használtam ilyen MCU-t, nem tudom mire kell oda figyelni, melyik lábat kell fixen felhúzni, lehúzni és milyen alap körítés kell az MCU körül.
Bár tán ez utóbbi lenne a legkevesebb kihámozni, mert egy két kapcsolás elárulja.
(#) cpt.zoltan.simon válasza don_peter hozzászólására (») Ápr 28, 2016 /
 
Interrupt relatív egyszerű.
Az interrupt-otkat az NVIC ISER[0..3] regiszterekben engedélyezed.
Interrupt Set Enable Register.
Az adatlap alapján pl az ADON interrupt az ISER[0] 18-as bitje.
Ezt a chip users manual-ban ellenőrizheted.

  1. NVIC->ISER[0] |= (1<<18);//ADCON Interrupt Enabled


Az ehhez tartozó interrupt hhandler-em így néz ki.

  1. void ADC_IRQHandler (void)      {
  2. unsigned short temp;
  3. NVIC->ICER[0]   |= (1<<18); //Disable the ACDON interrupt
  4. temp = ADC1->DR;        //Save result
  5. Voltage = AD1Res * temp;        //in uV
  6. Temperature = ((Voltage - 0.76 ) / 0.25 ) + 25; //in Celsius
  7. NVIC->ICPR[0]   |= (1<<18); //Clear Pendint ADCON Interrupt
  8. NVIC->ISER[0]   |= (1<<18); //Re-Enable the ADCON Interrupt
  9. }


Az egyes interrupt handlerek pontos nevét megtalálod az egyik "gyári" include file-ban.
(#) don_peter válasza cpt.zoltan.simon hozzászólására (») Ápr 28, 2016 /
 
És itt is ARM-nél, van olyan alap szabály amit mindig érdemes betartani?
A PIC-nél van egy sárga szövegdohoz, ahol le vannak írva, hogy pl:
Idézet:
„- A PIC ÖSSZES Vdd és Vss (AVdd és AVss) (tápfeszültség) lábát be kell kötni!
- A táplábak mellé a lehető legközelebb 100nF-os KERÁMIA kondenzátorokat kell elhelyezni.
- Az MCLR lábat, 10kohm-mal fel kell húzni a Vdd tápfeszültségre.
- Külső kvarc használatakor 4MHz-ig XT, a fölött pedig HS konfigurációt kell beállítani.
- Stabilizált tápegységet kell használni, a kapcsoló üzemű "telefon töltő" adapterek okozhatnak hibákat.”

Itt is vannak ilyen alap dolgok?
(#) killbill válasza don_peter hozzászólására (») Ápr 28, 2016 /
 
Az ARM egy processzorcsalad neve (tobbek kozt). Semmi koze nincs VDD-hez vagy MCLR-hez. ARM alapu mikrokontroller vagy ezer féle. Sot, ARM processzorbol is van egy csomo, pl. ARM7TDMI, Cortex-M0, Cortex-M3, hogy csak a gyakoribbakat emlitsem.
De egyebkent a fenti "okossagok" nagy resze igaz minden digitalis aramkorre. Minden tap labat be kell kotni, hidegitoket kell tenni kozvetlenul a tap labakhoz. A telefontolto dolog h@lyeseg, az MCLR es XT/HS kerdes meg PIC specifikus.
(#) steelgoofy hozzászólása Ápr 28, 2016 /
 
Üdv!

Látom mostanában és STM32-es ARM alapú boardokról is szó van itt, ezért fel merek tenni ezzel kapcsolatos kérdést. Írtam egy programot STM32 F4 Discovery boardra, amiben frekvencia mérés történik. A program tökéletesen működik, így átírtam a programot a szükséges változtatásokkal, STM32F103C8-as boardra is. A program ez esetben is tökéletesen működik, viszont a méréshez használt bemenet utóbbi esetben 20mA-t vesz fel, ami baj és a F4-es kártyánál (0 mA megy a bemeneten) nem fordult elő. Van ötletetek, hogy mi lehet a gond?

  1. #include "stm32f10x.h"
  2. #include "sajat.h"
  3. #include <stm32f10x_tim.h>
  4. #include <stm32f10x_gpio.h>
  5. #include <misc.h>
  6.  
  7.  
  8. uint32_t Value1 = 0;            // 1 élnél olvasott érték
  9. uint32_t Value2 = 0;            // 2. élnél olvasott érték
  10. uint32_t CaptureNumber = 0;             // segédváltozó
  11. uint32_t Capture = 0;                   // eltelt idő a két él között
  12. uint32_t Freq = 0;                      // a mért frekvencia
  13.  
  14. //int kva = 0;
  15.  
  16. int main(void)
  17. {
  18.         ora72();                // clock 72MHz
  19.         ////////////////////////////////////////////////////input capture//////////////////////////////////////////////
  20.  
  21.           GPIO_InitTypeDef GPIO_InitStructure;
  22.           NVIC_InitTypeDef NVIC_InitStructure;
  23.  
  24.           /* TIM3 clock enable */
  25.           RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
  26.  
  27.           /* GPIOA and special mode enable */
  28.           RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
  29.  
  30.           /* TIM3 channel 2 pin (PA.06) configuration */
  31.           GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6;
  32.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  33.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  34.           GPIO_Init(GPIOA, &GPIO_InitStructure);
  35.  
  36.           /* Enable the TIM3 global Interrupt */
  37.           NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
  38.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  39.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  40.           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  41.           NVIC_Init(&NVIC_InitStructure);
  42.  
  43.           TIM_ICInitTypeDef  TIM_ICInitStructure;
  44.           TIM_ICInitStructure.TIM_Channel = TIM_Channel_1;
  45.           TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
  46.           TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
  47.           TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  48.           TIM_ICInitStructure.TIM_ICFilter = 0x0;
  49.  
  50.           TIM_ICInit(TIM3, &TIM_ICInitStructure);
  51.  
  52.           /* TIM enable counter */
  53.           TIM_Cmd(TIM3, ENABLE);
  54.  
  55.           /* Enable the CC2 Interrupt Request */
  56.           TIM_ITConfig(TIM3, TIM_IT_CC1, ENABLE);
  57.  
  58.         ////////////////////////////////////////////////////end input capture//////////////////////////////////////////
  59.  
  60.           //kijelzés
  61.  
  62.           RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
  63.           /* GPIOC pin13 |LED| kijelzéshez használatos */
  64.           GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_13;
  65.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  66.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  67.           GPIO_SetBits(GPIOC, GPIO_Pin_13);
  68.           GPIO_Init(GPIOC, &GPIO_InitStructure);
  69.           int b=0;
  70.           while (1)
  71.           {
  72.                   if(TIM_GetITStatus(TIM3, TIM_IT_CC1) == RESET)
  73.                                         {
  74.                                                 b++;
  75.                                                 if(b > 20000)
  76.                                                         {
  77.                                                                 Freq = 0;
  78.                                                             b = 0;
  79.                                                           GPIO_SetBits(GPIOC, GPIO_Pin_13);
  80.                                                         }
  81.                                         }
  82.  
  83.                                   if(Freq>=3010 && Freq <=3013)
  84.                                         {
  85.                                                 GPIO_ResetBits(GPIOC, GPIO_Pin_13);
  86.  
  87.                                         }
  88.                                   if(Freq < 300)
  89.                                         {
  90.                                                 GPIO_SetBits(GPIOC, GPIO_Pin_13);
  91.  
  92.                                                 }
  93.           }
  94. }
  95.  
  96.  
  97.  
  98. void TIM3IntHandler(void)
  99. {
  100.  
  101.         if(TIM_GetITStatus(TIM3, TIM_IT_CC1) == SET)
  102.           {
  103.  
  104.             if(CaptureNumber == 0)
  105.             {
  106.               /* Get the Input Capture value 1 */
  107.               Value1 = TIM_GetCapture1(TIM3);
  108.               CaptureNumber = 1;
  109.  
  110.               /* Clear TIM3 Capture compare interrupt pending bit */
  111.               TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
  112.             }
  113.             else if(CaptureNumber == 1)
  114.             {
  115.               /* Get the Input Capture value 2 */
  116.               Value2 = TIM_GetCapture1(TIM3);
  117.  
  118.               /* Capture  */
  119.               if (Value2 > Value1)
  120.               {
  121.                 Capture = (Value2 - Value1);
  122.               }
  123.               else if (Value2 < Value1)
  124.               {
  125.                 Capture = ((0xFFFF - Value1) + Value2);
  126.               }
  127.  
  128.               /* freq */
  129.               if(Capture !=0)Freq = 72000000 / Capture;
  130.               CaptureNumber = 0;                                // segédváltozó reset
  131.               /* Clear TIM3 Capture compare interrupt pending bit */
  132.               TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
  133.             }
  134.           }
  135.  
  136. }
(#) cimopata hozzászólása Ápr 28, 2016 /
 
Üdv.

Van egy időzítőm amihez szeretném időzíteni az ADC mintavételt. A baj az hogy amikor a Timer interrupt hardveresen meghívódik akkor megtörténik az ADC mintavétel viszont az a függvény nem tud visszatérni az eredménnyel és a main függvényben nem látom az eredményt. Ezt onnan tudom hogy az ADC parancsot berakva a main fügvénybe adja az adatokat szépen.

Hogyan tudom ezt megoldani?
Amikor a timer interrupt fut az ADC-vel bele kéne írni egy direkt regiszterbe? Segítségeteket kérném.

Egész pontosan 10us-ra lesz hangolva a timer és úgy mentené az adatokat 900 adatot utána váltok csatornát gyorsan begyűjtene még 5 másik adatok a másik csatornáról és kezdődne előről.

Egyébként STM32F030 IC-t használok ha kell be tudom rakni a kódot.
(#) cimopata hozzászólása Ápr 28, 2016 /
 
Erről van szó, ha kirakom main-be akkor megy:
  1. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  2. {
  3.         if(htim->Instance==TIM14)
  4.                 {
  5.                         ADC1->CHSELR  = 2;
  6.                         ADC1->CR  = 5;                         
  7.                         while( !(ADC1->ISR & (1<<2)) );
  8.                         cucc = ADC1->DR;                                                                                               
  9.                
  10.                 }
  11. }
(#) killbill válasza cimopata hozzászólására (») Ápr 28, 2016 /
 
Lenyegeben ez a megoldas, miszerint az ADC eredmenyet beteszed egy valtozoba, amit a main-ed tud olvasni. De azert valamit nem ertek. 10us-onkent jon a timer interrupt? Mert akkor eleg bator dolog meg varakozo ciklust is beletenni. Azt mondjuk amugy sem szokas megszakitasba, de 100kHz megszakitasba vegkepp nem. Ennel sokkal jobb eredmenyt kapsz, ha a timer interrupt elejen kiolvasod az ADC-t, majd ujbol elinditod a merest. Ennek az lesz az eredmenye, hogy minden meresi eredmenyt csak 10us kesessel fogsz megkapni, viszont nem fogja a processzor ido 80%-at elvinni ez az egesz. Ami azt illeti, a 10us megszakitas ezen a processzoron amugy is necces.
(#) cpt.zoltan.simon válasza don_peter hozzászólására (») Ápr 28, 2016 /
 
Az ARM a cég neve. A Cortex-M0,M1,M3,M7 a mag, a szűken vett CPU, az NVIC-el (megszakítás kezelő áramkör), stb stb.
Az ARM-tól a magot egy félvezető gyártó pl a te esetedben az ST Micro licenszeli, és megépíti a saját mikrokontrollerét. A perifériákat SPI, UART, S(D)RAM, TFT vezérlőket a mag 32bites (AHB, APB) buszára már ők teszik fel. Így lesz az ST-nek a Cortex M3 családja az STM32F2xx, ugyan ez az NXP nevű cégnek pl LPC17xx
Ezeket a cuccokat - és ez szigorúan az én véleményem - nem érdemes chip-ben venni.
Ugyanis olyan pici plugin board-ban mint a tiéd, 4 rétegű áramkörön, pl az SDRAM miatt (STM32F429, LPC1788), nagy sebességű tervezést igényel, és sokkal olcsóbban meg tudod venni modulként, minden ami kell rajta van, semmivel nem kell foglalkoznod, 5V-ot adsz neki és már megy is. Ha mégis valami kisebbet veszel amin semmi gyors nincs kívül mint most én majd TSSOP20-as tokkal egy STM32F103-at, akkor a mellékelt kapcsolási rajzból ki tudod szedni a lényeges részeket. Föld-táp, Kvarc nem fontos bentről is megy, AVDD-AVSS szintén látható a rajzodon, és kb ennyi.
(#) cimopata válasza killbill hozzászólására (») Ápr 28, 2016 /
 
Nem. eredetileg nem volt benne semmi várakozás csak próbáltam már mindent.

Végképp nem értem mi történik ugyanis kiszedtem már szinte mindent ami nem kell.

Csak akkor hajlandó kiírni az adatokat ha benne hagyom a 4. sor HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_5); parancsot. Ha kiveszem akkor 000-t ír a kijelző.
Ha visszarakom akkor szépen írja a 330-000 közti értékeket amit az ADC-nek adok a potival.
Érthetetlen mi köze a kettőnek egymáshoz.

Ráadásul az még nem is a célpanel hanem egy nagyobb processzorral egy NUCLEO. A kis célpanel még ennyit sem csinál mivel ott bonyolódik már a program és nem jutottam el odáig hogy valamennyire működjön.


  1. while (1)
  2.   {
  3.  
  4.                 //HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_5);
  5.  
  6.                 for(i=0;i<100;i++)
  7.                 {
  8.                         szam[0]=cucc/1240;
  9.                         szam[1]=cucc/124-(szam[0]*10);
  10.                         szam[2]=((cucc*10)/124)-(szam[0]*100)-(szam[1]*10);
  11.                         TIM1->CCR1 = 100;
  12.                
  13.                         for(int a=0;a<3;a++)
  14.                                 {
  15.                                         if(a==0)k=0x0600;
  16.                                         if(a==1)k=0x0500;
  17.                                         if(a==2)k=0x0300;
  18.                                        
  19.                                         switch(szam[a])
  20.                                                 {
  21.                 case(0): GPIOC->ODR = 0x007E^k; break;
  22.                 case(1): GPIOC->ODR = 0x0030^k; break;
  23.                 case(2): GPIOC->ODR = 0x006D^k; break;
  24.                 case(3): GPIOC->ODR = 0x0079^k; break;
  25.                 case(4): GPIOC->ODR = 0x0033^k; break;
  26.                 case(5): GPIOC->ODR = 0x005B^k; break;
  27.                 case(6): GPIOC->ODR = 0x005F^k; break;
  28.                 case(7): GPIOC->ODR = 0x0070^k; break;
  29.                 case(8): GPIOC->ODR = 0x007F^k; break;
  30.                 case(9): GPIOC->ODR = 0x007B^k; break;
  31.                                                 }
  32.  
  33.                                 }
  34.                        
  35.                         }
  36.                
  37.   }
  38.  
  39.  
  40. }
  41.  
  42.  
  43. /** System Clock Configuration
  44. */
  45. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  46. {
  47.         if(htim->Instance==TIM14)
  48.                 {
  49.                        
  50.                        
  51.                
  52.         cucc= ADC1->DR;
  53.                        
  54.                 }
  55. }
A hozzászólás módosítva: Ápr 28, 2016
(#) cpt.zoltan.simon válasza cimopata hozzászólására (») Ápr 28, 2016 /
 
Én úgy csinálnám - mert ADC tudja - hogy Timer indítja a konverziót, amikor a konverzió kész, az ADC interrupt meg olvassa. Semmi szoftveres várakozás. Az ADC leírásában trigger néven találod ezt a módszert.
A 900 adathoz annyit hogy:
Én azt csinálnám hogy 512, 1024 stb mennyiségű mérést végeznék. Nyílván azért mérsz sokat hogy utána átlagolj. Ebben az esetben az osztás csak 9-10 léptetés balra lenne, nem pedig egy relatív időigényes decimális osztás.
A másik: Mondjuk digitalizálsz 12 biten. Az eredménynek van további 20 bitje (32bites változóról beszélünk). Én valahol az eredmény 20-31 bitje "magasságában" üzemeltetném a számlálót (nem külön változóban) és akkor tudnád azt is hogy hány konverzió volt.
(#) killbill válasza cimopata hozzászólására (») Ápr 28, 2016 /
 
A cucc hogyan van deklaralva?
(#) cimopata válasza killbill hozzászólására (») Ápr 28, 2016 /
 
  1. #include "stm32f0xx_hal.h"
  2.  
  3.  
  4. ADC_HandleTypeDef hadc;
  5.  
  6. TIM_HandleTypeDef htim1;
  7. TIM_HandleTypeDef htim14;
  8.  
  9. void SystemClock_Config(void);
  10. static void MX_GPIO_Init(void);
  11. static void MX_ADC_Init(void);
  12. static void MX_TIM1_Init(void);
  13. static void MX_TIM14_Init(void);
  14.  
  15. uint16_t cucc=0;
  16. uint16_t read_adc=0;
  17. int k;
  18.         int i;
  19.   uint16_t szam[3];
  20.  
  21.  
  22. int adat;
  23.  
  24.  
  25. int main(void)
  26. {
  27.  
  28.   HAL_Init();
  29.  
  30.  
  31.   SystemClock_Config();
  32.  
  33.  
  34.   MX_GPIO_Init();
  35.   MX_ADC_Init();
  36.   MX_TIM1_Init();
  37.   MX_TIM14_Init();
  38.        
  39.        
  40.         HAL_TIM_Base_Start(&htim1);
  41.         HAL_TIM_Base_Start_IT(&htim1);
  42.         HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_1);
  43.         HAL_TIM_Base_Start(&htim14);
  44.         HAL_TIM_Base_Start_IT(&htim14);
  45.  
  46.         ADC1->CHSELR  = 2;//(1<<0);
  47. HAL_ADC_Start(&hadc);                   //
  48.        
  49.        
  50.        
  51.        
  52.  
  53.   /* USER CODE BEGIN 2 */
  54.  
  55.   /* USER CODE END 2 */
  56.  
  57.   /* Infinite loop */
  58.   /* USER CODE BEGIN WHILE */
  59.   while (1)
  60.   {
(#) cimopata válasza cpt.zoltan.simon hozzászólására (») Ápr 28, 2016 /
 
Az 1000 úgy jön ki hogy a PWM vezérlés 10msec periódussal megy. Ezt felosztom 10us re a timerrel és mérek kb 990db-ot majd a maradék 10usec alatt vagy amennyi kell mérem a maradék 5 bemenetet amit nem kell nagy sebességgel mérni csak néha( pl poti)

Ennél a 990 mérésnél az ADC folyamatosan menne és csak 10u-kénz kiolvasnám az adat regisztert. Az nem tart semeddig.

Az 1000 db értéket viszonylag gyorsan dolgozná fel ugyanis elsőnek csak összeadom őket és mihelyst a minták száma eléri a maximumot akkor végzek osztást. Szerintem ez nem nagy időveszteség. Igazából mindegy is nem ragaszkodom ehhez a megoldáshoz csak az így nekem egyszerű megoldani. Nem is ezzel van a baj hanem mint írtam nem gazán akar működni a program.
A hozzászólás módosítva: Ápr 28, 2016
(#) cpt.zoltan.simon válasza cimopata hozzászólására (») Ápr 28, 2016 /
 
A CMSIS csupa rejtély...
(#) cimopata válasza cpt.zoltan.simon hozzászólására (») Ápr 28, 2016 /
 
Micsoda?
Ezekre szükség lehet! - HESTORE.HU

STM32F103-MS
STM32F429I-DISC1
STM32F030C6T6
SFM-27B
LR-BA9S-24
Következő: »»   67 / 177
Bejelentkezés

Belépés
Hirdetés
XDT.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