Fórum témák

» Több friss téma
Fórum » ARM - Miértek hogyanok
 
Témaindító: gtk, idő: Jún 26, 2007
Lapozás: OK   87 / 87
(#) rascal válasza csatti2 hozzászólására (») Szo, 19:33 /
 
Ez a 100-432MHz nem kerülte el a figyelmemet, arra lettem volna kíváncsi, hogy van-e valami optimum? Pl. 50 MHz-hez 100/2, 200/4, 400/8 párosok jók. Autónál tudom mivel jár ha kettesben megyek 50-el, vagy ha 4-esben, itt nem. Egyébként van cube-om, csak elméleti szempontból érdekelt, hogy van-e valami jelentősége?
(#) kiborg hozzászólása Szo, 22:41 /
 
Sziasztok!

Olvasgattam, nézegettem IDE-t és a CoIDE(CooCox) és az Atollic TrueStudio maradt bent a rostán.
STMF32F103C8 lenne programozva ST-LinkV2-n keresztül.
Tudtommal támogatja mindkettő, egyiknél sincs kódméret korlát.
Mindkettő csupa jót ír magáról. Van aki már próbálta esetleg mindkettőt? Vagy valakinek bármi tapasztalata/ismerete pro és kontra bármelyikkel kapcsolatban?
A hozzászólás módosítva: Szo, 22:42
(#) rascal válasza kiborg hozzászólására (») Vas, 3:34 /
 
Én az stm32 világába csak most ugrottam fejest. Az Atollic-ot telepítettem, még a 6-ost. Jól elvagyok a free verziójával. 5x7-es ledmátrixos kijelzőt hajtok meg vele IRQ-ból, rotary enkódereket figyelek, most jön egy kis ADC kezelés. Ezekhez biztos elég.
Debugolás is megy, pár fejlettebb dolgot a free verzió nem enged, de azt sem tudom micsodák, ezért nem is hiányoznak. Lépkedhetsz a programban, nézheted assemblyben is. A változókat, regisztereket nézheted és meg is változtathatod "pause"-ban. Több breakpointot rakhatsz, akár irq rutinokba is.
Az editora jelzi gépelés közben is a syntax errorokat, és van még pár kényelmi funkciója. Pl makró kifejtés kis ablakban, hogy lásd mi az az INGYOMBINGYOM_MAX.
Ismeri a különböző gyártók eval bordjait is, projekt létrehozásánál nem csak procit adhatsz meg, hanem ezt is és akkor már mindent tud.
Amivel viszont majdnem nagyon megszívatott, hogy a projekt létrehozásánál azt gondoltam, hogy a kijelölt könyvtár alatt, pl. "FEJLESZTÉSEK" létrehoz a projekt nevével azonos könyvtárat és abba dolgozik. Hát nem. A durva dolog csak ezután történt, amikor törölni akartam a projektet. Ugye létrehozáskor odapakol egy csomó fájlt, meg alkönyvtárat, ami törlés után nem kell. Amikor rákérdezett, hogy a fájlokat is törölje, gondoltam persze. Nos nem csak azt törölte, amit ő odarakott, hanem az egész könyvtárat, meg mindent ami alatta van. A Lomtár úgy látszik csak dísznek van, az Atollic nem használja. Annyi szerencsém volt, hogy az igazán fontos dolgokat pár perccel korábban átmásoltam egy teljesen máshol levő könyvtárba, ezért a lényeg megmaradt. Szóval csak óvatosan, mert simán letörli a fél gépedet ha nem figyelsz.
(#) vargham válasza kiborg hozzászólására (») Vas, 5:33 /
 
EmBitz? Kiesett vagy nem is nézted?
(#) kiborg válasza vargham hozzászólására (») Vas, 9:29 /
 
Szia!

Ez eddig kimaradt.Innen szemezgettem és az ismertebbeknek utána néztem. Az EmBitz nincs benne, és eddig máshol sem halottam.
De ezek szerint te használod. Milyen? Véleményt mondhatnál róla.
(#) rolandgw válasza kiborg hozzászólására (») Vas, 9:42 /
 
Ott van, csak régebben EmBlocks néven futott.
(#) kiborg válasza rolandgw hozzászólására (») Vas, 10:21 /
 
Aha. Info a használhatóságáról?
(#) kiborg válasza kiborg hozzászólására (») Vas, 11:05 /
 
Arról viszont nem találtam infót, hogy valamelyik IDE-nek van-e valami hasonló példa könyvtára, mint az Arduinonak. Tudtok ilyet?
Néztem videót a EmBitz-ről. Led Blinking. Egy csomó mindent be kell állítani, és kezdésnek lövésem sincs, hogy mit is, ezért lenne jó valami minta vagy példa összeállítás.
(#) vargham hozzászólása 6:24 /
 
Röviden: Desktop / mobil Java fejlesztés felől jövök, rapid prototypinghoz kerestem eszközt, ami nem Arduino. Az mbed szimpatikus, de az online IDE-t minél messzebbre el akartam kerülni, miközben megmaradnak a platform kényelmes szolgáltatásai. Ilyen alapon néztem végig egy csomó IDE-t.

Keil uVision: Szép, gyors. Kiválóan működik az mbed. Ha nem akarsz mbed-et, akkor rengeteg MCU-t ismer, és sok példakód is letölthető hozzá, akár MCU-hoz, akár boardhoz. Próbáltam mbed projektekkel, saját konfigurátorával és cubeMXszel is. Érdemes megnézni. Hátránya az ingyenes verzió 32 kB kódméret limitje.

System Workbench for STM32, és néhány másik Ecipse alapú cucc: Valami sosem működött az mbed projektekkel: Nem fordult le. Lefordult, de a feltöltött blinky szintű kód azonnal fagyott. Mbed nélkül nem próbáltam. Szóval akár még jó is lehet.

ARM-GCC + makefile: Szép, gyors, multiplatform. Akármilyen szövegszerkesztővel összerakható, aztán lehet telepíteni debug servert, és akkor abban fejlesztesz, amiben akarsz. Rész sikereket értem el benne, de túl sok idő volt mindent telepíteni / konfigurálni ahhoz képest, hogy a feltételeim között szerepelt a rapid szó is.

CooCox CoIDE: Szép is, jó is. Csak a weboldaluk döglődik (package manager download timeout...) + a némelyik mbed projektemet mindig újra fordítja + nem mindegyik mbed projekttel működik. Van hozzá sok könyvtár, package manager és mintakódok is. Saját maga kezeli a debuggert, így például akár ST-Linkkel is lehet Nuvotonra feltölteni.

Atmel Studio: Nagyon jó. A munkám során többször találkoztam vele. Hátránya, hogy csak Windows és csak Atmel.

SEGGER Embedded Studio: Sample projektekkel próbáltam csak. A telepítés után viszonylag hamar összeklikkeltem egy blinky-t, ami aztán tényleg futott is. Akár jó is lehet.

STM32Cube + Atollic. Szuper. Csak azért nem használom, mert nem akartam ennyire alacsony szintről indulni. Mbed import közvetlenül nincs, közvetve pedig nem jött össze.

EmBitz: Elég jó. Kicsit rontja csak el az mbed az exportot. Pár paramétert át kell írni, hogy működjön. Az IDE működik, teszi a dolgát, egész gyors. Az automatikus kódkiegészítés a projekt egyes részeire működik csak. Példa: Keil RTX API függvényeket ajánl, de az mbed API-t nem, miközben a projekt lefordul, tehát látja. De az is lehet, hogy ez megint csak mbed exporter hiba.
(#) csatti2 válasza kiborg hozzászólására (») 11:20 /
 
Az STM oldaláról kismillió példaprogramot letölthetsz a különböző perifériák használatához. Általában vmelyik discovery kithez optimalizálták őket, de kis munkával futtathatóak más eszközön is.

Annyi mindent szerintem nem kell beállítani egy "LED Blinking"-hez EmBitz-nél (én is azt használom). Létrehozol egy projektet SPL alappal a kívánt uC-hez. Hozzárendeled az ST-Linkedet (nem is kell konfigurálni rajta semmit). Ezután már írhatod is a programod.
(#) kiborg válasza csatti2 hozzászólására (») 11:56 /
 
Szia!
A sok beállítás alatt azt értettem, hogy egy port kimenet legyen, egy csomó paramétert kell beállítani.
EZT a videót elnézve legalábbis, egy szimpla 8bites AVR után soknak tűnik.
Akkor próba majd EmBitz és egy csomó példa lehúz
(#) csatti2 válasza kiborg hozzászólására (») 12:23 /
 
Szimpla 8 bites AVR alatt gondolom nem találkoztál az ATXMEGA családdal (már ott is jóval több minden volt mint az ATMEGA-nál).
Az a sok beállítás lehetővé tesz rengeteg olyan dolgot, amihez különben további hardver elemeket kellene betenni, az SPL használata pedig megkönnyíti a portolást az F0, F1 és F4 családok között. Amíg nem jön ki a LowLayer addig nálam marad az SPL, illetve a direkt regiszter piszkálgatás (ahol megéri a plusz macerát).
Egyébként úgyis copy-paste lesz később a konfigurációd. Az újrahasznosítást pedig megkönnyíti, ha nem direktbe hivatkozol a portokra, hanem definiálsz beszédesebb neveket és összegyűjtöd őket egy külön header fájlba, pl.:
  1. // DEBUG USART
  2. #define USART_DEBUG                       USART1
  3. #define USART_DEBUG_GPIO                  GPIOA
  4. #define USART_DEBUG_CLK                   RCC_APB2Periph_USART1
  5. #define USART_DEBUG_GPIO_CLK              RCC_APB2Periph_GPIOA
  6. #define USART_DEBUG_RxPin                 GPIO_Pin_10
  7. #define USART_DEBUG_TxPin                 GPIO_Pin_9
  8. #define USART_DEBUG_IRQn                  USART1_IRQn
  9. #define USART_DEBUG_IRQHandler            USART1_IRQHandler
  10. #define USART_DEBUG_DMA_CLK               RCC_AHBPeriph_DMA1
  11. #define USART_DEBUG_DMA_Channel           DMA1_Channel4     // Depends on USART! See DMA request mapping
  12. #define USART_DEBUG_DMA_IRQn              DMA1_Channel4_IRQn
  13. #define USART_DEBUG_DMA_IRQHandler        DMA1_Channel4_IRQHandler
  14. #define USART_DEBUG_DMA_FLAG              DMA1_FLAG_TC4

Majd a C fájl:
  1. // DEBUG - USART
  2. void USART_DEBUG_Config(uint32_t bufferAddr)
  3. {
  4.   GPIO_InitTypeDef GPIO_InitStruct;
  5.   USART_InitTypeDef USART_InitStruct;
  6.   DMA_InitTypeDef DMA_InitStructure;
  7.  
  8.   RCC_APB2PeriphClockCmd(USART_DEBUG_GPIO_CLK | RCC_APB2Periph_AFIO, ENABLE);
  9.   RCC_APB2PeriphClockCmd(USART_DEBUG_CLK, ENABLE);
  10.  
  11.  
  12.   // Tx
  13.   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
  14.   GPIO_InitStruct.GPIO_Pin = USART_DEBUG_TxPin;
  15.   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  16.   GPIO_Init(USART_DEBUG_GPIO, &GPIO_InitStruct);
  17.  
  18.   // Rx
  19.   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  20.   GPIO_InitStruct.GPIO_Pin = USART_DEBUG_RxPin;
  21.   GPIO_Init(USART_DEBUG_GPIO, &GPIO_InitStruct);
  22.  
  23.   // Enable the DMA Clock
  24.   RCC_AHBPeriphClockCmd(USART_DEBUG_DMA_CLK, ENABLE);
  25.   DMA_DeInit(USART_DEBUG_DMA_Channel);
  26.   DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART_DEBUG->DR;//USART_DEBUG_DR_Base;
  27.   DMA_InitStructure.DMA_MemoryBaseAddr = bufferAddr;
  28.   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
  29.   DMA_InitStructure.DMA_BufferSize = 0;
  30.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  31.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  32.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  33.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  34.   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  35.   DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
  36.   DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  37.   DMA_Init(USART_DEBUG_DMA_Channel, &DMA_InitStructure);
  38.   DMA_ITConfig(USART_DEBUG_DMA_Channel, DMA_IT_TC, ENABLE);
  39.   USART_DEBUG_DMA_NVIC_Configuration();
  40.   USART_InitStruct.USART_BaudRate = USART_DEBUG_BAUDRATE;
  41.   USART_InitStruct.USART_StopBits = USART_StopBits_1;
  42.   USART_InitStruct.USART_WordLength = USART_WordLength_8b;
  43.   USART_InitStruct.USART_Parity = USART_Parity_No;
  44.   USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  45.   USART_InitStruct.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
  46.   USART_Init(USART_DEBUG, &USART_InitStruct);
  47.   USART_DMACmd(USART_DEBUG, USART_DMAReq_Tx, ENABLE);
  48.   USART_ITConfig(USART_DEBUG,USART_IT_RXNE,ENABLE);
  49.   USART_DEBUG_NVIC_Configuration();
  50.   USART_Cmd(USART_DEBUG, ENABLE);
  51. }
A hozzászólás módosítva: 12:25
(#) benjami válasza csatti2 hozzászólására (») 13:08 / 1
 
F1-hez a GPIO-t én így oldottam meg.
A header file:
  1. // portláb módok (PP: push-pull, OD: open drain, FF: input floating
  2. #define ANALOG_INPUT          0x0
  3. #define PP_OUT_10MHZ          0x1
  4. #define PP_OUT_2MHZ           0x2
  5. #define PP_OUT_50MHZ          0x3
  6. #define FF_DIGITAL_INPUT      0x4
  7. #define OD_OUT_10MHZ          0x5
  8. #define OD_OUT_2MHZ           0x6
  9. #define OD_OUT_50MHZ          0x7
  10. #define PU_DIGITAL_INPUT      0x8
  11. #define PP_ALTER_10MHZ        0x9
  12. #define PP_ALTER_2MHZ         0xA
  13. #define PP_ALTER_50MH         0xB
  14. #define RESERVED              0xC
  15. #define OD_ALTER_10MHZ        0xD
  16. #define OD_ALTER_2MHZ         0xE
  17. #define OD_ALTER_50MHZ        0xF
  18.  
  19. #define GPIOX_PORT_(a, b)     GPIO ## a
  20. #define GPIOX_PORT(a)         GPIOX_PORT_(a)
  21.  
  22. #define GPIOX_PIN_(a, b)      b
  23. #define GPIOX_PIN(x)          GPIOX_PIN_(x)
  24.  
  25. #define GPIOX_CLOCK_(a, b)    RCC_APB2Periph_GPIO ## a
  26. #define GPIOX_CLOCK(a)        GPIOX_CLOCK_(a)
  27.  
  28. #define GPIOX_SETMODE_(a,b,c) ((GPIO_TypeDef*)(((c & 8) >> 1) + GPIO ## b ## _BASE))->CRL = (((GPIO_TypeDef*)(((c & 8) >> 1) + GPIO ## b ## _BASE))->CRL & ~(0xF << ((c & 7) << 2))) | (a << ((c & 7) << 2));
  29. #define GPIOX_SETMODE(a, b)   GPIOX_SETMODE_(a, b)
  30.  
  31. #define GPIOX_SETBIT_(a, b)   GPIO ## a->BSRR = 1 << b
  32. #define GPIOX_SETBIT(a)       GPIOX_SETBIT_(a)
  33.  
  34. #define GPIOX_CLRBIT_(a, b)   GPIO ## a->BSRR = 1 << (b + 16)
  35. #define GPIOX_CLRBIT(a)       GPIOX_CLRBIT_(a)
  36.  
  37. #define GPIOX_INBIT_(a, b)    (GPIO ## a->IDR & (1 << b))
  38. #define GPIOX_INBIT(a)        GPIOX_INBIT_(a)
  39.  
  40. #define GPIOX_LINE_(a, b)     EXTI_Line ## b
  41. #define GPIOX_LINE(a)         GPIOX_LINE_(a)
  42.  
  43. #define GPIOX_PORTSRC_(a, b)  GPIO_PortSourceGPIO ## a
  44. #define GPIOX_PORTSRC(a)      GPIOX_PORTSRC_(a)
  45.  
  46. #define GPIOX_PINSRC_(a, b)   GPIO_PinSource ## b
  47. #define GPIOX_PINSRC(a)       GPIOX_PINSRC_(a)


A c-ben pedig így lehet felhasználni:
  1. #define GOMB   A, 2
  2. #define LED_1  B, 9
  3. #define LED_2  B, 10
  4.  
  5. int main(int argc, char* argv[])
  6. {
  7.   RCC_APB2PeriphClockCmd(GPIOX_CLOCK(GOMB) | GPIOX_CLOCK(LED_1) | GPIOX_CLOCK(LED_2));
  8.   GPIOX_SETMODE(PU_DIGITAL_INPUT, GOMB);
  9.   GPIOX_SETBIT(GOMB); // hogy felhuzo ellenállás legyen
  10.   GPIOX_SETMODE(OD_OUT_2MHZ, LED_1);
  11.   GPIOX_SETMODE(OD_OUT_2MHZ, LED_2);
  12.   while(1);
  13.   {
  14.     if(GPIOX_INBIT(GOMB))
  15.     {
  16.       GPIOX_SETBIT(LED_1);
  17.       GPIOX_CLRBIT(LED_2);
  18.     }
  19.     else
  20.     {
  21.       GPIOX_CLRBIT(LED_1);
  22.       GPIOX_SETBIT(LED_2);
  23.     }
  24.   }
  25. }
A hozzászólás módosítva: 13:10
(#) benjami válasza benjami hozzászólására (») 13:22 /
 
A while(1) után nem kell a pontosvessző (csak már nem tudtam javítani) !
(#) csatti2 válasza benjami hozzászólására (») 13:34 /
 
Nem rossz megoldás. Mondjuk én maradok az SPL funkcióknál, ahol lehet (úgy értem, nem rejtem őket makrók mögé), bár vmiért eddig nem jutott eszembe makrókkal összefűzni a leszármaztatott elemeket (pedig rendszeresen használom ilyesmi célra a makrókat , lásd példa: )
  1. #define ISR(x)      void ALWAYSINLINE x ## _code (void); \
  2.                     void __attribute__ ((interrupt ("IRQ"))) x (void) { \
  3.                       MONITOR_1_SET(); \
  4.                       x ## _code(); \
  5.                       MONITOR_1_CLR(); \
  6.                     } \
  7.                     void ALWAYSINLINE x ## _code (void)
A hozzászólás módosítva: 13:35
Következő: »»   87 / 87
Bejelentkezés

Belépés

Hirdetés
Frissek
2017. Feb, 20. Hé
14:08:57
Jelenleg 482 fő olvassa az oldalt
Online tagok:
Lapoda.hu     XDT.hu     HEStore.hu