求达人帮忙读一段单片机C程

Q1:对于PageIndices定义中的0x2200若干项是绝对地址么？
Q2：对于PageIndices的读写模式是什么 字？还是其他
Q3：在写入完成后 如果我在PageIndices已经写入了 ABC那么 我想按字读出"A""B""C"应该用什么方法？（最好能给出语句）






data        BYTE code *        PageIndices[20]        =        {0x2200,0x2400,0x2600,0x2800,0x2A00,0x2C00,0x2E00,0x3000,0x3200,0x3400
                                                                        ,0x3600,0x3800,0x3A00,0x3C00,0x3E00,0x4000,0x4200,0x4400,0x4600};

void        Receive_File(void)
{
        ReadStageLength = ((BytesToRead - BytesRead) > MAX_BLOCK_SIZE_READ)? MAX_BLOCK_SIZE_READ:(BytesToRead - BytesRead);
       
        BytesRead        +=        Block_Read((BYTE*)(&TempStorage[BlockIndex]), ReadStageLength);        //        Read Block

        BlockIndex++;
        //        If device has received as many bytes as fit on one FLASH page, disable interrupts,
        //        write page to flash, reset packet index, enable interrupts
        //        Send handshake packet 0xFF to host after FLASH write
        if        ((BlockIndex        ==        (BLOCKS_PR_PAGE))        ||        (BytesRead        ==        BytesToRead))
        {
                Page_Erase((BYTE*)(PageIndices[PageIndex]));
                Page_Write((BYTE*)(PageIndices[PageIndex]));
                PageIndex++;
                Led1 = ~Led1;
                BlockIndex        =        0;
                Buffer[0]        =        0xFF;
                Block_Write(Buffer,        1);                        //        Send handshake Acknowledge to host
        }

        //        Go to Idle state if last packet has been received
        if        (BytesRead        ==        BytesToRead)        {M_State        =        ST_IDLE_DEV;        Led1        =        0;}
}





