极限编程题目B:移动数组

只看该作者 · 2009-5-22 13:58

A[256]移动到B[256].

pic16@5MIPS, pic18@10MIPS.

A:速度最快,给出时间.

B:使用资源最少.

p.s:A,B的位置可以任由阁下.

满足A条件或者B条件.

2万 · 2009-5-22 15:41

只看该作者 · 2009-5-22 17:24

B[0]=A[0];
...

B[255]=A[255];

就不晓得编出来要耗多少rom.

1万 · 2009-5-22 18:57

所以用循环，这都是因为PIC刚出道时ROM太少的缘故

2万 · 2009-5-22 21:07

最优化的循环？！

1万 · 2009-5-22 21:21

题目本身条件不全,比如说,数组单元的长度,不过我们可以假定以字节UNSIGNED CHAR为单位.

然后再考虑一下资源
16系列的SRAM最多只有368字节,显然在两个可改写的数组之间移动数据是不可能的,所以我们也要假定,A数组在ROM中.所以,最快,最省事的读A数组元素的指令应该是RETLW XX,而使用该指令读256个数据,不得不考虑PCL溢出问题
在以上两个条件成立的情况下,我们还要考虑B数组256个元素,需要最少跨越3个BANK,所以中间还需要有BANK变换.

只看该作者 · 2009-5-22 21:24

pic16,18中是否有供你连续寻址的256bytes的空间.

如没有,需要怎么去调节.

如何达到时间最优.

如何达到资源最优.

我也不知道最少要多少时间才能把数据搬完.
这些题目都必须动手去做才知道结果.

只看该作者 · 2009-5-22 21:30

pic16没512个字节ram给我们用.

所以pic16时,我们题目应该改成A[128],B[128]

好了.

哈哈，这个就是题目带给我们的价值.

题目其实并不是看上去那么简单.

希望我们做题的时候能对pic的构架有更深的认识.

2万 · 2009-5-22 21:32

呵呵，除了最低端的PIC16,其它的也没多少人用ASM些了。

现在PIC16F1XXX也出来了，更加没人做这些费力气的活啦，呵呵，我已经拿到PIC16F1936的样品，可惜还没弄到C编译器呢。

只看该作者 · 2009-5-22 21:35

极限的情况必须用asm,弄到差不多最底层,哈哈.

1万 · 2009-5-23 08:37

       LIST   P=PIC16F886,R=HEX
       #INCLUDE "P16F88x.INC"

;我们假定将数组A分配在0X20-0X6F,0XA0-0XEF SRAM空间内,将数组B分配在0X120-0X16F,0X1A0-0X1EF SRAM空间内
;
;
    MOVLW    0X20
    MOVWF    FSR
    BCF    STATUS,IRP
    MOVF    INDF,W
    BSF    STATUS,IRP
    MOVWF    INDF
    INCF    FSR
    BCF    STATUS,IRP
    MOVF    INDF,W
    BSF    STATUS,IRP
    MOVWF    INDF
;    .
;    .
;    .
    BCF    STATUS,IRP
    INCF    FSR            ;FSR = 0X6F
    MOVF    INDF,W
    BSF    STATUS,IRP
    MOVWF    INDF
    BCF    STATUS,IRP
    MOVLW    0XA0
    MOVWF    FSR
    MOVF    INDF,W
    BSF    STATUS,IRP
    MOVWF    INDF
;    .
;    .
;    .
    BCF    STATUS,IRP
    INCF    FSR            ;FSR = 0XEF
    MOVF    INDF,W
    BSF    STATUS,IRP
    MOVWF    INDF

    END

只看该作者 · 2009-5-25 13:13

1万 · 2009-5-25 13:15

大概642个周期.

1万 · 2009-5-26 17:10

2万 · 2009-5-26 17:17

只看该作者 · 2009-5-26 17:39

bank切来切去,切得很爽啊.

哈哈.

pic不来连续寻址,是有点打脑壳.

不知道其它类型的mcu如何处理该问题.

只看该作者 · 2009-5-26 18:37

1:
  0000    3000     MOVLW 0
  0001    008A     MOVWF 0xa
  0002    2804     GOTO 0x4
  0003    0000     NOP
