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   80 / 176
(#) kapu48 hozzászólása Dec 18, 2016 /
 
Próbáltam keresni a neten, „Trace.h, Trace.c”!
De mivel járatlan vagyok linux téma keresésében, nem találtam alkalmasat.
Ami a témába illő rutinokat tartalmazza.

Szeretném átültetni Keil alkalmazásokba.
Esetleg valaki közre adná, meg köszönném!
(#) SBahadurD válasza kapu48 hozzászólására (») Dec 18, 2016 /
 
Nem követtem most nagyon végig a beszélgetést, de Ebay-en olcsón lehet USB - I2C modult venni:
http://www.ebay.com/sch/i.html?_odkw=usb+to+i2c&_sop=15&LH_...acat=0
A hozzászólás módosítva: Dec 18, 2016
(#) kapu48 válasza SBahadurD hozzászólására (») Dec 18, 2016 /
 
Köszi! De a HW. Már megvan!
Az maga a programozó ST-LINK lenne!

Csak az alkalmazás kel, mert még olyat nem találtam Keilhez.
A hozzászólás módosítva: Dec 18, 2016
(#) benjami válasza kapu48 hozzászólására (») Dec 18, 2016 / 1
 
Nem tudom a Keil-be át lehet-e ültetni, mert ezek a protokollok az openocd-t használják. Mindenesetre a teljes system mappát berakom a mellékletbe, abban ott van a trace.h, trace.c, trace_impl.c is. Szerintem elég lassú a kommunikáció, a sima soros portos verzió sokkal gyorsabb. Ja és már írtam, hogy nincs köze a linuxhoz, legfeljebb annyiban, hogy az openocd linux és windows alá is létezik (én Win7 64bit alatt használom, és az Eclipse-be lett beleintegrálva).

system.zip		    
(#) kapu48 válasza benjami hozzászólására (») Dec 18, 2016 /
 
Köszönöm a mellékletet, és a hozzá fűzött infót is!

Így legalább már tudom, hol keressek több ismeretet a témához.
Úgy gondoltam, hogy így debugoláskor felszabadulna a sorosport másra.

Esetleg nem lehet a trace sebességét növelni? Mondjuk órajel osztójának csökkentésével.
(#) SBahadurD válasza kapu48 hozzászólására (») Dec 19, 2016 /
 
Hű, bocsi, most látom, hogy rossz helyre írtam. Egy másik topicba szántam ezt a kommentet... Bocsi.
(#) csabeszq válasza kapu48 hozzászólására (») Dec 19, 2016 /
 
A trace az lassú, semihosting mód. Ez azt jelenti, hogy amikor a debug üzenet átmegy, az egész IC áll és vár.
Úgy képzeld el, hogy megáll az órajel. Ez gondolom az UART-ot eleve kizárja, bár fogalmam sincs hogyan oldották meg.

A sebesség még lassabb is lehet, mert ha fprintf-et használsz, akkor egyesével küldi át a karaktereket, látványos lesz a lassulás. Inkább egész string-eket kell átküldeni, különben szemmel követheted a karaktereket..
A hozzászólás módosítva: Dec 19, 2016
(#) benjami válasza csabeszq hozzászólására (») Dec 19, 2016 /
 
Ez a lassúság volt az oka, hogy megírtam az uart modulomat. Az pufferelten küldi ki a soros portra az üzenetet, így nem várakozik addig, amíg ténylegesen be nem fejeződik az átvitel. A hátránya, persze a plusz 1 láb elfoglalása.
(#) kapu48 válasza csabeszq hozzászólására (») Dec 19, 2016 /
 
Most teljesen elvettétek a kedvemet!

Én úgy képzeltem, hogy futás közben küldhetek üzeneteket 1 plusz I2C szerű HW-n.
Ami fut a háttérben és nem számottevően lassítja a rendszert!
(#) csabeszq válasza kapu48 hozzászólására (») Dec 19, 2016 /
 
Ezt a kütyüt nézegetem

Ebben alapból van ST-LINK V2 és JTAG is. Semihostingot azért használok, mert nem akarok 2 USB portot fenntartani, egyet az ST-LINK-nek, meg egy USB-serialt.

A semihosting nem is erre van kitalálva. Tesztelésre. Beküldesz egy kérést, visszajön egy válasz, meg ilyenek. Magyarul Eclipse-ben írsz teszteket, amik mindenféle firnyákos dolgot csinálnak, kérés be, válasz ki, te meg összehasonlítod. Nem teljesítmény elérése a cél.
(#) kapu48 válasza csabeszq hozzászólására (») Dec 19, 2016 /
 
Jonak tünik a kütyü!

Akkor inkább maradok a Keil debugjánál!
(#) csabeszq hozzászólása Dec 22, 2016 /
 
Az SPI DMA kombóval problémám van. Jelanalizátorral kimérve (baud rate prescaler = 2 mellett) a bitek 2 MHz frekvenciával csorognak ki. Jobban örülnék, ha 8-16 MHz körül mennének. SPI LCD-t szeretnék kezelni és kellene a sebesség.

Az órajelek:
  1. Clocks: sys:72000000 adc:36000000 hclk:72000000 pclk1:36000000 pclk2:72000000


A beállítás:
  1. SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
  2.     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  3.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  4.     SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  5.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  6.     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  7.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
  8.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  9.     SPI_InitStructure.SPI_CRCPolynomial = 7;


Miért ennyire lassú? Mi kellene, hogy rendes sebességgel menjen? Az IO portok 50MHz-re vannak állítva.
(#) csabeszq válasza csabeszq hozzászólására (») Dec 22, 2016 /
 
Bocs, hülye volt a kérdés.

SPI_BaudRatePrescaler_2 az 18 MHz-t jelent, ha PCLK1 36 MHz.

Ezt ebay-es jelanalizátorral nem lehet kimérni, mert 24 msps a határfrekvenciája. Maximális érték 12 MHz, amit az analizátor mérni tud. Miután visszavettem a frekvenciát, hirtelen pontos lett.

A jelanalizátorral 18MHz mellett látszik, hogy 160x128x2 képpont átvitele 18 ms-t vett igénybe és ez megegyezik azzal, amit számoltam.
(#) csatti2 válasza csabeszq hozzászólására (») Dec 22, 2016 /
 
36MHz az ADC-nek? Nem 14MHz a javasolt maximum?
(#) benjami válasza csatti2 hozzászólására (») Dec 23, 2016 /
 
Moszkvában Mercedeseket osztogatnak? Mire a válasz: nem Moszkvában, hanem Leningrádban, nem Mercedeseket, hanem Moszkvicsokat és nem osztogatnak, hanem fosztogatnak.
Nem ADC, hanem SPI, nem 14Mhz, hanem 18Mhz, a többi stimmel. A 36Mhz-et a PCLK1-re írta nem a baudrate-ra. A baudrate az ennek a fele, azaz 18Mhz (ennyi van megadva maximumnak az adatlapon is).
(#) killbill válasza benjami hozzászólására (») Dec 23, 2016 /
 
Idézet:
„Clocks: sys:72000000 adc:36000000 hclk:72000000 pclk1:36000000 pclk2:72000000”
Akarhogy nezem, itt adc: 36000000 szerepel.
(#) benjami válasza killbill hozzászólására (») Dec 23, 2016 /
 
Jogos, bár a programrész pont nem az ADC-ről szólt
Amúgy 0,6MHz...14MHz között kell lenni az ADC órajelének. Az órajeles sor nekem úgy tűnik, hogy nem magára az ADC órajelére vonatkozik, hanem a buszrendszerre, amire az ADC is csatlakozik.
A hozzászólás módosítva: Dec 23, 2016
(#) csatti2 válasza benjami hozzászólására (») Dec 23, 2016 /
 
Szerintem pedig nem.

Az alábbi órajeleket használjuk a Cortex-M3-as F1-es szériánál (a RTC-től és PLL-től most tekintsünk el):

SYSCLK / AHB Prescaler = HCLK
HCLK / AHB1 Prescaler = PCLK1
HCLK / AHB2 Prescaler = PCLK2
PCLK2 / ADC Prescaler = ADCCLK

Ezeken kívül van még pár fix osztó és szorzó az időzítőkhöz és az SDIO-hoz, plusz egy kapcsolható 8-as osztó a SysTick timer-hez.

Nekem gyanúsan ismerősek ezek az órajelek a fent idézett sorból.
(#) benjami válasza csatti2 hozzászólására (») Dec 23, 2016 /
 
Igen, az ADC Prescaler-t 6-ra kellene beállítania (2, 4, 6, 8 a beállítható érték), akkor 12MHz lesz az ADC órajele. Néggyel osztva is 18MHz lesz, lehet hogy ott még működni fog, de a pontossága biztos rosszabb lesz.
(#) kapu48 hozzászólása Dec 28, 2016 /
 
Hali!

Valaki próbálta már az STM32F407-esekben levő RTC Backup regisztereit használni adatok tárolására?
Adatlap szerint 20db. 32bites SRAM van bennük.

Én írtam rá 1 rutint, de csak az első 5 * 32bitet tudom felülírni, a többit nem.

Az alap innen van: Bővebben: stm32fxxx_hal_libraries
24-STM32Fxxx_RTC.
  1. // * @brief  Write-Reads RTC backup register value.
  2.                 //      This method allows you to read 32bit value from backup register 0 - 19 for STM32F4xx
  3.                 // backW: RTC Backup registers Write.
  4.                 else if (TM_USART_FindString(PC_USART, "backW") > 0) {
  5.                         uint32_t BackupReg;
  6.                         printf("RTC Backup Write:\r\n");
  7.                         *(uint32_t *)(&RTC->TAFCR) &= ~(RTC_TAFCR_TAMP2E | RTC_TAFCR_TAMP1E); // Clear bits
  8.                         //*(uint32_t *)(&RTC->TAFCR) |= (RTC_TAFCR_TAMP2E | RTC_TAFCR_TAMP1E);  // Write bits
  9.                         TM_USART_ClearBuffer(PC_USART);         // Clear Usart buffer
  10.                         for(getC = 0; getC < 20; getC++){
  11.                                 BackupReg = ((getC + 3) << (3*8)) | ((getC+2) << (2*8)) | ((getC+1) << 8) | (getC );
  12.                                 TM_RTC_WriteBackupRegister(getC, BackupReg);                   
  13.                         }
  14.                         for(getC = 0; getC < 20; getC++){
  15.                                 printf("%02d: %08x\r\n", getC, TM_RTC_ReadBackupRegister(getC));
  16.                         }                      
  17.                 }

Az eredmény:
backW
RTC Backup Write:
00: 03020100
01: 04030201
02: 05040302
03: 06050403
04: 07060504
05: 00000000
06: 00000000
07: 00000000
08: 00000000
09: 00000000
10: 00000000
11: 00000000
12: 00000000
13: 00000000
14: 00000000
15: 00000000
16: 00000000
17: 00000000
18: 00000000
19: 00000000

Bármi ötlet jól jönne! Mit szúrhatok el?
A 'RTC_TAFCR_TAMP2E | RTC_TAFCR_TAMP1E Biteket már próbáltam állítgatni, de semmi hatása nem volt.

A 2 hívót rutin:
  1. void TM_RTC_WriteBackupRegister(uint8_t location, uint32_t value) {
  2.         /* Write data to backup register */
  3.        
  4.         *(uint32_t *)((&RTC->BKP0R) + 4 * location) = value;
  5. }
  6.  
  7. uint32_t TM_RTC_ReadBackupRegister(uint8_t location) {
  8.         /* Read data from backup register */
  9.         return *(uint32_t *)((&RTC->BKP0R) + 4 * location);
  10. }

A hozzászólás módosítva: Dec 28, 2016
(#) killbill válasza kapu48 hozzászólására (») Dec 28, 2016 / 1
 
A 4 * location helyett csak sima location-t irj! Ha egy pointer 32 bites elemre mutat, akkor a pointer + 1, az 32 bittel, azaz 4 byte-tal lesz tobb.
A hozzászólás módosítva: Dec 28, 2016
(#) killbill válasza killbill hozzászólására (») Dec 28, 2016 /
 
Amugy meg nem ertek valamit. Mitol mukodik a kodod? Hacsak nem azert, mert az RTC->BKP0R nem uint32_t tipusu, hanem mondjuk uint8_t. Marpedig, ha egy uint32_t tipusu valami cimehez hozzaadsz 1-et, akkor az fizikaliag 4-gyel nagyobb cim lesz, azaz a kovetkezo uint32_t tipusu elemre fog mutatni.
(#) kapu48 válasza killbill hozzászólására (») Dec 28, 2016 /
 
Kösszi! igazad vólt!

  1. __IO uint32_t BKP0R; /*!< RTC backup register 1,       Address offset: 0x50 */


Javítottam:
  1. // * @brief  Write-Reads RTC backup register value.
  2.                 //      This method allows you to read 32bit value from backup register 0 - 19 for STM32F4xx
  3.                 // backW: RTC Backup registers Write.
  4.                 else if (TM_USART_FindString(PC_USART, "backW") > 0) {
  5.                         uint32_t BackupReg;
  6.                         printf("RTC Backup Write:\r\n");
  7.                         *(uint32_t *)(&RTC->TAFCR) &= ~(RTC_TAFCR_TAMP2E | RTC_TAFCR_TAMP1E); // Clear bits
  8.                         //*(uint32_t *)(&RTC->TAFCR) |= (RTC_TAFCR_TAMP2E | RTC_TAFCR_TAMP1E);  // Write bits
  9.                         TM_USART_ClearBuffer(PC_USART);         // Clear Usart buffer
  10.                         for(getC = 0; getC < 20; getC++){
  11.                                 BackupReg = ((getC + 3) << (3*8)) | ((getC+2) << (2*8)) | ((getC+1) << 8) | (getC );
  12.                                 //TM_RTC_WriteBackupRegister(getC, BackupReg); 
  13.                                 *(uint32_t *)((&RTC->BKP0R) + (getC)) = BackupReg;
  14.                         }
  15.                         for(getC = 0; getC < 20; getC++){
  16.                                 //printf("%02d: %08x\r\n", getC, TM_RTC_ReadBackupRegister(getC));
  17.                                 printf("%02d: %08x\r\n", getC, *(uint32_t *)((&RTC->BKP0R) + (getC)));
  18.                         }                      
  19.                 }

És jó lett az eredmény:
backW
RTC Backup Write:
00: 03020100
01: 04030201
02: 05040302
03: 06050403
04: 07060504
05: 08070605
06: 09080706
07: 0a090807
08: 0b0a0908
09: 0c0b0a09
10: 0d0c0b0a
11: 0e0d0c0b
12: 0f0e0d0c
13: 100f0e0d
14: 11100f0e
15: 1211100f
16: 13121110
17: 14131211
18: 15141312
19: 16151413


Erre nem gondoltam, hogy a hívott rutinban van a hiba!
Mivel azt már készen kaptam.
(#) kapu48 válasza kapu48 hozzászólására (») Dec 28, 2016 /
 
Közben az is kiderült, hogy az utolsó BKP19R regiszter foglalt!
#define RTC_STATUS_TIME_OK 0x4321 /* RTC time OK */
19: 00004321

Ha felülírom, törlődik az RTC tartalma minden újraindításkor!
(#) kapu48 válasza kapu48 hozzászólására (») Dec 28, 2016 /
 
De a maradék 19 regiszter értéke nem változik ki/be kapcsolás után sem.
(#) killbill válasza kapu48 hozzászólására (») Dec 29, 2016 /
 
Lehet, hogy en rosszat nezek, de szerintem csak 5 regiszter van, BKP0R..BKP4R, darabja 4 byte, tehat osszesen 20 byte Backup RAM van benne. A te programod, ha getC erteke nagyobb, mint 4, akkor mar nem is a backup RAM-ba ir. Valami itt nekem nagyon nem vilagos.

megtenned a kovetkezot:

printf("%p %p\n", &(RTC->BKP0R), &(RTC->BKP0R) + 1);

Nagyon kivancsi vagyok, hogy a ket szam kozott 1 vagy 4 lesz a kulonbseg.
(#) kapu48 válasza killbill hozzászólására (») Dec 29, 2016 /
 
A következő RTC Backup listaázó, rutinba kerültbe a kért sor:
  1. // * @brief  Reads RTC backup register value.
  2.                 //      This method allows you to read 32bit value from backup register 0 - 18 for STM32F4xx
  3.                 // backL: RTC Backup lista.
  4.                 else if (TM_USART_FindString(PC_USART, "backL") > 0) {
  5.                         printf(":\r\n");
  6.                         TM_USART_ClearBuffer(PC_USART);         // Clear Usart buffer
  7.                         for(getC = 0; getC < 20; getC++){
  8.                                 printf("%02d: %08x\r\n", getC, *(uint32_t *)((&RTC->BKP0R) + getC));
  9.                         }      
  10.                                 printf("RTC->BKP0R: %p, %p\r\n", &(RTC->BKP0R), &(RTC->BKP0R) + 1);
  11.                                 printf("TAFCR: %08x\r\n", *(uint32_t *)(&RTC->TAFCR));                         
  12.                 }

  1. A RTC Backup regiszterek címe:
  2. #define RTC_BASE              (APB1PERIPH_BASE + 0x2800)
  3. __IO uint32_t BKP0R; /*!< RTC backup register 1,        Address offset: 0x50 */

És az eredmény:
backL
RTC Backup lista:
00: 03020100
01: 04030201
02: 05040302
03: 06050403
04: 07060504
05: 08070605
06: 09080706
07: 0a090807
08: 0b0a0908
09: 0c0b0a09
10: 0d0c0b0a
11: 0e0d0c0b
12: 0f0e0d0c
13: 100f0e0d
14: 11100f0e
15: 1211100f
16: 13121110
17: 14131211
18: 15141312
19: 00004321
RTC->BKP0R: 40002850, 40002854
TAFCR: 00040000

Szerintem OK!
(#) kapu48 válasza killbill hozzászólására (») Dec 29, 2016 /
 
Van törlő rutin is:
  1. // * @brief  Clear-Reads RTC backup register value.
  2.                 //      This method allows you to read 32bit value from backup register 0 - 18 for STM32F4xx
  3.                 // backW: RTC Backup registers Clear.
  4.                 else if (TM_USART_FindString(PC_USART, "backC") > 0) {
  5.                         printf("RTC Backup Clear:\r\n");
  6.                         TM_USART_ClearBuffer(PC_USART);         // Clear Usart buffer
  7.                         for(getC = 0; getC < 19; getC++){
  8.                                 *(uint32_t *)((&RTC->BKP0R) + getC) = 0;
  9.                         }
  10.                         for(getC = 0; getC < 20; getC++){
  11.                                 printf("%02d: %08x\r\n", getC, *(uint32_t *)((&RTC->BKP0R) + getC));
  12.                         }                      
  13.                 }

Az eredménye:

backC
RTC Backup Clear:
00: 00000000
01: 00000000
02: 00000000
03: 00000000
04: 00000000
05: 00000000
06: 00000000
07: 00000000
08: 00000000
09: 00000000
10: 00000000
11: 00000000
12: 00000000
13: 00000000
14: 00000000
15: 00000000
16: 00000000
17: 00000000
18: 00000000
19: 00004321
backL
RTC Backup lista:
00: 00000000
01: 00000000
02: 00000000
03: 00000000
04: 00000000
05: 00000000
06: 00000000
07: 00000000
08: 00000000
09: 00000000
10: 00000000
11: 00000000
12: 00000000
13: 00000000
14: 00000000
15: 00000000
16: 00000000
17: 00000000
18: 00000000
19: 00004321
RTC->BKP0R: 40002850, 40002854
TAFCR: 00040000

Eléggé meggyöző?
Megvan mind a 20 regiszter! A STM32F407-esben.
A hozzászólás módosítva: Dec 29, 2016
(#) killbill válasza kapu48 hozzászólására (») Dec 29, 2016 /
 
Ok, megneztem az adatlapot. 80 byte, azaz 20 szo backup register van. Valahol azt olvastam, hogy csak 5 szo, ami 20 byte, ez zavart meg.
(#) kapu48 válasza killbill hozzászólására (») Dec 29, 2016 /
 
Azt hiszem a kisseb STM32F0xx-esekben kevesebb van!
Utána kellene nézni!
Még az A STM32F103-as érdekel majd.

Köszi, a segítséget!
A hozzászólás módosítva: Dec 29, 2016
Ezekre szükség lehet! - HESTORE.HU

STM32F401RBT6
STM32F103-MS
STM32F407G-DISC1
STM32F030C6T6
NXG-06
Következő: »»   80 / 176
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