void        Page_Write(BYTE*        PageAddress)        small
{
        BYTE        EA_Save;                                        //        Used to save state of global interrupt enable
        BYTE        xdata        *pwrite;                        //        Write Pointer
        BYTE        xdata        *pread;                                //        Read Pointer
        UINT        x;                                                        //        Counter for 0-512 bytes
       
        pread        =        (BYTE xdata *)(TempStorage);
        EA_Save        =        EA;                                                //        Save EA
        EA        =        0;                                                        //        Turn off interrupts
        pwrite        =        (BYTE xdata *)(PageAddress);
        PSCTL        =        0x01;                                        //        Enable flash writes
        for(x = 0;        x         {
                FLKEY        =        0xA5;                                //        Write flash key sequence
                FLKEY        =        0xF1;
                *pwrite        =        *pread;                                //        Write data byte to flash

                pread++;                                                //        Increment pointers
                pwrite++;
        }
        PSCTL        =        0x00;                                        //        Disable flash writes
        EA        =        EA_Save;                                        //        Restore EA
}

void        Page_Erase(BYTE*        Page_Address)        small
{
        BYTE        EA_Save;                                        //        Used to save state of global interrupt enable
        BYTE        xdata        *pwrite;                        //        xdata pointer used to generate movx intruction

        EA_Save        =        EA;                                                //        Save current EA
        EA        =        0;                                                        //        Turn off interrupts
        pwrite        =        (BYTE xdata *)(Page_Address);        //        Set write pointer to Page_Address
        PSCTL        =        0x03;                                        //        Enable flash erase and writes

        FLKEY        =        0xA5;                                        //        Write flash key sequence to FLKEY
        FLKEY        =         0xF1;
        *pwrite        =        0x00;                                        //        Erase flash page using a write command

        PSCTL        =        0x00;                                        //        Disable flash erase and writes
        EA        =        EA_Save;                                        //        Restore state of EA
}

PageIndices定义中的若干项是程序存储空间中的地址,其实是FLASH中的地址,单位是字节.但在使用在是以这些地址为首地址,每次写512字节,写时先擦再写

至于读就很简单,直接把它当成程序存储空间中的数据,按地址读就可以

1. PageIndices是一个BYTE(char)型数组，从语法上说，仅仅只是8bit的整型数，不代表任何东西。
从程序看，是Page（页）的偏移地址，或者说是索引，同样也不是绝对地址。

2. PageIndices是字节型，一般程序这样写就是希望以字节方式操作。但是在内存中是连续存储，你可以用字（WORD，16bit）去存取，甚至可以用双字（DWORD，32bit）去操作，没有限制。

3. PageIndices[0]='a';PageIndices[1]='b'; //写操作
x=PageIndices[0]; y=PageIndices[1]; //读操作，x='a',y='b'

按照你的意思 在PageIndices存储的数据是连续的那么他每一位 存储仅仅是8BIT的话 整个PageIndices也仅仅能存储 20*8BIT 的存储量 可是实际程序中 PageIndices的上限是 可以读入4K的数据 这一点怎么解释？

我是和LZ一起做开发的
这段程序来源是SILCON 中USBXPRESS 例程希望用过的朋友能给出解释

不好意思刚才没看明白 ，
x=PageIndices[0]; y=PageIndices[1]; //读操作，x='a',y='b'
读写操作时指向PageIndices[0]只是指向页的首地址 那么如果这一页的数据量是满的即为 512BIT
取值的时候取出的是什么数据？如果我想取出整页信息该怎么办

data BYTE code * PageIndices[20]等效于BYTE code * data PageIndices[20]表示指针在data段共20个，他们都指向code段的BYTE。如果编译通过，调试时可以看到：
//PageIndices[D:0x22]={[0]=C:0x2200,[1]=C:0x2400,...

都是很明确的事情 PageIndices 就是页索引 0x2200等地质也就代表了 一个512BIT的存储空间，我现在就想从 这个存储空间里读数据怎么办？利用指针查找？还是其他方法
还有这个存储空间读取的数据形式是什么？ 例如我从外部输入了"A"字符
那我在单片机里直接读取的是什么？

利用指针你可以读写任何数据，如：
int  x = *((int*)PageIndices[0]);

PageIndices只是指向了 存储页 读写过程 是在PageIndices指向的存储页上发生的

例程给出的写程序 就已经利用了2个指针了 你的方法行不通

void        Page_Write(BYTE*        PageAddress)        small
{
        BYTE        EA_Save;                                        //        Used to save state of global interrupt enable
        BYTE        xdata        *pwrite;                        //        Write Pointer
        BYTE        xdata        *pread;                                //        Read Pointer
        UINT        x;                                                        //        Counter for 0-512 bytes
       
        pread        =        (BYTE xdata *)(TempStorage);
        EA_Save        =        EA;                                                //        Save EA
        EA        =        0;                                                        //        Turn off interrupts
        pwrite        =        (BYTE xdata *)(PageAddress);
        PSCTL        =        0x01;                                        //        Enable flash writes
        for(x = 0;        x         {
                FLKEY        =        0xA5;                                //        Write flash key sequence
                FLKEY        =        0xF1;
                *pwrite        =        *pread;                                //        Write data byte to flash

                pread++;                                                //        Increment pointers
                pwrite++;
        }
        PSCTL        =        0x00;                                        //        Disable flash writes
        EA        =        EA_Save;                                        //        Restore EA
}



刚才设想是在单片机里存储是按ASC码方式 然后 我从外部输入了一个“1”然后读取数据，根据1的ASCiI码为31判断（忽略高地位问题） 在0x2200的首地址可能存储数据为 3 而后存储了1于是进行如下编程验证
结果失败


void read(void)
{
char temp[2];
BYTE xdata *pwrite;
   
pwrite = (BYTE xdata *)(PageIndices[0]);
if(pwrite==0x2200)
  {
  Led1=1;
  Led2=0;
  }

  temp[1] =&pwrite[1];
  pwrite++;
if(temp[1] == '1')
{
  Led1=0;
  Led2=1;
}


}

那是因为flash读写有一定的要求如要求整页读写，你可以读写整页后再处理。与指针无关

能否给个例子？

例程里面的是按照BYTE写入 但是 我按字节读取时取不到准确值

写入的例程
void        Page_Write(BYTE*        PageAddress)        small
{
        BYTE        EA_Save;                                        //        Used to save state of global interrupt enable
        BYTE        xdata        *pwrite;                        //        Write Pointer
        BYTE        xdata        *pread;                                //        Read Pointer
        UINT        x;                                                        //        Counter for 0-512 bytes
       
        pread        =        (BYTE xdata *)(TempStorage);
        EA_Save        =        EA;                                                //        Save EA
        EA        =        0;                                                        //        Turn off interrupts
        pwrite        =        (BYTE xdata *)(PageAddress);
        PSCTL        =        0x01;                                        //        Enable flash writes
        for(x = 0;        x         {
                FLKEY        =        0xA5;                                //        Write flash key sequence
                FLKEY        =        0xF1;
                *pwrite        =        *pread;                                //        Write data byte to flash

                pread++;                                                //        Increment pointers
                pwrite++;
        }
        PSCTL        =        0x00;                                        //        Disable flash writes
        EA        =        EA_Save;                                        //        Restore EA
}

模仿“void Page_Write(BYTE* PageAddress) small ”写一个“void Page_Read(BYTE* PageAddress) small ”吧。

落落的问一下，这里的small是干嘛的？