2:
3:                 #if defined(__PCB__)
4:                 #include <16C56.h>
5:                 #fuses HS,NOWDT,NOPROTECT
6:                 #use delay(clock=20000000)
7:                 #use rs232(baud=9600, xmit=PIN_A3, rcv=PIN_A2)
8:
9:                 #elif defined(__PCM__)
10:
11:                #include <16F877.h>
12:                #device  *=16
13:                #fuses HS,NOWDT,NOPROTECT,NOLVP
14:                #use delay(clock=20000000)
15:
16:                #elif defined(__PCH__)
17:                #include <18F452.h>
18:                #fuses HS,NOWDT,NOPROTECT,NOLVP
19:                #use delay(clock=20000000)
20:                #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
21:                #endif
22:
23:
24:
25:
26:                //#include <string.h>
27:                int8 A[64];
28:                #locate  A = 0x020
29:                int8 B[64];
30:                #locate  B = 0x0A0
31:
32:                int8 C[64];
33:                #locate  C = 0x120
34:                int8 D[64];
35:                #locate  D = 0x1A0
36:
37:                int8 i;
38:                void main() {
  0004    0184     CLRF 0x4
  0005    1383     BCF 0x3, 0x7
  0006    301F     MOVLW 0x1f
  0007    0583     ANDWF 0x3, F
  0008    1683     BSF 0x3, 0x5
  0009    141F     BSF 0x1f, 0
  000A    149F     BSF 0x1f, 0x1
  000B    151F     BSF 0x1f, 0x2
  000C    119F     BCF 0x1f, 0x3
39:
40:
41:                    while(1){
42:
43:                    for(i=0;i<64;i++)
  000D    1283     BCF 0x3, 0x5
  000E    01E0     CLRF 0x60
  000F    0860     MOVF 0x60, W
  0010    3C3F     SUBLW 0x3f
  0011    1C03     BTFSS 0x3, 0
  0012    282C     GOTO 0x2c
44:                    {
45:                    A=i;
  0013    3020     MOVLW 0x20
  0014    0760     ADDWF 0x60, W
  0015    0084     MOVWF 0x4
  0016    1383     BCF 0x3, 0x7
  0017    0860     MOVF 0x60, W
  0018    0080     MOVWF 0
46:                    B=i+64;
  0019    30A0     MOVLW 0xa0
  001A    0760     ADDWF 0x60, W
  001B    0084     MOVWF 0x4
  001C    1383     BCF 0x3, 0x7
  001D    3040     MOVLW 0x40
  001E    0760     ADDWF 0x60, W
  001F    0080     MOVWF 0
47:                    C=0;
  0020    3020     MOVLW 0x20
  0021    0760     ADDWF 0x60, W
  0022    0084     MOVWF 0x4
  0023    1783     BSF 0x3, 0x7
  0024    0180     CLRF 0
48:                    D=0;
  0025    30A0     MOVLW 0xa0
  0026    0760     ADDWF 0x60, W
  0027    0084     MOVWF 0x4
  0028    1783     BSF 0x3, 0x7
  0029    0180     CLRF 0
49:                    }
  002A    0AE0     INCF 0x60, F
  002B    280F     GOTO 0xf
50:
51:
52:
53:                    #asm nop #endasm
  002C    0000     NOP
54:
55:                    MEMCPY( &C[0],&A[0], 64);
  002D    3001     MOVLW 0x1
  002E    00E2     MOVWF 0x62
  002F    3020     MOVLW 0x20
  0030    00E1     MOVWF 0x61
  0031    01E4     CLRF 0x64
  0032    00E3     MOVWF 0x63
  0033    3040     MOVLW 0x40
  0034    00F8     MOVWF 0x78
  0035    0863     MOVF 0x63, W
  0036    0084     MOVWF 0x4
  0037    1383     BCF 0x3, 0x7
  0038    1864     BTFSC 0x64, 0
  0039    1783     BSF 0x3, 0x7
  003A    0800     MOVF 0, W
  003B    00F7     MOVWF 0x77
  003C    0861     MOVF 0x61, W
  003D    0084     MOVWF 0x4
  003E    1383     BCF 0x3, 0x7
  003F    1862     BTFSC 0x62, 0
  0040    1783     BSF 0x3, 0x7
  0041    0877     MOVF 0x77, W
  0042    0080     MOVWF 0
  0043    0AE1     INCF 0x61, F
  0044    1903     BTFSC 0x3, 0x2
  0045    0AE2     INCF 0x62, F
  0046    0AE3     INCF 0x63, F
  0047    1903     BTFSC 0x3, 0x2
  0048    0AE4     INCF 0x64, F
  0049    0BF8     DECFSZ 0x78, F
  004A    2835     GOTO 0x35
56:                    MEMCPY( &D[0],&B[0], 64);
  004B    3001     MOVLW 0x1
  004C    00E2     MOVWF 0x62
  004D    30A0     MOVLW 0xa0
  004E    00E1     MOVWF 0x61
  004F    01E4     CLRF 0x64
  0050    00E3     MOVWF 0x63
  0051    3040     MOVLW 0x40
  0052    00F8     MOVWF 0x78
  0053    0863     MOVF 0x63, W
  0054    0084     MOVWF 0x4
  0055    1383     BCF 0x3, 0x7
  0056    1864     BTFSC 0x64, 0
  0057    1783     BSF 0x3, 0x7
  0058    0800     MOVF 0, W
  0059    00F7     MOVWF 0x77
  005A    0861     MOVF 0x61, W
  005B    0084     MOVWF 0x4
  005C    1383     BCF 0x3, 0x7
  005D    1862     BTFSC 0x62, 0
  005E    1783     BSF 0x3, 0x7
  005F    0877     MOVF 0x77, W
  0060    0080     MOVWF 0
  0061    0AE1     INCF 0x61, F
  0062    1903     BTFSC 0x3, 0x2
  0063    0AE2     INCF 0x62, F
  0064    0AE3     INCF 0x63, F
  0065    1903     BTFSC 0x3, 0x2
  0066    0AE4     INCF 0x64, F
  0067    0BF8     DECFSZ 0x78, F
  0068    2853     GOTO 0x53
57:
58:                    #asm nop #endasm
  0069    0000     NOP
59:                //    memmove(&A, &B ,5);
60:                    }
  006A    1683     BSF 0x3, 0x5
  006B    280D     GOTO 0xd
61:
  006C    0063     SLEEP

只看该作者 · 2009-5-26 18:39

1万 · 2009-5-26 18:51

应该说还是有点用处的,从ROM读一些数据到别的地方,比如发送出去等等.

只看该作者 · 2009-5-27 09:35

#if defined(__PCB__)
#include <16C56.h>
#fuses HS,NOWDT,NOPROTECT
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_A3, rcv=PIN_A2)

