关于开发产品的一些个人看法，我现在使用51和AVR单片机

qianhng · 发表于 2009-8-29 03:39:37

zhxzhx 一丁,你弄错了一点：
你使用了端口地址0x1c~0x1f来作为存放状态的变量，而不是使用寄存器。
端口地址0x1c~0x1f在m48中是EIFR、EIMSK、GPIOR0、EECR，如果用它们来作变量，后果不可预知。

我下载了IAR AVR 5.10A,试了下，效率还是不如汇编，麻烦你再找找吧！

使用寄存器的程序应该是这样：
# include <iom48.h>
# include <intrinsics.h>
# include <stdlib.h>
# include <stdio.h>
# include <string.h>
# include <math.h>
union BIT_VAR
{
  unsigned char Val;
  struct
  {
unsigned char Bit0:1,
   Bit1:1,
   Bit2:1,
   Bit3:1,
   Bit4:1,
   Bit5:1,
   Bit6:1,
   Bit7:1;
  };
};
__regvar __no_init union BIT_VAR BUTTON_A @ 12;
__regvar __no_init union BIT_VAR BUTTON_B @ 13;
__regvar __no_init union BIT_VAR BUTTON_C @ 14;
__regvar __no_init union BIT_VAR BUTTON_D @ 15;

void BUTTON_0_ON(void)
{BUTTON_A.Bit0=0;
}
void BUTTON_1_ON(void)
{BUTTON_A.Bit1=0;
}
void BUTTON_2_ON(void)
{BUTTON_A.Bit2=0;
}
void BUTTON_3_ON(void)
{BUTTON_A.Bit3=0;
}
void BUTTON_4_ON(void)
{BUTTON_A.Bit4=0;
}
void BUTTON_5_ON(void)
{BUTTON_A.Bit5=0;
}
void BUTTON_6_ON(void)
{BUTTON_A.Bit6=0;
}
void BUTTON_7_ON(void)
{BUTTON_A.Bit7=0;
}

void BUTTON_8_ON(void)
{BUTTON_B.Bit0=0;
}
void BUTTON_9_ON(void)
{BUTTON_B.Bit1=0;
}
void BUTTON_10_ON(void)
{BUTTON_B.Bit2=0;
}
void BUTTON_11_ON(void)
{BUTTON_B.Bit3=0;
}
void BUTTON_12_ON(void)
{BUTTON_B.Bit4=0;
}
void BUTTON_13_ON(void)
{BUTTON_B.Bit5=0;
}
void BUTTON_14_ON(void)
{BUTTON_B.Bit6=0;
}
void BUTTON_15_ON(void)
{BUTTON_B.Bit7=0;
}

void BUTTON_16_ON(void)
{BUTTON_C.Bit0=0;
}
void BUTTON_17_ON(void)
{BUTTON_C.Bit1=0;
}
void BUTTON_18_ON(void)
{BUTTON_C.Bit2=0;
}
void BUTTON_19_ON(void)
{BUTTON_C.Bit3=0;
}
void BUTTON_20_ON(void)
{BUTTON_C.Bit4=0;
}
void BUTTON_21_ON(void)
{BUTTON_C.Bit5=0;
}
void BUTTON_22_ON(void)
{BUTTON_C.Bit6=0;
}
void BUTTON_23_ON(void)
{BUTTON_C.Bit7=0;
}

void BUTTON_24_ON(void)
{BUTTON_D.Bit0=0;
}
void BUTTON_25_ON(void)
{BUTTON_D.Bit1=0;
}
void BUTTON_26_ON(void)
{BUTTON_D.Bit2=0;
}
void BUTTON_27_ON(void)
{BUTTON_D.Bit3=0;
}
void BUTTON_28_ON(void)
{BUTTON_D.Bit4=0;
}
void BUTTON_29_ON(void)
{BUTTON_D.Bit5=0;
}
void BUTTON_30_ON(void)
{BUTTON_D.Bit6=0;
}
void BUTTON_31_ON(void)
{BUTTON_D.Bit7=0;
}

void main(void)
{
while(1)
  {
  if (BUTTON_A.Bit0) BUTTON_0_ON();
  if (BUTTON_A.Bit1) BUTTON_1_ON();
  if (BUTTON_A.Bit2) BUTTON_2_ON();
  if (BUTTON_A.Bit3) BUTTON_3_ON();
  if (BUTTON_A.Bit4) BUTTON_4_ON();
  if (BUTTON_A.Bit5) BUTTON_5_ON();
  if (BUTTON_A.Bit6) BUTTON_6_ON();
  if (BUTTON_A.Bit7) BUTTON_7_ON();

  if (BUTTON_B.Bit0) BUTTON_8_ON();
  if (BUTTON_B.Bit1) BUTTON_9_ON();
  if (BUTTON_B.Bit2) BUTTON_10_ON();
  if (BUTTON_B.Bit3) BUTTON_11_ON();
  if (BUTTON_B.Bit4) BUTTON_12_ON();
  if (BUTTON_B.Bit5) BUTTON_13_ON();
  if (BUTTON_B.Bit6) BUTTON_14_ON();
  if (BUTTON_B.Bit7) BUTTON_15_ON();

  if (BUTTON_C.Bit0) BUTTON_16_ON();
  if (BUTTON_C.Bit1) BUTTON_17_ON();
  if (BUTTON_C.Bit2) BUTTON_18_ON();
  if (BUTTON_C.Bit3) BUTTON_19_ON();
  if (BUTTON_C.Bit4) BUTTON_20_ON();
  if (BUTTON_C.Bit5) BUTTON_21_ON();
  if (BUTTON_C.Bit6) BUTTON_22_ON();
  if (BUTTON_C.Bit7) BUTTON_23_ON();

  if (BUTTON_D.Bit0) BUTTON_24_ON();
  if (BUTTON_D.Bit1) BUTTON_25_ON();
  if (BUTTON_D.Bit2) BUTTON_26_ON();
  if (BUTTON_D.Bit3) BUTTON_27_ON();
  if (BUTTON_D.Bit4) BUTTON_28_ON();
  if (BUTTON_D.Bit5) BUTTON_29_ON();
  if (BUTTON_D.Bit6) BUTTON_30_ON();
  if (BUTTON_D.Bit7) BUTTON_31_ON();

  }
}
编译结果是：
###############################################################################
#                                                                            #
#                                                    29/Aug/2009  03:43:33 #
# IAR Atmel AVR C/C++ Compiler V5.10A/W32                                  #
# Copyright 1996-2008 IAR Systems. All rights reserved.                      #
#                                                                            #
# Source file  =  F:\单片机\制作\test_iar\main.c                         #
# Command line =  F:\单片机\制作\test_iar\main.c --cpu=m48 -ms -o       #
#                   F:\单片机\制作\test_iar\Debug\Obj\ -lCN                #
#                   F:\单片机\制作\test_iar\Debug\List\ -lB                #
#                   F:\单片机\制作\test_iar\Debug\List\                   #
#                   --initializers_in_flash -z3 --no_cse --no_inline       #
#                   --no_code_motion --no_cross_call --no_clustering       #
#                   --no_tbaa --debug -e -I "I:\Program Files\IAR          #
#                   Systems\Embedded Workbench 5.0 Evaluation\avr\INC\" -I #
#                   "I:\Program Files\IAR Systems\Embedded Workbench 5.0    #
#                   Evaluation\avr\INC\CLIB\" --eeprom_size 256             #
#                   --lock_regs=4                                           #
# List file =  F:\单片机\制作\test_iar\Debug\List\main.lst             #
# Object file  =  F:\单片机\制作\test_iar\Debug\Obj\main.r90             #
#                                                                            #
#                                                                            #
###############################################################################

F:\单片机\制作\test_iar\main.c
   1       # include <iom48.h>
   2       # include <intrinsics.h>
   3       # include <stdlib.h>
   4       # include <stdio.h>
   5       # include <string.h>
   6       # include <math.h>
   7       union BIT_VAR
   8       {
   9          unsigned char Val;
   10          struct
   11          {
   12             unsigned char Bit0:1,
   13             Bit1:1,
   14             Bit2:1,
   15             Bit3:1,
   16             Bit4:1,
   17             Bit5:1,
   18             Bit6:1,
   19             Bit7:1;
   20          };
   21       };

\                               In  segment REGVAR_AN, at 0xc, root
   22       __regvar __no_init union BIT_VAR BUTTON_A @ 12;
\                   BUTTON_A:
\ 00000000                   DS 1

\                               In  segment REGVAR_AN, at 0xd, root
   23       __regvar __no_init union BIT_VAR BUTTON_B @ 13;
\                   BUTTON_B:
\ 00000000                   DS 1

\                               In  segment REGVAR_AN, at 0xe, root
   24       __regvar __no_init union BIT_VAR BUTTON_C @ 14;
\                   BUTTON_C:
\ 00000000                   DS 1

\                               In  segment REGVAR_AN, at 0xf, root
   25       __regvar __no_init union BIT_VAR BUTTON_D @ 15;
\                   BUTTON_D:
\ 00000000                   DS 1
   26

\                               In  segment CODE, align 2, keep-with-next
   27       void BUTTON_0_ON(void)
