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

» Több friss téma
Fórum » PIC - Miértek, hogyanok haladóknak
Lapozás: OK   1307 / 1320
(#) sdrlab válasza don_peter hozzászólására (») Jún 19, 2020 / 1
 
Igen, pont azt akartam még hozzátenni, hogy előtte adtam meg a címet:
  1. TBLPTR=Cim;

S ha jól rémlik, 64 byte-os határra kell essen a törlés miatt.

Az nem az EEPROM címe, hanem egy szekvencia, ami az íráshoz kell!
A hozzászólás módosítva: Jún 19, 2020
(#) don_peter válasza sdrlab hozzászólására (») Jún 19, 2020 /
 
Oké, köszi, szerintem így már menni fog. Ha elakadok majd írok. Köszi a segítséget.
(#) Zsora válasza helektro hozzászólására (») Jún 19, 2020 /
 
Üdv!
Kissé megkésve bár, de nekem is van egy ötletem a problémád megoldására:

Definíciók:
  1. .equ    LED1,0
  2. .equ    LED1_P,PORTB
  3.                        
  4. .macro  BS bit
  5. bset    &bit&_P,#\bit
  6. .endm
  7.        
  8. .macro  BC bit
  9. bclr    &bit&_P,#\bit
  10. .endm

Felhasználás:
  1. BS      LED1
  2. BC      LED1
A hozzászólás módosítva: Jún 19, 2020
(#) don_peter válasza sdrlab hozzászólására (») Jún 19, 2020 /
 
Címzésben tudsz esetleg még segíteni?
Azt látom, hogy 21bit címet vár, de nem egészen értem az összetételét.
Azt írja, hogy 3 részből tevődik össze a TBLPTR regiszter, TBLPTRU, TBLPTRH és TBLPTRL.
TBLPTRL-ben lehet kiválasztani az írást, olvasást vagy törlést ez 7-0 bitek közt van, 0-ás az olvasás, 3-as az írás és 6-os a törlés. Aztán jön a cím 2 byte hosszan. Jól értelmezem?
Hol látom, hogy mettől meddig címezhetem meg a program memóriát? Gondolom a memória szervezésnél kell kitökölnom. A programozó lineárisan írja be a programot? Tehát feltételezve, hogy az a 3Kbyte adat az elejétől pontosan a maga 3Kbyte címet fedi csak le és utána nem kell számítanom másra? Ennyi hirtelen ami eszembe jutott. Köszi előre is.
(#) sdrlab válasza don_peter hozzászólására (») Jún 19, 2020 /
 
A Cim változó nálam 16 bites! 16 bit cím mindenre elég!(ismerős szöveg )
Szerintem valamit ott összekeversz, a művelet típusát nem a TBLPTR regiszterekben állítod be, abban a műveletre vonatkozó címet adod meg. Magát a műveletet pedig más regiszterekben állítod be. Lásd a kódrészlet, amit adtam...
Azt, hogy mettől, meddig írod az rajtad áll, nyilván az adott eszköz memóriája szabja meg a határt! A határoknál a törlésé a legnagyobb méret. Tehát erre kell kerekíteni minden utána(előtte) lévő címhatárt.... De az egész folyamatos, a legelejétől a legvégéig...
(#) Hp41C válasza don_peter hozzászólására (») Jún 19, 2020 /
 
Nem a TBLPTR -ben kell kiválasztani műveletet, hanem a műveleteknek van egy "fix mérete".
Az EECON1 -ben kell kiválasztani a műveletet.
EECON1bits.EEPGD=1; // 1 -> Program memória , 0 -> adat memória
EECON1bits.CFGS=0; // 1 -> Configurációs terület , 0 -> Program terület
EECON1bits.FREE=1; // Törlés
EECON1bits.WREN=1; // Írás engedélyezése

EECON1bits.RD=1; // Olvasási művelet indítása

EECON1bits.WR=1; // Írási művelet indítása

Idézet:
„Hol látom, hogy mettől meddig címezhetem meg a program memóriát?”

Röviden: Az adatlapban... Memory orgenaization.
18F2x25 - 18F4x26:
A "TABLE POINTER OPERATIONS WITH TBLRD AND TBLWT INSTRUCTIONS" mutatja az egyes műveletek "fix méreteit".

TABLE WRITE --- Ebben a típusban egyszerre csak 32 utasítás / 64 byte írható
TABLE ERASE --- Ebben a típusban egyszerre csak 32 utasítás / 64 byte törölhető
A fenti két művenetnél a TBLPTR 5..0 bitjei nem vesznek részt a címzésben.
TABLE READ --- Egyesével olvashatók a byte-ok, a címzésben mind a 21 bit részt vesz.
(#) don_peter hozzászólása Jún 19, 2020 /
 
  1. // PIC18F452 program memóriájának törlése 64byte / block
  2. void PICFlashBlockErase(unsigned int Addr)
  3. {
  4.         TBLPTR=Addr;
  5.         //----------------- Blokk törlés ----------------------------------
  6.         EECON1bits.EEPGD=1;                     // Flash Program vagy adat EEPROM memória vélasztó bit
  7.                                                                 // 1 = Hozzáférés a flash program memóriához
  8.                                                                 // 0 = Hozzáférés az EEPROM memóriához
  9.         EECON1bits.CFGS=0;                      // Flash Program / adat EEPROM vagy konfiguráció választó bit
  10.                                                                 // 1 = Hozzáférés a konfigurációs nyilvántartásokhoz
  11.                                                                 // 0 = Hozzáférés a Flash program vagy adat EEPROM memóriához
  12.         EECON1bits.WREN=1;                      // Flash Program / adat EEPROM írást engedélyező bit
  13.                                                                 // 1 = Engedélyezi a Flash program / adat EEPROM írását
  14.                                                                 // 0 = Gátolja a Flash program / adat EEPROM írását
  15.         EECON1bits.FREE=1;                      // flash törlésének engedélyezése
  16.                                                                 // 1 = Törlés engedélyezése
  17.                                                                 // 0 = Csak olvasás
  18.         INTCONbits.GIE=0;                       // Megszakítás letiltva
  19.         EECON2=0x55;                            // EEPROM nem fizikai adat regiszter, írás és törlési szekvencia
  20.         EECON2=0xAA;
  21.         EECON1bits.WR=1;                        // Írást vezérlő bit
  22.                                                                 // 1 = kezdeményez adat EEPROM törlés / írás ciklust vagy a program memória törlési ciklust vagy írási ciklus
  23.                                                                 // 0 = Write ciklus az EEPROM teljes
  24.         Nop();                                          // 1 órajel szünet
  25.         INTCONbits.GIE=1;                       // Megszakítás engedélyezve
  26.         EECON1bits.WREN=0;                      // Flash Program / adat EEPROM írást engedélyező bit
  27.                                                                 // 1 = Engedélyezi a Flash program / adat EEPROM írását
  28.                                                                 // 0 = Gátolja a Flash program / adat EEPROM írását
  29. }
  30.  
  31. // PIC18F452 program memória írása 64byte / block és 8 byte / írás
  32. void PICFlashBlockWrite(unsigned int Addr, unsigned char *Data)
  33. {
  34.         unsigned char i = 0, K = 0;
  35.         TBLPTR=Addr;
  36.         EECON1bits.WREN=0;                              // Flash Program / adat EEPROM írást engedélyező bit
  37.                                                                         // 1 = Engedélyezi a Flash program / adat EEPROM írását
  38.                                                                         // 0 = Gátolja a Flash program / adat EEPROM írását
  39.         for(K=0;K<64;K=K+8)    
  40.         {
  41.                 for(i=0;i<8;i++)
  42.                 {
  43.                    TABLAT = Data[K+i];
  44.                    _asm TBLWTPOSTINC _endasm;
  45.                 }
  46.                 _asm TBLRDPOSTDEC _endasm;
  47.                 EECON1bits.EEPGD=1;                     // Flash Program vagy adat EEPROM memória vélasztó bit
  48.                                                                         // 1 = Hozzáférés a flash program memóriához
  49.                                                                         // 0 = Hozzáférés az EEPROM memóriához
  50.                 EECON1bits.CFGS=0;                      // Flash Program / adat EEPROM vagy konfiguráció választó bit
  51.                                                                         // 1 = Hozzáférés a konfigurációs nyilvántartásokhoz
  52.                                                                         // 0 = Hozzáférés a Flash program vagy adat EEPROM memóriához
  53.                 EECON1bits.WREN=1;                      // Flash Program / adat EEPROM írást engedélyező bit
  54.                                                                         // 1 = Engedélyezi a Flash program / adat EEPROM írását
  55.                                                                         // 0 = Gátolja a Flash program / adat EEPROM írását
  56.                 INTCONbits.GIE=0;                       // Megszakítás letiltva
  57.                 EECON2=0x55;                            // EEPROM nem fizikai adat regiszter, írás és törlési szekvencia
  58.                 EECON2=0xAA;
  59.                 EECON1bits.WR=1;                        // Írást vezérlő bit
  60.                                                                         // 1 = kezdeményez adat EEPROM törlés / írás ciklust vagy a program memória törlési ciklust vagy írási ciklus
  61.                                                                         // 0 = Write ciklus az EEPROM teljes
  62.                 Nop();                                          // 1 órajel szünet
  63.                 EECON1bits.WREN=0;                      // Flash Program / adat EEPROM írást engedélyező bit
  64.                                                                         // 1 = Engedélyezi a Flash program / adat EEPROM írását
  65.                                                                         // 0 = Gátolja a Flash program / adat EEPROM írását
  66.                 INTCONbits.GIE=1;                       // Megszakítás engedélyezése
  67.                 _asm TBLRDPOSTINC _endasm;
  68.         }
  69. }

Eddig jutottam.
Csatoltam egy képet a memória szervezésről, ez kell nekem, hogy lássam hogy hova címezhetek adatokat? Még azt nem értem, hogy itt 0-tól 7FFF-ig lehet címezni, de az 32Kbyte, és az adatlap csak 16-ot ír, amit használni lehet.
Milyen címtől írhatok a program memóriára biztonságosan? Le kell egyáltalán foglalni a területet vagy a direkt írás miatt felesleges? Köszi előre is a kiokítást.

pic18f452_a.PNG		    
(#) Hp41C válasza don_peter hozzászólására (») Jún 19, 2020 /
 
Gondod, bajod rögtön elszáll, ha figyelembe veszed, hogy a Program memória byte szervezésű, de egy utasítás 2 (4) byte.

A 0x0000 - 0x7FFF byte címeken elérhető. azaz 32kbyte, de csak 16k utasítás.
Idézet:
„The PIC18F252 and PIC18F452 each have 32 Kbytes of FLASH memory, while the PIC18F242 and PIC18F442 have 16 Kbytes of FLASH. This means that PIC18FX52 devices can store up to 16K of single word instructions, and PIC18FX42 devices can store up to 8K of single word instructions.”
(#) don_peter válasza Hp41C hozzászólására (») Jún 19, 2020 /
 
Nah igen, ez világos, de most akkor sem áll össze a kép. A kód amúgy jó amit beágyaztam?
Debugolom, de fingom nincs egyelőre mit kellene látnom, vagy is sejtem, de egyelőre nem működik.
(#) Hp41C válasza don_peter hozzászólására (») Jún 19, 2020 /
 
Annyi biztos hiányzik, hogy meg kell várni, amíg a művelet befejeződik, azaz a WR bit 0-ra áll.
(#) don_peter válasza Hp41C hozzászólására (») Jún 19, 2020 /
 
Be raktam a kódba.
  1. // PIC18F452 program memóriájának törlése 64byte / block
  2. void PICFlashBlockErase(unsigned int Addr)
  3. {
  4.         TBLPTR=Addr;
  5.         //----------------- Blokk törlés ----------------------------------
  6.         EECON1bits.EEPGD=1;                     // Flash Program vagy adat EEPROM memória vélasztó bit
  7.                                                                 // 1 = Hozzáférés a flash program memóriához
  8.                                                                 // 0 = Hozzáférés az EEPROM memóriához
  9.         EECON1bits.CFGS=0;                      // Flash Program / adat EEPROM vagy konfiguráció választó bit
  10.                                                                 // 1 = Hozzáférés a konfigurációs nyilvántartásokhoz
  11.                                                                 // 0 = Hozzáférés a Flash program vagy adat EEPROM memóriához
  12.         EECON1bits.WREN=1;                      // Flash Program / adat EEPROM írást engedélyező bit
  13.                                                                 // 1 = Engedélyezi a Flash program / adat EEPROM írását
  14.                                                                 // 0 = Gátolja a Flash program / adat EEPROM írását
  15.         EECON1bits.FREE=1;                      // flash törlésének engedélyezése
  16.                                                                 // 1 = Törlés engedélyezése
  17.                                                                 // 0 = Csak olvasás
  18.         INTCONbits.GIE=0;                       // Megszakítás letiltva
  19.         EECON2=0x55;                            // EEPROM nem fizikai adat regiszter, írás és törlési szekvencia
  20.         EECON2=0xAA;
  21.         EECON1bits.WR=1;                        // Írást vezérlő bit
  22.                                                                 // 1 = kezdeményez adat EEPROM törlés / írás ciklust vagy a program memória törlési ciklust vagy írási ciklus
  23.                                                                 // 0 = Write ciklus az EEPROM teljes
  24.         while (EECON1bits.WR == 1);     // Várakozunk az írás befejezéséig
  25.         Nop();                                          // 1 órajel szünet
  26.         INTCONbits.GIE=1;                       // Megszakítás engedélyezve
  27.         EECON1bits.WREN=0;                      // Flash Program / adat EEPROM írást engedélyező bit
  28.                                                                 // 1 = Engedélyezi a Flash program / adat EEPROM írását
  29.                                                                 // 0 = Gátolja a Flash program / adat EEPROM írását
  30. }
  31.  
  32. // PIC18F452 program memória írása 64byte / block és 8 byte / írás
  33. void PICFlashBlockWrite(unsigned int Addr, unsigned char *Data)
  34. {
  35.         unsigned char i = 0, K = 0;
  36.         TBLPTR=Addr;
  37.         EECON1bits.WREN=0;                              // Flash Program / adat EEPROM írást engedélyező bit
  38.                                                                         // 1 = Engedélyezi a Flash program / adat EEPROM írását
  39.                                                                         // 0 = Gátolja a Flash program / adat EEPROM írását
  40.         for(K=0;K<64;K=K+8)    
  41.         {
  42.                 for(i=0;i<8;i++)
  43.                 {
  44.                    TABLAT = Data[K+i];
  45.                    _asm TBLWTPOSTINC _endasm;
  46.                 }
  47.                 _asm TBLRDPOSTDEC _endasm;
  48.                 EECON1bits.EEPGD=1;                     // Flash Program vagy adat EEPROM memória vélasztó bit
  49.                                                                         // 1 = Hozzáférés a flash program memóriához
  50.                                                                         // 0 = Hozzáférés az EEPROM memóriához
  51.                 EECON1bits.CFGS=0;                      // Flash Program / adat EEPROM vagy konfiguráció választó bit
  52.                                                                         // 1 = Hozzáférés a konfigurációs nyilvántartásokhoz
  53.                                                                         // 0 = Hozzáférés a Flash program vagy adat EEPROM memóriához
  54.                 EECON1bits.WREN=1;                      // Flash Program / adat EEPROM írást engedélyező bit
  55.                                                                         // 1 = Engedélyezi a Flash program / adat EEPROM írását
  56.                                                                         // 0 = Gátolja a Flash program / adat EEPROM írását
  57.                 INTCONbits.GIE=0;                       // Megszakítás letiltva
  58.                 EECON2=0x55;                            // EEPROM nem fizikai adat regiszter, írás és törlési szekvencia
  59.                 EECON2=0xAA;
  60.                 EECON1bits.WR=1;                        // Írást vezérlő bit
  61.                                                                         // 1 = kezdeményez adat EEPROM törlés / írás ciklust vagy a program memória törlési ciklust vagy írási ciklus
  62.                                                                         // 0 = Write ciklus az EEPROM teljes
  63.                 while (EECON1bits.WR == 1);     // Várakozunk az írás befejezéséig
  64.                 Nop();                                          // 1 órajel szünet
  65.                 EECON1bits.WREN=0;                      // Flash Program / adat EEPROM írást engedélyező bit
  66.                                                                         // 1 = Engedélyezi a Flash program / adat EEPROM írását
  67.                                                                         // 0 = Gátolja a Flash program / adat EEPROM írását
  68.                 INTCONbits.GIE=1;                       // Megszakítás engedélyezése
  69.                 _asm TBLRDPOSTINC _endasm;
  70.         }
  71. }
A hozzászólás módosítva: Jún 19, 2020
(#) don_peter válasza don_peter hozzászólására (») Jún 19, 2020 /
 
Közben még kutakodtam a témában és egy ilyesmi kódot is találtam, persze nem pont ebben a formában, már picit átírtam a teszteléshez, meg hogy kompatibilis legyen, de sajnos nem működik.

Definíció:
  1. #define PRGM_BUFFER_SIZE 8
  2. #define TABLE_WRITE_SIZE 64
  3.  
  4. #define LOAD_TBL_PTR(x) { TBLPTRU = ((((x)>>8)>>8)&0xff);\
  5.                       TBLPTRH = (((x) >> 8) & 0xff);\
  6.                       TBLPTRL = ((x) & 0xff);\
  7.                     }

Funkciók:
  1. /******************************************************
  2.  * Function     : write_block
  3.  * Input        : uint16_t position in destination flash
  4.  * Global       : uint8_t buffer[64] - Location of source data
  5.  * Output       : None
  6.  * Description  : Writes the contents of the 64 byte
  7.  * data buffer to program flash space.  Only 64 bytes
  8.  * can be written at once.   The process of writing
  9.  * to flash is: Erase->Write.
  10.  ******************************************************/
  11. static void write_block(unsigned int addr, unsigned char *buffer)
  12. {
  13.     int r, c;
  14.  
  15.     // Erase flash block first.  Erases a 64 byte block at a time.
  16.  
  17.     LOAD_TBL_PTR(addr);
  18.  
  19.     EECON1bits.EEPGD = 1;   // Point to flash program memory
  20.     EECON1bits.CFGS = 0;    // Access flash memory
  21.     EECON1bits.WREN = 1;    // Enable write to memory
  22.     EECON1bits.FREE = 1;    // Enable Erase operation
  23.  
  24.     EECON2 = 0x55;
  25.     EECON2 = 0xAA;
  26.  
  27.     EECON1bits.WR = 1;      // Clear the flash
  28.     while(EECON1bits.WR);
  29.  
  30.     Nop();             // Stall
  31.  
  32.     // Write buffer to internal buffer.  This process writes 8 bytes at a time
  33.     // so we need to loop 8 times (8*8 = 64).)
  34.  
  35.     for (r = 0; r < 8; r++)
  36.     {
  37.         LOAD_TBL_PTR((addr + (r * 8)));
  38.  
  39.         for (c = 0; c < PRGM_BUFFER_SIZE; c++)
  40.         {
  41.             TABLAT = buffer[(r * 8) + c];
  42.             _asm TBLWTPOSTINC _endasm;      // Push byte and then inc to next internal buffer cell
  43.         }
  44.  
  45.         // Write the block to flash
  46.         _asm TBLRDPOSTDEC _endasm;         // Point back to original row
  47.  
  48.         // Write internal buffer to flash
  49.         EECON1bits.EEPGD = 1;   // Point to flash program memory
  50.         EECON1bits.CFGS = 0;    // Access flash program memory
  51.         EECON1bits.WREN = 1;    // Enable write to memory
  52.         INTCONbits.GIE = 0;     // Disable interrupts
  53.  
  54.         EECON2 = 0x55;
  55.         EECON2 = 0xAA;
  56.  
  57.         EECON1bits.WR = 1;      // Start programming flash
  58.         while(EECON1bits.WR);
  59.        
  60.         INTCONbits.GIE = 1;     // Re-enable interrupts
  61.         EECON1bits.WREN = 0;    // Disable write to memory
  62.     }
  63. }
  64.  
  65. /******************************************************
  66.  * Function     : compare_block
  67.  * Input        : uint16_t position in destination flash
  68.  * Global       : uint8_t buffer[64] - Location of previous written data
  69.  * Output       : bool true=successful, false=did not match
  70.  * Description  : Reads a 64 byte block of flash memory and
  71.  * compares it to the data found in the global buffer.
  72.  ******************************************************/
  73. static unsigned char compare_block(unsigned int addr, unsigned char *buffer)
  74. {
  75.     unsigned char retVal = 1; // succeeds
  76.     unsigned char i = 0;
  77.  
  78.     INTCONbits.GIE = 0;     // Disable interrupts
  79.  
  80.     LOAD_TBL_PTR(addr);
  81.  
  82.     for (i = 0; i < TABLE_WRITE_SIZE && retVal == 1; i++)
  83.     {
  84.         _asm TBLWTPOSTINC _endasm;
  85.  
  86.         if (buffer[i] != TABLAT)
  87.             retVal = 0;
  88.     }
  89.  
  90.     INTCONbits.GIE = 1;     // Enable interrupts
  91.  
  92.     return retVal;
  93. }

Main()-ba pedig így:
  1. write_block(0x2000, Data);
  2.         Upload = 1;
  3.         Upload = compare_block(0x2000, Data);

A compre_block() elvileg ellenőrzi, hogy helyes adat van e a címen.. Sajna 0xFF-eket olvas vissza, így feltételezem, hogy nem ír a kiválasztott címre.
Mi lehet a gond?
(#) sdrlab válasza don_peter hozzászólására (») Jún 19, 2020 /
 
Az a kódrészlet, amit küldtem 100%-ban működő, mert működő projectből másoltam ki! Ha nem megy, akkor valami más oka van neki....
(#) superuser válasza don_peter hozzászólására (») Jún 19, 2020 / 1
 
Én ilyenkor a programozóval (PICKIT / ICD) szoktam visszaolvasni a PIC memóriáját, hogy lássam mit csinált az író rutin.
(#) don_peter válasza sdrlab hozzászólására (») Jún 20, 2020 /
 
Egyelőre nem működik. Most azt fogom csinálni, hogy egy teljesen új projektet nyitok és nulláról indított projektben tesztelem mert ha tényleg így működni kell, akkor tényleg nálam lesz valami gond. Bár egyelőre nem értem mi lehet.
(#) don_peter válasza superuser hozzászólására (») Jún 20, 2020 /
 
Program memóriát vizsgálgatom MPLAB-ban, de ott nincs semmi változás.
(#) don_peter hozzászólása Jún 20, 2020 /
 
Uraim, agyaltam és nem lehet az a baj, hogy debugban nézegetem a program memóriát és a debug nem tudja nyomon követni azt? Mert hogy új projektben, amelyben semmi sallang nincs, sem működik egyik kód sem. Nem írja a program memóriát. header állományt is átnéztem nincs bekapcsolva védelem.

Köszi srácok a segítséget. Utóbbi volt a baj, debug módban nem tudtam nyomon követni a programmemória változását. superuser-nek jár a mancs..
A hozzászólás módosítva: Jún 20, 2020
(#) Hp41C válasza don_peter hozzászólására (») Jún 20, 2020 /
 
A régi jó MpLab 8.92 szimulátora rendesen mutatja a memória változását.
(#) don_peter válasza Hp41C hozzászólására (») Jún 20, 2020 /
 
Sajnos nekem nem, 8.91-est használok, lehet frissítenem kellene?
Vagy ezzel is látnom kellene? Azt hiszem valahol meg is van a 8.92-is.
Tévedtem nincs meg.
A hozzászólás módosítva: Jún 20, 2020
(#) Hp41C válasza don_peter hozzászólására (») Jún 20, 2020 / 2
 
Látnod kelllene. Debugger / MpLab Sim. Újrafordítás. Indítás előtt a törlésre kijelült területre a View / Program Memory segítségével valamit beírni. Ezután lépésneként is lehet menni...
Ez is működik:
  1. ...
  2. for(i=0;i<8;i++)
  3. {
  4.         *(rom far char *)((Addr) + K + i) = Data[K + i];
  5. }
  6. ...
A hozzászólás módosítva: Jún 20, 2020
(#) szucsistvan123 hozzászólása Jún 20, 2020 /
 
Üdv!

Próbálkozott már valaki dinamikus memóriakezeléssel (malloc / calloc függvénnyel) PIC -el? (MPLAB és xc16)
Sehogy nem akar működni a dolog. (Később rakok fel kódot is)
(#) don_peter válasza Hp41C hozzászólására (») Jún 20, 2020 /
 
Ez az írás mutatóval történő megadása. Van ilyen olvasásra is gondolom? Ott a mutatót hogy kell megadni? Tehát ha egy adott címről akarok közvetlen olvasni, ezzel a módszerrel is megtehetem? Tudsz mutatni arra is egy példát? Köszi.
(#) Hp41C válasza don_peter hozzászólására (») Jún 21, 2020 / 1
 
  1. rom far char *pAdr;
  2. unsigned chr data;
  3. ...
  4. data = *(pAdr);
(#) don_peter válasza Hp41C hozzászólására (») Jún 21, 2020 /
 
Véleményed szerint melyik hajtódik hamarabb végre?
Az általad mutatott mutatós megoldás vagy az amelyet feljebb beillesztettem?
(#) sdrlab válasza Hp41C hozzászólására (») Jún 21, 2020 /
 
Ez a kód mit csinál? A háttérben a program memóriába ír adatokat?
(#) Hp41C válasza don_peter hozzászólására (») Jún 21, 2020 /
 
Vegyük számba. mit csinál a 4. sor:
- (far rom char *) 24 aza 21 bites cím kezelését írja elő. A sorhoz fordított kód feltölti a TBLPTRU, TBLPTRH, TBLPTR regisztereket a címmel. A fordító nem használhatja ki, hogy esetleg egymás utáni címeket olhasunk.
- ki kell olvasni az adatot. tblrd* utasítással a TABLAT regiszterbe.
- át kell adni az étéket a data változónak: movff TABLAT, data.

Ha máskép csinálod meg, kihasználhatod az egyszerűsítési lehetőségeket:
- TBLPTRU feltöltése egyszer,
- TBLPTRH feltöltése egyszer, módosítása ha szükséges,
- TBLPTR módosítható azzal a művelettel, amivel kiolvassuk az adatot tblrd*+
(#) Hp41C válasza sdrlab hozzászólására (») Jún 21, 2020 /
 
Ez a sor csak a program memória buffer latch -eit tölti fel. A sor egy előző hozzászólás környezetében működik és a program memóriát tölti fel (adattal vagy utasításokkal). Arra kell vigyázni, hogy ne "maga alatt" töröljön, módosítson.
(#) sdrlab válasza Hp41C hozzászólására (») Jún 21, 2020 /
 
Azért kérdeztem, mert pl az xc8 fordítónak van egy érdekes egyszerűsítése, hogy képes az EEPROM-ot kezelni a háttérben, anélkül, hogy neked bármit kellene vele tenni, tehát a megfelelő módon létrehozott változó, kódban történő hivatkozása(írás, olvasás) az EEPROM memória írását, olvasását váltja ki a háttérben.
Azt gondoltam, ez is valami hasonló dolog lesz....
(#) cross51 válasza don_peter hozzászólására (») Jún 22, 2020 /
 
Csak régi emlékekből, flash-t és eeprom-ot is az EECON-on keresztül fogsz írni, egy bit determinálja a regiszterekben, hogy flash vagy eeprom írás fog következni.
A címet EEADR vagy hasonló regiszterrel fogod megadni.
Az általad írt két sor unlock sequence.
(#) don_peter válasza cross51 hozzászólására (») Jún 22, 2020 /
 
Köszi, sikeresen átrágtuk magunkat a témán, és most már működik is.. Debugban volt gondom, hogy nem láttam a program memória írt részét, de programozóval kiolvasva már látom, de sajnos nem segített az egyik kérdéses gondomon, amiért a program memóriához fordultam, max több helyem lett, amivel gazdálkodhatok, de ..., ez már nem ide tartozik.
Következő: »»   1307 / 1320
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