#elif defined(__PCM__)

#include <16F877.h>
#device  *=16
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)

#elif defined(__PCH__)
#include <18F452.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
#endif

//#include <string.h>
int8 A[64];
#locate  A = 0x020
int8 B[64];
#locate  B = 0x0A0

int8 C[64];
#locate  C = 0x120
int8 D[64];
#locate  D = 0x1A0

int8 i,j;
void main() {

    while(1){

    for(i=0;i<64;i++)
    {
    A=i;
    B=i+64;
    C=0;
    D=0;
    }

    #asm nop #endasm
    #asm nop #endasm

    MEMCPY( &C[0],&A[0], 64);
    MEMCPY( &D[0],&B[0], 64);

    #asm nop #endasm //2959 指令周
    #asm nop #endasm

    for(i=0;i<64;i++)
    {
    A=i;
    B=i+64;
    C=0;
    D=0;
    }

    #asm nop #endasm
    #asm nop #endasm

    for(i=0;i<64;i++)
    {
    C=A;
    D=B;
    }

    #asm nop #endasm //3015
    #asm nop #endasm

    for(i=0;i<64;i++)
    {
    A=i;
    B=i+64;
    C=0;
    D=0;
    }

    #asm nop #endasm
    #asm nop #endasm

    for(i=63;i!=255;--i)
    {
    C=A;
    D=B;
    }

    #asm nop #endasm //2951
    #asm nop #endasm

    for(i=0;i<64;i++)
    {
    A=i;
    B=i+64;
    C=0;
    D=0;
    }

    #asm nop #endasm
    #asm nop #endasm

    for(i=64;i>0;--i)
    {j=i-1;
    C[j]=A[j];
    D[j]=B[j];
    }

    #asm nop #endasm //3143
    #asm nop #endasm

    for(i=0;i<64;i++)
    {
    A=i;
    B=i+64;
    C=0;
    D=0;
    }

    #asm nop #endasm
    #asm nop #endasm

    C[0]=A[0];
    C[1]=A[1];
    C[2]=A[2];
    C[3]=A[3];
    C[4]=A[4];
    C[5]=A[5];
    C[6]=A[6];
    C[7]=A[7];
    C[8]=A[8];
    C[9]=A[9];
    C[10]=A[10];
    C[11]=A[11];
    C[12]=A[12];
    C[13]=A[13];
    C[14]=A[14];
    C[15]=A[15];

    C[16+0]=A[16+0];
    C[16+1]=A[16+1];
    C[16+2]=A[16+2];
    C[16+3]=A[16+3];
    C[16+4]=A[16+4];
    C[16+5]=A[16+5];
    C[16+6]=A[16+6];
    C[16+7]=A[16+7];
    C[16+8]=A[16+8];
    C[16+9]=A[16+9];
    C[16+10]=A[16+10];
    C[16+11]=A[16+11];
    C[16+12]=A[16+12];
    C[16+13]=A[16+13];
    C[16+14]=A[16+14];
    C[16+15]=A[16+15];

    C[32+0]=A[32+0];
    C[32+1]=A[32+1];
    C[32+2]=A[32+2];
    C[32+3]=A[32+3];
    C[32+4]=A[32+4];
    C[32+5]=A[32+5];
    C[32+6]=A[32+6];
    C[32+7]=A[32+7];
    C[32+8]=A[32+8];
    C[32+9]=A[32+9];
    C[32+10]=A[32+10];
    C[32+11]=A[32+11];
    C[32+12]=A[32+12];
    C[32+13]=A[32+13];
    C[32+14]=A[32+14];
    C[32+15]=A[32+15];

    C[48+0]=A[48+0];
    C[48+1]=A[48+1];
    C[48+2]=A[48+2];
    C[48+3]=A[48+3];
    C[48+4]=A[48+4];
    C[48+5]=A[48+5];
    C[48+6]=A[48+6];
    C[48+7]=A[48+7];
    C[48+8]=A[48+8];
    C[48+9]=A[48+9];
    C[48+10]=A[48+10];
    C[48+11]=A[48+11];
    C[48+12]=A[48+12];
    C[48+13]=A[48+13];
    C[48+14]=A[48+14];
    C[48+15]=A[48+15];
////////////////////////

    D[0]=B[0];
    D[1]=B[1];
    D[2]=B[2];
    D[3]=B[3];
    D[4]=B[4];
    D[5]=B[5];
    D[6]=B[6];
    D[7]=B[7];
    D[8]=B[8];
    D[9]=B[9];
    D[10]=B[10];
    D[11]=B[11];
    D[12]=B[12];
    D[13]=B[13];
    D[14]=B[14];
    D[15]=B[15];

    D[16+0]=B[16+0];
    D[16+1]=B[16+1];
    D[16+2]=B[16+2];
    D[16+3]=B[16+3];
    D[16+4]=B[16+4];
    D[16+5]=B[16+5];
    D[16+6]=B[16+6];
    D[16+7]=B[16+7];
    D[16+8]=B[16+8];
    D[16+9]=B[16+9];
    D[16+10]=B[16+10];
    D[16+11]=B[16+11];
    D[16+12]=B[16+12];
    D[16+13]=B[16+13];
    D[16+14]=B[16+14];
    D[16+15]=B[16+15];

    D[32+0]=B[32+0];
    D[32+1]=B[32+1];
    D[32+2]=B[32+2];
    D[32+3]=B[32+3];
    D[32+4]=B[32+4];
    D[32+5]=B[32+5];
    D[32+6]=B[32+6];
    D[32+7]=B[32+7];
    D[32+8]=B[32+8];
    D[32+9]=B[32+9];
    D[32+10]=B[32+10];
    D[32+11]=B[32+11];
    D[32+12]=B[32+12];
    D[32+13]=B[32+13];
    D[32+14]=B[32+14];
    D[32+15]=B[32+15];

    D[48+0]=B[48+0];
    D[48+1]=B[48+1];
    D[48+2]=B[48+2];
    D[48+3]=B[48+3];
    D[48+4]=B[48+4];
    D[48+5]=B[48+5];
    D[48+6]=B[48+6];
    D[48+7]=B[48+7];
    D[48+8]=B[48+8];
    D[48+9]=B[48+9];
    D[48+10]=B[48+10];
    D[48+11]=B[48+11];
    D[48+12]=B[48+12];
    D[48+13]=B[48+13];
    D[48+14]=B[48+14];
    D[48+15]=B[48+15];

    #asm nop #endasm //513
    #asm nop #endasm

//    memmove(&A, &B ,5);
    }

}

极限编程题目B:移动数组

呵呵，我只会一个个COPY 。。。

en,好方法

我一般会使ROM最少

呵呵，主要考什么呢 ？

先讨论一下16系列的条件

haha,考什么?问得好

谢兄说得对

呵呵，要考虑那么多，那就需要用ASM了。

asm有它的价值

用汇编写的16系列

不错,汇编弄得好,效率高

这个题目前我自己还无法用C弄出来.

除了楼主,没人看得懂吗?

呵呵，不是看不懂，只是感觉好象实在没什么太大用处

谢兄,是花了工夫的

C能弄出来,但傻得多

用掉2959指令周

在8楼出来之前,我按照6楼设计了一个思路

看来最蠢的反而是最快的,513指令周搞定

精华达人奖章

技术奇才奖章

欢快之小溪

伴坛终老

终身成就奖章

坚毅之洋流

十世金身

技术领袖奖章

核心会员奖章

奔腾之江水

以坛为家

技术导师奖章

沉静之湖泊

常驻人口

呵呵，主要考什么呢？