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   101 / 175
(#) cimopata válasza icserny hozzászólására (») Szept 6, 2017 /
 
Rakosgatom a verziókat 2.3-at letöröltem felraktam a 3.3-at ezzel gem F031-es lát. Ha simán program& verify nyomok akkor megy feltéve ha az options WDG_SW be lett állítva.

Ha bemegyek automatic mode ba (ez lenne a cél hogy egymás után levédve tudjam programozgatni) akkor valamit ráprogramoz de vagy nem idnul a proci vay csak újraindulgat. Most éppen egyáltalán nem indul el automatic mode-ban a felprogramozás csak vár az eszközre, pedig rajta van. Totál beteges a szoftver. 3.8 jó volt de gondolván frissebb verzió jobb frissítettem a 4.1-re de az is egy kalap szar a 3.8 bezzeg nincs fent a neten sehol . ST-nek üzenetet írni???.... hagyjuk.... nulla a weboldaluk nem várok tőlük segítséget.

Mondjuk az ST szoftvereitől már megszokhattam a CUBE is olyan kódokat generál hogy tele van hibával.

Felrakom a 4.1-et azzal még egy kicsit még ba...tom de már itt van mellettem a fejsze készenlétben...
(#) Andr3wJ válasza cimopata hozzászólására (») Szept 6, 2017 /
 
Magát a programozót nem lehet vagy érdemes frissíteni?
Én megvettem 2 hete, egyből toltam rá a gyárira meg a klónra is az utolsót ami fent van.
(#) rolandgw hozzászólása Szept 24, 2017 /
 
Sziasztok!
Egy egyszerű kérdésem lenne, még nem vagyok járatos az ARM assemblerben.
Ha egy while ciklusban ránézek egy flag-re egy status regiszterben és a reserved bitek az ábra szerint vannak meghatározva, akkor 0-ra kell maszkolni ezeket a biteket? Vagy úgy is kérdezhetném, hogy ez read-modify-write művelet? Két könyvtáram is van adott chip-hez, az egyikben így van, a másik Codebundle-ben pedig nem.

reserved.PNG
    
(#) kiborg hozzászólása Okt 2, 2017 /
 
Sziasztok!
Ha van egy Arduino bootloader egy BluePill-en, akkor ha egy IDE-ből(EmBitz) letöltök STLink V2-n keresztül egy C programot, akkor a bootloader felül fog íródni?
Ha nem, akkor van arra mód, hogy kérdés és boot nélkül az én programom induljon el? (nem akarok bootloadert írni,ahhoz még messze vagyok) vagy van valami gyári,amit fel kell/lehet rakni?
Kiborg
A hozzászólás módosítva: Okt 2, 2017
(#) ha1drp válasza kiborg hozzászólására (») Okt 2, 2017 /
 
Az STM kontrollerekbe gyárilag van (ebben pl. soros porti ) bootloader, azt kitörölni nem lehet. Ez a BOOT0 '0' szintjével aktiválható. A BluePill is alapban ezt tartalmazza. Persze rengeteg más bootloader létezik, itt már más a helyzet.
(#) kiborg válasza ha1drp hozzászólására (») Okt 2, 2017 /
 
SZia!
Az ebben a hozzászólában linkelt bootloader van rajta,amit a soros porton keresztül töltöttem fel rá.
Ez úgy kezdett, hogy gyorsan villantott párat, majd futott az én programom.
Letöltöttem rá most az EmBitzen keresztül a saját programomat és megszünt a pár gyors villogás.
Akkor felülírta a bootloadert vagy mi történt?
(#) icserny válasza kiborg hozzászólására (») Okt 3, 2017 /
 
Igen, az általad rátöltött bootloadert felülírta.

Ha újra Arduino IDE-vel akarod használni és USB bootloaderrel (elvégre az a legkényelmesebb), akkor előtte újra töltsd rá a generic_boot20_pc13.bin bootloadert, pl. a soros porton, a beépített bootloader segítségével.

Ahogy ha1drp kolléga írta, a soros porti gyári bootloader viszont mindig rendelkezésre áll. Csak a BOOT0 jumpert kell állítgatni...
(#) kiborg válasza icserny hozzászólására (») Okt 3, 2017 /
 
SZia!

Köszi az infót.
Úgy néz ki, hogy nem lesz Arduinos kitérőm. Pár próbálkozás után rájöttem, hogy nagyon elrejti a hardvert, nem szimpatikus.
Még mindig a megfelelő IDE kiválasztásán gondolkozom.
EmBitz tetszik, de nem nagyon találok mintakódokat,pedig SPI-t jó lenne használni.
Van esetleg valami mintád STM32F103C8 vagy valami hasonlóra?
(#) csatti2 válasza kiborg hozzászólására (») Okt 3, 2017 /
 
EmBitz szerintem jó választás, én is azt használom.

A bootloader szintén nem olyan bonyolult. Ha nem akarod, hogy a főprogramod felülírja akkor meg kell változtatnod pár dolgot, hogy ne az alapértelmezett pontról induljon a progid (és ne oda tegye a programozó se).
Első lépésként meg kell változtanod a linker scriptet (ld fájl):
A példában láthatod, hogy eltoltam a kezdőcímet 64K-val és lecsökkentettem az elérhető flash-t is ugyanennyivel.
  1. /* Memory Spaces Definitions */
  2. MEMORY
  3. {
  4.     ROM  (rx) : ORIGIN = 0x08010000, LENGTH = 448K
  5.     RAM (rwx) : ORIGIN = 0x20000000, LENGTH = 64K
  6. }


Ha az új low layer HAL-t használod, akkor a system_stm32f1xx.c-ben módosítanod kell a vektor tábla (megszakítások) ofszetet az alábbi módon:
  1. /* #define VECT_TAB_SRAM */
  2. #define VECT_TAB_OFFSET  0x00010000U /*!< Vector Table base offset field.
  3.                                   This value must be a multiple of 0x200. */


Ugyanez a régi SPL HAL-nál a system_stm32f10x.c-ben található. Az ofszetet értelemszerűen annyival kell eltolni, mint amennyivel eltoltad a programot a flash-ban a linker script-el.

Ahhoz, hogy a bootloader miután végzett elinduljon a főprogram, módosítanod kell a program kezdőcímét a bootloaderben az ORIGIN-nél megadott értékre.
(#) csatti2 válasza kiborg hozzászólására (») Okt 3, 2017 /
 
Létezik gyári mintaprogram mind SPL, LL, illetve Cube HAL-hoz. Csak regisztrálni kell az ST oldalán és letölthetőek.

Ha megmondod mit használsz a fentiek közül, akkor lehet tudunk adni saját implementációnkra is példát. Van itt köztünk olyan is, aki regiszter szinten piszkálja a saját mikrokontrollereit (a low layer is ugyanezt csinálja, csak olvashatóbb marad a kód).
A hozzászólás módosítva: Okt 3, 2017
(#) Andr3wJ hozzászólása Okt 3, 2017 /
 
Blue Pill-t használok most én is, előbb utóbb szeretnék leszokni a HAL használatától, igaz még csak most kezdtem de már nem szimpatikus. Ráadásul többen ajánlották itt hogy inkább alacsonyabb szinten kéne programozni.
Alap dolgokat ADC DMA-val és Timer megszakítással már elég jól sikerül kezelni, plusz soros porton küldi ki szépen az adatokat.
Most egy olyat szeretnék hogy ADC watchdoggal figyeltetni a jelet és a jel hosszát mérni.
Az én elgondolásom az hogy mikor küszöbszintet átlépi, megszakítást generál de ezt minden AD átalakításnál meg fogja tenni, megszakítási rutinban indítom a számlálót. Majd ha nincs megszakítás megállítom a főprogramban?
Vagy az alsó hátárérték küszöböt viszem a felső határ alá pár tizeddel, és megszakításban eldöntöm hogy kisebb e vagy nagyobb a felső határértéknél , és indítom vagy megállítom a számlálót.

Watchdog szépen működik, menet közben gombbal állítom be a felső értéket, az AD átalakítóra meg egy poti van kötve, LED jelzi ha felette van.Gombnyomás után persze össze vissza villog egyrészt nyers jelet dolgoz fel,másrészt elég kicsi a lépték(3,3V/4095).

Megszakításon belül nem szerencsés nagyon számolgatásokat végezni gondolom, csak mondjuk változót beállítani, aztán főprogramban ettől függően számolgatni?

Nem vagyok programozó, csak egy amatőr. Nagyon ritkán kérdezek, próbálok csak olvasás módban maradni, de néha nem találom meg amit keresek vagy nem tudom hogyan keressek.
A hozzászólás módosítva: Okt 3, 2017
(#) vargham válasza Andr3wJ hozzászólására (») Okt 3, 2017 /
 
> előbb utóbb szeretnék leszokni a HAL használatától, igaz még csak most kezdtem de már nem szimpatikus
Konkrétabban? Mi nem tetszik benne?
(#) kiborg válasza csatti2 hozzászólására (») Okt 3, 2017 /
 
Szia!
A bootloader nem izgat, jobb is, hogy eltűnt
Igazából nem a HAL-t használom, hanem szeretném megérteni a működést,ezért regiszter szinten piszkálom a vezérlőt,mint a 8-bites AVR-es időkben.
Egy SPI-s VFD-t kötnék rá (Samsung 16L102DA4S),tehát vissza nem olvasnék semmit, de ez a beállítást nem befolyásolja.
SPL az minek a rövidítése?
HAL-t már halottam, de pontosan ezt sem tudom.
LL - Low Layer, gondolom valami assemler szintű programozás.
Én C-ben tolom,de ott is frankón hozzáférhetőek a regiszter bitek és tényleg olvasható marad a kód.
(#) Andr3wJ válasza vargham hozzászólására (») Okt 3, 2017 /
 
Ezeket most úgy írom hogy nagyon keveset foglalkoztam vele , és nem vagyok szakértő.
Egyrészt az olvasottak alapján se szimpatikus, több helyen írták hogy bugos, és tanácsok alapján is jobb nem használni. Valószínűleg az én szintemen jó ez is.
Az se tette szimpatikussá az információk után, mikor elkezdtem használni és belefutottam a CubeMx által generált hibába, ekkora cég és ilyen hiba...
Valamit sokkal egyszerűbb beállítani, mint HAL-nak átadni és majd ő megcsinálja.
Gondolom akkor van értelme HAL-nak ha hasonló eszközökre kell ugyan azt lefejleszteni.
Aztán dupla meló megtanulni a HAL-t , és a regisztereket is.

Oké hogy ez csinál egy ellenőrzést is.
  1. AnalogWDGConfig.HighThreshold = 2048;
  2.    if (HAL_ADC_AnalogWDGConfig(&hadc1, &AnalogWDGConfig) != HAL_OK)
  3.   {
  4.     Error_Handler();
  5.   }


De nem könnyebb ha tudom a regiszter és betöltöm az értéket pl: ADC_HTR
A hozzászólás módosítva: Okt 3, 2017
(#) icserny válasza kiborg hozzászólására (») Okt 3, 2017 /
 
Nem volt még időm komolyabban foglalkozni vele. Elvileg az mbed környezetben is programozható. Bővebben: Link
(#) csatti2 válasza kiborg hozzászólására (») Okt 3, 2017 /
 
SPL - Standard Peripheral Libraries, ezt tartalmazza alapból az EmBitz STM32-höz. Már nem támogatják, ehelyett hozták be a low layer-t. Valamelyest absztraktabb, mint a low layer.
HAL - Hardware Abstracture Layer, azokat a könyvtárakat szokták így hívni, amelyek egy plusz réteget képeznek a programod és a vas között. HAL tehát a low layer is, az SPL is, illetve a CubeMX magasabb szintű HAL-ja is.
LL - Low Layer, nem assembler hanem C könyvtárak. Gyakorlatilag a regisztereket hívja direktben a legtöbb utasítása, megkönnyíti valamelyest a hordozhatóságot a különböző ST mikrokontrollerek között (persze komoly korlátokkal) és olvashatóbb marad a kód, mintha te magad írogatnád közvetlenül a regisztereket. Én személy szerint most már ezt használom. Viszonylag új dolog és még vannak benne bug-ok.

Ami a dupla melót illeti, HAL és HAL között is óriási a különbség. A legmagasabb szintűt, amit a CubeMX generál én sem szeretem, mert túl absztrakt és nem elég hatékony. A low layer viszont jelentősen megkönnyíti a munkát. Itt némileg több regisztered van mint a 8bites AVR-nél. Kezdőként iszonyat megnehezíted a dolgod, ha egyből regiszterekkel kezdesz. Direkt regiszterkezelés a low layer-hez viszonyítva pedig nem igazán hoz teljesítmény többletet. Ettől még természetesen tudnod kell majd a dokumentáció alapján ellenőrizni, hogy mégis minden jól lett beállítva debugoláskor az élő regisztereknél.
(#) csatti2 válasza Andr3wJ hozzászólására (») Okt 3, 2017 /
 
Próbálj majd egyszer egy FSMC buszt felkonfigurálni regiszterekkel, majd rájössz miért is jó egy kis absztrakció.
(#) kiborg válasza csatti2 hozzászólására (») Okt 3, 2017 /
 
Akkor SPL-ben dolgozom. Most már legalább ezt is tudom.Nincs semmi extra fenn, csak amit az EmBitz felrakott alapból.
Így szeretném az SPI-t munkára fogni.
Köszi az okosítást.
Délután rakok fel egy kódrészletet majd,ahogy inicializálom az SPI-t.Majd ha ránéznétek,azt megköszönném.
(#) Andr3wJ válasza csatti2 hozzászólására (») Okt 3, 2017 /
 
Na igen.

Köszi az információkat, akkor kicsit utánaolvasgatok az LL-nek.
(#) vargham hozzászólása Okt 3, 2017 / 1
 
Azért nem kell leírni a HAL-t elég jó ütemben dolgoznak rajta. Fejlesztőként pedig nem mindegy, hogy napokig, hetekig regisztereket piszkálok, vagy tervezés után azonnal írhatom az alkalmazást, amiért a piac, vagy a megbízó fizet.

Dolgozom egy projektben, ahol az applikációt STM32 HAL és RTOS fölé fejlesztjük. Szuperül hordozható az applikáció a különféle mikrokontrollerek között. Kell is, mert nem szeretnénk minden komponensre újra megírni.
A projekt alapvetően Makefile alapú. A fejlesztéshez és hibakereséshez a legtöbben EmBitz-et használunk. Az applikáció fejlesztési nyelve a C++, 2014-es szabvány. Kidolgoztuk a mikéntjét, hogy a CubeMX által összerakott kódhoz egy sort sem kell hozzáírni. Az applikáció is egy osztály, és minden szükséges objektumnak tulajdonosa, nincsenek globális változók sem. A megfelelő osztályok konstruktor paramáterben kapják a CubeMX által inicalizált eszköz handlerjét, így az applikció fejlesztője nem találkozik HAL hívásokkal, csak a saját, C++ API-val.
A sok HAL-t lehúzó fórum hozzászólás főleg 2015-ös. Azóta sokat javult a HAL minősége. Kár szidni az STM-et, semelyik cég kódja nem tökéletes. És nem csak a kódja. A hardverben is előfordulnak bugok. Fejlesztés közben folyamatosan figyelni kell az errata dokumentumokat, és számon tartani, hogy melyik gyártási időpontú MCU-n mi nem működik... Ez egy ilyen szakma.
Az SPL-t dobta az STM, nem érdemes alapozni rá. Az LL is C, és főleg a felfelé adott interfészben klönbözik a HAL-tól. Például LL-ben I2C olvasás: Generate start condition, write I2C address, read bytes, generate stop condition. Ez 4 hívás. HAL-ban van egy darab olvasás függvény, ami paraméterben kapja a címet, és az olvasandó bájtok számát, a többit intézi maga. Mindenki döntse el, hogy neki melyik kényelmesebb.
(#) kiborg válasza kiborg hozzászólására (») Okt 3, 2017 /
 
  1. void init_SPI1(void){
  2.  
  3.         GPIO_InitTypeDef GPIO_InitStruccture;
  4.         SPI_InitTypeDef SPI_InitStruct;
  5.  
  6.         // enable clock for used IO pins
  7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  8.  
  9.         /* configure pins used by SPI1
  10.          * PA5 = SCK
  11.          * PA6 = MISO
  12.          * PA7 = MOSI
  13.          */
  14.         GPIO_InitStruccture.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_6 | GPIO_Pin_5;
  15.         GPIO_InitStruccture.GPIO_Mode = GPIO_Mode_Out_PP;
  16.         GPIO_InitStruccture.GPIO_Speed = GPIO_Speed_50MHz;
  17.         GPIO_Init(GPIOA, &GPIO_InitStruccture);
  18.  
  19.         // connect SPI1 pins to SPI alternate function
  20.         GPIO_PinRemapConfig(GPIO_Remap_SPI1, ENABLE);
  21.  
  22.  
  23.         // enable clock for used IO pins
  24.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  25.  
  26.         GPIO_InitStruccture.GPIO_Pin = VFD_SEL;
  27.         GPIO_InitStruccture.GPIO_Mode = GPIO_Mode_Out_PP;
  28.         GPIO_InitStruccture.GPIO_Speed = GPIO_Speed_50MHz;
  29.         GPIO_Init(VFD_Port, &GPIO_InitStruccture);
  30.         GPIO_SetBits(VFD_Port,VFD_SEL);
  31.  
  32.         GPIO_InitStruccture.GPIO_Pin = VFD_RES;
  33.         GPIO_InitStruccture.GPIO_Mode = GPIO_Mode_Out_PP;
  34.         GPIO_InitStruccture.GPIO_Speed = GPIO_Speed_50MHz;
  35.         GPIO_Init(VFD_Port, &GPIO_InitStruccture);
  36.     GPIO_ResetBits(VFD_Port,VFD_RES);
  37.                 // enable peripheral clock
  38.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
  39.  
  40.         SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex; // set to full duplex mode, seperate MOSI and MISO lines
  41.         SPI_InitStruct.SPI_Mode = SPI_Mode_Master;     // transmit in master mode, NSS pin has to be always high
  42.         SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b; // one packet of data is 8 bits wide
  43.         SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;        // clock is low when idle
  44.         SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;      // data sampled at first edge
  45.         SPI_InitStruct.SPI_NSS = SPI_NSS_Soft | SPI_NSSInternalSoft_Set; // set the NSS management to internal and pull internal NSS high
  46.         SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256; // SPI frequency is APB2 frequency / 4
  47.         SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_LSB;// data is transmitted MSB first
  48.         SPI_Init(SPI1, &SPI_InitStruct);
  49.  
  50.         SPI_Cmd(SPI1, ENABLE); // enable SPI1
  51. }


Azt nem tudom, hogy a forrás amit felhasználtam, az a // connect SPI1 pins to SPI alternate function részt másképp oldotta meg, három utasítással,külön PIN-enként. Jó-e ez így ahogy van?
EmBizt 1.11 SPL

Ez meg az adatküldő modul:
  1. uint8_t SPI1_send(uint8_t data){
  2.  
  3.         SPI1->DR = data; // write data to be transmitted to the SPI data register
  4.         while( !(SPI1->SR & SPI_I2S_FLAG_TXE) ); // wait until transmit complete
  5.         while( !(SPI1->SR & SPI_I2S_FLAG_RXNE) ); // wait until receive complete
  6.         while( SPI1->SR & SPI_I2S_FLAG_BSY ); // wait until SPI is not busy anymore
  7.         return SPI1->DR; // return received data from SPI data register
  8. }
(#) csatti2 válasza kiborg hozzászólására (») Okt 3, 2017 /
 
Szerintem nem jó.
Az SCK-t és a MOSI-t GPIO_Mode_AF_PP-nek szoktam konfigurálni. A MISO-t pedig GPIO_Mode_IN_FLOATING-nak.

Az adatküldőbe betennék vmilyen timeout mechanizmust, illetve a while-okat is átrendezném úgy, hogy először ellenőrzöd, hogy szabad-e küldeni (ez később lesz igazán hasznos, amikor kiegészíted DMA-val az SPI kezelést, mert csak úgy gyors igazán). Ezután küldesz, majd megvárod lehet-e vmit beolvasni. Beolvasod. A BSY flag-es várakozás felesleges.
(#) kiborg válasza csatti2 hozzászólására (») Okt 3, 2017 /
 
Szia!

OK, kipróbálom.
Viszont, hogy egy kijelző van csak rákötve az SPI-re, az nem küld vissza semmit,mert nincs is olyan PIN-je, amit a MISO-ra kellene kötni, azt így szabadon hagytam.
DMA-t még hanyagolom,mert nem igazán hizsem, hogy szükségem lesz rá, hobbi szinten nyomom csak még.
Akkor felmerült bennem a kérdés, hogy van-e értelme, a wait until receive complete while-jának vagy azt is törölhetem jelen esetben?
A BSY-s sort meg töröltem.

Így néz ki a móka:
  1. void init_SPI1(void){
  2.  
  3.         GPIO_InitTypeDef GPIO_InitStruccture;
  4.         SPI_InitTypeDef SPI_InitStruct;
  5.  
  6.         // enable clock for used IO pins
  7.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  8.  
  9.         /* configure pins used by SPI1
  10.          * PA5 = SCK
  11.          * PA6 = MISO
  12.          * PA7 = MOSI
  13.          */
  14.         GPIO_InitStruccture.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_5;
  15.         GPIO_InitStruccture.GPIO_Mode = GPIO_Mode_AF_PP;
  16.         GPIO_InitStruccture.GPIO_Speed = GPIO_Speed_50MHz;
  17.         GPIO_Init(GPIOA, &GPIO_InitStruccture);
  18.  
  19.         GPIO_InitStruccture.GPIO_Pin = GPIO_Pin_6;
  20.         GPIO_InitStruccture.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  21.         GPIO_InitStruccture.GPIO_Speed = GPIO_Speed_50MHz;
  22.         GPIO_Init(GPIOA, &GPIO_InitStruccture);
  23.  
  24.         // connect SPI1 pins to SPI alternate function
  25.         GPIO_PinRemapConfig(GPIO_Remap_SPI1, ENABLE);
  26.  
  27.  
  28.         // enable clock for used IO pins
  29.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  30.  
  31.         GPIO_InitStruccture.GPIO_Pin = VFD_SEL;
  32.         GPIO_InitStruccture.GPIO_Mode = GPIO_Mode_Out_PP;
  33.         GPIO_InitStruccture.GPIO_Speed = GPIO_Speed_50MHz;
  34.         GPIO_Init(VFD_Port, &GPIO_InitStruccture);
  35.         GPIO_SetBits(VFD_Port,VFD_SEL);
  36.  
  37.         GPIO_InitStruccture.GPIO_Pin = VFD_RES;
  38.         GPIO_InitStruccture.GPIO_Mode = GPIO_Mode_Out_PP;
  39.         GPIO_InitStruccture.GPIO_Speed = GPIO_Speed_50MHz;
  40.         GPIO_Init(VFD_Port, &GPIO_InitStruccture);
  41.     GPIO_ResetBits(VFD_Port,VFD_RES);
  42.                 // enable peripheral clock
  43.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
  44.  
  45.         /* configure SPI1 in Mode 0
  46.          * CPOL = 0 --> clock is low when idle
  47.          * CPHA = 0 --> data is sampled at the first edge
  48.          */
  49.         SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex; // set to full duplex mode, seperate MOSI and MISO lines
  50.         SPI_InitStruct.SPI_Mode = SPI_Mode_Master;     // transmit in master mode, NSS pin has to be always high
  51.         SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b; // one packet of data is 8 bits wide
  52.         SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;        // clock is low when idle
  53.         SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;      // data sampled at first edge
  54.         SPI_InitStruct.SPI_NSS = SPI_NSS_Soft | SPI_NSSInternalSoft_Set; // set the NSS management to internal and pull internal NSS high
  55.         SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256; // SPI frequency is APB2 frequency / 4
  56.         SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_LSB;// data is transmitted MSB first
  57.         SPI_Init(SPI1, &SPI_InitStruct);
  58.  
  59.         SPI_Cmd(SPI1, ENABLE); // enable SPI1
  60. }
  61.  
  62. uint8_t SPI1_send(uint8_t data){
  63.  
  64.         SPI1->DR = data; // write data to be transmitted to the SPI data register
  65.         while( !(SPI1->SR & SPI_I2S_FLAG_TXE) ); // wait until transmit complete
  66.         while( !(SPI1->SR & SPI_I2S_FLAG_RXNE) ); // wait until receive complete
  67.         //while( SPI1->SR & SPI_I2S_FLAG_BSY ); // wait until SPI is not busy anymore
  68.         return SPI1->DR; // return received data from SPI data register
  69. }


A remap-os részt jónak véled ?
A mintát pedig innen vettem, bár ez nem STM32F103, de nagyjából hasonló.
(#) csatti2 válasza kiborg hozzászólására (») Okt 3, 2017 /
 
Szerintem neked nincs szükséged remap-re.

A "while( !(SPI1->SR & SPI_I2S_FLAG_TXE) );"-t tedd az "SPI1->DR = data;" elé.

A DMA nem csak a profik játékszere. Nem olyan bonyolult a használata és cserébe sokkal gyorsabb képernyőkezelést lehet megvalósítani a CPU felesleges blokkolása nélkül, arról nem is beszélve, hogy a fent vázolt regisztereken keresztül írás/olvasás, majd flag-ekre várással kb. 5-öd olyan lassú a kommunikáció, mint DMA-val. Az egyik projektemben például direktben olvasok ikonokat és képeket egy külső SPI-os flash memóriáról az FSMC buszon keresztül meghajtott LCD-re DMA-val, eközben pedig a CPU teljesen mással foglalkozhat. Ez látszólag periféria-periféria kommunikáció (valójában az is ), amit a DMA alapból nem tudna, de szerencsére az FSMC automatikusan működik, ha a megfelelő memóriacímre tolom az adatokat (ez a cím a hardveres bekötéstől függ).
A hozzászólás módosítva: Okt 3, 2017
(#) kiborg válasza csatti2 hozzászólására (») Okt 3, 2017 /
 
Akkor ahonnan vettem, mi célt szolgál ez a rész:
  1. // connect SPI1 pins to SPI alternate function
  2.         GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);
  3.         GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_SPI1);
  4.         GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);
?

Remapot kiveszem és próba.
(#) csatti2 válasza kiborg hozzászólására (») Okt 3, 2017 /
 
Az az F4-es sorozatra vonatkozik, semmi köze az F1-es remapunkhoz.
(#) kiborg válasza csatti2 hozzászólására (») Okt 3, 2017 /
 
OK, akkor köszi és próbálkozok.
Egyelőre semmi, de nem tudom, hogy miért.
Az SPI_CPOL és SPI_CPHA állítgatásával próbálkoztam, de nincs eredmény egyelőre. Ránézek majd szkóppal is.
Viszont ami kérdéses még, hogy elvileg a kijelző 5V-os szintekkel megy. Kipróbáltam egy 3,3V és 5V-ról is működő uC-vel, hogy ha 3,3V tápot kap a uC,akkor is vezérelte a kijelzőt, tehát elvileg nem szabadna, hogy problémát okozzon a 3,3Vos jelszint.
(#) kiborg válasza kiborg hozzászólására (») Okt 3, 2017 /
 
AZ SCk és MOSI vonalakon van jel, bár nem igazán felismerhető, hogy mi, mert csak egy DSO138-al tudtam ránézni hirtelen, de a kijelző egyelőre meg sem mukkan
(#) csatti2 válasza kiborg hozzászólására (») Okt 3, 2017 /
 
Hát ez már a te harcod. Én inkább logikai analizátort szoktam ilyesmihez használni, de a szkóp is jó ha más nem akad.
(#) kiborg válasza csatti2 hozzászólására (») Okt 3, 2017 /
 
Sajnos logikai analizátorom nincs
Viszont van egy működő programom AVR-re, abban megnztem, hogy pontosan hogyan is inicializáltam a kijelzőt és láss csodát úgy néz ki, hogy működik
Nagyon örülök és köszönöm a segítséget.
Legközelebbi nagy falat majd az I2C lesz. Ha nem boldogulok, remélem abban is kapok majd némi segítséget.

Köszönöm mindenkinek!
Következő: »»   101 / 175
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