Fórum témák

» Több friss téma
Fórum » AM29F010B flash ROM programozása
Lapozás: OK   4 / 4
(#) don_peter válasza sdrlab hozzászólására (») Feb 19, 2016 /
 
Azt hiszem 24Mhz-ig, legalább is utoljára ennyin használtam.
Lehet tud többet is, de ez biztos.
(#) sdrlab válasza don_peter hozzászólására (») Feb 19, 2016 /
 
Az elégnek tűnik....
(#) don_peter hozzászólása Feb 19, 2016 /
 
Találtam egy ASM forrást.
Valaki ezt letudja fordítani nekem?
Amit kiolvastam, az megegyezik azzal amit én is megírtam.
  1. /************************************************************************
  2.  *  JEDEC FLASH Read/Write driver                                                                       *
  3.  *                                                                                                                                              *
  4.  *  AM29F800                                                                                                                            *
  5.  *                                                                                                                                              *
  6.  *                                                                                                                                              *
  7.  *                                                                                                                                              *
  8.  *************************************************************************/
  9.  #include "Flash.h"
  10.  
  11.  
  12.  
  13.  /********************************************************
  14.  *                                       AMDreadFlash                                           *
  15.  *                                      ---------------                                         *
  16.  * Input        : address of byte to read                                               *
  17.  * Return: byte to read                                                                 *
  18.  *                                                                                                              *
  19.  * Comments:                                                                                            *
  20.  *                                                                                                              *
  21.  *                                                                                                              *
  22.  ********************************************************/
  23.  char AMDreadFlash(DWORD adress)
  24.  {
  25.         adress|=FLASH_BASE;
  26.         #asm
  27.                 movf _AMDreadFlash$adress+0,w
  28.                 movwf tblptrl
  29.                 movf _AMDreadFlash$adress+1,w
  30.                 movwf tblptrh
  31.                 movf _AMDreadFlash$adress+2,w
  32.                 movwf tblptru
  33.  
  34.                 TBLRD*
  35.                 movf tablat,w
  36.         #endasm
  37.  }
  38.  
  39.  /********************************************************
  40.  *                                       AMDwriteFlash                                          *
  41.  *                                      ---------------                                         *
  42.  * Input        : address of WORD to write, WORD to write               *
  43.  * Return: none                                                                                 *
  44.  *                                                                                                              *
  45.  * Comments:                                                                                            *
  46.  *              - Only writing bit  1 to 0 is possible          *
  47.  *              - Reverting back to 1 need erase                                *
  48.  *              - Addresses MUST be word-aligned                                *
  49.  ********************************************************/
  50.  void AMDwriteFlash(DWORD adress,WORD data)
  51.  {
  52.         adress|=FLASH_BASE;
  53.         MEMCON = 0b00110010;            // WORD write mode
  54.         #asm
  55.         ; **** Unlock procedure ****
  56.         base equ 0x100000
  57.  
  58.         ; Writing 0xAA to 0x555
  59.                 movlw   low ((0x555 shl 1) | base)
  60.                 movwf   tblptrl
  61.                 movlw   low (((0x555 shl 1) | base) shr 8)
  62.                 movwf   tblptrh
  63.                 movlw   low (((0x555 shl 1) | base) shr 16)
  64.                 movwf   tblptru
  65.  
  66.                 movlw 0xAA
  67.                 movwf tablat
  68.                 TBLWT*+
  69.                 TBLWT*+
  70.  
  71.         ; Writing 0x55 to 0x2AA
  72.                 movlw   low ((0x2AA shl 1) | base)
  73.                 movwf   tblptrl
  74.                 movlw   low (((0x2AA shl 1) | base) shr 8)
  75.                 movwf   tblptrh
  76.                 movlw   low (((0x2AA shl 1) | base) shr 16)
  77.                 movwf   tblptru
  78.                
  79.                 movlw 0x55
  80.                 movwf tablat           
  81.                 TBLWT*+
  82.                 TBLWT*+
  83.         ; **** End of unlock procedure ****
  84.         ; **** Issue Write Command         ****
  85.         ; Writing 0xA0 to 0x555
  86.                 movlw   low ((0x555 shl 1) | base)
  87.                 movwf   tblptrl
  88.                 movlw   low (((0x555 shl 1) | base) shr 8)
  89.                 movwf   tblptrh
  90.                 movlw   low (((0x555 shl 1) | base) shr 16)
  91.                 movwf   tblptru
  92.  
  93.                 movlw 0xA0
  94.                 movwf tablat
  95.                 TBLWT*+
  96.                 TBLWT*+
  97.         ; **** End of Write Command     ****
  98.        
  99.  
  100.         ; **** Writing data to adress
  101.  
  102.                 movf _AMDwriteFlash$adress+0,w
  103.                 movwf tblptrl
  104.  
  105.                 bcf tblptrl,0   ; //Force even addressing
  106.  
  107.                 movf _AMDwriteFlash$adress+1,w
  108.                 movwf tblptrh
  109.                 movf _AMDwriteFlash$adress+2,w
  110.                 movwf tblptru
  111.  
  112.                 movf _AMDwriteFlash$data+0,w
  113.                 movwf tablat
  114.                 TBLWT*+
  115.                 movf _AMDwriteFlash$data+1,w
  116.                 movwf tablat
  117.                 TBLWT*+
  118.         #endasm
  119.  
  120.         MEMCON = 0b00110001;    //Reverting back to BYTE SELECT mode
  121.        
  122.  }

Forrás: Bővebben: Link
(#) don_peter hozzászólása Feb 21, 2016 /
 
Nos eljutottam már addig kínomba, hogy kipróbáltam WORD módban is, mert már nem volt jobb ötletem és lás csodát, működik...
Na igen, örülök is neki, de most akkor mi is van? (persze már berendeltem hozzá a majd 8eFt-os adaptert is)
WORD módban működik, de BYTE módban miért is nem?

Persze ha más nincs meg fogom oldani WORD módban a dolgot, de jobb szeretném BYTE módban kezelni, mert ügye úgy minden byte-ot elérnék, WORD módban meg csak 2bájtonként.
Ilyenkor mi van?
(#) killbill válasza don_peter hozzászólására (») Feb 21, 2016 /
 
Idézet:
„WORD módban működik, de BYTE módban miért is nem?”
Mert WORD modban mas a cim, mint BYTE modban.
A hozzászólás módosítva: Feb 21, 2016
(#) don_peter válasza killbill hozzászólására (») Feb 21, 2016 /
 
Köszönöm, most megvilágosodtam
Remélem nem veszed zokon az előzőt, de jót mosolyogtam ezen.
Nem akartalak megsérteni ne értsd félre, csak azt hiszem az eddigi bejegyzéseimet tekintve ennyire nem nézhetek ki madárnak, hogy ekkora hibát elkövetek, nem beszélve arról, hogy megosztottam előzőleg a forrást is amiből egyértelműen kiderül, hogy mindent jól csináltam, csak a memória BYTE módban nem fogadja a (BYTE módban előrítt parancsokat) parancsokat.

Szóval a kéred marad ugyan az..
Miért is nem fogadja a BYTE parancsokat?
Csillió dolláros kérdés: lehet hamisítvány?
A hozzászólás módosítva: Feb 21, 2016
(#) killbill válasza don_peter hozzászólására (») Feb 21, 2016 /
 
Minden lehet, meg az ellenkezője is. Lehet hamisitvany, persze. De csak nem vagy akkora madár, hogy hamisítványt sóznak rád
(#) don_peter válasza killbill hozzászólására (») Feb 21, 2016 /
 
Áhhh nem bírtad kihagyni a magas labdát
Remélem nem hamisítvány, de persze minden egy helyről jön szóval megeshet.
Mindegy most WORD módban fogom használni amíg rá nem jövök mi a bibi..
(#) killbill válasza don_peter hozzászólására (») Feb 21, 2016 /
 
A labdák márcsak ilyenek BYTE modban a DQ15 (A-1) labat is allitgatod? Mert az A0-A18 az ugyanaz BYTE es WORD modban, de BYTE modban az A-1 labat is allitgatni kell:
0xAAA eseten 0, 0x555 eseten 1. WORD modban ennek a bitnek nincs jelentosege. Ez még megér egy próbát.
(#) don_peter válasza killbill hozzászólására (») Feb 21, 2016 /
 
Azt így nem próbáltam, de amúgy igen, olvasást BYTE módban csinálom és működik rendesen.
A parancsok sajnos csak WORD be mennek.

DQ15 (A-1) - et csak olvasásban használtam (0 és 1 attól függően, hogy alsó vagy felső byte-ot akarom olvasni), beírásnál az adatlap szerint nincs jelentősége mert csak az alsó 8bit-et használja, így DQ15 (A-1) = 0;

De kipróbálhatom, nem tart semeddig.
A hozzászólás módosítva: Feb 21, 2016
(#) killbill válasza don_peter hozzászólására (») Feb 21, 2016 / 1
 
Idézet:
„DQ15 (A-1) - et csak olvasásban használtam (0 és 1 attól függően, hogy alsó vagy felső byte-ot akarom olvasni), beírásnál az adatlap szerint nincs jelentősége mert csak az alsó 8bit-et használja, így DQ15 (A-1) = 0;”
Azt nem mondanam, hogy nincs jelentosege, mert BYTE modban a cim resze az A-1 is, mivel az a legalso cimbit.
  1. chip addr:  10  9 8 7 6 5 4 3 2 1 0  A-1
  2.  
  3. word 555     1  0  1 0 1 0 1 0 1 0 1  -
  4. byte AAA     1  0  1 0 1 0 1 0 1 0 1  0
  5.  
  6. word 2AA     0  1  0 1 0 1 0 1 0 1 0  -
  7. byte 555     0  1 0  1 0 1 0 1 0 1 0  1
(#) don_peter válasza killbill hozzászólására (») Feb 21, 2016 /
 
Nincs jelentősége mert az adat csak 1 bájt.
  1. AM29F800WordCmdWrite(0x555, 0xAA);
  2. AM29F800WordCmdWrite(0x2AA, 0x55);
  3. AM29F800WordCmdWrite(0x555, 0xA0);

A címnél 19bit van adatnál csak 8bit.
BYTE módban A-1 = 0, nem kell váltani. (írásnál)
De kipróbáltam és nem működik.
A hozzászólás módosítva: Feb 21, 2016
(#) killbill válasza don_peter hozzászólására (») Feb 21, 2016 / 1
 
Ezt gondold at meg egyszer. Nezd meg a fenti tablazatot, amit csinaltam. Irasnal es olvasasnal pontosan ugyanaz a cim. Ezek processzor buszra kifejlesztett aramkorok, a cimbusz az cimbusz irasnal is, olvasasnal is. Azt ertsed meg, hogy BYTE modban a DQ15 lab az cimbit. Megpedig az A0. Tovabba, byte modban az A18 az valojaban az A19, az A7 az valojaban az A8, es az A0 az valojaban A1, es a DQ15 az A0. Szoval az osszes cimbit eggyel elcsuszik, es legalulra bekerul a DQ15. Mert igy lesz byte modban A19..A0, azaz 20 cimvezetek, ami pont 1 megabyte megcimzesehez kell. Irasnal is, meg olvasasnal is. WORD modban csak 19 cimvezetek kell (A18-A0), mert csak 512k word-ot kell megcimezni.
(#) don_peter válasza killbill hozzászólására (») Feb 21, 2016 /
 
És neked 5perc alatt sikerült megértetned velem amint 2 hete nem sikerült megértenem, pedig itt volt az orrom előtt.
(#) Hp41C válasza don_peter hozzászólására (») Feb 21, 2016 /
 
Azt hittük mindannyian, hogy ezt már január 24. -én megértetted... Bővebben: Link
(#) don_peter hozzászólása Feb 21, 2016 /
 
Átgondolva és a programot írva eszembe jutott, hogy olvasásnál csak 19bit-ben A0-A18-is működik a címzés, és minden címen A-1 változtatásával 2byte-ot nyerünk ki.
Így csak írásnál működik a BYTE mód A-1 legalsó bitje címzésként, nem?

Mind kettő BYTE módban:
Olvasásnál összesen 512k a címbusz mérete, és A-1 az alsó vagy felső bájt választó.
Írásnál pedig 20biten megy a címzés : 1Mbite a mérete DQ15(A-1), A0, A1....., A18-ig megy a címzés jól mondom?

Hp41C: hát én is azt hittem, de ezek szerint nem és emiatt újra kell írnom a rutinokat, mert A-1 == A0-val nem számoltam.
A hozzászólás módosítva: Feb 21, 2016
(#) killbill válasza don_peter hozzászólására (») Feb 21, 2016 /
 
Ha byte modban vagy, akkor ez egy 1Mx8 bites memoria. 20 cimvezetek, 8 adat. Ne variald byte valasztoval. A cimbusz maga a byte valaszto, espedig azt valasztja ki, hogy az 1 millio byte-bol melyiket irod vagy olvasod. Ehhez 20 vezetek kell. A19-A0. Csak byte modban ennek az a neve, hogy A18-A0 es DQ15. Elarulom neked, hogy a legtobb alkalmazasban a BYTE lab fixen le van foldelve vagy eppen tapra van kotve. Arra jo, hogy 8 bites es 16 bites buszhoz is lehessen illeszteni a chipet. De menet kozben senki nem valtogatja. Byte modban 20 cimvezetek van es 8 adat. Nem hiszem el, hogy meg mindig nem erted.
(#) don_peter válasza killbill hozzászólására (») Feb 21, 2016 /
 
Mindegy írtam egy hosszút miért kavarodtam össze, de lényegtelen.
Akkor 20bit a címzés olvasás és írásnál is.. Ennyi se több.
(#) don_peter hozzászólása Márc 21, 2016 /
 
Uraim, nézegetek egy újabb flash memóriát, nevén nevezve ezt: MX29LV640
És kérdezném, hogy mit kell érteni a WP lábon?
És mire való?
Kell az nekem, ha folyton írogatom, törölgetem és olvasgatom a memóriát?
Ha nem kell, mit csináljak vele?
Hagyjam lebegni vagy, kössem le GND-re esetleg húzzam magas szintre?

Azt látom, hogy mit ír rá:
WP/ACC - Hardware Write Protect/Acceleration Pin
Ezzel a lábbal lehet hardveresen írás védetté tenni a memóriát?
Tehát ha felhúzom 3v-ra akkor hardveresen van levédve és ekkor nem lehet írni?
Ha viszont nincs logikai 1-en, akkor lehet nyugodtan használni a memóriát, írásra?
Ezt jelenti ez a WP/ ACC láb?

Mert ha igen akkor azt nem kell még csak bekötnöm sem.
Előre is köszi..
(#) don_peter válasza don_peter hozzászólására (») Márc 21, 2016 /
 
No azt már megértettem, hogy lebegni nem szabad hagyni mert az megbízhatatlan működést eredményez.
Már csak azt kellene tudnom, hogy LE vagy FEL húzzam a lábat.
Nekem kicsit érthetetlen a elírás, de mint ha, akkor lenne csak írható, ha fel van húzva WP/ACC láb...
Azért kell ezt jól átgondolnom, mert nincs elég láb amivel ezt a Flash memória WP lábat is tudnám külön vezérelni.
Tehát azt fixre kellene kötnöm.
A hozzászólás módosítva: Márc 21, 2016
(#) sdrlab válasza don_peter hozzászólására (») Márc 21, 2016 /
 
Szerintem 1-re kell kötni. 0-ban korlátozza az írás/törlés funkciókat a boot területeken. Nagyfeszt kötve rá pedig hardveresen gyorsítja az írási folyamatot.
(#) don_peter válasza sdrlab hozzászólására (») Márc 21, 2016 /
 
Értem, én is hasonlóan olvasom ki..
Lehet valahogy állíthatóra kellene csinálnom.
Jumper vagy valami....
Köszi..
(#) sdrlab válasza don_peter hozzászólására (») Márc 21, 2016 /
 
Nagyfeszültséget nem hiszem, hogy használni szeretnél....
Védeni szintén nincs értelme akkor, amikor ismerkedsz az IC-vel, ráadásul ha 1-be van, még mindig lehet aktív a boot védelme, csak az kikapcsolható. Tehát nincs szükség más üzemmódra, mint amit a log 1 szint ad.
(#) don_peter válasza sdrlab hozzászólására (») Márc 21, 2016 /
 
Igen teljesen igazad van.
Ez is lesz, felhúzom 3v-ra egy 10K-ossal fixre és kész.
(#) don_peter hozzászólása Júl 7, 2016 /
 
Uraim,

Van valakinek MX29LV640-es (vagy 29LV160, 29LV320) Flash memória használatban tapasztalata?
Már pár hete vacakolok felette, de nincs normális eredménye.

Valamennyit szerintem talán kommunikál, mert olvas ki fars adatokat, vagy lehet ezek is csak a beragadt szekvenciák által beírt adatok maradványai.

Az adatlapja olyan mint a 29F800 Flash memóriáé, szóval a már működő kódokat próbálom átemelni, de úgy fest nem sok sikerrel.

Az Manufacturer ID lekérdezésének kódját bemásolom:
  1. unsigned char NOR_ReadID(unsigned char id){
  2.         unsigned char temp;
  3.         TRISB = 1; // Adat lábak bemenetre
  4.         MEM_WE = 1;
  5.         MEM_CE = 1;
  6.         MEM_OE = 1;
  7.         MEM_BYTE = 1;  // Word mód
  8.         TRISB = 0; // Adat lábak kimenetre
  9.         MEM_CE = 0;
  10.         // Szekvenciák
  11.         AM29F800WordCmdWrite(0x555, 0xAA);
  12.         AM29F800WordCmdWrite(0x2AA, 0x55);
  13.         AM29F800WordCmdWrite(0x555, 0x90);
  14.         AM29F800ADDRWORD.addr = id; // id = 0x00;
  15.         ShortDelay( 70 * US_TO_CT_TICKS );
  16.         temp = Am29F800WordRead(AM29F800ADDRWORD);    // Portot beolvasom
  17.         ShortDelay( 70 * US_TO_CT_TICKS );
  18.         return temp;
  19. }


Memória adatlapját csatoltam.
Előre is köszi a segítséget.

MX29LV640.pdf
    
(#) don_peter hozzászólása Júl 11, 2016 /
 
Valaki meg tud erősíteni abban, hogy egy az egyben a már megírt 29F800-ra írt programok 29LV640-re is alkalmazható?
Előre is köszi..
(#) don_peter hozzászólása Júl 23, 2016 /
 
Közben meglett a hiba.
A szétszórt címbitek kevertek be, a teljes D portra átkötve azonnal működött a dolog. (PIC32MX795)
Következő: »»   4 / 4
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