\                   BUTTON_0_ON:
   28       {BUTTON_A.Bit0=0;
\ 00000000                   REQUIRE ?Register_R12_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8C0             BLD    R12, 0
   29       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_A

\                               In  segment CODE, align 2, keep-with-next
   30       void BUTTON_1_ON(void)
\                   BUTTON_1_ON:
   31       {BUTTON_A.Bit1=0;
\ 00000000                   REQUIRE ?Register_R12_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8C1             BLD    R12, 1
   32       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_A

\                               In  segment CODE, align 2, keep-with-next
   33       void BUTTON_2_ON(void)
\                   BUTTON_2_ON:
   34       {BUTTON_A.Bit2=0;
\ 00000000                   REQUIRE ?Register_R12_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8C2             BLD    R12, 2
   35       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_A

\                               In  segment CODE, align 2, keep-with-next
   36       void BUTTON_3_ON(void)
\                   BUTTON_3_ON:
   37       {BUTTON_A.Bit3=0;
\ 00000000                   REQUIRE ?Register_R12_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8C3             BLD    R12, 3
   38       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_A

\                               In  segment CODE, align 2, keep-with-next
   39       void BUTTON_4_ON(void)
\                   BUTTON_4_ON:
   40       {BUTTON_A.Bit4=0;
\ 00000000                   REQUIRE ?Register_R12_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8C4             BLD    R12, 4
   41       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_A

\                               In  segment CODE, align 2, keep-with-next
   42       void BUTTON_5_ON(void)
\                   BUTTON_5_ON:
   43       {BUTTON_A.Bit5=0;
\ 00000000                   REQUIRE ?Register_R12_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8C5             BLD    R12, 5
   44       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_A

\                               In  segment CODE, align 2, keep-with-next
   45       void BUTTON_6_ON(void)
\                   BUTTON_6_ON:
   46       {BUTTON_A.Bit6=0;
\ 00000000                   REQUIRE ?Register_R12_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8C6             BLD    R12, 6
   47       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_A

\                               In  segment CODE, align 2, keep-with-next
   48       void BUTTON_7_ON(void)
\                   BUTTON_7_ON:
   49       {BUTTON_A.Bit7=0;
\ 00000000                   REQUIRE ?Register_R12_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8C7             BLD    R12, 7
   50       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_A
   51

\                               In  segment CODE, align 2, keep-with-next
   52       void BUTTON_8_ON(void)
\                   BUTTON_8_ON:
   53       {BUTTON_B.Bit0=0;
\ 00000000                   REQUIRE ?Register_R13_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8D0             BLD    R13, 0
   54       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_B

\                               In  segment CODE, align 2, keep-with-next
   55       void BUTTON_9_ON(void)
\                   BUTTON_9_ON:
   56       {BUTTON_B.Bit1=0;
\ 00000000                   REQUIRE ?Register_R13_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8D1             BLD    R13, 1
   57       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_B

\                               In  segment CODE, align 2, keep-with-next
   58       void BUTTON_10_ON(void)
\                   BUTTON_10_ON:
   59       {BUTTON_B.Bit2=0;
\ 00000000                   REQUIRE ?Register_R13_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8D2             BLD    R13, 2
   60       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_B

\                               In  segment CODE, align 2, keep-with-next
   61       void BUTTON_11_ON(void)
\                   BUTTON_11_ON:
   62       {BUTTON_B.Bit3=0;
\ 00000000                   REQUIRE ?Register_R13_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8D3             BLD    R13, 3
   63       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_B

\                               In  segment CODE, align 2, keep-with-next
   64       void BUTTON_12_ON(void)
\                   BUTTON_12_ON:
   65       {BUTTON_B.Bit4=0;
\ 00000000                   REQUIRE ?Register_R13_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8D4             BLD    R13, 4
   66       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_B

\                               In  segment CODE, align 2, keep-with-next
   67       void BUTTON_13_ON(void)
\                   BUTTON_13_ON:
   68       {BUTTON_B.Bit5=0;
\ 00000000                   REQUIRE ?Register_R13_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8D5             BLD    R13, 5
   69       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_B

\                               In  segment CODE, align 2, keep-with-next
   70       void BUTTON_14_ON(void)
\                   BUTTON_14_ON:
   71       {BUTTON_B.Bit6=0;
\ 00000000                   REQUIRE ?Register_R13_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8D6             BLD    R13, 6
   72       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_B

\                               In  segment CODE, align 2, keep-with-next
   73       void BUTTON_15_ON(void)
\                   BUTTON_15_ON:
   74       {BUTTON_B.Bit7=0;
\ 00000000                   REQUIRE ?Register_R13_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8D7             BLD    R13, 7
   75       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_B
   76

\                               In  segment CODE, align 2, keep-with-next
   77       void BUTTON_16_ON(void)
\                   BUTTON_16_ON:
   78       {BUTTON_C.Bit0=0;
\ 00000000                   REQUIRE ?Register_R14_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8E0             BLD    R14, 0
   79       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_C

\                               In  segment CODE, align 2, keep-with-next
   80       void BUTTON_17_ON(void)
\                   BUTTON_17_ON:
   81       {BUTTON_C.Bit1=0;
\ 00000000                   REQUIRE ?Register_R14_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8E1             BLD    R14, 1
   82       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_C

\                               In  segment CODE, align 2, keep-with-next
   83       void BUTTON_18_ON(void)
\                   BUTTON_18_ON:
   84       {BUTTON_C.Bit2=0;
\ 00000000                   REQUIRE ?Register_R14_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8E2             BLD    R14, 2
   85       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_C

\                               In  segment CODE, align 2, keep-with-next
   86       void BUTTON_19_ON(void)
\                   BUTTON_19_ON:
   87       {BUTTON_C.Bit3=0;
\ 00000000                   REQUIRE ?Register_R14_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8E3             BLD    R14, 3
   88       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_C

\                               In  segment CODE, align 2, keep-with-next
   89       void BUTTON_20_ON(void)
\                   BUTTON_20_ON:
   90       {BUTTON_C.Bit4=0;
\ 00000000                   REQUIRE ?Register_R14_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8E4             BLD    R14, 4
   91       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_C

\                               In  segment CODE, align 2, keep-with-next
   92       void BUTTON_21_ON(void)
\                   BUTTON_21_ON:
   93       {BUTTON_C.Bit5=0;
\ 00000000                   REQUIRE ?Register_R14_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8E5             BLD    R14, 5
   94       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_C

\                               In  segment CODE, align 2, keep-with-next
   95       void BUTTON_22_ON(void)
\                   BUTTON_22_ON:
   96       {BUTTON_C.Bit6=0;
\ 00000000                   REQUIRE ?Register_R14_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8E6             BLD    R14, 6
   97       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_C

\                               In  segment CODE, align 2, keep-with-next
   98       void BUTTON_23_ON(void)
\                   BUTTON_23_ON:
   99       {BUTTON_C.Bit7=0;
\ 00000000                   REQUIRE ?Register_R14_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8E7             BLD    R14, 7
100       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_C
101

\                               In  segment CODE, align 2, keep-with-next
102       void BUTTON_24_ON(void)
\                   BUTTON_24_ON:
103       {BUTTON_D.Bit0=0;
\ 00000000                   REQUIRE ?Register_R15_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8F0             BLD    R15, 0
104       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_D

\                               In  segment CODE, align 2, keep-with-next
105       void BUTTON_25_ON(void)
\                   BUTTON_25_ON:
106       {BUTTON_D.Bit1=0;
\ 00000000                   REQUIRE ?Register_R15_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8F1             BLD    R15, 1
107       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_D

\                               In  segment CODE, align 2, keep-with-next
108       void BUTTON_26_ON(void)
\                   BUTTON_26_ON:
109       {BUTTON_D.Bit2=0;
\ 00000000                   REQUIRE ?Register_R15_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8F2             BLD    R15, 2
110       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_D

\                               In  segment CODE, align 2, keep-with-next
111       void BUTTON_27_ON(void)
\                   BUTTON_27_ON:
112       {BUTTON_D.Bit3=0;
\ 00000000                   REQUIRE ?Register_R15_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8F3             BLD    R15, 3
113       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_D

\                               In  segment CODE, align 2, keep-with-next
114       void BUTTON_28_ON(void)
\                   BUTTON_28_ON:
115       {BUTTON_D.Bit4=0;
\ 00000000                   REQUIRE ?Register_R15_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8F4             BLD    R15, 4
116       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_D

\                               In  segment CODE, align 2, keep-with-next
117       void BUTTON_29_ON(void)
\                   BUTTON_29_ON:
118       {BUTTON_D.Bit5=0;
\ 00000000                   REQUIRE ?Register_R15_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8F5             BLD    R15, 5
119       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_D

\                               In  segment CODE, align 2, keep-with-next
120       void BUTTON_30_ON(void)
\                   BUTTON_30_ON:
121       {BUTTON_D.Bit6=0;
\ 00000000                   REQUIRE ?Register_R15_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8F6             BLD    R15, 6
122       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_D

\                               In  segment CODE, align 2, keep-with-next
123       void BUTTON_31_ON(void)
\                   BUTTON_31_ON:
124       {BUTTON_D.Bit7=0;
\ 00000000                   REQUIRE ?Register_R15_is_global_regvar
\ 00000000 94E8             CLT
\ 00000002 F8F7             BLD    R15, 7
125       }
\ 00000004 9508             RET
\ 00000006                   REQUIRE BUTTON_D
126

\                               In  segment CODE, align 2, keep-with-next
127       void main(void)
\                   main:
128       {
\ 00000000                   REQUIRE ?Register_R12_is_global_regvar
\ 00000000                   REQUIRE ?Register_R13_is_global_regvar
\ 00000000                   REQUIRE ?Register_R14_is_global_regvar
\ 00000000                   REQUIRE ?Register_R15_is_global_regvar
129       while(1)
130          {
131          if (BUTTON_A.Bit0) BUTTON_0_ON();
\                   ??main_0:
\ 00000000 FAC0             BST    R12, 0
\ 00000002 F40E             BRTC ??main_1
\ 00000004 ....             RCALL BUTTON_0_ON
132          if (BUTTON_A.Bit1) BUTTON_1_ON();
\                   ??main_1:
\ 00000006 FAC1             BST    R12, 1
\ 00000008 F40E             BRTC ??main_2
\ 0000000A ....             RCALL BUTTON_1_ON
133          if (BUTTON_A.Bit2) BUTTON_2_ON();
\                   ??main_2:
\ 0000000C FAC2             BST    R12, 2
\ 0000000E F40E             BRTC ??main_3
\ 00000010 ....             RCALL BUTTON_2_ON
134          if (BUTTON_A.Bit3) BUTTON_3_ON();
\                   ??main_3:
\ 00000012 FAC3             BST    R12, 3
\ 00000014 F40E             BRTC ??main_4
\ 00000016 ....             RCALL BUTTON_3_ON
135          if (BUTTON_A.Bit4) BUTTON_4_ON();
\                   ??main_4:
\ 00000018 FAC4             BST    R12, 4
\ 0000001A F40E             BRTC ??main_5
\ 0000001C ....             RCALL BUTTON_4_ON
136          if (BUTTON_A.Bit5) BUTTON_5_ON();
\                   ??main_5:
\ 0000001E FAC5             BST    R12, 5
\ 00000020 F40E             BRTC ??main_6
\ 00000022 ....             RCALL BUTTON_5_ON
137          if (BUTTON_A.Bit6) BUTTON_6_ON();
\                   ??main_6:
\ 00000024 FAC6             BST    R12, 6
\ 00000026 F40E             BRTC ??main_7
\ 00000028 ....             RCALL BUTTON_6_ON
138          if (BUTTON_A.Bit7) BUTTON_7_ON();
\                   ??main_7:
\ 0000002A FAC7             BST    R12, 7
\ 0000002C F40E             BRTC ??main_8
\ 0000002E ....             RCALL BUTTON_7_ON
139
140          if (BUTTON_B.Bit0) BUTTON_8_ON();
\                   ??main_8:
\ 00000030 FAD0             BST    R13, 0
\ 00000032 F40E             BRTC ??main_9
\ 00000034 ....             RCALL BUTTON_8_ON
141          if (BUTTON_B.Bit1) BUTTON_9_ON();
\                   ??main_9:
\ 00000036 FAD1             BST    R13, 1
\ 00000038 F40E             BRTC ??main_10
\ 0000003A ....             RCALL BUTTON_9_ON
142          if (BUTTON_B.Bit2) BUTTON_10_ON();
\                   ??main_10:
\ 0000003C FAD2             BST    R13, 2
\ 0000003E F40E             BRTC ??main_11
\ 00000040 ....             RCALL BUTTON_10_ON
143          if (BUTTON_B.Bit3) BUTTON_11_ON();
\                   ??main_11:
\ 00000042 FAD3             BST    R13, 3
\ 00000044 F40E             BRTC ??main_12
\ 00000046 ....             RCALL BUTTON_11_ON
144          if (BUTTON_B.Bit4) BUTTON_12_ON();
\                   ??main_12:
\ 00000048 FAD4             BST    R13, 4
\ 0000004A F40E             BRTC ??main_13
\ 0000004C ....             RCALL BUTTON_12_ON
145          if (BUTTON_B.Bit5) BUTTON_13_ON();
\                   ??main_13:
\ 0000004E FAD5             BST    R13, 5
\ 00000050 F40E             BRTC ??main_14
\ 00000052 ....             RCALL BUTTON_13_ON
146          if (BUTTON_B.Bit6) BUTTON_14_ON();
\                   ??main_14:
\ 00000054 FAD6             BST    R13, 6
\ 00000056 F40E             BRTC ??main_15
\ 00000058 ....             RCALL BUTTON_14_ON
147          if (BUTTON_B.Bit7) BUTTON_15_ON();
\                   ??main_15:
\ 0000005A FAD7             BST    R13, 7
\ 0000005C F40E             BRTC ??main_16
\ 0000005E ....             RCALL BUTTON_15_ON
148
149          if (BUTTON_C.Bit0) BUTTON_16_ON();
\                   ??main_16:
\ 00000060 FAE0             BST    R14, 0
\ 00000062 F40E             BRTC ??main_17
\ 00000064 ....             RCALL BUTTON_16_ON
150          if (BUTTON_C.Bit1) BUTTON_17_ON();
\                   ??main_17:
\ 00000066 FAE1             BST    R14, 1
\ 00000068 F40E             BRTC ??main_18
\ 0000006A ....             RCALL BUTTON_17_ON
151          if (BUTTON_C.Bit2) BUTTON_18_ON();
\                   ??main_18:
\ 0000006C FAE2             BST    R14, 2
\ 0000006E F40E             BRTC ??main_19
\ 00000070 ....             RCALL BUTTON_18_ON
152          if (BUTTON_C.Bit3) BUTTON_19_ON();
\                   ??main_19:
\ 00000072 FAE3             BST    R14, 3
\ 00000074 F40E             BRTC ??main_20
\ 00000076 ....             RCALL BUTTON_19_ON
153          if (BUTTON_C.Bit4) BUTTON_20_ON();
\                   ??main_20:
\ 00000078 FAE4             BST    R14, 4
\ 0000007A F40E             BRTC ??main_21
\ 0000007C ....             RCALL BUTTON_20_ON
154          if (BUTTON_C.Bit5) BUTTON_21_ON();
\                   ??main_21:
\ 0000007E FAE5             BST    R14, 5
\ 00000080 F40E             BRTC ??main_22
\ 00000082 ....             RCALL BUTTON_21_ON
155          if (BUTTON_C.Bit6) BUTTON_22_ON();
\                   ??main_22:
\ 00000084 FAE6             BST    R14, 6
\ 00000086 F40E             BRTC ??main_23
\ 00000088 ....             RCALL BUTTON_22_ON
156          if (BUTTON_C.Bit7) BUTTON_23_ON();
\                   ??main_23:
\ 0000008A FAE7             BST    R14, 7
\ 0000008C F40E             BRTC ??main_24
\ 0000008E ....             RCALL BUTTON_23_ON
157
158          if (BUTTON_D.Bit0) BUTTON_24_ON();
\                   ??main_24:
\ 00000090 FAF0             BST    R15, 0
\ 00000092 F40E             BRTC ??main_25
\ 00000094 ....             RCALL BUTTON_24_ON
159          if (BUTTON_D.Bit1) BUTTON_25_ON();
\                   ??main_25:
\ 00000096 FAF1             BST    R15, 1
\ 00000098 F40E             BRTC ??main_26
\ 0000009A ....             RCALL BUTTON_25_ON
160          if (BUTTON_D.Bit2) BUTTON_26_ON();
\                   ??main_26:
\ 0000009C FAF2             BST    R15, 2
\ 0000009E F40E             BRTC ??main_27
\ 000000A0 ....             RCALL BUTTON_26_ON
161          if (BUTTON_D.Bit3) BUTTON_27_ON();
\                   ??main_27:
\ 000000A2 FAF3             BST    R15, 3
\ 000000A4 F40E             BRTC ??main_28
\ 000000A6 ....             RCALL BUTTON_27_ON
162          if (BUTTON_D.Bit4) BUTTON_28_ON();
\                   ??main_28:
\ 000000A8 FAF4             BST    R15, 4
\ 000000AA F40E             BRTC ??main_29
\ 000000AC ....             RCALL BUTTON_28_ON
163          if (BUTTON_D.Bit5) BUTTON_29_ON();
\                   ??main_29:
\ 000000AE FAF5             BST    R15, 5
\ 000000B0 F40E             BRTC ??main_30
\ 000000B2 ....             RCALL BUTTON_29_ON
164          if (BUTTON_D.Bit6) BUTTON_30_ON();
\                   ??main_30:
\ 000000B4 FAF6             BST    R15, 6
\ 000000B6 F40E             BRTC ??main_31
\ 000000B8 ....             RCALL BUTTON_30_ON
165          if (BUTTON_D.Bit7) BUTTON_31_ON();
\                   ??main_31:
\ 000000BA FAF7             BST    R15, 7
\ 000000BC F00E             BRTS $+2+2
\ 000000BE CFA0             RJMP ??main_0
\ 000000C0 ....             RCALL BUTTON_31_ON
\ 000000C2 CF9E             RJMP ??main_0
\ 000000C4                   REQUIRE BUTTON_A
\ 000000C4                   REQUIRE BUTTON_B
\ 000000C4                   REQUIRE BUTTON_C
\ 000000C4                   REQUIRE BUTTON_D
166
167          }
168       }

Maximum stack usage in bytes:

   Function       CSTACK RSTACK
   --------       ------ ------
   BUTTON_0_ON          0    2
   BUTTON_10_ON       0    2
   BUTTON_11_ON       0    2
   BUTTON_12_ON       0    2
   BUTTON_13_ON       0    2
   BUTTON_14_ON       0    2
   BUTTON_15_ON       0    2
   BUTTON_16_ON       0    2
   BUTTON_17_ON       0    2
   BUTTON_18_ON       0    2
   BUTTON_19_ON       0    2
   BUTTON_1_ON          0    2
   BUTTON_20_ON       0    2
   BUTTON_21_ON       0    2
   BUTTON_22_ON       0    2
   BUTTON_23_ON       0    2
   BUTTON_24_ON       0    2
   BUTTON_25_ON       0    2
   BUTTON_26_ON       0    2
   BUTTON_27_ON       0    2
   BUTTON_28_ON       0    2
   BUTTON_29_ON       0    2
   BUTTON_2_ON          0    2
   BUTTON_30_ON       0    2
   BUTTON_31_ON       0    2
   BUTTON_3_ON          0    2
   BUTTON_4_ON          0    2
   BUTTON_5_ON          0    2
   BUTTON_6_ON          0    2
   BUTTON_7_ON          0    2
   BUTTON_8_ON          0    2
   BUTTON_9_ON          0    2
   main                0    2
   -> BUTTON_0_ON    0    2
   -> BUTTON_1_ON    0    2
   -> BUTTON_2_ON    0    2
   -> BUTTON_3_ON    0    2
   -> BUTTON_4_ON    0    2
   -> BUTTON_5_ON    0    2
   -> BUTTON_6_ON    0    2
   -> BUTTON_7_ON    0    2
   -> BUTTON_8_ON    0    2
   -> BUTTON_9_ON    0    2
   -> BUTTON_10_ON    0    2
   -> BUTTON_11_ON    0    2
   -> BUTTON_12_ON    0    2
   -> BUTTON_13_ON    0    2
   -> BUTTON_14_ON    0    2
   -> BUTTON_15_ON    0    2
   -> BUTTON_16_ON    0    2
   -> BUTTON_17_ON    0    2
   -> BUTTON_18_ON    0    2
   -> BUTTON_19_ON    0    2
   -> BUTTON_20_ON    0    2
   -> BUTTON_21_ON    0    2
   -> BUTTON_22_ON    0    2
   -> BUTTON_23_ON    0    2
   -> BUTTON_24_ON    0    2
   -> BUTTON_25_ON    0    2
   -> BUTTON_26_ON    0    2
   -> BUTTON_27_ON    0    2
   -> BUTTON_28_ON    0    2
   -> BUTTON_29_ON    0    2
   -> BUTTON_30_ON    0    2
   -> BUTTON_31_ON    0    2

Segment part sizes:

   Function/Label Bytes
   -------------- -----
   BUTTON_A       1
   BUTTON_B       1
   BUTTON_C       1
   BUTTON_D       1
   BUTTON_0_ON    6
   BUTTON_1_ON    6
   BUTTON_2_ON    6
   BUTTON_3_ON    6
   BUTTON_4_ON    6
   BUTTON_5_ON    6
   BUTTON_6_ON    6
   BUTTON_7_ON    6
   BUTTON_8_ON    6
   BUTTON_9_ON    6
   BUTTON_10_ON    6
   BUTTON_11_ON    6
   BUTTON_12_ON    6
   BUTTON_13_ON    6
   BUTTON_14_ON    6
   BUTTON_15_ON    6
   BUTTON_16_ON    6
   BUTTON_17_ON    6
   BUTTON_18_ON    6
   BUTTON_19_ON    6
   BUTTON_20_ON    6
   BUTTON_21_ON    6
   BUTTON_22_ON    6
   BUTTON_23_ON    6
   BUTTON_24_ON    6
   BUTTON_25_ON    6
   BUTTON_26_ON    6
   BUTTON_27_ON    6
   BUTTON_28_ON    6
   BUTTON_29_ON    6
   BUTTON_30_ON    6
   BUTTON_31_ON    6
   ??main_0       196

388 bytes in segment CODE
4 bytes in segment REGVAR_AN

388 bytes of CODE memory
0 bytes of DATA memory (+ 4 bytes shared)

Errors: none
Warnings: none

sharpufo · 发表于 2009-8-29 21:37:03

很多情况不必这么计较，像我一般的应用就是。8MIPS够快了，空间也够用，不够再选大一点的，也贵不了多少。
用汇编太杀脑细胞。自己觉得好就行。
汇编效率高于c是肯定的，他直接用指令，实际上已经是变相的机器指令，可以说是最底层的语言了，效率高是自然地。
但是也不能说汇编运行效率高就排斥c,对与那些空间时间效率要求不高的，用C真的是开发方便得很多了.
像最近在做的FAT文件系统，如果用汇编，那不如杀了我吧。。。
一般情况用C,但不排斥汇编，必要的时候用。
没有那种语言是最有效率的，只有最合适的。要不然也不会有这么多编程语言了。

qianhng · 发表于 2009-8-30 00:16:12

C我知道一点但绝对远远低于精通，也许因为我的avr只是业余爱好而已。
假如只是用来做控制，我会用汇编，其它的我觉得用C也不错。
汇编的强大在于它的随心所欲，比如说写EEPROM,对EECR 寄存器的EEMPE写"1"，同时清零EEPE,在置位EEMPE 之后的4 个周期内置位EEPE,用C在这4 个周期内很难做些什么，但是在汇编可以插入对写入的合法性进行判断以决定到底是否应置位EEPE，当然是否得当还要看你的方法。
但是汇编要投入的精力实在是太多了，C就没有这个问题，但用C很多时候心里没底(比如说中断触发后是否能够及时响应？中断程序是否耗时太多以至下一个中断被滞后了？)，也许是我的C还太差了点。

zhxzhx · 发表于 2009-8-30 15:33:28

qianhng 这已经很不错了啊,一些特殊的地方,你可以嵌入汇编,比如你上面提到的对EECR的检测,你就可以嵌入汇编完成,
这样C的优点,汇编的优点你都能兼顾.
用C很多时候心里没底这个,你可以看看它生成的汇编列表不就知道了吗?

zhxzhx · 发表于 2009-8-30 17:18:53

这个,可能是最精简的代码了

/*包含所需头文件*/
# include <iom48.h>
# include <intrinsics.h>
# include <stdlib.h>
# include <stdio.h>
# include <string.h>
# include <math.h>

#define BUTTON_A R20
#define BUTTON_B R21
#define BUTTON_C R22
#define BUTTON_D R23

#define BUTTON_0_ON() \
{asm("CBR R20,0");}

#define BUTTON_1_ON() \
{asm("CBR R20,1");}
#define BUTTON_2_ON() \
{asm("CBR R20,2");}
#define BUTTON_3_ON() \
{asm("CBR R20,3");}
#define BUTTON_4_ON() \
{asm("CBR R20,4");}
#define BUTTON_5_ON() \
{asm("CBR R20,5");}
#define BUTTON_6_ON() \
{asm("CBR R20,6");}
#define BUTTON_7_ON() \
{asm("CBR R20,7");}

#define BUTTON_8_ON() \
{asm("CBR R21,0");}
#define BUTTON_9_ON() \
{asm("CBR R21,1");}
#define BUTTON_10_ON() \
{asm("CBR R21,2");}
#define BUTTON_11_ON() \
{asm("CBR R21,3");}
#define BUTTON_12_ON() \
{asm("CBR R21,4");}
#define BUTTON_13_ON() \
{asm("CBR R21,5");}
#define BUTTON_14_ON() \
{asm("CBR R21,6");}
#define BUTTON_15_ON() \
{asm("CBR R21,7");}

#define BUTTON_16_ON() \
{asm("CBR R22,0");}
#define BUTTON_17_ON() \
{asm("CBR R22,1");}
#define BUTTON_18_ON() \
{asm("CBR R22,2");}
#define BUTTON_19_ON() \
{asm("CBR R22,3");}
#define BUTTON_20_ON() \
{asm("CBR R22,4");}
#define BUTTON_21_ON() \
{asm("CBR R22,5");}
#define BUTTON_22_ON() \
{asm("CBR R22,6");}
#define BUTTON_23_ON() \
{asm("CBR R22,7");}

#define BUTTON_24_ON() \
{asm("CBR R23,0");}
#define BUTTON_25_ON() \
{asm("CBR R23,1");}
#define BUTTON_26_ON() \
{asm("CBR R23,2");}
#define BUTTON_27_ON() \
{asm("CBR R23,3");}
#define BUTTON_28_ON() \
{asm("CBR R23,4");}
#define BUTTON_29_ON() \
{asm("CBR R23,5");}
#define BUTTON_30_ON() \
{asm("CBR R23,6");}
#define BUTTON_31_ON() \
{asm("CBR R23,7");}

void main(void)
{while(1)
  {
  asm("SBRC R20,0"); BUTTON_0_ON();
  asm("SBRC R20,1"); BUTTON_1_ON();
  asm("SBRC R20,2"); BUTTON_2_ON();
  asm("SBRC R20,3"); BUTTON_3_ON();
  asm("SBRC R20,4"); BUTTON_4_ON();
  asm("SBRC R20,5"); BUTTON_5_ON();
  asm("SBRC R20,6"); BUTTON_6_ON();
  asm("SBRC R20,7"); BUTTON_7_ON();

  asm("SBRC R21,0"); BUTTON_8_ON();
  asm("SBRC R21,1"); BUTTON_9_ON();
  asm("SBRC R21,2"); BUTTON_10_ON();
  asm("SBRC R21,3"); BUTTON_11_ON();
  asm("SBRC R21,4"); BUTTON_12_ON();
  asm("SBRC R21,5"); BUTTON_13_ON();
  asm("SBRC R21,6"); BUTTON_14_ON();
  asm("SBRC R21,7"); BUTTON_15_ON();

  asm("SBRC R22,0"); BUTTON_16_ON();
  asm("SBRC R22,1"); BUTTON_17_ON();
  asm("SBRC R22,2"); BUTTON_18_ON();
  asm("SBRC R22,3"); BUTTON_19_ON();
  asm("SBRC R22,4"); BUTTON_20_ON();
  asm("SBRC R22,5"); BUTTON_21_ON();
  asm("SBRC R22,6"); BUTTON_22_ON();
  asm("SBRC R22,7"); BUTTON_23_ON();

  asm("SBRC R23,0"); BUTTON_24_ON();
  asm("SBRC R23,1"); BUTTON_25_ON();
  asm("SBRC R23,2"); BUTTON_26_ON();
  asm("SBRC R23,3"); BUTTON_27_ON();
  asm("SBRC R23,4"); BUTTON_28_ON();
  asm("SBRC R23,5"); BUTTON_29_ON();
  asm("SBRC R23,6"); BUTTON_30_ON();
  asm("SBRC R23,7"); BUTTON_31_ON();
  }
}

//////////////////////////////////////////////////////////////////////////////
//                                                                         /
//                                                    30/Aug/2009  17:21:38 /
// IAR Atmel AVR C/C++ Compiler V4.10A/W32, Evaluation Version             /
// Copyright 1996-2005 IAR Systems. All rights reserved.                   /
//                                                                         /
// Source file  =  D:\AVR\CTEST\main.c                                  /
// Command line =  --cpu=m48 -ms -o D:\AVR\CTEST\Debug\Obj\ -lb          /
//                   D:\AVR\CTEST\Debug\List\ --initializers_in_flash -z2 /
//                   --no_cse --no_inline --no_code_motion --no_cross_call  /
//                   --no_clustering --no_tbaa --debug                   /
//                   -DENABLE_BIT_DEFINITIONS -e --enable_multibytes -I    /
//                   "C:\Program Files\IAR Systems\Embedded Workbench    /
//                   Evaluation version\avr\INC\" -I "C:\Program Files\IAR  /
//                   Systems\Embedded Workbench  Evaluation                /
//                   version\avr\INC\CLIB\" --eeprom_size 256             /
//                   D:\AVR\CTEST\main.c                                  /
// List file =  D:\AVR\CTEST\Debug\List\main.s90                      /
//                                                                         /
//                                                                         /
//////////////////////////////////////////////////////////////////////////////

      NAME main

      RSEG CSTACK:DATA:NOROOT(0)
      RSEG RSTACK:DATA:NOROOT(0)

      PUBWEAK __?EEARL
      PUBWEAK __?EECR
      PUBWEAK __?EEDR
      PUBLIC main

      RSEG CODE:CODE:NOROOT(1)
main:
??main_0:
      SBRC R20,0
      CBR R20,0
      SBRC R20,1
      CBR R20,1
      SBRC R20,2
      CBR R20,2
      SBRC R20,3
      CBR R20,3
      SBRC R20,4
      CBR R20,4
      SBRC R20,5
      CBR R20,5
      SBRC R20,6
      CBR R20,6
      SBRC R20,7
      CBR R20,7
      SBRC R21,0
      CBR R21,0
      SBRC R21,1
      CBR R21,1
      SBRC R21,2
      CBR R21,2
      SBRC R21,3
      CBR R21,3
      SBRC R21,4
      CBR R21,4
      SBRC R21,5
      CBR R21,5
      SBRC R21,6
      CBR R21,6
      SBRC R21,7
      CBR R21,7
      SBRC R22,0
      CBR R22,0
      SBRC R22,1
      CBR R22,1
      SBRC R22,2
      CBR R22,2
      SBRC R22,3
      CBR R22,3
      SBRC R22,4
      CBR R22,4
      SBRC R22,5
      CBR R22,5
      SBRC R22,6
      CBR R22,6
      SBRC R22,7
      CBR R22,7
      SBRC R23,0
      CBR R23,0
      SBRC R23,1
      CBR R23,1
      SBRC R23,2
      CBR R23,2
      SBRC R23,3
      CBR R23,3
      SBRC R23,4
      CBR R23,4
      SBRC R23,5
      CBR R23,5
      SBRC R23,6
      CBR R23,6
      SBRC R23,7
      CBR R23,7
      RJMP ??main_0

      ASEGN ABSOLUTE:DATA:NOROOT,01fH
__?EECR:

      ASEGN ABSOLUTE:DATA:NOROOT,020H
__?EEDR:

      ASEGN ABSOLUTE:DATA:NOROOT,021H
__?EEARL:

      END
//
// 130 bytes in segment CODE
//
// 130 bytes of CODE memory
//
//Errors: none
//Warnings: none

qianhng · 发表于 2009-8-30 19:50:56

我晕,你的这个已经和C的效率没有任何关系了,这是用镶嵌汇编和汇编比效率了!

之前的汇编程序之所以调用子程序是因为要在里面处理触发的事件,总不能把所有的触发事件也写出来吧?

你要是想说服我C的效率不比汇编低,你还是再找找吧!

zhxzhx · 发表于 2009-8-30 20:30:19

C的效率不比汇编低,不是说C的效率可以比汇编高,只要C的效率不算太低,C有手段提高效率就行,毕竟C还有汇编不能比的其他优点,
毕竟效率是汇编的长处,另外,C嵌入汇编,也是C语言的功能,C嵌入了汇编,也还是C,证明你有的优点我能拿来用,我的优点你就用不了!

执行效率是效率,开发效率也是效率,有的时候,开发效率更关键.

大多数情况下,效率的提高,是通过优化算法来实现的,这里提高的效率可不是1倍2倍,而是几十倍,上百倍,而高级语言正是把人的精力从简单单调重复的劳动里解脱出来,使人们有精力去关注更高层次的数据结构,算法等的优化.

好的数据结构,对效率的提高也是很明显的,比如说你严格满足了第三范式,你的机器就会累死.

qianhng · 发表于 2009-8-30 20:56:04

既然你都在C里用起汇编来提高效率了，我就懒得和你打口水仗了，结果不是大家一目了然吗？！
（另：希望你下次想说别人误人子弟前先看看自己的论点是否能站住脚）

qianhng · 发表于 2009-8-30 20:59:36

按你的说法，我把C程序生成汇编程序了，那就是汇编程序了，还是汇编程序效率最高^_^

上一个帖才说不打口水仗了，刚才还是忍不住发了以上内容，在这里修改这个帖向大家郑重道歉：“sorry！”

zhxzhx · 发表于 2009-8-30 23:47:06

汇编程序效率最高是对的,但C的效率也不是很差,不能应为这一点而拒绝C语言,如果有的学生因为看了你的结论,而不去学习高级语言了,这不是误人子弟吗?

现在的项目还有多少是汇编完成的?现在还有多少处理器不支持高级语言?

C有手段达到汇编的效率,你汇编能能达到高级语言的简洁,明晰吗?

我并不是反对汇编,而是要接受新的事物,要兼容并蓄,该用什么用什么,要发挥各自的长处.

当年没有高级语言的时候,我们不得不用汇编,可是现在有条件了,为什么不解放自己?

一个程序,不是运行快了就是好程序,好维护,可修改,可剪裁,别人好理解,这也是好程序的标准,

  现在已经不是玩技巧的时代了,已经没有代码英雄了,吴晓军,鲍岳桥,求伯君再也不会有了,有的只是代码工人

  要说技巧,效率,还是早期的电脑英雄们伟大,Steve Wozniak 为 APPLEII写的DOS3.3 操作系统才12K,比尔盖茨写的BASIC解释语言才4K,
其实汇编我已经玩了20年了,该放弃还是要放弃的...

  问一下,还有人知道1/2轨,3/4轨,螺旋轨吗?

zhxzhx · 发表于 2009-8-31 00:00:47

求伯君,陈榕,严援朝,梁肇新,鲍岳桥,吴晓军,朱崇君,吴涛

广州还有个人,叫什么忘了,开了一个公司叫天河电脑,APPLE 解密很厉害,当时流行他的一个手抄本(蜡纸刻的),可惜后来因为走私电脑进去了,就没有消息了

TMD 现在APPLE 只记得一个Call-151了,还是回忆半天想起来的!

Appcat · 发表于 2009-8-31 00:14:06

先膜拜一下楼上提到的各位前辈！
1/2轨,3/4轨,螺旋轨，软磁盘加密技术吧。

AppleII还是小学接触的，基本忘记光光了，程序存在砖头录音机的磁带里边的。

zhxzhx · 发表于 2009-8-31 00:21:15

还真有没睡的啊!

都是APPle 的加密技术,那对硬件控制的才叫彻底啊

qianhng · 发表于 2009-8-31 01:36:19

我晕，我都不想跟你打口水仗了，你还不依不饶了，想不理你都不行啊。是不是程序效率上比不过就老羞成怒乱扣帽子啊。下面一句句反驳你：

你说：“汇编程序效率最高是对的,但C的效率也不是很差,不能应为这一点而拒绝C语言,如果有的学生因为看了你的结论,而不去学习高级语言了,这不是误人子弟吗? ”
我在【172楼】说过：“晕，居然说"C语言不比汇编效率低",不知道说什么好！”及“说C开发速度快我还是认同的，但实际上决定一个程序的效率的，还是程序员的思路，而C限制了不少提高效率的方法的使用”
我的结论只是说C效率不高（为了支持C让我歪曲事实我办不到，那是学术骗子干的），并没有说C不可用，没有让大家“拒绝C语言”。进一步来说，难道学了汇编就是被误了吗？

你说：“现在的项目还有多少是汇编完成的?现在还有多少处理器不支持高级语言?”
难道有了飞机你就不走路了？你认为汇编语言比高级语言差，要是这样想就不对了，不同的语言用在不同的场合，见你的【205楼】：“毕竟效率是汇编的长处”你没说到的还有时序等问题，这些都是你无法否认的，你自己都要在程序里添加汇编代码，凭什么让别人不学汇编？

你为什么就认为“C有手段达到汇编的效率,你汇编能能达到高级语言的简洁,明晰吗?”
你的提高效率的手段就是在C里镶嵌汇编，而且镶嵌的汇编晦涩难懂、一点都没有做到“简洁,明晰”见你的【203楼】：
#define BUTTON_31_ON() \
{asm("CBR R23,7");}

void main(void)
{while(1)
   {
   asm("SBRC R20,0"); BUTTON_0_ON();
   asm("SBRC R20,1"); BUTTON_1_ON();
读到R23、R20,谁知道是什么呀！
而汇编就“明晰”多了，见我的【178楼】：
SBRC BUTTON_D,BUTTON_31_BIT
RCALL BUTTON_31_ON
RJMP MAIN_LOOP

BUTTON_0_ON:
CBR BUTTON_A,1<<BUTTON_0_BIT
RET

你说：“我并不是反对汇编,而是要接受新的事物,要兼容并蓄,该用什么用什么,要发挥各自的长处”
那你凭什么见我说汇编效率高就说我误人子弟？你【176楼】“说C语言效率低的,好好研究研究C再发表议论,不要误人子弟! ”

你说：“当年没有高级语言的时候,我们不得不用汇编,可是现在有条件了,为什么不解放自己?”
你自己都在C里镶嵌汇编，凭什么让别人“解放自己”不用汇编？

你说：“一个程序,不是运行快了就是好程序,好维护,可修改,可剪裁,别人好理解,这也是好程序的标准,”
这点没错，但这并不是你说我“误人子弟”的证据，无论C还是汇编，都是可以写得晦涩难懂的：比如C里，要是你所有变量都起名i0,i1,i2,i3,i4......，所有子程序都起名proc1,proc2,proc3.......结果大家还是很难读你的程序。即使是汇编，别象你老是R20,R21那样，给变量一个有意义的名字，给子程序一个恰当的名字，加上合适的注释，读起来一样很轻松。你的汇编程序难读是因为你把精力放C了，汇编水平......

你说：“现在已经不是玩技巧的时代了,已经没有代码英雄了,吴晓军,鲍岳桥,求伯君再也不会有了,有的只是代码工人”
那大家别学单片机语言算了、写代码的都是工人了！

你说：“要说技巧,效率,还是早期的电脑英雄们伟大,Steve Wozniak 为 APPLEII写的DOS3.3 操作系统才12K,比尔盖茨写的BASIC解释语言才4K,
其实汇编我已经玩了20年了,该放弃还是要放弃的...”
没有汇编的基础，你今天怎么样还不好说！

你说：“问一下,还有人知道1/2轨,3/4轨,螺旋轨吗? ”
这个我真不知道，你可以给大家讲讲，看看这是否和“误人子弟”是否有关。

zhxzhx · 发表于 2009-8-31 02:24:52

你还没睡觉啊!

  这个程序,本身就是一个抬杠的程序,如果大家来开发一个操作系统,你说是C的明晰,还是汇编的明晰.

  我有很长时间使用汇编在北工大的STD系统下开发程序,是很痛苦的经历,主要是一些工程量的计算,用汇编完成一些浮点的开方,三角函数的计算,光算法就头大,当时干了3个多月,才把几个公式计算下来,过后移植到PC机,才4天就完事了.

  我也不和你抬杠了,爱用什么用什么吧.

  1/2轨,3/4轨,螺旋轨都是APPLE的磁盘加密技术,是我当年钻的牛角尖,浪费了我很多精力,现在一文不值了,当时就是没有把握住技术的发展方向.想到他主要是感到学习一定要把握技术的主流,不是先进的东西就必定在市场上就有生命力的,比如DEC 的alpha 处理器好象叫21064,IBM powerpc 现在谁还在使用,VMS 谁还使用?OS/2谁还在使用?我在这些东西上浪费的精力海了去了,现在都是垃圾了.

  汇编要学,但不能过分的钻牛角尖,高级语言一定要学,并且要精通,这才是将来吃饭的工具.

CRCTABL:LDI    XH,$01
      CLR    XL
      CLR    R16
      LDI    R17,$05
      LDI    R18,$80
CRCT0:  LDI    R19,8
      CLR    R14
      CLR    R15
CRCTT1: LSL    R14
      ROL    R15
      ROL    R16
      BRCC    T2
      EOR    R14,R17
      EOR    R15,R18
CRCTT2: DEC          R19
      BRNE    CRCT1
      ST          X+,R14
      ST          X+,R15
      INC    R16
      BRNE CRCT0
      RET

看看这段代码完成了什么功能.

qianhng · 发表于 2009-8-31 08:28:11

CRCTABL:LDI  XH,$01
      CLR  XL
      CLR  R16
      LDI  R17,$05
      LDI  R18,$80
CRCT0:  LDI  R19,8
      CLR  R14
      CLR  R15
CRCTT1: LSL  R14
      ROL  R15
      ROL  R16
      BRCC  T2
      EOR  R14,R17
      EOR  R15,R18
CRCTT2: DEC          R19
      BRNE  CRCT1
      ST          X+,R14
      ST          X+,R15
      INC  R16
      BRNE CRCT0
      RET

首先“       BRCC  T2 ”没找到T2这个标号，估计是CRCTT2,就当它是CRCTT2

从你程序的标号来看，这很像是冗余校验码表生成函数，$8005像是CRC16的生成多项式：11000000000000101
从这两点看，是为CRC16查表作准备用的。
程序的可读性一般，我觉得这样写可读性比较好（当然本人水平有限）：

首先，在数据段应该
.DATA
CRC16_TABLE:
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
      .DW 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
其次在代码段
;----------------------------------------------------------------------------
CRC16_TABLE_GEN: ;CRC16表生成子程序
.EQU CRC16_GEN_POLY = $8005
      LDI  XH,HIGH（CRC16_TABLE）
      LDI  XL,  LOW(CRC16_TABLE)
      CLR  R16
      LDI  R17,LOW(CRC16_GEN_POLY)
      LDI  R18,HIGH(CRC16_GEN_POLY)
CRC16_TABLE_GEN_FOR_BYTES_LOOP: ;循环生成表码
      LDI  R19,8
      CLR  R14
      CLR  R15
CRC16_TABLE_GEN_EACH_BYTE_LOOP: ;每字节的循环
      LSL  R14
      ROL  R15
      ROL  R16
      BRCC  CRC16_TABLE_GEN_BIT_ZERO ;非1则转
      EOR  R14,R17
      EOR  R15,R18
CRC16_TABLE_GEN_BIT_ZERO:
   DEC          R19
      BRNE  CRC16_TABLE_GEN_EACH_BYTE_LOOP ;每字节的循环结束判断
      ST          X+,R14
      ST          X+,R15
      INC  R16
      BRNE CRC16_TABLE_GEN_FOR_BYTES_LOOP ;是否生成完毕
      RET

zhxzhx · 发表于 2009-8-31 09:38:38

你还真行,table是故意拿掉的,标号想改,后来合计合计算了,就没改.

这个是计算DS18b20的CRC校验的码表的程序

再来一段C语言的

unsigned int CRC16(unsigned char * pSendBuf, unsigned int nEnd)/*获得校验码 */
{unsigned int i,j;
unsigned int  wCrc = (unsigned int)(0xFFFF);
for(i=0; i<nEnd; i++)
  {wCrc ^= (unsigned int)((unsigned char)(pSendBuf));
for(j=0; j<8; j++)
   {if(wCrc & 1)
      {wCrc >>= 1;
      wCrc ^= 0xA001;
      }
   else
      {wCrc >>= 1;}
   }
  }
return wCrc;
}

qianhng · 发表于 2009-8-31 09:53:38

其实，无论哪种语言，只要注释得当，都是易读的，假如C程序像下面那样，也是很难读懂的：
unsigned int proc1(unsigned char * p1, unsigned int i1)
{unsigned int i,j;
unsigned int  i2 = (unsigned int)(0xFFFF);
for(i=0; i<i1; i++)
  {i2 ^= (unsigned int)((unsigned char)(p1));
for(j=0; j<8; j++)
   {if(i2 & 1)
      {i2 >>= 1;
      i2 ^= 0xA001;
      }
   else
      {i2 >>= 1;}
   }
  }
return i2;
}

zhxzhx · 发表于 2009-8-31 10:28:28

我才明白你的意思,我和你讨论的不是那个语言的问题,我说的是技术导向的问题,

以我自己为例:
在学生时代,我处在APPLE 和PC的选择中,当时选择了APPLE去发展,APPLE多好啊,便宜,灵活,灵活到你可以直接控制磁盘步进电机的每个相的时序,控制磁头的写入电流,改变写入的编码,于是就出现了我上面说的加密方法,PC机就死板多了.我于是就开始玩APPLE,最高成绩是为APPLE开发了一套软汉字系统,当时APPLE的仓颉汉卡太贵了,这套系统卖给了一个学校,收入500元,买了一个APPLE,更加深入的研究,等抬起头的时候,天已经变了.
第二次选择,这回一定要先进的,于是看好了DEC的alpha,64位的 RISC 微处理器啊,PC现在才走到64位,于是研究VMS操作系统,结果那,DEC倒闭了.
第三次选择,我还是唯技术论,看好了IBM的OS2,真好,稳定,实时性强,windows简直是垃圾里的垃圾,可是他就是没有干过垃圾,现在windows简直是铺天盖地了.
第四次,不选择了,什么通用来什么吧,玩玩单片机,挣点小钱,什么有的多就用什么,推销产品都不用多费口舌,对方明白一点啊,马上装明白人,我就省劲了.

qianhng · 发表于 2009-8-31 10:50:38

我觉得搞技术最好的出路是有自己的拳头产品而不是给别人打工，打工只不过是个赚生活费并提高自己技术的过程，不是出路。
而自己的拳头产品不一定要是多高的技术含量，只要有足够的性价比和足够的市场需求就可以了，跟着潮流转对搞技术来说不一定是好事。
不过惭愧的是，我没有任何拿得出手的设计，我还在打工中（职业不是电子）。

zhxzhx · 发表于 2009-8-31 11:06:41

现在,我做电力保护设备

  上面的经历,是我年轻时走过的,毕竟,很多人是要去打工的

  自己的拳头产品是很难形成的,毕竟别人也没有闲着.

  跟着潮流转对搞技术来说不一定是好事,是不是好事,可你不跟不行,单片机还好点,你看应用软件市场,那个不是潮流在主导,

  我姥姥有一句话,我现在体会颇深----干活不由东,累死也无功

sxndwg · 发表于 2009-8-31 13:04:25

我个人观点是：对于初学者学习C比较容易，更容易入门。在开发应用中根据需要选择使用什么语言。我比较喜欢C和汇编混合起来用。

micintavr · 发表于 2009-9-5 17:23:40

老贴了，上次论坛资料被毁以前我就看过，现在还在呢！

gxy508 · 发表于 2009-9-8 10:43:10

这个贴上高手真多

yaojinhao · 发表于 2009-9-8 17:18:46

太多了，看得头晕晕的

在盖一楼

让后面的更晕 O(∩_∩)O~

Stillness · 发表于 2009-9-10 11:59:14

220楼，不同意你观点。个人认为：混编的人都是在炫耀。其实根本没有多大意义！

xiongtoto · 发表于 2009-10-10 14:06:36

eric_wang · 发表于 2009-10-12 18:17:28

Mark

hkap · 发表于 2009-10-24 10:05:51

这个贴横跨4年，够经典！

modelfly · 发表于 2009-10-24 13:43:39

也来说说我的感觉吧，仅仅是我的个人感受，请勿对号入座。

看到坛中很多朋友，在和不良的老板战斗，应该都是兼职吧，小弟也做过几个兼职项目，但是后来也都放弃了，为什么呢？太花精力了。

不知道有的朋友兼职的出发点是什么？赚外快，还是提高自己。

如果答案是后者，那么最好的方法是寻找并加入一个开源团队。

如果答案是赚外快的话，对我个人而言，用这些时间学习更新自己行业的知识，更划算。这样我在单位的提升待遇都会快速提高；这就好比挣当下的现金和投资未来。那一种更好呢？

mrf245 · 发表于 2009-10-24 15:42:03

这个帖子一定要顶，以前看过受益匪浅

ygr205217 · 发表于 2009-11-10 13:40:00

我顶！！
LZ的砖好样的，咋拍的啊？

yzlyear · 发表于 2009-11-10 14:00:29

記號，有時間慢慢看

aaron96031 · 发表于 2009-11-10 14:10:24

这个帖确实让很多同行者所关注，用 ASM 也好，C 也好， PIC或HYNIX/EMC/SONIX/AVR 也好。JTAG, 还是 D-WIRE ,isp调试，其实都是方便自己开发调试，至于喜欢用哪种方法实现，全靠自己当时手上的开发工具了。

guokw · 发表于 2009-11-12 15:40:38

强贴呀,大家继续讨论

mrightt · 发表于 2009-11-12 17:19:37

lz是高手，我学习了

AVR-GCC · 发表于 2009-11-12 19:31:58

lloovve · 发表于 2009-11-12 20:00:36

顶一个

tianwei · 发表于 2009-11-12 21:42:34

赶快做个记号收藏，呵呵

henangongda · 发表于 2009-11-14 10:47:15

强！学习啦

robustman · 发表于 2009-11-14 14:37:12

用汇编纯粹是炫耀，正如很多人说的纯手工打造。数年后你会为此感到好笑。

robustman · 发表于 2009-11-14 14:46:32

有时候您觉得速度很要命吗？想象协和客机是怎么死的你就该明白些什么。

qianhng · 发表于 2009-11-14 16:50:58

【239楼】 robustman
积分：60
派别：
等级：------
来自：
用汇编纯粹是炫耀，正如很多人说的纯手工打造。数年后你会为此感到好笑。
===================================================================
robustman的C可以让单片机干任何事，只要robustman来了，汇编避让！
只要robustman来了，mcu都不敢跑二进制码，只能跑C源程序。

st8051 · 发表于 2009-11-14 21:13:05

协和客机怎么死的？都是汇编害死的？

qianhng · 发表于 2009-11-14 21:24:22

估计协和客机上的芯片没跑C源程序，所以羞死的。

king_0102 · 发表于 2009-11-15 14:21:12

赶紧收藏占位

谢谢各位狂人啊

rocky.ra · 发表于 2009-11-15 17:55:37

在EEPROM中放炸_弹是不安全的。我曾经使用电压冲击法，很容易使EEPROM清空！汗...

lqzh1872 · 发表于 2009-11-17 11:48:21

学习了，我觉得要写个免责声明就好了，现在都流行这个,反正爱用不用，是他的自由。不交钱就不能用，农民工工资都不能拖呢？

gmolzc · 发表于 2009-12-4 22:18:53

强帖，顶下，听大虾们的计论，还好本人汇编和C都会点！

lucky4325 · 发表于 2010-1-6 19:25:45

个人觉得，单片机一定得会汇编，但不一定要用汇编编程。汇编有助于我们了解内部结构！
对于开发，我觉得还是用C语言，必要时小嵌汇编！
学了51，avr，arm7，cortex-m3；我都会去熟悉它的汇编，并写一些汇编程序；当然，在开发时还是用C语言！
本人还是在校大学生，有什么说得不对的地方，请见谅！！

wang_xm · 发表于 2010-1-29 17:33:28

高桌子低板凳都是木头，他大9他29都是他9

mslei · 发表于 2010-1-30 13:09:27

标记

ringan865 · 发表于 2010-2-2 21:06:53

唉，花了一个多小时看完，不得不顶一下

avrstm32 · 发表于 2010-2-2 21:28:12

学习了。

a13736925316 · 发表于 2010-2-7 22:06:06

好！

fshunj · 发表于 2010-2-8 00:46:52

这贴实在厉害，本人_大一刚自学C语言，在学51单片机学习板…看来以后还是要学学汇编，但是汇编实在麻烦，不知道学好汇编后以后是否真的有用，你们说的Os是什么意思？是不是要用好OS则要有好的汇编基础？

fshunj · 发表于 2010-2-8 00:48:30

这贴实在厉害，本人_大一刚自学C语言，在学51单片机学习板…看来以后还是要学学汇编，但是汇编实在麻烦，不知道学好汇编后以后是否真的有用，前面几位大虾讨论“误人子弟”那些看得我一头雾水，你们说的Os是什么意思？是不是要用好OS则要有好的汇编基础？

TBN1 · 发表于 2010-2-8 09:12:43

怎么说呢，在嵌入式里面，精通C是比熟悉汇编还要难的。

现在编译器这么发达，有时候优化编译以后，比你写出的汇编都要小。

C语言灵活，开发时间短，代码可以复用。

但是C本身很多时候有副作用（SIDE EFFECT），所以才有MISRA C的出现。因为很多人吃过亏了，因此导致大规模的产品召回都发生过。所以，熟悉C，熟悉编译器是非常重要的。

有两本书不可不看，一本是《C陷阱与缺陷》，一本是《C专家编程》，如果想进一步在嵌入C作为职业前途的话，MISRAC规范不可不看

aydali · 发表于 2010-2-8 13:35:58

：
其实不论是C还是汇编，所谓精通，就是能理解到每一段代码甚至每一个指令在MCU内核中是怎么被执行的，只有如此，才会开发出超一流的产品。
所以，从这个要求来说，精通C更难一些。

avr-arm · 发表于 2010-2-24 05:20:34

汇编也不能不会的，对于玩操作系统的汇编与C同样重要，在这只代表在程序操作上
关于速度上，速度要求高的不得不用汇编的再用，别拿汇编炫耀，如果要求处理一个1兆的信号，足可以秒杀所有单片机，高速信号处理是FPGA的天下，不是汇编所能行的

wugaohui04 · 发表于 2010-2-24 08:08:18

目前还没用到！到时候慢慢看！！！

zdaly · 发表于 2010-4-3 15:04:36

需要学习啊！mark！

yangyi · 发表于 2010-4-3 15:18:41

ADuC系列的谁知道能解密吗?

ascetic_mcu · 发表于 2010-4-5 12:44:33

Study!

renjun861214 · 发表于 2010-4-19 17:32:08

楼主为什么说用C写超过30K就已经很大了呢？
很多程序都是七八十K的哦

moon0213 · 发表于 2010-4-19 23:42:39

好贴！

chen3bing · 发表于 2010-4-20 08:46:47

好贴！

myyule · 发表于 2010-4-20 09:47:12

赶紧收藏占位

谢谢各位狂人啊

mrf245 · 发表于 2010-4-20 12:07:26

求助一个问题！AVR M8 M16等片子，加密之后，加密位可以直接用ponyprog软件擦掉，也就是说加密位形同虚设，请问要如何处理？？？？？？？

sailfish · 发表于 2010-5-5 23:31:31

哈哈有意思学习。。。

sophy.lin · 发表于 2010-5-29 16:57:59

觉得LZ的很多观点都完全只是个人之见，
富士康怎么就五百强了呢

sunpei0337115 · 发表于 2010-5-29 21:10:47

牛啊！学习

wukaka · 发表于 2010-5-30 21:26:26

呵呵，这招好！学习了

guangan854214 · 发表于 2010-5-31 13:48:34

学习了

AVRookie · 发表于 2010-6-9 15:44:34

mark 好帖

millwood0 · 发表于 2010-6-10 05:23:12

for the 8-bit market, Microchips / PIC have the largest market share. somewhere in the 2/3 - 3/4 territory, in terms of shipment.

51 has the mostly implementation, supposedly, because of its long history.

AVR has a tiny market.

It is not fair to compare the 32-bit mcus against 8-bit mcus.

htgyhgj · 发表于 2010-6-10 09:44:45

学习了！记号！

fickle · 发表于 2010-6-10 11:56:00

忍不住说几句，也许话不中听。

看得出来，楼主是位有经验51使用者。但是，我要说，也许楼主抱着open的心态，多看看dsp，arm之类，花时间学习c语言，或者多出去
走走。也许，不会说出那些话。

ball648500361 · 发表于 2010-6-10 14:16:05

mark

joing2000 · 发表于 2010-6-10 15:04:42

强帖留名！！！

lhb335 · 发表于 2010-6-15 10:06:01

用了一段时间的mega8，总体感觉不错，但eeprom可真是鸡肋，坛子里也讨论了很多办法，不过只做到了比以前好点，而不是完全杜绝数据丢失问题。

lhb335 · 发表于 2010-6-15 10:10:44

这位朋友用汇编，但也不至于看不到C/C++的优点吧，钻牛角尖的态度可不是很好，C也可以写出实时性很好的产品，按照你的说法，这个就看你水平够不够了。
多人开发，大的项目，综合评价下来，C的优势毋庸置疑。

superyongzhe · 发表于 2010-6-15 14:09:05

路过留声！！

zhangyunfu · 发表于 2010-6-15 17:38:43

要说合算还是ARM，用51的改换avr可能不值，现在51也有一些速度和其他功能接近的芯片，价格也不便宜。

thx0925 · 发表于 2010-8-29 10:32:44

我现在接手别人做的一个项目，CPU用的是ATmega32，程序都是汇编写的。我现在要改他的程序，增加几路AD采集，增加个RS422通信。以前一直用C语言做TI的DSP编程，现在很头疼，不知道从何下手。各位高人给我指点指点，我从哪里学习，或者推荐一些资料。很急！！

AVR125 · 发表于 2010-9-3 09:39:42

学的是技术，比的是技术之外！
大大受益！

wnstony · 发表于 2010-9-3 23:10:16

mark

forever37 · 发表于 2010-9-3 23:34:40

顶一下慢慢学习。呵呵

myqiang1990 · 发表于 2010-9-4 03:05:01

挖坟啊。。。我也挖挖。。挖挖更健康

backup · 发表于 2010-9-4 08:07:17

回复【5楼】JAMESKING
-----------------------------------------------------------------------

逻辑炸_弹学习啦，哈哈！

facat · 发表于 2010-9-4 13:18:37

其实汇编也不难，把指令多看看就行了。

chaled · 发表于 2010-9-4 16:55:28

mark

longriver05 · 发表于 2010-9-8 10:36:59

那个逻辑炸_弹挺有意思的，楼主也是湘潭的啊

xtaens · 发表于 2010-9-30 21:03:58

这个帖子从05年10月到现在还在讨论，估计15年都论不完

太精彩了，有时间就那来看看，谢谢楼主和给位大侠了

avr-job · 发表于 2010-10-1 17:38:49

mark

d20062303732 · 发表于 2010-10-14 11:31:29

回复【5楼】JAMESKING
楼上的，放逻辑炸_弹也是实在没办法的事情，原来做项目时，个别人总是用了我的设备，用好了，质量保证金10%就不付给我了，催了好几年，实在没办法了，给了一点，后来痛下决心，内部没有eeprom的mcu一概不用，编一个定时程序放在eeprom里面，用实时时钟控制，到了时间还不付钱钱，对不起，程序锁死，不能使用，变成一堆废铁，款子打到我的帐上了，电话通知密码，一切ok。
-----------------------------------------------------------------------

这个我之前想过！我认为是我异想天开！原来真有这种方法！

ringan865 · 发表于 2010-10-14 20:21:26

mark

tom_2_2 · 发表于 2010-10-16 16:04:05

没必要全用汇编写！至少像按键扫描的程序人机接口的地方，就用不着考虑实时性要求了吧，难道人手的按键速度可以达到微妙级别！？如果楼主没有系统学习和使用过C语言的话建议用一下！C语言移植性太强了，最近由于烧掉AVR芯片(可能死锁了，没解锁成功！)，把原来在AVR里跑的程序稍微改一下几个芯片外设的不同的地方，轻松移植到STC单片机中，其中的加减乘除的算法全是拷贝过去的！呵呵。。。简直是秒杀！
另外C语言的效率很高，可以完全应对大多的实时性要求！

qianhng · 发表于 2010-10-16 17:22:14

回复【297楼】tom_2_2
没必要全用汇编写！至少像按键扫描的程序人机接口的地方，就用不着考虑实时性要求了吧，难道人手的按键速度可以达到微妙级别！？如果楼主没有系统学习和使用过c语言的话建议用一下！c语言移植性太强了，最近由于烧掉avr芯片(可能死锁了，没解锁成功！)，把原来在avr里跑的程序稍微改一下几个芯片外设的不同的地方，轻松移植到stc单片机中，其中的加减乘除的算法全是拷贝过去的！呵呵。。。简直是秒杀！
另外c语言的效率很高，可以完全应对大多的实时性要求！
-----------------------------------------------------------------------

看来，tom_2_2 是个高手，你设想用纯C开发一个USBASP试试？！
http://www.ourdev.cn/bbs/bbs_content.jsp?bbs_sn=3702311&bbs_page_no=1&search_mode=1&search_text=usb&bbs_id=1000

又：嘿嘿，没看清楚，刚才把“没必要全用汇编写！”看成“没必要用汇编写！”了！

03024003 · 发表于 2010-12-30 09:05:44