1 ;-------------------------------------------------------- 2 ; File Created by SDCC : free open source ANSI-C Compiler 3 ; Version 3.0.0 #6037 (Oct 31 2010) (Linux) 4 ; This file was generated Fri Mar 2 02:38:16 2012 5 ;-------------------------------------------------------- 6 .module test_spi_can 7 .optsdcc -mmcs51 --model-medium 8 9 ;-------------------------------------------------------- 10 ; Public variables in this module 11 ;-------------------------------------------------------- 12 .globl _param_report_period_ms 13 .globl _param_bar_graph 14 .globl _param_input_mode 15 .globl _main 16 .globl _sendReportIfNeeded 17 .globl _updateLeds 18 .globl _read_can_reg 19 .globl _read_rxbuf0 20 .globl _load_can_txbuf2 21 .globl _load_can_txbuf1 22 .globl _load_can_txbuf0 23 .globl _txdata 24 .globl _rxdata 25 .globl _txdata2 26 .globl _report 27 .globl _write_can_reg_PARM_2 28 .globl _msg2 29 .globl _reportBytesSent 30 .globl _reportLength 31 .globl _Can_init 32 .globl _Can_setnormalmode 33 .globl _Can_setconfigmode 34 .globl _Can_reset 35 .globl _read_can_reg 36 .globl _write_can_reg 37 .globl _buf0ovfbuf1 38 .globl _setmask0 39 .globl _setrxfil0 40 .globl _setrxfil1 41 .globl _set_Can_baudrate 42 .globl _send_Canmsg_wait 43 .globl _get_Canmsg 44 .globl _rxbuf0_full 45 .globl _testfun 46 .globl _putchar 47 ;-------------------------------------------------------- 48 ; special function registers 49 ;-------------------------------------------------------- 50 .area RSEG (ABS,DATA) 0000 51 .org 0x0000 0080 52 Ftest_spi_can$P0$0$0 == 0x0080 0080 53 _P0 = 0x0080 0081 54 Ftest_spi_can$SP$0$0 == 0x0081 0081 55 _SP = 0x0081 0082 56 Ftest_spi_can$DPL0$0$0 == 0x0082 0082 57 _DPL0 = 0x0082 0083 58 Ftest_spi_can$DPH0$0$0 == 0x0083 0083 59 _DPH0 = 0x0083 0084 60 Ftest_spi_can$DPL1$0$0 == 0x0084 0084 61 _DPL1 = 0x0084 0085 62 Ftest_spi_can$DPH1$0$0 == 0x0085 0085 63 _DPH1 = 0x0085 0086 64 Ftest_spi_can$U0CSR$0$0 == 0x0086 0086 65 _U0CSR = 0x0086 0087 66 Ftest_spi_can$PCON$0$0 == 0x0087 0087 67 _PCON = 0x0087 0088 68 Ftest_spi_can$TCON$0$0 == 0x0088 0088 69 _TCON = 0x0088 0089 70 Ftest_spi_can$P0IFG$0$0 == 0x0089 0089 71 _P0IFG = 0x0089 008A 72 Ftest_spi_can$P1IFG$0$0 == 0x008a 008A 73 _P1IFG = 0x008a 008B 74 Ftest_spi_can$P2IFG$0$0 == 0x008b 008B 75 _P2IFG = 0x008b 008C 76 Ftest_spi_can$PICTL$0$0 == 0x008c 008C 77 _PICTL = 0x008c 008D 78 Ftest_spi_can$P1IEN$0$0 == 0x008d 008D 79 _P1IEN = 0x008d 008F 80 Ftest_spi_can$P0INP$0$0 == 0x008f 008F 81 _P0INP = 0x008f 0090 82 Ftest_spi_can$P1$0$0 == 0x0090 0090 83 _P1 = 0x0090 0091 84 Ftest_spi_can$RFIM$0$0 == 0x0091 0091 85 _RFIM = 0x0091 0092 86 Ftest_spi_can$DPS$0$0 == 0x0092 0092 87 _DPS = 0x0092 0093 88 Ftest_spi_can$MPAGE$0$0 == 0x0093 0093 89 _MPAGE = 0x0093 0095 90 Ftest_spi_can$ENDIAN$0$0 == 0x0095 0095 91 _ENDIAN = 0x0095 0098 92 Ftest_spi_can$S0CON$0$0 == 0x0098 0098 93 _S0CON = 0x0098 009A 94 Ftest_spi_can$IEN2$0$0 == 0x009a 009A 95 _IEN2 = 0x009a 009B 96 Ftest_spi_can$S1CON$0$0 == 0x009b 009B 97 _S1CON = 0x009b 009C 98 Ftest_spi_can$T2CT$0$0 == 0x009c 009C 99 _T2CT = 0x009c 009D 100 Ftest_spi_can$T2PR$0$0 == 0x009d 009D 101 _T2PR = 0x009d 009E 102 Ftest_spi_can$T2CTL$0$0 == 0x009e 009E 103 _T2CTL = 0x009e 00A0 104 Ftest_spi_can$P2$0$0 == 0x00a0 00A0 105 _P2 = 0x00a0 00A1 106 Ftest_spi_can$WORIRQ$0$0 == 0x00a1 00A1 107 _WORIRQ = 0x00a1 00A2 108 Ftest_spi_can$WORCTRL$0$0 == 0x00a2 00A2 109 _WORCTRL = 0x00a2 00A3 110 Ftest_spi_can$WOREVT0$0$0 == 0x00a3 00A3 111 _WOREVT0 = 0x00a3 00A4 112 Ftest_spi_can$WOREVT1$0$0 == 0x00a4 00A4 113 _WOREVT1 = 0x00a4 00A5 114 Ftest_spi_can$WORTIME0$0$0 == 0x00a5 00A5 115 _WORTIME0 = 0x00a5 00A6 116 Ftest_spi_can$WORTIME1$0$0 == 0x00a6 00A6 117 _WORTIME1 = 0x00a6 00A8 118 Ftest_spi_can$IEN0$0$0 == 0x00a8 00A8 119 _IEN0 = 0x00a8 00A9 120 Ftest_spi_can$IP0$0$0 == 0x00a9 00A9 121 _IP0 = 0x00a9 00AB 122 Ftest_spi_can$FWT$0$0 == 0x00ab 00AB 123 _FWT = 0x00ab 00AC 124 Ftest_spi_can$FADDRL$0$0 == 0x00ac 00AC 125 _FADDRL = 0x00ac 00AD 126 Ftest_spi_can$FADDRH$0$0 == 0x00ad 00AD 127 _FADDRH = 0x00ad 00AE 128 Ftest_spi_can$FCTL$0$0 == 0x00ae 00AE 129 _FCTL = 0x00ae 00AF 130 Ftest_spi_can$FWDATA$0$0 == 0x00af 00AF 131 _FWDATA = 0x00af 00B1 132 Ftest_spi_can$ENCDI$0$0 == 0x00b1 00B1 133 _ENCDI = 0x00b1 00B2 134 Ftest_spi_can$ENCDO$0$0 == 0x00b2 00B2 135 _ENCDO = 0x00b2 00B3 136 Ftest_spi_can$ENCCS$0$0 == 0x00b3 00B3 137 _ENCCS = 0x00b3 00B4 138 Ftest_spi_can$ADCCON1$0$0 == 0x00b4 00B4 139 _ADCCON1 = 0x00b4 00B5 140 Ftest_spi_can$ADCCON2$0$0 == 0x00b5 00B5 141 _ADCCON2 = 0x00b5 00B6 142 Ftest_spi_can$ADCCON3$0$0 == 0x00b6 00B6 143 _ADCCON3 = 0x00b6 00B8 144 Ftest_spi_can$IEN1$0$0 == 0x00b8 00B8 145 _IEN1 = 0x00b8 00B9 146 Ftest_spi_can$IP1$0$0 == 0x00b9 00B9 147 _IP1 = 0x00b9 00BA 148 Ftest_spi_can$ADCL$0$0 == 0x00ba 00BA 149 _ADCL = 0x00ba 00BB 150 Ftest_spi_can$ADCH$0$0 == 0x00bb 00BB 151 _ADCH = 0x00bb 00BC 152 Ftest_spi_can$RNDL$0$0 == 0x00bc 00BC 153 _RNDL = 0x00bc 00BD 154 Ftest_spi_can$RNDH$0$0 == 0x00bd 00BD 155 _RNDH = 0x00bd 00BE 156 Ftest_spi_can$SLEEP$0$0 == 0x00be 00BE 157 _SLEEP = 0x00be 00C0 158 Ftest_spi_can$IRCON$0$0 == 0x00c0 00C0 159 _IRCON = 0x00c0 00C1 160 Ftest_spi_can$U0DBUF$0$0 == 0x00c1 00C1 161 _U0DBUF = 0x00c1 00C2 162 Ftest_spi_can$U0BAUD$0$0 == 0x00c2 00C2 163 _U0BAUD = 0x00c2 00C4 164 Ftest_spi_can$U0UCR$0$0 == 0x00c4 00C4 165 _U0UCR = 0x00c4 00C5 166 Ftest_spi_can$U0GCR$0$0 == 0x00c5 00C5 167 _U0GCR = 0x00c5 00C6 168 Ftest_spi_can$CLKCON$0$0 == 0x00c6 00C6 169 _CLKCON = 0x00c6 00C7 170 Ftest_spi_can$MEMCTR$0$0 == 0x00c7 00C7 171 _MEMCTR = 0x00c7 00C9 172 Ftest_spi_can$WDCTL$0$0 == 0x00c9 00C9 173 _WDCTL = 0x00c9 00CA 174 Ftest_spi_can$T3CNT$0$0 == 0x00ca 00CA 175 _T3CNT = 0x00ca 00CB 176 Ftest_spi_can$T3CTL$0$0 == 0x00cb 00CB 177 _T3CTL = 0x00cb 00CC 178 Ftest_spi_can$T3CCTL0$0$0 == 0x00cc 00CC 179 _T3CCTL0 = 0x00cc 00CD 180 Ftest_spi_can$T3CC0$0$0 == 0x00cd 00CD 181 _T3CC0 = 0x00cd 00CE 182 Ftest_spi_can$T3CCTL1$0$0 == 0x00ce 00CE 183 _T3CCTL1 = 0x00ce 00CF 184 Ftest_spi_can$T3CC1$0$0 == 0x00cf 00CF 185 _T3CC1 = 0x00cf 00D0 186 Ftest_spi_can$PSW$0$0 == 0x00d0 00D0 187 _PSW = 0x00d0 00D1 188 Ftest_spi_can$DMAIRQ$0$0 == 0x00d1 00D1 189 _DMAIRQ = 0x00d1 00D2 190 Ftest_spi_can$DMA1CFGL$0$0 == 0x00d2 00D2 191 _DMA1CFGL = 0x00d2 00D3 192 Ftest_spi_can$DMA1CFGH$0$0 == 0x00d3 00D3 193 _DMA1CFGH = 0x00d3 00D4 194 Ftest_spi_can$DMA0CFGL$0$0 == 0x00d4 00D4 195 _DMA0CFGL = 0x00d4 00D5 196 Ftest_spi_can$DMA0CFGH$0$0 == 0x00d5 00D5 197 _DMA0CFGH = 0x00d5 00D6 198 Ftest_spi_can$DMAARM$0$0 == 0x00d6 00D6 199 _DMAARM = 0x00d6 00D7 200 Ftest_spi_can$DMAREQ$0$0 == 0x00d7 00D7 201 _DMAREQ = 0x00d7 00D8 202 Ftest_spi_can$TIMIF$0$0 == 0x00d8 00D8 203 _TIMIF = 0x00d8 00D9 204 Ftest_spi_can$RFD$0$0 == 0x00d9 00D9 205 _RFD = 0x00d9 00DA 206 Ftest_spi_can$T1CC0L$0$0 == 0x00da 00DA 207 _T1CC0L = 0x00da 00DB 208 Ftest_spi_can$T1CC0H$0$0 == 0x00db 00DB 209 _T1CC0H = 0x00db 00DC 210 Ftest_spi_can$T1CC1L$0$0 == 0x00dc 00DC 211 _T1CC1L = 0x00dc 00DD 212 Ftest_spi_can$T1CC1H$0$0 == 0x00dd 00DD 213 _T1CC1H = 0x00dd 00DE 214 Ftest_spi_can$T1CC2L$0$0 == 0x00de 00DE 215 _T1CC2L = 0x00de 00DF 216 Ftest_spi_can$T1CC2H$0$0 == 0x00df 00DF 217 _T1CC2H = 0x00df 00E0 218 Ftest_spi_can$ACC$0$0 == 0x00e0 00E0 219 _ACC = 0x00e0 00E1 220 Ftest_spi_can$RFST$0$0 == 0x00e1 00E1 221 _RFST = 0x00e1 00E2 222 Ftest_spi_can$T1CNTL$0$0 == 0x00e2 00E2 223 _T1CNTL = 0x00e2 00E3 224 Ftest_spi_can$T1CNTH$0$0 == 0x00e3 00E3 225 _T1CNTH = 0x00e3 00E4 226 Ftest_spi_can$T1CTL$0$0 == 0x00e4 00E4 227 _T1CTL = 0x00e4 00E5 228 Ftest_spi_can$T1CCTL0$0$0 == 0x00e5 00E5 229 _T1CCTL0 = 0x00e5 00E6 230 Ftest_spi_can$T1CCTL1$0$0 == 0x00e6 00E6 231 _T1CCTL1 = 0x00e6 00E7 232 Ftest_spi_can$T1CCTL2$0$0 == 0x00e7 00E7 233 _T1CCTL2 = 0x00e7 00E8 234 Ftest_spi_can$IRCON2$0$0 == 0x00e8 00E8 235 _IRCON2 = 0x00e8 00E9 236 Ftest_spi_can$RFIF$0$0 == 0x00e9 00E9 237 _RFIF = 0x00e9 00EA 238 Ftest_spi_can$T4CNT$0$0 == 0x00ea 00EA 239 _T4CNT = 0x00ea 00EB 240 Ftest_spi_can$T4CTL$0$0 == 0x00eb 00EB 241 _T4CTL = 0x00eb 00EC 242 Ftest_spi_can$T4CCTL0$0$0 == 0x00ec 00EC 243 _T4CCTL0 = 0x00ec 00ED 244 Ftest_spi_can$T4CC0$0$0 == 0x00ed 00ED 245 _T4CC0 = 0x00ed 00EE 246 Ftest_spi_can$T4CCTL1$0$0 == 0x00ee 00EE 247 _T4CCTL1 = 0x00ee 00EF 248 Ftest_spi_can$T4CC1$0$0 == 0x00ef 00EF 249 _T4CC1 = 0x00ef 00F0 250 Ftest_spi_can$B$0$0 == 0x00f0 00F0 251 _B = 0x00f0 00F1 252 Ftest_spi_can$PERCFG$0$0 == 0x00f1 00F1 253 _PERCFG = 0x00f1 00F2 254 Ftest_spi_can$ADCCFG$0$0 == 0x00f2 00F2 255 _ADCCFG = 0x00f2 00F3 256 Ftest_spi_can$P0SEL$0$0 == 0x00f3 00F3 257 _P0SEL = 0x00f3 00F4 258 Ftest_spi_can$P1SEL$0$0 == 0x00f4 00F4 259 _P1SEL = 0x00f4 00F5 260 Ftest_spi_can$P2SEL$0$0 == 0x00f5 00F5 261 _P2SEL = 0x00f5 00F6 262 Ftest_spi_can$P1INP$0$0 == 0x00f6 00F6 263 _P1INP = 0x00f6 00F7 264 Ftest_spi_can$P2INP$0$0 == 0x00f7 00F7 265 _P2INP = 0x00f7 00F8 266 Ftest_spi_can$U1CSR$0$0 == 0x00f8 00F8 267 _U1CSR = 0x00f8 00F9 268 Ftest_spi_can$U1DBUF$0$0 == 0x00f9 00F9 269 _U1DBUF = 0x00f9 00FA 270 Ftest_spi_can$U1BAUD$0$0 == 0x00fa 00FA 271 _U1BAUD = 0x00fa 00FB 272 Ftest_spi_can$U1UCR$0$0 == 0x00fb 00FB 273 _U1UCR = 0x00fb 00FC 274 Ftest_spi_can$U1GCR$0$0 == 0x00fc 00FC 275 _U1GCR = 0x00fc 00FD 276 Ftest_spi_can$P0DIR$0$0 == 0x00fd 00FD 277 _P0DIR = 0x00fd 00FE 278 Ftest_spi_can$P1DIR$0$0 == 0x00fe 00FE 279 _P1DIR = 0x00fe 00FF 280 Ftest_spi_can$P2DIR$0$0 == 0x00ff 00FF 281 _P2DIR = 0x00ff FFFFD5D4 282 Ftest_spi_can$DMA0CFG$0$0 == 0xffffd5d4 FFFFD5D4 283 _DMA0CFG = 0xffffd5d4 FFFFD3D2 284 Ftest_spi_can$DMA1CFG$0$0 == 0xffffd3d2 FFFFD3D2 285 _DMA1CFG = 0xffffd3d2 FFFFADAC 286 Ftest_spi_can$FADDR$0$0 == 0xffffadac FFFFADAC 287 _FADDR = 0xffffadac FFFFBBBA 288 Ftest_spi_can$ADC$0$0 == 0xffffbbba FFFFBBBA 289 _ADC = 0xffffbbba FFFFDBDA 290 Ftest_spi_can$T1CC0$0$0 == 0xffffdbda FFFFDBDA 291 _T1CC0 = 0xffffdbda FFFFDDDC 292 Ftest_spi_can$T1CC1$0$0 == 0xffffdddc FFFFDDDC 293 _T1CC1 = 0xffffdddc FFFFDFDE 294 Ftest_spi_can$T1CC2$0$0 == 0xffffdfde FFFFDFDE 295 _T1CC2 = 0xffffdfde 296 ;-------------------------------------------------------- 297 ; special function bits 298 ;-------------------------------------------------------- 299 .area RSEG (ABS,DATA) 0000 300 .org 0x0000 0080 301 Ftest_spi_can$P0_0$0$0 == 0x0080 0080 302 _P0_0 = 0x0080 0081 303 Ftest_spi_can$P0_1$0$0 == 0x0081 0081 304 _P0_1 = 0x0081 0082 305 Ftest_spi_can$P0_2$0$0 == 0x0082 0082 306 _P0_2 = 0x0082 0083 307 Ftest_spi_can$P0_3$0$0 == 0x0083 0083 308 _P0_3 = 0x0083 0084 309 Ftest_spi_can$P0_4$0$0 == 0x0084 0084 310 _P0_4 = 0x0084 0085 311 Ftest_spi_can$P0_5$0$0 == 0x0085 0085 312 _P0_5 = 0x0085 0086 313 Ftest_spi_can$P0_6$0$0 == 0x0086 0086 314 _P0_6 = 0x0086 0087 315 Ftest_spi_can$P0_7$0$0 == 0x0087 0087 316 _P0_7 = 0x0087 0088 317 Ftest_spi_can$_TCON_0$0$0 == 0x0088 0088 318 __TCON_0 = 0x0088 0089 319 Ftest_spi_can$RFTXRXIF$0$0 == 0x0089 0089 320 _RFTXRXIF = 0x0089 008A 321 Ftest_spi_can$_TCON_2$0$0 == 0x008a 008A 322 __TCON_2 = 0x008a 008B 323 Ftest_spi_can$URX0IF$0$0 == 0x008b 008B 324 _URX0IF = 0x008b 008C 325 Ftest_spi_can$_TCON_4$0$0 == 0x008c 008C 326 __TCON_4 = 0x008c 008D 327 Ftest_spi_can$ADCIF$0$0 == 0x008d 008D 328 _ADCIF = 0x008d 008E 329 Ftest_spi_can$_TCON_6$0$0 == 0x008e 008E 330 __TCON_6 = 0x008e 008F 331 Ftest_spi_can$URX1IF$0$0 == 0x008f 008F 332 _URX1IF = 0x008f 0090 333 Ftest_spi_can$P1_0$0$0 == 0x0090 0090 334 _P1_0 = 0x0090 0091 335 Ftest_spi_can$P1_1$0$0 == 0x0091 0091 336 _P1_1 = 0x0091 0092 337 Ftest_spi_can$P1_2$0$0 == 0x0092 0092 338 _P1_2 = 0x0092 0093 339 Ftest_spi_can$P1_3$0$0 == 0x0093 0093 340 _P1_3 = 0x0093 0094 341 Ftest_spi_can$P1_4$0$0 == 0x0094 0094 342 _P1_4 = 0x0094 0095 343 Ftest_spi_can$P1_5$0$0 == 0x0095 0095 344 _P1_5 = 0x0095 0096 345 Ftest_spi_can$P1_6$0$0 == 0x0096 0096 346 _P1_6 = 0x0096 0097 347 Ftest_spi_can$P1_7$0$0 == 0x0097 0097 348 _P1_7 = 0x0097 0098 349 Ftest_spi_can$ENCIF_0$0$0 == 0x0098 0098 350 _ENCIF_0 = 0x0098 0099 351 Ftest_spi_can$ENCIF_1$0$0 == 0x0099 0099 352 _ENCIF_1 = 0x0099 009A 353 Ftest_spi_can$_SOCON2$0$0 == 0x009a 009A 354 __SOCON2 = 0x009a 009B 355 Ftest_spi_can$_SOCON3$0$0 == 0x009b 009B 356 __SOCON3 = 0x009b 009C 357 Ftest_spi_can$_SOCON4$0$0 == 0x009c 009C 358 __SOCON4 = 0x009c 009D 359 Ftest_spi_can$_SOCON5$0$0 == 0x009d 009D 360 __SOCON5 = 0x009d 009E 361 Ftest_spi_can$_SOCON6$0$0 == 0x009e 009E 362 __SOCON6 = 0x009e 009F 363 Ftest_spi_can$_SOCON7$0$0 == 0x009f 009F 364 __SOCON7 = 0x009f 00A0 365 Ftest_spi_can$P2_0$0$0 == 0x00a0 00A0 366 _P2_0 = 0x00a0 00A1 367 Ftest_spi_can$P2_1$0$0 == 0x00a1 00A1 368 _P2_1 = 0x00a1 00A2 369 Ftest_spi_can$P2_2$0$0 == 0x00a2 00A2 370 _P2_2 = 0x00a2 00A3 371 Ftest_spi_can$P2_3$0$0 == 0x00a3 00A3 372 _P2_3 = 0x00a3 00A4 373 Ftest_spi_can$P2_4$0$0 == 0x00a4 00A4 374 _P2_4 = 0x00a4 00A5 375 Ftest_spi_can$P2_5$0$0 == 0x00a5 00A5 376 _P2_5 = 0x00a5 00A6 377 Ftest_spi_can$P2_6$0$0 == 0x00a6 00A6 378 _P2_6 = 0x00a6 00A7 379 Ftest_spi_can$P2_7$0$0 == 0x00a7 00A7 380 _P2_7 = 0x00a7 00A8 381 Ftest_spi_can$RFTXRXIE$0$0 == 0x00a8 00A8 382 _RFTXRXIE = 0x00a8 00A9 383 Ftest_spi_can$ADCIE$0$0 == 0x00a9 00A9 384 _ADCIE = 0x00a9 00AA 385 Ftest_spi_can$URX0IE$0$0 == 0x00aa 00AA 386 _URX0IE = 0x00aa 00AB 387 Ftest_spi_can$URX1IE$0$0 == 0x00ab 00AB 388 _URX1IE = 0x00ab 00AC 389 Ftest_spi_can$ENCIE$0$0 == 0x00ac 00AC 390 _ENCIE = 0x00ac 00AD 391 Ftest_spi_can$STIE$0$0 == 0x00ad 00AD 392 _STIE = 0x00ad 00AE 393 Ftest_spi_can$_IEN06$0$0 == 0x00ae 00AE 394 __IEN06 = 0x00ae 00AF 395 Ftest_spi_can$EA$0$0 == 0x00af 00AF 396 _EA = 0x00af 00B8 397 Ftest_spi_can$DMAIE$0$0 == 0x00b8 00B8 398 _DMAIE = 0x00b8 00B9 399 Ftest_spi_can$T1IE$0$0 == 0x00b9 00B9 400 _T1IE = 0x00b9 00BA 401 Ftest_spi_can$T2IE$0$0 == 0x00ba 00BA 402 _T2IE = 0x00ba 00BB 403 Ftest_spi_can$T3IE$0$0 == 0x00bb 00BB 404 _T3IE = 0x00bb 00BC 405 Ftest_spi_can$T4IE$0$0 == 0x00bc 00BC 406 _T4IE = 0x00bc 00BD 407 Ftest_spi_can$P0IE$0$0 == 0x00bd 00BD 408 _P0IE = 0x00bd 00BE 409 Ftest_spi_can$_IEN16$0$0 == 0x00be 00BE 410 __IEN16 = 0x00be 00BF 411 Ftest_spi_can$_IEN17$0$0 == 0x00bf 00BF 412 __IEN17 = 0x00bf 00C0 413 Ftest_spi_can$DMAIF$0$0 == 0x00c0 00C0 414 _DMAIF = 0x00c0 00C1 415 Ftest_spi_can$T1IF$0$0 == 0x00c1 00C1 416 _T1IF = 0x00c1 00C2 417 Ftest_spi_can$T2IF$0$0 == 0x00c2 00C2 418 _T2IF = 0x00c2 00C3 419 Ftest_spi_can$T3IF$0$0 == 0x00c3 00C3 420 _T3IF = 0x00c3 00C4 421 Ftest_spi_can$T4IF$0$0 == 0x00c4 00C4 422 _T4IF = 0x00c4 00C5 423 Ftest_spi_can$P0IF$0$0 == 0x00c5 00C5 424 _P0IF = 0x00c5 00C6 425 Ftest_spi_can$_IRCON6$0$0 == 0x00c6 00C6 426 __IRCON6 = 0x00c6 00C7 427 Ftest_spi_can$STIF$0$0 == 0x00c7 00C7 428 _STIF = 0x00c7 00D0 429 Ftest_spi_can$P$0$0 == 0x00d0 00D0 430 _P = 0x00d0 00D1 431 Ftest_spi_can$F1$0$0 == 0x00d1 00D1 432 _F1 = 0x00d1 00D2 433 Ftest_spi_can$OV$0$0 == 0x00d2 00D2 434 _OV = 0x00d2 00D3 435 Ftest_spi_can$RS0$0$0 == 0x00d3 00D3 436 _RS0 = 0x00d3 00D4 437 Ftest_spi_can$RS1$0$0 == 0x00d4 00D4 438 _RS1 = 0x00d4 00D5 439 Ftest_spi_can$F0$0$0 == 0x00d5 00D5 440 _F0 = 0x00d5 00D6 441 Ftest_spi_can$AC$0$0 == 0x00d6 00D6 442 _AC = 0x00d6 00D7 443 Ftest_spi_can$CY$0$0 == 0x00d7 00D7 444 _CY = 0x00d7 00D8 445 Ftest_spi_can$T3OVFIF$0$0 == 0x00d8 00D8 446 _T3OVFIF = 0x00d8 00D9 447 Ftest_spi_can$T3CH0IF$0$0 == 0x00d9 00D9 448 _T3CH0IF = 0x00d9 00DA 449 Ftest_spi_can$T3CH1IF$0$0 == 0x00da 00DA 450 _T3CH1IF = 0x00da 00DB 451 Ftest_spi_can$T4OVFIF$0$0 == 0x00db 00DB 452 _T4OVFIF = 0x00db 00DC 453 Ftest_spi_can$T4CH0IF$0$0 == 0x00dc 00DC 454 _T4CH0IF = 0x00dc 00DD 455 Ftest_spi_can$T4CH1IF$0$0 == 0x00dd 00DD 456 _T4CH1IF = 0x00dd 00DE 457 Ftest_spi_can$OVFIM$0$0 == 0x00de 00DE 458 _OVFIM = 0x00de 00DF 459 Ftest_spi_can$_TIMIF7$0$0 == 0x00df 00DF 460 __TIMIF7 = 0x00df 00E0 461 Ftest_spi_can$ACC_0$0$0 == 0x00e0 00E0 462 _ACC_0 = 0x00e0 00E1 463 Ftest_spi_can$ACC_1$0$0 == 0x00e1 00E1 464 _ACC_1 = 0x00e1 00E2 465 Ftest_spi_can$ACC_2$0$0 == 0x00e2 00E2 466 _ACC_2 = 0x00e2 00E3 467 Ftest_spi_can$ACC_3$0$0 == 0x00e3 00E3 468 _ACC_3 = 0x00e3 00E4 469 Ftest_spi_can$ACC_4$0$0 == 0x00e4 00E4 470 _ACC_4 = 0x00e4 00E5 471 Ftest_spi_can$ACC_5$0$0 == 0x00e5 00E5 472 _ACC_5 = 0x00e5 00E6 473 Ftest_spi_can$ACC_6$0$0 == 0x00e6 00E6 474 _ACC_6 = 0x00e6 00E7 475 Ftest_spi_can$ACC_7$0$0 == 0x00e7 00E7 476 _ACC_7 = 0x00e7 00E8 477 Ftest_spi_can$P2IF$0$0 == 0x00e8 00E8 478 _P2IF = 0x00e8 00E9 479 Ftest_spi_can$UTX0IF$0$0 == 0x00e9 00E9 480 _UTX0IF = 0x00e9 00EA 481 Ftest_spi_can$UTX1IF$0$0 == 0x00ea 00EA 482 _UTX1IF = 0x00ea 00EB 483 Ftest_spi_can$P1IF$0$0 == 0x00eb 00EB 484 _P1IF = 0x00eb 00EC 485 Ftest_spi_can$WDTIF$0$0 == 0x00ec 00EC 486 _WDTIF = 0x00ec 00ED 487 Ftest_spi_can$_IRCON25$0$0 == 0x00ed 00ED 488 __IRCON25 = 0x00ed 00EE 489 Ftest_spi_can$_IRCON26$0$0 == 0x00ee 00EE 490 __IRCON26 = 0x00ee 00EF 491 Ftest_spi_can$_IRCON27$0$0 == 0x00ef 00EF 492 __IRCON27 = 0x00ef 00F0 493 Ftest_spi_can$B_0$0$0 == 0x00f0 00F0 494 _B_0 = 0x00f0 00F1 495 Ftest_spi_can$B_1$0$0 == 0x00f1 00F1 496 _B_1 = 0x00f1 00F2 497 Ftest_spi_can$B_2$0$0 == 0x00f2 00F2 498 _B_2 = 0x00f2 00F3 499 Ftest_spi_can$B_3$0$0 == 0x00f3 00F3 500 _B_3 = 0x00f3 00F4 501 Ftest_spi_can$B_4$0$0 == 0x00f4 00F4 502 _B_4 = 0x00f4 00F5 503 Ftest_spi_can$B_5$0$0 == 0x00f5 00F5 504 _B_5 = 0x00f5 00F6 505 Ftest_spi_can$B_6$0$0 == 0x00f6 00F6 506 _B_6 = 0x00f6 00F7 507 Ftest_spi_can$B_7$0$0 == 0x00f7 00F7 508 _B_7 = 0x00f7 00F8 509 Ftest_spi_can$U1ACTIVE$0$0 == 0x00f8 00F8 510 _U1ACTIVE = 0x00f8 00F9 511 Ftest_spi_can$U1TX_BYTE$0$0 == 0x00f9 00F9 512 _U1TX_BYTE = 0x00f9 00FA 513 Ftest_spi_can$U1RX_BYTE$0$0 == 0x00fa 00FA 514 _U1RX_BYTE = 0x00fa 00FB 515 Ftest_spi_can$U1ERR$0$0 == 0x00fb 00FB 516 _U1ERR = 0x00fb 00FC 517 Ftest_spi_can$U1FE$0$0 == 0x00fc 00FC 518 _U1FE = 0x00fc 00FD 519 Ftest_spi_can$U1SLAVE$0$0 == 0x00fd 00FD 520 _U1SLAVE = 0x00fd 00FE 521 Ftest_spi_can$U1RE$0$0 == 0x00fe 00FE 522 _U1RE = 0x00fe 00FF 523 Ftest_spi_can$U1MODE$0$0 == 0x00ff 00FF 524 _U1MODE = 0x00ff 525 ;-------------------------------------------------------- 526 ; overlayable register banks 527 ;-------------------------------------------------------- 528 .area REG_BANK_0 (REL,OVR,DATA) 0000 529 .ds 8 530 ;-------------------------------------------------------- 531 ; overlayable bit register bank 532 ;-------------------------------------------------------- 533 .area BIT_BANK (REL,OVR,DATA) 0000 534 bits: 0000 535 .ds 1 8000 536 b0 = bits[0] 8100 537 b1 = bits[1] 8200 538 b2 = bits[2] 8300 539 b3 = bits[3] 8400 540 b4 = bits[4] 8500 541 b5 = bits[5] 8600 542 b6 = bits[6] 8700 543 b7 = bits[7] 544 ;-------------------------------------------------------- 545 ; internal ram data 546 ;-------------------------------------------------------- 547 .area DSEG (DATA) 0000 548 Lsend_Canmsg_wait$sloc0$1$0==. 0000 549 _send_Canmsg_wait_sloc0_1_0: 0000 550 .ds 2 0002 551 Lget_Canmsg$sloc0$1$0==. 0002 552 _get_Canmsg_sloc0_1_0: 0002 553 .ds 3 0005 554 Lget_Canmsg$sloc1$1$0==. 0005 555 _get_Canmsg_sloc1_1_0: 0005 556 .ds 1 0006 557 Lget_Canmsg$sloc2$1$0==. 0006 558 _get_Canmsg_sloc2_1_0: 0006 559 .ds 1 0007 560 Lget_Canmsg$sloc3$1$0==. 0007 561 _get_Canmsg_sloc3_1_0: 0007 562 .ds 1 0008 563 Lget_Canmsg$sloc4$1$0==. 0008 564 _get_Canmsg_sloc4_1_0: 0008 565 .ds 2 000A 566 Lget_Canmsg$sloc5$1$0==. 000A 567 _get_Canmsg_sloc5_1_0: 000A 568 .ds 3 000D 569 G$reportLength$0$0==. 000D 570 _reportLength:: 000D 571 .ds 2 000F 572 G$reportBytesSent$0$0==. 000F 573 _reportBytesSent:: 000F 574 .ds 2 0011 575 G$msg2$0$0==. 0011 576 _msg2:: 0011 577 .ds 11 001C 578 LsendReportIfNeeded$sloc0$1$0==. 001C 579 _sendReportIfNeeded_sloc0_1_0: 001C 580 .ds 4 0020 581 Lmain$sloc0$1$0==. 0020 582 _main_sloc0_1_0: 0020 583 .ds 4 0024 584 Lmain$sloc1$1$0==. 0024 585 _main_sloc1_1_0: 0024 586 .ds 4 587 ;-------------------------------------------------------- 588 ; overlayable items in internal ram 589 ;-------------------------------------------------------- 590 .area OSEG (OVR,DATA) 591 ;-------------------------------------------------------- 592 ; Stack segment in internal ram 593 ;-------------------------------------------------------- 594 .area SSEG (DATA) 0000 595 __start__stack: 0000 596 .ds 1 597 598 ;-------------------------------------------------------- 599 ; indirectly addressable internal ram data 600 ;-------------------------------------------------------- 601 .area ISEG (DATA) 602 ;-------------------------------------------------------- 603 ; absolute internal ram data 604 ;-------------------------------------------------------- 605 .area IABS (ABS,DATA) 606 .area IABS (ABS,DATA) 607 ;-------------------------------------------------------- 608 ; bit data 609 ;-------------------------------------------------------- 610 .area BSEG (BIT) 611 ;-------------------------------------------------------- 612 ; paged external ram data 613 ;-------------------------------------------------------- 614 .area PSEG (PAG,XDATA) 0000 615 Lwrite_can_reg$val$1$1==. 0000 616 _write_can_reg_PARM_2: 0000 617 .ds 1 0001 618 Lsend_Canmsg_wait$msg$1$1==. 0001 619 _send_Canmsg_wait_msg_1_1: 0001 620 .ds 3 0004 621 Lsend_Canmsg_wait$i$1$1==. 0004 622 _send_Canmsg_wait_i_1_1: 0004 623 .ds 2 0006 624 Lsend_Canmsg_wait$sent$1$1==. 0006 625 _send_Canmsg_wait_sent_1_1: 0006 626 .ds 1 0007 627 Lget_Canmsg$msg$1$1==. 0007 628 _get_Canmsg_msg_1_1: 0007 629 .ds 3 000A 630 LsendReportIfNeeded$lastReport$1$1==. 000A 631 _sendReportIfNeeded_lastReport_1_1: 000A 632 .ds 4 000E 633 LsendReportIfNeeded$result$1$1==. 000E 634 _sendReportIfNeeded_result_1_1: 000E 635 .ds 12 001A 636 Lmain$msg1$1$1==. 001A 637 _main_msg1_1_1: 001A 638 .ds 11 639 ;-------------------------------------------------------- 640 ; external ram data 641 ;-------------------------------------------------------- 642 .area XSEG (XDATA) DF00 643 Ftest_spi_can$SYNC1$0$0 == 0xdf00 DF00 644 _SYNC1 = 0xdf00 DF01 645 Ftest_spi_can$SYNC0$0$0 == 0xdf01 DF01 646 _SYNC0 = 0xdf01 DF02 647 Ftest_spi_can$PKTLEN$0$0 == 0xdf02 DF02 648 _PKTLEN = 0xdf02 DF03 649 Ftest_spi_can$PKTCTRL1$0$0 == 0xdf03 DF03 650 _PKTCTRL1 = 0xdf03 DF04 651 Ftest_spi_can$PKTCTRL0$0$0 == 0xdf04 DF04 652 _PKTCTRL0 = 0xdf04 DF05 653 Ftest_spi_can$ADDR$0$0 == 0xdf05 DF05 654 _ADDR = 0xdf05 DF06 655 Ftest_spi_can$CHANNR$0$0 == 0xdf06 DF06 656 _CHANNR = 0xdf06 DF07 657 Ftest_spi_can$FSCTRL1$0$0 == 0xdf07 DF07 658 _FSCTRL1 = 0xdf07 DF08 659 Ftest_spi_can$FSCTRL0$0$0 == 0xdf08 DF08 660 _FSCTRL0 = 0xdf08 DF09 661 Ftest_spi_can$FREQ2$0$0 == 0xdf09 DF09 662 _FREQ2 = 0xdf09 DF0A 663 Ftest_spi_can$FREQ1$0$0 == 0xdf0a DF0A 664 _FREQ1 = 0xdf0a DF0B 665 Ftest_spi_can$FREQ0$0$0 == 0xdf0b DF0B 666 _FREQ0 = 0xdf0b DF0C 667 Ftest_spi_can$MDMCFG4$0$0 == 0xdf0c DF0C 668 _MDMCFG4 = 0xdf0c DF0D 669 Ftest_spi_can$MDMCFG3$0$0 == 0xdf0d DF0D 670 _MDMCFG3 = 0xdf0d DF0E 671 Ftest_spi_can$MDMCFG2$0$0 == 0xdf0e DF0E 672 _MDMCFG2 = 0xdf0e DF0F 673 Ftest_spi_can$MDMCFG1$0$0 == 0xdf0f DF0F 674 _MDMCFG1 = 0xdf0f DF10 675 Ftest_spi_can$MDMCFG0$0$0 == 0xdf10 DF10 676 _MDMCFG0 = 0xdf10 DF11 677 Ftest_spi_can$DEVIATN$0$0 == 0xdf11 DF11 678 _DEVIATN = 0xdf11 DF12 679 Ftest_spi_can$MCSM2$0$0 == 0xdf12 DF12 680 _MCSM2 = 0xdf12 DF13 681 Ftest_spi_can$MCSM1$0$0 == 0xdf13 DF13 682 _MCSM1 = 0xdf13 DF14 683 Ftest_spi_can$MCSM0$0$0 == 0xdf14 DF14 684 _MCSM0 = 0xdf14 DF15 685 Ftest_spi_can$FOCCFG$0$0 == 0xdf15 DF15 686 _FOCCFG = 0xdf15 DF16 687 Ftest_spi_can$BSCFG$0$0 == 0xdf16 DF16 688 _BSCFG = 0xdf16 DF17 689 Ftest_spi_can$AGCCTRL2$0$0 == 0xdf17 DF17 690 _AGCCTRL2 = 0xdf17 DF18 691 Ftest_spi_can$AGCCTRL1$0$0 == 0xdf18 DF18 692 _AGCCTRL1 = 0xdf18 DF19 693 Ftest_spi_can$AGCCTRL0$0$0 == 0xdf19 DF19 694 _AGCCTRL0 = 0xdf19 DF1A 695 Ftest_spi_can$FREND1$0$0 == 0xdf1a DF1A 696 _FREND1 = 0xdf1a DF1B 697 Ftest_spi_can$FREND0$0$0 == 0xdf1b DF1B 698 _FREND0 = 0xdf1b DF1C 699 Ftest_spi_can$FSCAL3$0$0 == 0xdf1c DF1C 700 _FSCAL3 = 0xdf1c DF1D 701 Ftest_spi_can$FSCAL2$0$0 == 0xdf1d DF1D 702 _FSCAL2 = 0xdf1d DF1E 703 Ftest_spi_can$FSCAL1$0$0 == 0xdf1e DF1E 704 _FSCAL1 = 0xdf1e DF1F 705 Ftest_spi_can$FSCAL0$0$0 == 0xdf1f DF1F 706 _FSCAL0 = 0xdf1f DF23 707 Ftest_spi_can$TEST2$0$0 == 0xdf23 DF23 708 _TEST2 = 0xdf23 DF24 709 Ftest_spi_can$TEST1$0$0 == 0xdf24 DF24 710 _TEST1 = 0xdf24 DF25 711 Ftest_spi_can$TEST0$0$0 == 0xdf25 DF25 712 _TEST0 = 0xdf25 DF2E 713 Ftest_spi_can$PA_TABLE0$0$0 == 0xdf2e DF2E 714 _PA_TABLE0 = 0xdf2e DF2F 715 Ftest_spi_can$IOCFG2$0$0 == 0xdf2f DF2F 716 _IOCFG2 = 0xdf2f DF30 717 Ftest_spi_can$IOCFG1$0$0 == 0xdf30 DF30 718 _IOCFG1 = 0xdf30 DF31 719 Ftest_spi_can$IOCFG0$0$0 == 0xdf31 DF31 720 _IOCFG0 = 0xdf31 DF36 721 Ftest_spi_can$PARTNUM$0$0 == 0xdf36 DF36 722 _PARTNUM = 0xdf36 DF37 723 Ftest_spi_can$VERSION$0$0 == 0xdf37 DF37 724 _VERSION = 0xdf37 DF38 725 Ftest_spi_can$FREQEST$0$0 == 0xdf38 DF38 726 _FREQEST = 0xdf38 DF39 727 Ftest_spi_can$LQI$0$0 == 0xdf39 DF39 728 _LQI = 0xdf39 DF3A 729 Ftest_spi_can$RSSI$0$0 == 0xdf3a DF3A 730 _RSSI = 0xdf3a DF3B 731 Ftest_spi_can$MARCSTATE$0$0 == 0xdf3b DF3B 732 _MARCSTATE = 0xdf3b DF3C 733 Ftest_spi_can$PKTSTATUS$0$0 == 0xdf3c DF3C 734 _PKTSTATUS = 0xdf3c DF3D 735 Ftest_spi_can$VCO_VC_DAC$0$0 == 0xdf3d DF3D 736 _VCO_VC_DAC = 0xdf3d DF40 737 Ftest_spi_can$I2SCFG0$0$0 == 0xdf40 DF40 738 _I2SCFG0 = 0xdf40 DF41 739 Ftest_spi_can$I2SCFG1$0$0 == 0xdf41 DF41 740 _I2SCFG1 = 0xdf41 DF42 741 Ftest_spi_can$I2SDATL$0$0 == 0xdf42 DF42 742 _I2SDATL = 0xdf42 DF43 743 Ftest_spi_can$I2SDATH$0$0 == 0xdf43 DF43 744 _I2SDATH = 0xdf43 DF44 745 Ftest_spi_can$I2SWCNT$0$0 == 0xdf44 DF44 746 _I2SWCNT = 0xdf44 DF45 747 Ftest_spi_can$I2SSTAT$0$0 == 0xdf45 DF45 748 _I2SSTAT = 0xdf45 DF46 749 Ftest_spi_can$I2SCLKF0$0$0 == 0xdf46 DF46 750 _I2SCLKF0 = 0xdf46 DF47 751 Ftest_spi_can$I2SCLKF1$0$0 == 0xdf47 DF47 752 _I2SCLKF1 = 0xdf47 DF48 753 Ftest_spi_can$I2SCLKF2$0$0 == 0xdf48 DF48 754 _I2SCLKF2 = 0xdf48 DE00 755 Ftest_spi_can$USBADDR$0$0 == 0xde00 DE00 756 _USBADDR = 0xde00 DE01 757 Ftest_spi_can$USBPOW$0$0 == 0xde01 DE01 758 _USBPOW = 0xde01 DE02 759 Ftest_spi_can$USBIIF$0$0 == 0xde02 DE02 760 _USBIIF = 0xde02 DE04 761 Ftest_spi_can$USBOIF$0$0 == 0xde04 DE04 762 _USBOIF = 0xde04 DE06 763 Ftest_spi_can$USBCIF$0$0 == 0xde06 DE06 764 _USBCIF = 0xde06 DE07 765 Ftest_spi_can$USBIIE$0$0 == 0xde07 DE07 766 _USBIIE = 0xde07 DE09 767 Ftest_spi_can$USBOIE$0$0 == 0xde09 DE09 768 _USBOIE = 0xde09 DE0B 769 Ftest_spi_can$USBCIE$0$0 == 0xde0b DE0B 770 _USBCIE = 0xde0b DE0C 771 Ftest_spi_can$USBFRML$0$0 == 0xde0c DE0C 772 _USBFRML = 0xde0c DE0D 773 Ftest_spi_can$USBFRMH$0$0 == 0xde0d DE0D 774 _USBFRMH = 0xde0d DE0E 775 Ftest_spi_can$USBINDEX$0$0 == 0xde0e DE0E 776 _USBINDEX = 0xde0e DE10 777 Ftest_spi_can$USBMAXI$0$0 == 0xde10 DE10 778 _USBMAXI = 0xde10 DE11 779 Ftest_spi_can$USBCSIL$0$0 == 0xde11 DE11 780 _USBCSIL = 0xde11 DE12 781 Ftest_spi_can$USBCSIH$0$0 == 0xde12 DE12 782 _USBCSIH = 0xde12 DE13 783 Ftest_spi_can$USBMAXO$0$0 == 0xde13 DE13 784 _USBMAXO = 0xde13 DE14 785 Ftest_spi_can$USBCSOL$0$0 == 0xde14 DE14 786 _USBCSOL = 0xde14 DE15 787 Ftest_spi_can$USBCSOH$0$0 == 0xde15 DE15 788 _USBCSOH = 0xde15 DE16 789 Ftest_spi_can$USBCNTL$0$0 == 0xde16 DE16 790 _USBCNTL = 0xde16 DE17 791 Ftest_spi_can$USBCNTH$0$0 == 0xde17 DE17 792 _USBCNTH = 0xde17 DE20 793 Ftest_spi_can$USBF0$0$0 == 0xde20 DE20 794 _USBF0 = 0xde20 DE22 795 Ftest_spi_can$USBF1$0$0 == 0xde22 DE22 796 _USBF1 = 0xde22 DE24 797 Ftest_spi_can$USBF2$0$0 == 0xde24 DE24 798 _USBF2 = 0xde24 DE26 799 Ftest_spi_can$USBF3$0$0 == 0xde26 DE26 800 _USBF3 = 0xde26 DE28 801 Ftest_spi_can$USBF4$0$0 == 0xde28 DE28 802 _USBF4 = 0xde28 DE2A 803 Ftest_spi_can$USBF5$0$0 == 0xde2a DE2A 804 _USBF5 = 0xde2a 0000 805 G$report$0$0==. 0000 806 _report:: 0000 807 .ds 500 808 ;-------------------------------------------------------- 809 ; absolute external ram data 810 ;-------------------------------------------------------- 811 .area XABS (ABS,XDATA) 812 ;-------------------------------------------------------- 813 ; external initialized ram data 814 ;-------------------------------------------------------- 815 .area XISEG (XDATA) 0000 816 G$txdata2$0$0==. 0000 817 _txdata2:: 0000 818 .ds 14 000E 819 G$rxdata$0$0==. 000E 820 _rxdata:: 000E 821 .ds 14 001C 822 G$txdata$0$0==. 001C 823 _txdata:: 001C 824 .ds 14 825 .area HOME (CODE) 826 .area GSINIT0 (CODE) 827 .area GSINIT1 (CODE) 828 .area GSINIT2 (CODE) 829 .area GSINIT3 (CODE) 830 .area GSINIT4 (CODE) 831 .area GSINIT5 (CODE) 832 .area GSINIT (CODE) 833 .area GSFINAL (CODE) 834 .area CSEG (CODE) 835 ;-------------------------------------------------------- 836 ; interrupt vector 837 ;-------------------------------------------------------- 838 .area HOME (CODE) 0000 839 __interrupt_vect: 0000 02s00r00 840 ljmp __sdcc_gsinit_startup 0003 32 841 reti 0004 842 .ds 7 000B 32 843 reti 000C 844 .ds 7 0013 32 845 reti 0014 846 .ds 7 001B 02s00r00 847 ljmp _ISR_URX1 001E 848 .ds 5 0023 32 849 reti 0024 850 .ds 7 002B 32 851 reti 002C 852 .ds 7 0033 32 853 reti 0034 854 .ds 7 003B 32 855 reti 003C 856 .ds 7 0043 32 857 reti 0044 858 .ds 7 004B 32 859 reti 004C 860 .ds 7 0053 32 861 reti 0054 862 .ds 7 005B 32 863 reti 005C 864 .ds 7 0063 02s00r00 865 ljmp _ISR_T4 866 ;-------------------------------------------------------- 867 ; global & static initialisations 868 ;-------------------------------------------------------- 869 .area HOME (CODE) 870 .area GSINIT (CODE) 871 .area GSFINAL (CODE) 872 .area GSINIT (CODE) 873 .globl __sdcc_gsinit_startup 874 .globl __sdcc_program_startup 875 .globl __start__stack 876 .globl __mcs51_genXINIT 877 .globl __mcs51_genXRAMCLEAR 878 .globl __mcs51_genRAMCLEAR 0000 879 G$main$0$0 ==. 0000 880 C$test_spi_can.c$45$1$1 ==. 881 ; apps/test_spi_can/test_spi_can.c:45: uint16 DATA reportLength = 0; 0000 E4 882 clr a 0001 F5*0D 883 mov _reportLength,a 0003 F5*0E 884 mov (_reportLength + 1),a 0005 885 G$main$0$0 ==. 0005 886 C$test_spi_can.c$49$1$1 ==. 887 ; apps/test_spi_can/test_spi_can.c:49: uint16 DATA reportBytesSent = 0; 0005 E4 888 clr a 0006 F5*0F 889 mov _reportBytesSent,a 0008 F5*10 890 mov (_reportBytesSent + 1),a 891 .area GSFINAL (CODE) 0000 02s00r66 892 ljmp __sdcc_program_startup 893 ;-------------------------------------------------------- 894 ; Home 895 ;-------------------------------------------------------- 896 .area HOME (CODE) 897 .area HOME (CODE) 0066 898 __sdcc_program_startup: 0066 12s07r47 899 lcall _main 900 ; return from main will lock up 0069 80 FE 901 sjmp . 902 ;-------------------------------------------------------- 903 ; code 904 ;-------------------------------------------------------- 905 .area CSEG (CODE) 906 ;------------------------------------------------------------ 907 ;Allocation info for local variables in function 'Can_init' 908 ;------------------------------------------------------------ 909 ;------------------------------------------------------------ 0000 910 G$Can_init$0$0 ==. 0000 911 C$CAN.c$24$0$0 ==. 912 ; apps/test_spi_can/../CAN.c:24: void Can_init(uint8 baudrate){ 913 ; ----------------------------------------- 914 ; function Can_init 915 ; ----------------------------------------- 0000 916 _Can_init: 0002 917 ar2 = 0x02 0003 918 ar3 = 0x03 0004 919 ar4 = 0x04 0005 920 ar5 = 0x05 0006 921 ar6 = 0x06 0007 922 ar7 = 0x07 0000 923 ar0 = 0x00 0001 924 ar1 = 0x01 0000 AA 82 925 mov r2,dpl 0002 926 C$CAN.c$28$1$1 ==. 927 ; apps/test_spi_can/../CAN.c:28: spiXMasterInit(); 0002 C0 02 928 push ar2 0004 12s00r00 929 lcall _spi1MasterInit 0007 930 C$CAN.c$29$1$1 ==. 931 ; apps/test_spi_can/../CAN.c:29: spiXMasterSetFrequency(230400); 0007 90 84 00 932 mov dptr,#0x8400 000A 75 F0 03 933 mov b,#0x03 000D E4 934 clr a 000E 12s00r00 935 lcall _spi1MasterSetFrequency 0011 936 C$CAN.c$30$1$1 ==. 937 ; apps/test_spi_can/../CAN.c:30: spiXMasterSetClockPolarity(SPI_POLARITY_IDLE_HIGH); // idle when high 0011 D2*00 938 setb _spi1MasterSetClockPolarity_PARM_1 0013 12s00r00 939 lcall _spi1MasterSetClockPolarity 0016 940 C$CAN.c$31$1$1 ==. 941 ; apps/test_spi_can/../CAN.c:31: spiXMasterSetClockPhase(SPI_PHASE_EDGE_TRAILING); // data sampled when clock goes from active to idle 0016 D2*00 942 setb _spi1MasterSetClockPhase_PARM_1 0018 12s00r00 943 lcall _spi1MasterSetClockPhase 001B 944 C$CAN.c$32$1$1 ==. 945 ; apps/test_spi_can/../CAN.c:32: spiXMasterSetBitOrder(SPI_BIT_ORDER_MSB_FIRST); 001B C2*00 946 clr _spi1MasterSetBitOrder_PARM_1 001D 12s00r00 947 lcall _spi1MasterSetBitOrder 0020 948 C$CAN.c$33$1$1 ==. 949 ; apps/test_spi_can/../CAN.c:33: Can_reset(); //Reset CAN Controller & bring to CONFIG mode 0020 12s00r5D 950 lcall _Can_reset 0023 D0 02 951 pop ar2 0025 952 C$CAN.c$34$1$1 ==. 953 ; apps/test_spi_can/../CAN.c:34: set_Can_baudrate(baudrate); 0025 8A 82 954 mov dpl,r2 0027 12s01rEA 955 lcall _set_Can_baudrate 002A 956 C$CAN.c$35$1$1 ==. 957 ; apps/test_spi_can/../CAN.c:35: write_can_reg(0x0F,0x03); // set CAN CTRL in normal mode 002A 78r00 958 mov r0,#_write_can_reg_PARM_2 002C 74 03 959 mov a,#0x03 002E F2 960 movx @r0,a 002F 75 82 0F 961 mov dpl,#0x0F 0032 962 C$CAN.c$37$1$1 ==. 0032 963 XG$Can_init$0$0 ==. 0032 02s00rDB 964 ljmp _write_can_reg 965 ;------------------------------------------------------------ 966 ;Allocation info for local variables in function 'Can_setnormalmode' 967 ;------------------------------------------------------------ 968 ;------------------------------------------------------------ 0035 969 G$Can_setnormalmode$0$0 ==. 0035 970 C$CAN.c$40$1$1 ==. 971 ; apps/test_spi_can/../CAN.c:40: void Can_setnormalmode(){ 972 ; ----------------------------------------- 973 ; function Can_setnormalmode 974 ; ----------------------------------------- 0035 975 _Can_setnormalmode: 0035 976 C$CAN.c$41$1$1 ==. 977 ; apps/test_spi_can/../CAN.c:41: uint8 val = read_can_reg(0x0F); 0035 75 82 0F 978 mov dpl,#0x0F 0038 12s00r95 979 lcall _read_can_reg 003B AA 82 980 mov r2,dpl 003D 981 C$CAN.c$42$1$1 ==. 982 ; apps/test_spi_can/../CAN.c:42: val = val & 0x1F; 003D 78r00 983 mov r0,#_write_can_reg_PARM_2 003F 74 1F 984 mov a,#0x1F 0041 5A 985 anl a,r2 0042 F2 986 movx @r0,a 0043 987 C$CAN.c$43$1$1 ==. 988 ; apps/test_spi_can/../CAN.c:43: write_can_reg(0x0F,val); // set CAN CTRL in normal mode 0043 75 82 0F 989 mov dpl,#0x0F 0046 990 C$CAN.c$44$1$1 ==. 0046 991 XG$Can_setnormalmode$0$0 ==. 0046 02s00rDB 992 ljmp _write_can_reg 993 ;------------------------------------------------------------ 994 ;Allocation info for local variables in function 'Can_setconfigmode' 995 ;------------------------------------------------------------ 996 ;------------------------------------------------------------ 0049 997 G$Can_setconfigmode$0$0 ==. 0049 998 C$CAN.c$46$1$1 ==. 999 ; apps/test_spi_can/../CAN.c:46: void Can_setconfigmode(){ 1000 ; ----------------------------------------- 1001 ; function Can_setconfigmode 1002 ; ----------------------------------------- 0049 1003 _Can_setconfigmode: 0049 1004 C$CAN.c$47$1$1 ==. 1005 ; apps/test_spi_can/../CAN.c:47: uint8 val = read_can_reg(0x0F); 0049 75 82 0F 1006 mov dpl,#0x0F 004C 12s00r95 1007 lcall _read_can_reg 004F AA 82 1008 mov r2,dpl 0051 1009 C$CAN.c$48$1$1 ==. 1010 ; apps/test_spi_can/../CAN.c:48: val = val | 0x80; 0051 78r00 1011 mov r0,#_write_can_reg_PARM_2 0053 74 80 1012 mov a,#0x80 0055 4A 1013 orl a,r2 0056 F2 1014 movx @r0,a 0057 1015 C$CAN.c$49$1$1 ==. 1016 ; apps/test_spi_can/../CAN.c:49: write_can_reg(0x0F,val); // set CAN CTRL in config mode 0057 75 82 0F 1017 mov dpl,#0x0F 005A 1018 C$CAN.c$50$1$1 ==. 005A 1019 XG$Can_setconfigmode$0$0 ==. 005A 02s00rDB 1020 ljmp _write_can_reg 1021 ;------------------------------------------------------------ 1022 ;Allocation info for local variables in function 'Can_reset' 1023 ;------------------------------------------------------------ 1024 ;------------------------------------------------------------ 005D 1025 G$Can_reset$0$0 ==. 005D 1026 C$CAN.c$55$1$1 ==. 1027 ; apps/test_spi_can/../CAN.c:55: void Can_reset(){ 1028 ; ----------------------------------------- 1029 ; function Can_reset 1030 ; ----------------------------------------- 005D 1031 _Can_reset: 005D 1032 C$CAN.c$56$1$1 ==. 1033 ; apps/test_spi_can/../CAN.c:56: txdata[0] = 0xC0; 005D 90s00r1C 1034 mov dptr,#_txdata 0060 74 C0 1035 mov a,#0xC0 0062 F0 1036 movx @dptr,a 0063 1037 C$CAN.c$57$1$1 ==. 1038 ; apps/test_spi_can/../CAN.c:57: CSlow; 0063 C2 F0 1039 clr b[0] 0065 85 F0*00 1040 mov bits,b 0068 75 82 0E 1041 mov dpl,#0x0E 006B 12s00r00 1042 lcall _setDigitalOutput 006E 1043 C$CAN.c$58$1$1 ==. 1044 ; apps/test_spi_can/../CAN.c:58: spiXMasterTransfer(txdata,rxdata,1); 006E 78r00 1045 mov r0,#_spi1MasterTransfer_PARM_2 0070 74r0E 1046 mov a,#_rxdata 0072 F2 1047 movx @r0,a 0073 08 1048 inc r0 0074 74s00 1049 mov a,#(_rxdata >> 8) 0076 F2 1050 movx @r0,a 0077 78r00 1051 mov r0,#_spi1MasterTransfer_PARM_3 0079 74 01 1052 mov a,#0x01 007B F2 1053 movx @r0,a 007C 08 1054 inc r0 007D E4 1055 clr a 007E F2 1056 movx @r0,a 007F 90s00r1C 1057 mov dptr,#_txdata 0082 12s00r00 1058 lcall _spi1MasterTransfer 0085 1059 C$CAN.c$59$1$1 ==. 1060 ; apps/test_spi_can/../CAN.c:59: while(spiXMasterBusy()){ } 0085 1061 00101$: 0085 12s00r00 1062 lcall _spi1MasterBusy 0088 40 FB 1063 jc 00101$ 008A 1064 C$CAN.c$60$1$1 ==. 1065 ; apps/test_spi_can/../CAN.c:60: CShigh; 008A D2 F0 1066 setb b[0] 008C 85 F0*00 1067 mov bits,b 008F 75 82 0E 1068 mov dpl,#0x0E 0092 1069 C$CAN.c$61$1$1 ==. 0092 1070 XG$Can_reset$0$0 ==. 0092 02s00r00 1071 ljmp _setDigitalOutput 1072 ;------------------------------------------------------------ 1073 ;Allocation info for local variables in function 'read_can_reg' 1074 ;------------------------------------------------------------ 1075 ;------------------------------------------------------------ 0095 1076 G$read_can_reg$0$0 ==. 0095 1077 C$CAN.c$63$1$1 ==. 1078 ; apps/test_spi_can/../CAN.c:63: uint8 read_can_reg(uint8 addr){ 1079 ; ----------------------------------------- 1080 ; function read_can_reg 1081 ; ----------------------------------------- 0095 1082 _read_can_reg: 0095 AA 82 1083 mov r2,dpl 0097 1084 C$CAN.c$65$1$1 ==. 1085 ; apps/test_spi_can/../CAN.c:65: txdata[0] = 0x03; // read instruction 0097 90s00r1C 1086 mov dptr,#_txdata 009A 74 03 1087 mov a,#0x03 009C F0 1088 movx @dptr,a 009D 1089 C$CAN.c$66$1$1 ==. 1090 ; apps/test_spi_can/../CAN.c:66: txdata[1] = addr; // read reg at address 009D 90s00r1D 1091 mov dptr,#(_txdata + 0x0001) 00A0 EA 1092 mov a,r2 00A1 F0 1093 movx @dptr,a 00A2 1094 C$CAN.c$67$1$1 ==. 1095 ; apps/test_spi_can/../CAN.c:67: CSlow; 00A2 C2 F0 1096 clr b[0] 00A4 85 F0*00 1097 mov bits,b 00A7 75 82 0E 1098 mov dpl,#0x0E 00AA 12s00r00 1099 lcall _setDigitalOutput 00AD 1100 C$CAN.c$68$1$1 ==. 1101 ; apps/test_spi_can/../CAN.c:68: spiXMasterTransfer(txdata,rxdata,3); 00AD 78r00 1102 mov r0,#_spi1MasterTransfer_PARM_2 00AF 74r0E 1103 mov a,#_rxdata 00B1 F2 1104 movx @r0,a 00B2 08 1105 inc r0 00B3 74s00 1106 mov a,#(_rxdata >> 8) 00B5 F2 1107 movx @r0,a 00B6 78r00 1108 mov r0,#_spi1MasterTransfer_PARM_3 00B8 74 03 1109 mov a,#0x03 00BA F2 1110 movx @r0,a 00BB 08 1111 inc r0 00BC E4 1112 clr a 00BD F2 1113 movx @r0,a 00BE 90s00r1C 1114 mov dptr,#_txdata 00C1 12s00r00 1115 lcall _spi1MasterTransfer 00C4 1116 C$CAN.c$69$1$1 ==. 1117 ; apps/test_spi_can/../CAN.c:69: while(spiXMasterBusy()){ } 00C4 1118 00101$: 00C4 12s00r00 1119 lcall _spi1MasterBusy 00C7 40 FB 1120 jc 00101$ 00C9 1121 C$CAN.c$70$1$1 ==. 1122 ; apps/test_spi_can/../CAN.c:70: CShigh; 00C9 D2 F0 1123 setb b[0] 00CB 85 F0*00 1124 mov bits,b 00CE 75 82 0E 1125 mov dpl,#0x0E 00D1 12s00r00 1126 lcall _setDigitalOutput 00D4 1127 C$CAN.c$71$1$1 ==. 1128 ; apps/test_spi_can/../CAN.c:71: return rxdata[2]; 00D4 90s00r10 1129 mov dptr,#(_rxdata + 0x0002) 00D7 E0 1130 movx a,@dptr 00D8 1131 C$CAN.c$72$1$1 ==. 00D8 1132 XG$read_can_reg$0$0 ==. 00D8 F5 82 1133 mov dpl,a 00DA 22 1134 ret 1135 ;------------------------------------------------------------ 1136 ;Allocation info for local variables in function 'write_can_reg' 1137 ;------------------------------------------------------------ 1138 ;------------------------------------------------------------ 00DB 1139 G$write_can_reg$0$0 ==. 00DB 1140 C$CAN.c$74$1$1 ==. 1141 ; apps/test_spi_can/../CAN.c:74: void write_can_reg(uint8 addr,uint8 val){ 1142 ; ----------------------------------------- 1143 ; function write_can_reg 1144 ; ----------------------------------------- 00DB 1145 _write_can_reg: 00DB AA 82 1146 mov r2,dpl 00DD 1147 C$CAN.c$75$1$1 ==. 1148 ; apps/test_spi_can/../CAN.c:75: txdata[0] = 0x02; // write instruction 00DD 90s00r1C 1149 mov dptr,#_txdata 00E0 74 02 1150 mov a,#0x02 00E2 F0 1151 movx @dptr,a 00E3 1152 C$CAN.c$76$1$1 ==. 1153 ; apps/test_spi_can/../CAN.c:76: txdata[1] = addr; // write to addr 00E3 90s00r1D 1154 mov dptr,#(_txdata + 0x0001) 00E6 EA 1155 mov a,r2 00E7 F0 1156 movx @dptr,a 00E8 1157 C$CAN.c$77$1$1 ==. 1158 ; apps/test_spi_can/../CAN.c:77: txdata[2] = val; // write val 00E8 90s00r1E 1159 mov dptr,#(_txdata + 0x0002) 00EB 78r00 1160 mov r0,#_write_can_reg_PARM_2 00ED E2 1161 movx a,@r0 00EE F0 1162 movx @dptr,a 00EF 1163 C$CAN.c$78$1$1 ==. 1164 ; apps/test_spi_can/../CAN.c:78: CSlow; 00EF C2 F0 1165 clr b[0] 00F1 85 F0*00 1166 mov bits,b 00F4 75 82 0E 1167 mov dpl,#0x0E 00F7 12s00r00 1168 lcall _setDigitalOutput 00FA 1169 C$CAN.c$79$1$1 ==. 1170 ; apps/test_spi_can/../CAN.c:79: spiXMasterTransfer(txdata,rxdata,3); 00FA 78r00 1171 mov r0,#_spi1MasterTransfer_PARM_2 00FC 74r0E 1172 mov a,#_rxdata 00FE F2 1173 movx @r0,a 00FF 08 1174 inc r0 0100 74s00 1175 mov a,#(_rxdata >> 8) 0102 F2 1176 movx @r0,a 0103 78r00 1177 mov r0,#_spi1MasterTransfer_PARM_3 0105 74 03 1178 mov a,#0x03 0107 F2 1179 movx @r0,a 0108 08 1180 inc r0 0109 E4 1181 clr a 010A F2 1182 movx @r0,a 010B 90s00r1C 1183 mov dptr,#_txdata 010E 12s00r00 1184 lcall _spi1MasterTransfer 0111 1185 C$CAN.c$80$1$1 ==. 1186 ; apps/test_spi_can/../CAN.c:80: while(spiXMasterBusy()){ } 0111 1187 00101$: 0111 12s00r00 1188 lcall _spi1MasterBusy 0114 40 FB 1189 jc 00101$ 0116 1190 C$CAN.c$81$1$1 ==. 1191 ; apps/test_spi_can/../CAN.c:81: CShigh; 0116 D2 F0 1192 setb b[0] 0118 85 F0*00 1193 mov bits,b 011B 75 82 0E 1194 mov dpl,#0x0E 011E 1195 C$CAN.c$82$1$1 ==. 011E 1196 XG$write_can_reg$0$0 ==. 011E 02s00r00 1197 ljmp _setDigitalOutput 1198 ;------------------------------------------------------------ 1199 ;Allocation info for local variables in function 'buf0ovfbuf1' 1200 ;------------------------------------------------------------ 1201 ;------------------------------------------------------------ 0121 1202 G$buf0ovfbuf1$0$0 ==. 0121 1203 C$CAN.c$86$1$1 ==. 1204 ; apps/test_spi_can/../CAN.c:86: void buf0ovfbuf1(uint8 stat){ 1205 ; ----------------------------------------- 1206 ; function buf0ovfbuf1 1207 ; ----------------------------------------- 0121 1208 _buf0ovfbuf1: 0121 AA 82 1209 mov r2,dpl 0123 1210 C$CAN.c$87$1$1 ==. 1211 ; apps/test_spi_can/../CAN.c:87: uint8 val = read_can_reg(0x60); 0123 75 82 60 1212 mov dpl,#0x60 0126 C0 02 1213 push ar2 0128 12s00r95 1214 lcall _read_can_reg 012B AB 82 1215 mov r3,dpl 012D D0 02 1216 pop ar2 012F 1217 C$CAN.c$88$1$1 ==. 1218 ; apps/test_spi_can/../CAN.c:88: if(stat){ 012F EA 1219 mov a,r2 0130 60 0D 1220 jz 00102$ 0132 1221 C$CAN.c$89$2$2 ==. 1222 ; apps/test_spi_can/../CAN.c:89: val = val | (1<<2); // Write to BUKT 0132 43 03 04 1223 orl ar3,#0x04 0135 1224 C$CAN.c$90$2$2 ==. 1225 ; apps/test_spi_can/../CAN.c:90: write_can_reg(0x60,val); 0135 78r00 1226 mov r0,#_write_can_reg_PARM_2 0137 EB 1227 mov a,r3 0138 F2 1228 movx @r0,a 0139 75 82 60 1229 mov dpl,#0x60 013C 02s00rDB 1230 ljmp _write_can_reg 013F 1231 00102$: 013F 1232 C$CAN.c$92$2$3 ==. 1233 ; apps/test_spi_can/../CAN.c:92: val = val & (0xFB); // Write to BUKT 013F 78r00 1234 mov r0,#_write_can_reg_PARM_2 0141 74 FB 1235 mov a,#0xFB 0143 5B 1236 anl a,r3 0144 F2 1237 movx @r0,a 0145 1238 C$CAN.c$93$2$3 ==. 1239 ; apps/test_spi_can/../CAN.c:93: write_can_reg(0x60,val); 0145 75 82 60 1240 mov dpl,#0x60 0148 1241 C$CAN.c$95$1$1 ==. 0148 1242 XG$buf0ovfbuf1$0$0 ==. 0148 02s00rDB 1243 ljmp _write_can_reg 1244 ;------------------------------------------------------------ 1245 ;Allocation info for local variables in function 'setmask0' 1246 ;------------------------------------------------------------ 1247 ;------------------------------------------------------------ 014B 1248 G$setmask0$0$0 ==. 014B 1249 C$CAN.c$97$1$1 ==. 1250 ; apps/test_spi_can/../CAN.c:97: void setmask0(uint16 mask){ 1251 ; ----------------------------------------- 1252 ; function setmask0 1253 ; ----------------------------------------- 014B 1254 _setmask0: 014B AA 82 1255 mov r2,dpl 014D AB 83 1256 mov r3,dph 014F 1257 C$CAN.c$98$1$1 ==. 1258 ; apps/test_spi_can/../CAN.c:98: write_can_reg(0x20,(uint8) (mask>>3)); 014F 8A 04 1259 mov ar4,r2 0151 EB 1260 mov a,r3 0152 C4 1261 swap a 0153 23 1262 rl a 0154 CC 1263 xch a,r4 0155 C4 1264 swap a 0156 23 1265 rl a 0157 54 1F 1266 anl a,#0x1f 0159 6C 1267 xrl a,r4 015A CC 1268 xch a,r4 015B 54 1F 1269 anl a,#0x1f 015D CC 1270 xch a,r4 015E 6C 1271 xrl a,r4 015F CC 1272 xch a,r4 0160 78r00 1273 mov r0,#_write_can_reg_PARM_2 0162 EC 1274 mov a,r4 0163 F2 1275 movx @r0,a 0164 75 82 20 1276 mov dpl,#0x20 0167 C0 02 1277 push ar2 0169 C0 03 1278 push ar3 016B 12s00rDB 1279 lcall _write_can_reg 016E D0 03 1280 pop ar3 0170 D0 02 1281 pop ar2 0172 1282 C$CAN.c$99$1$1 ==. 1283 ; apps/test_spi_can/../CAN.c:99: write_can_reg(0x21,(uint8) (mask<<5)); 0172 78r00 1284 mov r0,#_write_can_reg_PARM_2 0174 EA 1285 mov a,r2 0175 C4 1286 swap a 0176 23 1287 rl a 0177 54 E0 1288 anl a,#0xe0 0179 F2 1289 movx @r0,a 017A 75 82 21 1290 mov dpl,#0x21 017D 1291 C$CAN.c$100$1$1 ==. 017D 1292 XG$setmask0$0$0 ==. 017D 02s00rDB 1293 ljmp _write_can_reg 1294 ;------------------------------------------------------------ 1295 ;Allocation info for local variables in function 'setrxfil0' 1296 ;------------------------------------------------------------ 1297 ;------------------------------------------------------------ 0180 1298 G$setrxfil0$0$0 ==. 0180 1299 C$CAN.c$102$1$1 ==. 1300 ; apps/test_spi_can/../CAN.c:102: void setrxfil0(uint16 fil){ 1301 ; ----------------------------------------- 1302 ; function setrxfil0 1303 ; ----------------------------------------- 0180 1304 _setrxfil0: 0180 AA 82 1305 mov r2,dpl 0182 AB 83 1306 mov r3,dph 0184 1307 C$CAN.c$103$1$1 ==. 1308 ; apps/test_spi_can/../CAN.c:103: write_can_reg(0x00,(uint8) (fil>>3)); 0184 8A 04 1309 mov ar4,r2 0186 EB 1310 mov a,r3 0187 C4 1311 swap a 0188 23 1312 rl a 0189 CC 1313 xch a,r4 018A C4 1314 swap a 018B 23 1315 rl a 018C 54 1F 1316 anl a,#0x1f 018E 6C 1317 xrl a,r4 018F CC 1318 xch a,r4 0190 54 1F 1319 anl a,#0x1f 0192 CC 1320 xch a,r4 0193 6C 1321 xrl a,r4 0194 CC 1322 xch a,r4 0195 78r00 1323 mov r0,#_write_can_reg_PARM_2 0197 EC 1324 mov a,r4 0198 F2 1325 movx @r0,a 0199 75 82 00 1326 mov dpl,#0x00 019C C0 02 1327 push ar2 019E C0 03 1328 push ar3 01A0 12s00rDB 1329 lcall _write_can_reg 01A3 D0 03 1330 pop ar3 01A5 D0 02 1331 pop ar2 01A7 1332 C$CAN.c$104$1$1 ==. 1333 ; apps/test_spi_can/../CAN.c:104: write_can_reg(0x01,(uint8) (fil<<5)); 01A7 78r00 1334 mov r0,#_write_can_reg_PARM_2 01A9 EA 1335 mov a,r2 01AA C4 1336 swap a 01AB 23 1337 rl a 01AC 54 E0 1338 anl a,#0xe0 01AE F2 1339 movx @r0,a 01AF 75 82 01 1340 mov dpl,#0x01 01B2 1341 C$CAN.c$105$1$1 ==. 01B2 1342 XG$setrxfil0$0$0 ==. 01B2 02s00rDB 1343 ljmp _write_can_reg 1344 ;------------------------------------------------------------ 1345 ;Allocation info for local variables in function 'setrxfil1' 1346 ;------------------------------------------------------------ 1347 ;------------------------------------------------------------ 01B5 1348 G$setrxfil1$0$0 ==. 01B5 1349 C$CAN.c$107$1$1 ==. 1350 ; apps/test_spi_can/../CAN.c:107: void setrxfil1(uint16 fil){ 1351 ; ----------------------------------------- 1352 ; function setrxfil1 1353 ; ----------------------------------------- 01B5 1354 _setrxfil1: 01B5 AA 82 1355 mov r2,dpl 01B7 AB 83 1356 mov r3,dph 01B9 1357 C$CAN.c$108$1$1 ==. 1358 ; apps/test_spi_can/../CAN.c:108: write_can_reg(0x04,(uint8) (fil>>3)); 01B9 8A 04 1359 mov ar4,r2 01BB EB 1360 mov a,r3 01BC C4 1361 swap a 01BD 23 1362 rl a 01BE CC 1363 xch a,r4 01BF C4 1364 swap a 01C0 23 1365 rl a 01C1 54 1F 1366 anl a,#0x1f 01C3 6C 1367 xrl a,r4 01C4 CC 1368 xch a,r4 01C5 54 1F 1369 anl a,#0x1f 01C7 CC 1370 xch a,r4 01C8 6C 1371 xrl a,r4 01C9 CC 1372 xch a,r4 01CA 78r00 1373 mov r0,#_write_can_reg_PARM_2 01CC EC 1374 mov a,r4 01CD F2 1375 movx @r0,a 01CE 75 82 04 1376 mov dpl,#0x04 01D1 C0 02 1377 push ar2 01D3 C0 03 1378 push ar3 01D5 12s00rDB 1379 lcall _write_can_reg 01D8 D0 03 1380 pop ar3 01DA D0 02 1381 pop ar2 01DC 1382 C$CAN.c$109$1$1 ==. 1383 ; apps/test_spi_can/../CAN.c:109: write_can_reg(0x05,(uint8) (fil<<5)); 01DC 78r00 1384 mov r0,#_write_can_reg_PARM_2 01DE EA 1385 mov a,r2 01DF C4 1386 swap a 01E0 23 1387 rl a 01E1 54 E0 1388 anl a,#0xe0 01E3 F2 1389 movx @r0,a 01E4 75 82 05 1390 mov dpl,#0x05 01E7 1391 C$CAN.c$110$1$1 ==. 01E7 1392 XG$setrxfil1$0$0 ==. 01E7 02s00rDB 1393 ljmp _write_can_reg 1394 ;------------------------------------------------------------ 1395 ;Allocation info for local variables in function 'set_Can_baudrate' 1396 ;------------------------------------------------------------ 1397 ;------------------------------------------------------------ 01EA 1398 G$set_Can_baudrate$0$0 ==. 01EA 1399 C$CAN.c$115$1$1 ==. 1400 ; apps/test_spi_can/../CAN.c:115: void set_Can_baudrate(uint8 A){ 1401 ; ----------------------------------------- 1402 ; function set_Can_baudrate 1403 ; ----------------------------------------- 01EA 1404 _set_Can_baudrate: 01EA AA 82 1405 mov r2,dpl 01EC 1406 C$CAN.c$116$1$1 ==. 1407 ; apps/test_spi_can/../CAN.c:116: switch(A){ 01EC BA 01 02 1408 cjne r2,#0x01,00109$ 01EF 80 05 1409 sjmp 00101$ 01F1 1410 00109$: 01F1 1411 C$CAN.c$117$2$2 ==. 1412 ; apps/test_spi_can/../CAN.c:117: case 1: //125kbit/s BRP = 04h 01F1 BA 02 44 1413 cjne r2,#0x02,00103$ 01F4 80 21 1414 sjmp 00102$ 01F6 1415 00101$: 01F6 1416 C$CAN.c$119$2$2 ==. 1417 ; apps/test_spi_can/../CAN.c:119: write_can_reg(0x2A,0x04); // write to CNF1 01F6 78r00 1418 mov r0,#_write_can_reg_PARM_2 01F8 74 04 1419 mov a,#0x04 01FA F2 1420 movx @r0,a 01FB 75 82 2A 1421 mov dpl,#0x2A 01FE 12s00rDB 1422 lcall _write_can_reg 0201 1423 C$CAN.c$120$2$2 ==. 1424 ; apps/test_spi_can/../CAN.c:120: write_can_reg(0x29,0xB1); // write to CNF2 0201 78r00 1425 mov r0,#_write_can_reg_PARM_2 0203 74 B1 1426 mov a,#0xB1 0205 F2 1427 movx @r0,a 0206 75 82 29 1428 mov dpl,#0x29 0209 12s00rDB 1429 lcall _write_can_reg 020C 1430 C$CAN.c$121$2$2 ==. 1431 ; apps/test_spi_can/../CAN.c:121: write_can_reg(0x28,0x05); // write to CNF3 020C 78r00 1432 mov r0,#_write_can_reg_PARM_2 020E 74 05 1433 mov a,#0x05 0210 F2 1434 movx @r0,a 0211 75 82 28 1435 mov dpl,#0x28 0214 1436 C$CAN.c$122$2$2 ==. 1437 ; apps/test_spi_can/../CAN.c:122: break; 0214 1438 C$CAN.c$123$2$2 ==. 1439 ; apps/test_spi_can/../CAN.c:123: case 2: 0214 02s00rDB 1440 ljmp _write_can_reg 0217 1441 00102$: 0217 1442 C$CAN.c$126$2$2 ==. 1443 ; apps/test_spi_can/../CAN.c:126: write_can_reg(0x2A,0x03); // write to CNF1 0217 78r00 1444 mov r0,#_write_can_reg_PARM_2 0219 74 03 1445 mov a,#0x03 021B F2 1446 movx @r0,a 021C 75 82 2A 1447 mov dpl,#0x2A 021F 12s00rDB 1448 lcall _write_can_reg 0222 1449 C$CAN.c$127$2$2 ==. 1450 ; apps/test_spi_can/../CAN.c:127: write_can_reg(0x29,0x91); // write to CNF2 0222 78r00 1451 mov r0,#_write_can_reg_PARM_2 0224 74 91 1452 mov a,#0x91 0226 F2 1453 movx @r0,a 0227 75 82 29 1454 mov dpl,#0x29 022A 12s00rDB 1455 lcall _write_can_reg 022D 1456 C$CAN.c$128$2$2 ==. 1457 ; apps/test_spi_can/../CAN.c:128: write_can_reg(0x28,0x03); // write to CNF3 022D 78r00 1458 mov r0,#_write_can_reg_PARM_2 022F 74 03 1459 mov a,#0x03 0231 F2 1460 movx @r0,a 0232 75 82 28 1461 mov dpl,#0x28 0235 1462 C$CAN.c$129$2$2 ==. 1463 ; apps/test_spi_can/../CAN.c:129: break; 0235 1464 C$CAN.c$130$2$2 ==. 1465 ; apps/test_spi_can/../CAN.c:130: default: 0235 02s00rDB 1466 ljmp _write_can_reg 0238 1467 00103$: 0238 1468 C$CAN.c$133$2$2 ==. 1469 ; apps/test_spi_can/../CAN.c:133: write_can_reg(0x2A,0x03); // write to CNF1 0238 78r00 1470 mov r0,#_write_can_reg_PARM_2 023A 74 03 1471 mov a,#0x03 023C F2 1472 movx @r0,a 023D 75 82 2A 1473 mov dpl,#0x2A 0240 12s00rDB 1474 lcall _write_can_reg 0243 1475 C$CAN.c$134$2$2 ==. 1476 ; apps/test_spi_can/../CAN.c:134: write_can_reg(0x29,0x91); // write to CNF2 0243 78r00 1477 mov r0,#_write_can_reg_PARM_2 0245 74 91 1478 mov a,#0x91 0247 F2 1479 movx @r0,a 0248 75 82 29 1480 mov dpl,#0x29 024B 12s00rDB 1481 lcall _write_can_reg 024E 1482 C$CAN.c$135$2$2 ==. 1483 ; apps/test_spi_can/../CAN.c:135: write_can_reg(0x28,0x03); // write to CNF3 024E 78r00 1484 mov r0,#_write_can_reg_PARM_2 0250 74 03 1485 mov a,#0x03 0252 F2 1486 movx @r0,a 0253 75 82 28 1487 mov dpl,#0x28 0256 1488 C$CAN.c$137$1$1 ==. 1489 ; apps/test_spi_can/../CAN.c:137: } 0256 1490 C$CAN.c$138$1$1 ==. 0256 1491 XG$set_Can_baudrate$0$0 ==. 0256 02s00rDB 1492 ljmp _write_can_reg 1493 ;------------------------------------------------------------ 1494 ;Allocation info for local variables in function 'load_can_txbuf0' 1495 ;------------------------------------------------------------ 1496 ;------------------------------------------------------------ 0259 1497 G$load_can_txbuf0$0$0 ==. 0259 1498 C$CAN.c$142$1$1 ==. 1499 ; apps/test_spi_can/../CAN.c:142: void load_can_txbuf0(){ 1500 ; ----------------------------------------- 1501 ; function load_can_txbuf0 1502 ; ----------------------------------------- 0259 1503 _load_can_txbuf0: 0259 1504 C$CAN.c$143$1$1 ==. 1505 ; apps/test_spi_can/../CAN.c:143: CSlow; 0259 C2 F0 1506 clr b[0] 025B 85 F0*00 1507 mov bits,b 025E 75 82 0E 1508 mov dpl,#0x0E 0261 12s00r00 1509 lcall _setDigitalOutput 0264 1510 C$CAN.c$146$1$1 ==. 1511 ; apps/test_spi_can/../CAN.c:146: spiXMasterTransfer(txdata2,rxdata,14); 0264 78r00 1512 mov r0,#_spi1MasterTransfer_PARM_2 0266 74r0E 1513 mov a,#_rxdata 0268 F2 1514 movx @r0,a 0269 08 1515 inc r0 026A 74s00 1516 mov a,#(_rxdata >> 8) 026C F2 1517 movx @r0,a 026D 78r00 1518 mov r0,#_spi1MasterTransfer_PARM_3 026F 74 0E 1519 mov a,#0x0E 0271 F2 1520 movx @r0,a 0272 08 1521 inc r0 0273 E4 1522 clr a 0274 F2 1523 movx @r0,a 0275 90s00r00 1524 mov dptr,#_txdata2 0278 12s00r00 1525 lcall _spi1MasterTransfer 027B 1526 C$CAN.c$147$1$1 ==. 1527 ; apps/test_spi_can/../CAN.c:147: while(spiXMasterBusy()){ } 027B 1528 00101$: 027B 12s00r00 1529 lcall _spi1MasterBusy 027E 40 FB 1530 jc 00101$ 0280 1531 C$CAN.c$148$1$1 ==. 1532 ; apps/test_spi_can/../CAN.c:148: CShigh; 0280 D2 F0 1533 setb b[0] 0282 85 F0*00 1534 mov bits,b 0285 75 82 0E 1535 mov dpl,#0x0E 0288 1536 C$CAN.c$149$1$1 ==. 0288 1537 XG$load_can_txbuf0$0$0 ==. 0288 02s00r00 1538 ljmp _setDigitalOutput 1539 ;------------------------------------------------------------ 1540 ;Allocation info for local variables in function 'load_can_txbuf1' 1541 ;------------------------------------------------------------ 1542 ;------------------------------------------------------------ 028B 1543 G$load_can_txbuf1$0$0 ==. 028B 1544 C$CAN.c$151$1$1 ==. 1545 ; apps/test_spi_can/../CAN.c:151: void load_can_txbuf1(){ 1546 ; ----------------------------------------- 1547 ; function load_can_txbuf1 1548 ; ----------------------------------------- 028B 1549 _load_can_txbuf1: 028B 1550 C$CAN.c$152$1$1 ==. 1551 ; apps/test_spi_can/../CAN.c:152: CSlow; 028B C2 F0 1552 clr b[0] 028D 85 F0*00 1553 mov bits,b 0290 75 82 0E 1554 mov dpl,#0x0E 0293 12s00r00 1555 lcall _setDigitalOutput 0296 1556 C$CAN.c$153$1$1 ==. 1557 ; apps/test_spi_can/../CAN.c:153: txdata2[0] = 0x42; //tx buffer1 SIDH 0296 90s00r00 1558 mov dptr,#_txdata2 0299 74 42 1559 mov a,#0x42 029B F0 1560 movx @dptr,a 029C 1561 C$CAN.c$154$1$1 ==. 1562 ; apps/test_spi_can/../CAN.c:154: spiXMasterTransfer(txdata2,rxdata,14); 029C 78r00 1563 mov r0,#_spi1MasterTransfer_PARM_2 029E 74r0E 1564 mov a,#_rxdata 02A0 F2 1565 movx @r0,a 02A1 08 1566 inc r0 02A2 74s00 1567 mov a,#(_rxdata >> 8) 02A4 F2 1568 movx @r0,a 02A5 78r00 1569 mov r0,#_spi1MasterTransfer_PARM_3 02A7 74 0E 1570 mov a,#0x0E 02A9 F2 1571 movx @r0,a 02AA 08 1572 inc r0 02AB E4 1573 clr a 02AC F2 1574 movx @r0,a 02AD 90s00r00 1575 mov dptr,#_txdata2 02B0 12s00r00 1576 lcall _spi1MasterTransfer 02B3 1577 C$CAN.c$155$1$1 ==. 1578 ; apps/test_spi_can/../CAN.c:155: while(spiXMasterBusy()){ } 02B3 1579 00101$: 02B3 12s00r00 1580 lcall _spi1MasterBusy 02B6 40 FB 1581 jc 00101$ 02B8 1582 C$CAN.c$156$1$1 ==. 1583 ; apps/test_spi_can/../CAN.c:156: CShigh; 02B8 D2 F0 1584 setb b[0] 02BA 85 F0*00 1585 mov bits,b 02BD 75 82 0E 1586 mov dpl,#0x0E 02C0 1587 C$CAN.c$157$1$1 ==. 02C0 1588 XG$load_can_txbuf1$0$0 ==. 02C0 02s00r00 1589 ljmp _setDigitalOutput 1590 ;------------------------------------------------------------ 1591 ;Allocation info for local variables in function 'load_can_txbuf2' 1592 ;------------------------------------------------------------ 1593 ;------------------------------------------------------------ 02C3 1594 G$load_can_txbuf2$0$0 ==. 02C3 1595 C$CAN.c$159$1$1 ==. 1596 ; apps/test_spi_can/../CAN.c:159: void load_can_txbuf2(){ 1597 ; ----------------------------------------- 1598 ; function load_can_txbuf2 1599 ; ----------------------------------------- 02C3 1600 _load_can_txbuf2: 02C3 1601 C$CAN.c$160$1$1 ==. 1602 ; apps/test_spi_can/../CAN.c:160: CSlow; 02C3 C2 F0 1603 clr b[0] 02C5 85 F0*00 1604 mov bits,b 02C8 75 82 0E 1605 mov dpl,#0x0E 02CB 12s00r00 1606 lcall _setDigitalOutput 02CE 1607 C$CAN.c$161$1$1 ==. 1608 ; apps/test_spi_can/../CAN.c:161: txdata2[0] = 0x44; //tx buffer2 SIDH 02CE 90s00r00 1609 mov dptr,#_txdata2 02D1 74 44 1610 mov a,#0x44 02D3 F0 1611 movx @dptr,a 02D4 1612 C$CAN.c$162$1$1 ==. 1613 ; apps/test_spi_can/../CAN.c:162: spiXMasterTransfer(txdata2,rxdata,14); 02D4 78r00 1614 mov r0,#_spi1MasterTransfer_PARM_2 02D6 74r0E 1615 mov a,#_rxdata 02D8 F2 1616 movx @r0,a 02D9 08 1617 inc r0 02DA 74s00 1618 mov a,#(_rxdata >> 8) 02DC F2 1619 movx @r0,a 02DD 78r00 1620 mov r0,#_spi1MasterTransfer_PARM_3 02DF 74 0E 1621 mov a,#0x0E 02E1 F2 1622 movx @r0,a 02E2 08 1623 inc r0 02E3 E4 1624 clr a 02E4 F2 1625 movx @r0,a 02E5 90s00r00 1626 mov dptr,#_txdata2 02E8 12s00r00 1627 lcall _spi1MasterTransfer 02EB 1628 C$CAN.c$163$1$1 ==. 1629 ; apps/test_spi_can/../CAN.c:163: while(spiXMasterBusy()){ } 02EB 1630 00101$: 02EB 12s00r00 1631 lcall _spi1MasterBusy 02EE 40 FB 1632 jc 00101$ 02F0 1633 C$CAN.c$164$1$1 ==. 1634 ; apps/test_spi_can/../CAN.c:164: CShigh; 02F0 D2 F0 1635 setb b[0] 02F2 85 F0*00 1636 mov bits,b 02F5 75 82 0E 1637 mov dpl,#0x0E 02F8 1638 C$CAN.c$165$1$1 ==. 02F8 1639 XG$load_can_txbuf2$0$0 ==. 02F8 02s00r00 1640 ljmp _setDigitalOutput 1641 ;------------------------------------------------------------ 1642 ;Allocation info for local variables in function 'read_rxbuf0' 1643 ;------------------------------------------------------------ 1644 ;------------------------------------------------------------ 02FB 1645 G$read_rxbuf0$0$0 ==. 02FB 1646 C$CAN.c$167$1$1 ==. 1647 ; apps/test_spi_can/../CAN.c:167: void read_rxbuf0(){ 1648 ; ----------------------------------------- 1649 ; function read_rxbuf0 1650 ; ----------------------------------------- 02FB 1651 _read_rxbuf0: 02FB 1652 C$CAN.c$169$1$1 ==. 1653 ; apps/test_spi_can/../CAN.c:169: txdata2[0] = 0x90; // receive buffer0 starting with SIDH 02FB 90s00r00 1654 mov dptr,#_txdata2 02FE 74 90 1655 mov a,#0x90 0300 F0 1656 movx @dptr,a 0301 1657 C$CAN.c$170$1$1 ==. 1658 ; apps/test_spi_can/../CAN.c:170: CSlow; 0301 C2 F0 1659 clr b[0] 0303 85 F0*00 1660 mov bits,b 0306 75 82 0E 1661 mov dpl,#0x0E 0309 12s00r00 1662 lcall _setDigitalOutput 030C 1663 C$CAN.c$171$1$1 ==. 1664 ; apps/test_spi_can/../CAN.c:171: spiXMasterTransfer(txdata2,rxdata,14); 030C 78r00 1665 mov r0,#_spi1MasterTransfer_PARM_2 030E 74r0E 1666 mov a,#_rxdata 0310 F2 1667 movx @r0,a 0311 08 1668 inc r0 0312 74s00 1669 mov a,#(_rxdata >> 8) 0314 F2 1670 movx @r0,a 0315 78r00 1671 mov r0,#_spi1MasterTransfer_PARM_3 0317 74 0E 1672 mov a,#0x0E 0319 F2 1673 movx @r0,a 031A 08 1674 inc r0 031B E4 1675 clr a 031C F2 1676 movx @r0,a 031D 90s00r00 1677 mov dptr,#_txdata2 0320 12s00r00 1678 lcall _spi1MasterTransfer 0323 1679 C$CAN.c$172$1$1 ==. 1680 ; apps/test_spi_can/../CAN.c:172: while(spiXMasterBusy()){ } 0323 1681 00101$: 0323 12s00r00 1682 lcall _spi1MasterBusy 0326 40 FB 1683 jc 00101$ 0328 1684 C$CAN.c$173$1$1 ==. 1685 ; apps/test_spi_can/../CAN.c:173: CShigh; 0328 D2 F0 1686 setb b[0] 032A 85 F0*00 1687 mov bits,b 032D 75 82 0E 1688 mov dpl,#0x0E 0330 1689 C$CAN.c$174$1$1 ==. 0330 1690 XG$read_rxbuf0$0$0 ==. 0330 02s00r00 1691 ljmp _setDigitalOutput 1692 ;------------------------------------------------------------ 1693 ;Allocation info for local variables in function 'send_Canmsg_wait' 1694 ;------------------------------------------------------------ 1695 ;sloc0 Allocated with name '_send_Canmsg_wait_sloc0_1_0' 1696 ;------------------------------------------------------------ 0333 1697 G$send_Canmsg_wait$0$0 ==. 0333 1698 C$CAN.c$180$1$1 ==. 1699 ; apps/test_spi_can/../CAN.c:180: void send_Canmsg_wait(Can_msg *msg){ 1700 ; ----------------------------------------- 1701 ; function send_Canmsg_wait 1702 ; ----------------------------------------- 0333 1703 _send_Canmsg_wait: 0333 AA F0 1704 mov r2,b 0335 AB 83 1705 mov r3,dph 0337 E5 82 1706 mov a,dpl 0339 78r01 1707 mov r0,#_send_Canmsg_wait_msg_1_1 033B F2 1708 movx @r0,a 033C 08 1709 inc r0 033D EB 1710 mov a,r3 033E F2 1711 movx @r0,a 033F 08 1712 inc r0 0340 EA 1713 mov a,r2 0341 F2 1714 movx @r0,a 0342 1715 C$CAN.c$182$1$1 ==. 1716 ; apps/test_spi_can/../CAN.c:182: uint8 sent=0; 0342 78r06 1717 mov r0,#_send_Canmsg_wait_sent_1_1 0344 E4 1718 clr a 0345 F2 1719 movx @r0,a 0346 1720 C$CAN.c$184$1$1 ==. 1721 ; apps/test_spi_can/../CAN.c:184: txdata2[1] =(uint8) (msg->id >> 3); 0346 78r01 1722 mov r0,#_send_Canmsg_wait_msg_1_1 0348 E2 1723 movx a,@r0 0349 F5 82 1724 mov dpl,a 034B 08 1725 inc r0 034C E2 1726 movx a,@r0 034D F5 83 1727 mov dph,a 034F 08 1728 inc r0 0350 E2 1729 movx a,@r0 0351 F5 F0 1730 mov b,a 0353 12s00r00 1731 lcall __gptrget 0356 FE 1732 mov r6,a 0357 A3 1733 inc dptr 0358 12s00r00 1734 lcall __gptrget 035B FF 1735 mov r7,a 035C 8E 05 1736 mov ar5,r6 035E C4 1737 swap a 035F 23 1738 rl a 0360 CD 1739 xch a,r5 0361 C4 1740 swap a 0362 23 1741 rl a 0363 54 1F 1742 anl a,#0x1f 0365 6D 1743 xrl a,r5 0366 CD 1744 xch a,r5 0367 54 1F 1745 anl a,#0x1f 0369 CD 1746 xch a,r5 036A 6D 1747 xrl a,r5 036B CD 1748 xch a,r5 036C 90s00r01 1749 mov dptr,#(_txdata2 + 0x0001) 036F ED 1750 mov a,r5 0370 F0 1751 movx @dptr,a 0371 1752 C$CAN.c$185$1$1 ==. 1753 ; apps/test_spi_can/../CAN.c:185: txdata2[2] = (uint8) (msg->id << 5); 0371 EE 1754 mov a,r6 0372 C4 1755 swap a 0373 23 1756 rl a 0374 54 E0 1757 anl a,#0xe0 0376 FE 1758 mov r6,a 0377 90s00r02 1759 mov dptr,#(_txdata2 + 0x0002) 037A F0 1760 movx @dptr,a 037B 1761 C$CAN.c$187$1$1 ==. 1762 ; apps/test_spi_can/../CAN.c:187: txdata2[5] = msg->len;// data len 037B 78r01 1763 mov r0,#_send_Canmsg_wait_msg_1_1 037D E2 1764 movx a,@r0 037E 24 02 1765 add a,#0x02 0380 FA 1766 mov r2,a 0381 08 1767 inc r0 0382 E2 1768 movx a,@r0 0383 34 00 1769 addc a,#0x00 0385 FB 1770 mov r3,a 0386 08 1771 inc r0 0387 E2 1772 movx a,@r0 0388 FC 1773 mov r4,a 0389 8A 82 1774 mov dpl,r2 038B 8B 83 1775 mov dph,r3 038D 8C F0 1776 mov b,r4 038F 12s00r00 1777 lcall __gptrget 0392 FA 1778 mov r2,a 0393 90s00r05 1779 mov dptr,#(_txdata2 + 0x0005) 0396 F0 1780 movx @dptr,a 0397 1781 C$CAN.c$188$2$2 ==. 1782 ; apps/test_spi_can/../CAN.c:188: for(i = 0;i < msg->len; i++){ 0397 78r01 1783 mov r0,#_send_Canmsg_wait_msg_1_1 0399 E2 1784 movx a,@r0 039A 24 03 1785 add a,#0x03 039C FB 1786 mov r3,a 039D 08 1787 inc r0 039E E2 1788 movx a,@r0 039F 34 00 1789 addc a,#0x00 03A1 FC 1790 mov r4,a 03A2 08 1791 inc r0 03A3 E2 1792 movx a,@r0 03A4 FD 1793 mov r5,a 03A5 78r04 1794 mov r0,#_send_Canmsg_wait_i_1_1 03A7 E4 1795 clr a 03A8 F2 1796 movx @r0,a 03A9 08 1797 inc r0 03AA F2 1798 movx @r0,a 03AB 1799 00112$: 03AB C0 03 1800 push ar3 03AD C0 04 1801 push ar4 03AF C0 05 1802 push ar5 03B1 8A 03 1803 mov ar3,r2 03B3 7C 00 1804 mov r4,#0x00 03B5 78r04 1805 mov r0,#_send_Canmsg_wait_i_1_1 03B7 C3 1806 clr c 03B8 E2 1807 movx a,@r0 03B9 9B 1808 subb a,r3 03BA 08 1809 inc r0 03BB E2 1810 movx a,@r0 03BC 64 80 1811 xrl a,#0x80 03BE 8C F0 1812 mov b,r4 03C0 63 F0 80 1813 xrl b,#0x80 03C3 95 F0 1814 subb a,b 03C5 D0 05 1815 pop ar5 03C7 D0 04 1816 pop ar4 03C9 D0 03 1817 pop ar3 03CB 50 3B 1818 jnc 00109$ 03CD 1819 C$CAN.c$189$1$1 ==. 1820 ; apps/test_spi_can/../CAN.c:189: txdata2[6+i] = msg->dat[i]; 03CD C0 02 1821 push ar2 03CF 78r04 1822 mov r0,#_send_Canmsg_wait_i_1_1 03D1 E2 1823 movx a,@r0 03D2 24 06 1824 add a,#0x06 03D4 24r00 1825 add a,#_txdata2 03D6 F5*00 1826 mov _send_Canmsg_wait_sloc0_1_0,a 03D8 E4 1827 clr a 03D9 34s00 1828 addc a,#(_txdata2 >> 8) 03DB F5*01 1829 mov (_send_Canmsg_wait_sloc0_1_0 + 1),a 03DD 78r04 1830 mov r0,#_send_Canmsg_wait_i_1_1 03DF E2 1831 movx a,@r0 03E0 2B 1832 add a,r3 03E1 FF 1833 mov r7,a 03E2 08 1834 inc r0 03E3 E2 1835 movx a,@r0 03E4 3C 1836 addc a,r4 03E5 FA 1837 mov r2,a 03E6 8D 06 1838 mov ar6,r5 03E8 8F 82 1839 mov dpl,r7 03EA 8A 83 1840 mov dph,r2 03EC 8E F0 1841 mov b,r6 03EE 12s00r00 1842 lcall __gptrget 03F1 FF 1843 mov r7,a 03F2 85*00 82 1844 mov dpl,_send_Canmsg_wait_sloc0_1_0 03F5 85*01 83 1845 mov dph,(_send_Canmsg_wait_sloc0_1_0 + 1) 03F8 F0 1846 movx @dptr,a 03F9 1847 C$CAN.c$188$1$1 ==. 1848 ; apps/test_spi_can/../CAN.c:188: for(i = 0;i < msg->len; i++){ 03F9 78r04 1849 mov r0,#_send_Canmsg_wait_i_1_1 03FB E2 1850 movx a,@r0 03FC 24 01 1851 add a,#0x01 03FE F2 1852 movx @r0,a 03FF 08 1853 inc r0 0400 E2 1854 movx a,@r0 0401 34 00 1855 addc a,#0x00 0403 F2 1856 movx @r0,a 0404 D0 02 1857 pop ar2 0406 1858 C$CAN.c$192$1$1 ==. 1859 ; apps/test_spi_can/../CAN.c:192: while(!sent){ 0406 80 A3 1860 sjmp 00112$ 0408 1861 00109$: 0408 78r06 1862 mov r0,#_send_Canmsg_wait_sent_1_1 040A E2 1863 movx a,@r0 040B 70 60 1864 jnz 00116$ 040D 1865 C$CAN.c$193$2$3 ==. 1866 ; apps/test_spi_can/../CAN.c:193: if((read_can_reg(0x30) & (1<<3)) == 0){ // check if message in txbuf0 is pending transmission 040D 75 82 30 1867 mov dpl,#0x30 0410 12s00r95 1868 lcall _read_can_reg 0413 E5 82 1869 mov a,dpl 0415 20 E3 15 1870 jb acc.3,00107$ 0418 1871 C$CAN.c$194$3$4 ==. 1872 ; apps/test_spi_can/../CAN.c:194: load_can_txbuf0(); 0418 12s02r59 1873 lcall _load_can_txbuf0 041B 1874 C$CAN.c$195$3$4 ==. 1875 ; apps/test_spi_can/../CAN.c:195: write_can_reg(0x30,0x0B);// initiate tx from txbuf0 041B 78r00 1876 mov r0,#_write_can_reg_PARM_2 041D 74 0B 1877 mov a,#0x0B 041F F2 1878 movx @r0,a 0420 75 82 30 1879 mov dpl,#0x30 0423 12s00rDB 1880 lcall _write_can_reg 0426 1881 C$CAN.c$196$3$4 ==. 1882 ; apps/test_spi_can/../CAN.c:196: sent=1; 0426 78r06 1883 mov r0,#_send_Canmsg_wait_sent_1_1 0428 74 01 1884 mov a,#0x01 042A F2 1885 movx @r0,a 042B 80 DB 1886 sjmp 00109$ 042D 1887 00107$: 042D 1888 C$CAN.c$197$2$3 ==. 1889 ; apps/test_spi_can/../CAN.c:197: }else if((read_can_reg(0x40) & (1<<3)) == 0){ // check if message in txbuf1 is pending transmission 042D 75 82 40 1890 mov dpl,#0x40 0430 12s00r95 1891 lcall _read_can_reg 0433 E5 82 1892 mov a,dpl 0435 20 E3 15 1893 jb acc.3,00104$ 0438 1894 C$CAN.c$198$3$5 ==. 1895 ; apps/test_spi_can/../CAN.c:198: load_can_txbuf1(); 0438 12s02r8B 1896 lcall _load_can_txbuf1 043B 1897 C$CAN.c$199$3$5 ==. 1898 ; apps/test_spi_can/../CAN.c:199: write_can_reg(0x40,0x0B);// initiate tx from txbuf1 043B 78r00 1899 mov r0,#_write_can_reg_PARM_2 043D 74 0B 1900 mov a,#0x0B 043F F2 1901 movx @r0,a 0440 75 82 40 1902 mov dpl,#0x40 0443 12s00rDB 1903 lcall _write_can_reg 0446 1904 C$CAN.c$200$3$5 ==. 1905 ; apps/test_spi_can/../CAN.c:200: sent=1; 0446 78r06 1906 mov r0,#_send_Canmsg_wait_sent_1_1 0448 74 01 1907 mov a,#0x01 044A F2 1908 movx @r0,a 044B 80 BB 1909 sjmp 00109$ 044D 1910 00104$: 044D 1911 C$CAN.c$201$2$3 ==. 1912 ; apps/test_spi_can/../CAN.c:201: }else if((read_can_reg(0x50) & (1<<3)) == 0){// check if message in txbuf2 is pending transmission 044D 75 82 50 1913 mov dpl,#0x50 0450 12s00r95 1914 lcall _read_can_reg 0453 E5 82 1915 mov a,dpl 0455 20 E3 B0 1916 jb acc.3,00109$ 0458 1917 C$CAN.c$202$3$6 ==. 1918 ; apps/test_spi_can/../CAN.c:202: load_can_txbuf2(); 0458 12s02rC3 1919 lcall _load_can_txbuf2 045B 1920 C$CAN.c$203$3$6 ==. 1921 ; apps/test_spi_can/../CAN.c:203: write_can_reg(0x50,0x0B);// initiate tx from txbuf2 045B 78r00 1922 mov r0,#_write_can_reg_PARM_2 045D 74 0B 1923 mov a,#0x0B 045F F2 1924 movx @r0,a 0460 75 82 50 1925 mov dpl,#0x50 0463 12s00rDB 1926 lcall _write_can_reg 0466 1927 C$CAN.c$204$3$6 ==. 1928 ; apps/test_spi_can/../CAN.c:204: sent=1; 0466 78r06 1929 mov r0,#_send_Canmsg_wait_sent_1_1 0468 74 01 1930 mov a,#0x01 046A F2 1931 movx @r0,a 046B 80 9B 1932 sjmp 00109$ 046D 1933 00116$: 046D 1934 C$CAN.c$207$1$1 ==. 046D 1935 XG$send_Canmsg_wait$0$0 ==. 046D 22 1936 ret 1937 ;------------------------------------------------------------ 1938 ;Allocation info for local variables in function 'get_Canmsg' 1939 ;------------------------------------------------------------ 1940 ;sloc0 Allocated with name '_get_Canmsg_sloc0_1_0' 1941 ;sloc1 Allocated with name '_get_Canmsg_sloc1_1_0' 1942 ;sloc2 Allocated with name '_get_Canmsg_sloc2_1_0' 1943 ;sloc3 Allocated with name '_get_Canmsg_sloc3_1_0' 1944 ;sloc4 Allocated with name '_get_Canmsg_sloc4_1_0' 1945 ;sloc5 Allocated with name '_get_Canmsg_sloc5_1_0' 1946 ;------------------------------------------------------------ 046E 1947 G$get_Canmsg$0$0 ==. 046E 1948 C$CAN.c$211$1$1 ==. 1949 ; apps/test_spi_can/../CAN.c:211: uint8 get_Canmsg(Can_msg *msg){ 1950 ; ----------------------------------------- 1951 ; function get_Canmsg 1952 ; ----------------------------------------- 046E 1953 _get_Canmsg: 046E AA F0 1954 mov r2,b 0470 AB 83 1955 mov r3,dph 0472 E5 82 1956 mov a,dpl 0474 78r07 1957 mov r0,#_get_Canmsg_msg_1_1 0476 F2 1958 movx @r0,a 0477 08 1959 inc r0 0478 EB 1960 mov a,r3 0479 F2 1961 movx @r0,a 047A 08 1962 inc r0 047B EA 1963 mov a,r2 047C F2 1964 movx @r0,a 047D 1965 C$CAN.c$212$1$1 ==. 1966 ; apps/test_spi_can/../CAN.c:212: uint8 nmsg = 0,i; 047D 7D 00 1967 mov r5,#0x00 047F 1968 C$CAN.c$213$1$1 ==. 1969 ; apps/test_spi_can/../CAN.c:213: if((read_can_reg(0x2c) & 1) == 1){ // rxbuf0 is full 047F 75 82 2C 1970 mov dpl,#0x2C 0482 C0 05 1971 push ar5 0484 12s00r95 1972 lcall _read_can_reg 0487 E5 82 1973 mov a,dpl 0489 D0 05 1974 pop ar5 048B 54 01 1975 anl a,#0x01 048D FE 1976 mov r6,a 048E BE 01 02 1977 cjne r6,#0x01,00113$ 0491 80 03 1978 sjmp 00114$ 0493 1979 00113$: 0493 02s05r53 1980 ljmp 00102$ 0496 1981 00114$: 0496 1982 C$CAN.c$214$2$2 ==. 1983 ; apps/test_spi_can/../CAN.c:214: read_rxbuf0(); //takes care of clearing interrupt 0496 12s02rFB 1984 lcall _read_rxbuf0 0499 1985 C$CAN.c$215$2$2 ==. 1986 ; apps/test_spi_can/../CAN.c:215: msg->len = rxdata[5] & 0x0F; 0499 78r07 1987 mov r0,#_get_Canmsg_msg_1_1 049B E2 1988 movx a,@r0 049C 24 02 1989 add a,#0x02 049E F5*02 1990 mov _get_Canmsg_sloc0_1_0,a 04A0 08 1991 inc r0 04A1 E2 1992 movx a,@r0 04A2 34 00 1993 addc a,#0x00 04A4 F5*03 1994 mov (_get_Canmsg_sloc0_1_0 + 1),a 04A6 08 1995 inc r0 04A7 E2 1996 movx a,@r0 04A8 F5*04 1997 mov (_get_Canmsg_sloc0_1_0 + 2),a 04AA 90s00r13 1998 mov dptr,#(_rxdata + 0x0005) 04AD E0 1999 movx a,@dptr 04AE F5*05 2000 mov _get_Canmsg_sloc1_1_0,a 04B0 74 0F 2001 mov a,#0x0F 04B2 55*05 2002 anl a,_get_Canmsg_sloc1_1_0 04B4 F5*06 2003 mov _get_Canmsg_sloc2_1_0,a 04B6 85*02 82 2004 mov dpl,_get_Canmsg_sloc0_1_0 04B9 85*03 83 2005 mov dph,(_get_Canmsg_sloc0_1_0 + 1) 04BC 85*04 F0 2006 mov b,(_get_Canmsg_sloc0_1_0 + 2) 04BF 12s00r00 2007 lcall __gptrput 04C2 2008 C$CAN.c$216$2$2 ==. 2009 ; apps/test_spi_can/../CAN.c:216: msg->id = (rxdata[1] << 3) + (rxdata[2] >> 5); 04C2 90s00r0F 2010 mov dptr,#(_rxdata + 0x0001) 04C5 E0 2011 movx a,@dptr 04C6 F5*07 2012 mov _get_Canmsg_sloc3_1_0,a 04C8 85*07*08 2013 mov _get_Canmsg_sloc4_1_0,_get_Canmsg_sloc3_1_0 04CB 75*09 00 2014 mov (_get_Canmsg_sloc4_1_0 + 1),#0x00 04CE AB*08 2015 mov r3,_get_Canmsg_sloc4_1_0 04D0 E5*09 2016 mov a,(_get_Canmsg_sloc4_1_0 + 1) 04D2 C4 2017 swap a 04D3 03 2018 rr a 04D4 54 F8 2019 anl a,#0xf8 04D6 CB 2020 xch a,r3 04D7 C4 2021 swap a 04D8 03 2022 rr a 04D9 CB 2023 xch a,r3 04DA 6B 2024 xrl a,r3 04DB CB 2025 xch a,r3 04DC 54 F8 2026 anl a,#0xf8 04DE CB 2027 xch a,r3 04DF 6B 2028 xrl a,r3 04E0 FC 2029 mov r4,a 04E1 90s00r10 2030 mov dptr,#(_rxdata + 0x0002) 04E4 E0 2031 movx a,@dptr 04E5 C4 2032 swap a 04E6 03 2033 rr a 04E7 54 07 2034 anl a,#0x07 04E9 FE 2035 mov r6,a 04EA 7F 00 2036 mov r7,#0x00 04EC 2B 2037 add a,r3 04ED FB 2038 mov r3,a 04EE EF 2039 mov a,r7 04EF 3C 2040 addc a,r4 04F0 FC 2041 mov r4,a 04F1 78r07 2042 mov r0,#_get_Canmsg_msg_1_1 04F3 E2 2043 movx a,@r0 04F4 F5 82 2044 mov dpl,a 04F6 08 2045 inc r0 04F7 E2 2046 movx a,@r0 04F8 F5 83 2047 mov dph,a 04FA 08 2048 inc r0 04FB E2 2049 movx a,@r0 04FC F5 F0 2050 mov b,a 04FE EB 2051 mov a,r3 04FF 12s00r00 2052 lcall __gptrput 0502 A3 2053 inc dptr 0503 EC 2054 mov a,r4 0504 12s00r00 2055 lcall __gptrput 0507 2056 C$CAN.c$217$3$3 ==. 2057 ; apps/test_spi_can/../CAN.c:217: for( i = 0;ilen;i++){ 0507 78r07 2058 mov r0,#_get_Canmsg_msg_1_1 0509 E2 2059 movx a,@r0 050A 24 03 2060 add a,#0x03 050C F5*0A 2061 mov _get_Canmsg_sloc5_1_0,a 050E 08 2062 inc r0 050F E2 2063 movx a,@r0 0510 34 00 2064 addc a,#0x00 0512 F5*0B 2065 mov (_get_Canmsg_sloc5_1_0 + 1),a 0514 08 2066 inc r0 0515 E2 2067 movx a,@r0 0516 F5*0C 2068 mov (_get_Canmsg_sloc5_1_0 + 2),a 0518 7A 00 2069 mov r2,#0x00 051A 2070 00103$: 051A 85*02 82 2071 mov dpl,_get_Canmsg_sloc0_1_0 051D 85*03 83 2072 mov dph,(_get_Canmsg_sloc0_1_0 + 1) 0520 85*04 F0 2073 mov b,(_get_Canmsg_sloc0_1_0 + 2) 0523 12s00r00 2074 lcall __gptrget 0526 FB 2075 mov r3,a 0527 EA 2076 mov a,r2 0528 B5 03 00 2077 cjne a,ar3,00115$ 052B 2078 00115$: 052B 50 24 2079 jnc 00106$ 052D 2080 C$CAN.c$218$3$3 ==. 2081 ; apps/test_spi_can/../CAN.c:218: msg->dat[i] = rxdata[6+i]; 052D EA 2082 mov a,r2 052E 25*0A 2083 add a,_get_Canmsg_sloc5_1_0 0530 FF 2084 mov r7,a 0531 E4 2085 clr a 0532 35*0B 2086 addc a,(_get_Canmsg_sloc5_1_0 + 1) 0534 FB 2087 mov r3,a 0535 AC*0C 2088 mov r4,(_get_Canmsg_sloc5_1_0 + 2) 0537 74 06 2089 mov a,#0x06 0539 2A 2090 add a,r2 053A 24r0E 2091 add a,#_rxdata 053C F5 82 2092 mov dpl,a 053E E4 2093 clr a 053F 34s00 2094 addc a,#(_rxdata >> 8) 0541 F5 83 2095 mov dph,a 0543 E0 2096 movx a,@dptr 0544 FE 2097 mov r6,a 0545 8F 82 2098 mov dpl,r7 0547 8B 83 2099 mov dph,r3 0549 8C F0 2100 mov b,r4 054B 12s00r00 2101 lcall __gptrput 054E 2102 C$CAN.c$217$2$2 ==. 2103 ; apps/test_spi_can/../CAN.c:217: for( i = 0;ilen;i++){ 054E 0A 2104 inc r2 054F 80 C9 2105 sjmp 00103$ 0551 2106 00106$: 0551 2107 C$CAN.c$220$2$2 ==. 2108 ; apps/test_spi_can/../CAN.c:220: nmsg += 1; 0551 7D 01 2109 mov r5,#0x01 0553 2110 00102$: 0553 2111 C$CAN.c$224$1$1 ==. 2112 ; apps/test_spi_can/../CAN.c:224: return nmsg; 0553 8D 82 2113 mov dpl,r5 0555 2114 C$CAN.c$225$1$1 ==. 0555 2115 XG$get_Canmsg$0$0 ==. 0555 22 2116 ret 2117 ;------------------------------------------------------------ 2118 ;Allocation info for local variables in function 'rxbuf0_full' 2119 ;------------------------------------------------------------ 2120 ;------------------------------------------------------------ 0556 2121 G$rxbuf0_full$0$0 ==. 0556 2122 C$CAN.c$227$1$1 ==. 2123 ; apps/test_spi_can/../CAN.c:227: uint8 rxbuf0_full() 2124 ; ----------------------------------------- 2125 ; function rxbuf0_full 2126 ; ----------------------------------------- 0556 2127 _rxbuf0_full: 0556 2128 C$CAN.c$229$1$1 ==. 2129 ; apps/test_spi_can/../CAN.c:229: if((read_can_reg(0x2c) & 1) == 1){ 0556 75 82 2C 2130 mov dpl,#0x2C 0559 12s00r95 2131 lcall _read_can_reg 055C E5 82 2132 mov a,dpl 055E 54 01 2133 anl a,#0x01 0560 FA 2134 mov r2,a 0561 BA 01 04 2135 cjne r2,#0x01,00102$ 0564 2136 C$CAN.c$230$2$2 ==. 2137 ; apps/test_spi_can/../CAN.c:230: return 1; 0564 75 82 01 2138 mov dpl,#0x01 0567 2139 C$CAN.c$232$1$1 ==. 2140 ; apps/test_spi_can/../CAN.c:232: return 0; 0567 2141 C$CAN.c$233$1$1 ==. 0567 2142 XG$rxbuf0_full$0$0 ==. 0567 22 2143 ret 0568 2144 00102$: 0568 75 82 00 2145 mov dpl,#0x00 056B 22 2146 ret 2147 ;------------------------------------------------------------ 2148 ;Allocation info for local variables in function 'testfun' 2149 ;------------------------------------------------------------ 2150 ;------------------------------------------------------------ 056C 2151 G$testfun$0$0 ==. 056C 2152 C$CAN.c$235$1$1 ==. 2153 ; apps/test_spi_can/../CAN.c:235: uint8 testfun(){ 2154 ; ----------------------------------------- 2155 ; function testfun 2156 ; ----------------------------------------- 056C 2157 _testfun: 056C 2158 C$CAN.c$236$1$1 ==. 2159 ; apps/test_spi_can/../CAN.c:236: return 88; 056C 75 82 58 2160 mov dpl,#0x58 056F 2161 C$CAN.c$237$1$1 ==. 056F 2162 XG$testfun$0$0 ==. 056F 22 2163 ret 2164 ;------------------------------------------------------------ 2165 ;Allocation info for local variables in function 'updateLeds' 2166 ;------------------------------------------------------------ 2167 ;------------------------------------------------------------ 0570 2168 G$updateLeds$0$0 ==. 0570 2169 C$test_spi_can.c$56$1$1 ==. 2170 ; apps/test_spi_can/test_spi_can.c:56: void updateLeds() 2171 ; ----------------------------------------- 2172 ; function updateLeds 2173 ; ----------------------------------------- 0570 2174 _updateLeds: 0570 2175 C$test_spi_can.c$58$1$1 ==. 2176 ; apps/test_spi_can/test_spi_can.c:58: usbShowStatusWithGreenLed(); 0570 2177 C$test_spi_can.c$61$1$1 ==. 0570 2178 XG$updateLeds$0$0 ==. 0570 02s00r00 2179 ljmp _usbShowStatusWithGreenLed 2180 ;------------------------------------------------------------ 2181 ;Allocation info for local variables in function 'putchar' 2182 ;------------------------------------------------------------ 2183 ;------------------------------------------------------------ 0573 2184 G$putchar$0$0 ==. 0573 2185 C$test_spi_can.c$65$1$1 ==. 2186 ; apps/test_spi_can/test_spi_can.c:65: void putchar(char c) 2187 ; ----------------------------------------- 2188 ; function putchar 2189 ; ----------------------------------------- 0573 2190 _putchar: 0573 AA 82 2191 mov r2,dpl 0575 2192 C$test_spi_can.c$67$1$1 ==. 2193 ; apps/test_spi_can/test_spi_can.c:67: report[reportLength] = c; 0575 E5*0D 2194 mov a,_reportLength 0577 24r00 2195 add a,#_report 0579 F5 82 2196 mov dpl,a 057B E5*0E 2197 mov a,(_reportLength + 1) 057D 34s00 2198 addc a,#(_report >> 8) 057F F5 83 2199 mov dph,a 0581 EA 2200 mov a,r2 0582 F0 2201 movx @dptr,a 0583 2202 C$test_spi_can.c$68$1$1 ==. 2203 ; apps/test_spi_can/test_spi_can.c:68: reportLength++; 0583 05*0D 2204 inc _reportLength 0585 E4 2205 clr a 0586 B5*0D 02 2206 cjne a,_reportLength,00103$ 0589 05*0E 2207 inc (_reportLength + 1) 058B 2208 00103$: 058B 2209 C$test_spi_can.c$69$1$1 ==. 058B 2210 XG$putchar$0$0 ==. 058B 22 2211 ret 2212 ;------------------------------------------------------------ 2213 ;Allocation info for local variables in function 'sendReportIfNeeded' 2214 ;------------------------------------------------------------ 2215 ;sloc0 Allocated with name '_sendReportIfNeeded_sloc0_1_0' 2216 ;------------------------------------------------------------ 058C 2217 G$sendReportIfNeeded$0$0 ==. 058C 2218 C$test_spi_can.c$73$1$1 ==. 2219 ; apps/test_spi_can/test_spi_can.c:73: void sendReportIfNeeded() 2220 ; ----------------------------------------- 2221 ; function sendReportIfNeeded 2222 ; ----------------------------------------- 058C 2223 _sendReportIfNeeded: 058C 2224 C$test_spi_can.c$82$1$1 ==. 2225 ; apps/test_spi_can/test_spi_can.c:82: if (getMs() - lastReport >= param_report_period_ms && reportLength == 0) 058C 12s00r00 2226 lcall _getMs 058F AA 82 2227 mov r2,dpl 0591 AB 83 2228 mov r3,dph 0593 AC F0 2229 mov r4,b 0595 FD 2230 mov r5,a 0596 78r0A 2231 mov r0,#_sendReportIfNeeded_lastReport_1_1 0598 D3 2232 setb c 0599 E2 2233 movx a,@r0 059A 9A 2234 subb a,r2 059B F4 2235 cpl a 059C B3 2236 cpl c 059D F5*1C 2237 mov _sendReportIfNeeded_sloc0_1_0,a 059F B3 2238 cpl c 05A0 08 2239 inc r0 05A1 E2 2240 movx a,@r0 05A2 9B 2241 subb a,r3 05A3 F4 2242 cpl a 05A4 B3 2243 cpl c 05A5 F5*1D 2244 mov (_sendReportIfNeeded_sloc0_1_0 + 1),a 05A7 B3 2245 cpl c 05A8 08 2246 inc r0 05A9 E2 2247 movx a,@r0 05AA 9C 2248 subb a,r4 05AB F4 2249 cpl a 05AC B3 2250 cpl c 05AD F5*1E 2251 mov (_sendReportIfNeeded_sloc0_1_0 + 2),a 05AF B3 2252 cpl c 05B0 08 2253 inc r0 05B1 E2 2254 movx a,@r0 05B2 9D 2255 subb a,r5 05B3 F4 2256 cpl a 05B4 F5*1F 2257 mov (_sendReportIfNeeded_sloc0_1_0 + 3),a 05B6 90s00r08 2258 mov dptr,#_param_report_period_ms 05B9 E4 2259 clr a 05BA 93 2260 movc a,@a+dptr 05BB FE 2261 mov r6,a 05BC 74 01 2262 mov a,#0x01 05BE 93 2263 movc a,@a+dptr 05BF FF 2264 mov r7,a 05C0 74 02 2265 mov a,#0x02 05C2 93 2266 movc a,@a+dptr 05C3 FA 2267 mov r2,a 05C4 74 03 2268 mov a,#0x03 05C6 93 2269 movc a,@a+dptr 05C7 FB 2270 mov r3,a 05C8 C3 2271 clr c 05C9 E5*1C 2272 mov a,_sendReportIfNeeded_sloc0_1_0 05CB 9E 2273 subb a,r6 05CC E5*1D 2274 mov a,(_sendReportIfNeeded_sloc0_1_0 + 1) 05CE 9F 2275 subb a,r7 05CF E5*1E 2276 mov a,(_sendReportIfNeeded_sloc0_1_0 + 2) 05D1 9A 2277 subb a,r2 05D2 E5*1F 2278 mov a,(_sendReportIfNeeded_sloc0_1_0 + 3) 05D4 9B 2279 subb a,r3 05D5 50 03 2280 jnc 00118$ 05D7 02s06rE3 2281 ljmp 00104$ 05DA 2282 00118$: 05DA E5*0D 2283 mov a,_reportLength 05DC 45*0E 2284 orl a,(_reportLength + 1) 05DE 60 03 2285 jz 00119$ 05E0 02s06rE3 2286 ljmp 00104$ 05E3 2287 00119$: 05E3 2288 C$test_spi_can.c$84$2$2 ==. 2289 ; apps/test_spi_can/test_spi_can.c:84: lastReport = getMs(); 05E3 12s00r00 2290 lcall _getMs 05E6 AA 82 2291 mov r2,dpl 05E8 AB 83 2292 mov r3,dph 05EA AC F0 2293 mov r4,b 05EC FD 2294 mov r5,a 05ED 78r0A 2295 mov r0,#_sendReportIfNeeded_lastReport_1_1 05EF EA 2296 mov a,r2 05F0 F2 2297 movx @r0,a 05F1 08 2298 inc r0 05F2 EB 2299 mov a,r3 05F3 F2 2300 movx @r0,a 05F4 08 2301 inc r0 05F5 EC 2302 mov a,r4 05F6 F2 2303 movx @r0,a 05F7 08 2304 inc r0 05F8 ED 2305 mov a,r5 05F9 F2 2306 movx @r0,a 05FA 2307 C$test_spi_can.c$85$2$2 ==. 2308 ; apps/test_spi_can/test_spi_can.c:85: reportBytesSent = 0; 05FA E4 2309 clr a 05FB F5*0F 2310 mov _reportBytesSent,a 05FD F5*10 2311 mov (_reportBytesSent + 1),a 05FF 2312 C$test_spi_can.c$88$2$2 ==. 2313 ; apps/test_spi_can/test_spi_can.c:88: if (param_bar_graph) 05FF 90s00r04 2314 mov dptr,#_param_bar_graph 0602 E4 2315 clr a 0603 93 2316 movc a,@a+dptr 0604 FA 2317 mov r2,a 0605 74 01 2318 mov a,#0x01 0607 93 2319 movc a,@a+dptr 0608 FB 2320 mov r3,a 0609 74 02 2321 mov a,#0x02 060B 93 2322 movc a,@a+dptr 060C FC 2323 mov r4,a 060D 74 03 2324 mov a,#0x03 060F 93 2325 movc a,@a+dptr 0610 FD 2326 mov r5,a 0611 EA 2327 mov a,r2 0612 4B 2328 orl a,r3 0613 4C 2329 orl a,r4 0614 4D 2330 orl a,r5 0615 70 03 2331 jnz 00120$ 0617 02s06rE3 2332 ljmp 00104$ 061A 2333 00120$: 061A 2334 C$test_spi_can.c$90$3$3 ==. 2335 ; apps/test_spi_can/test_spi_can.c:90: printf("\x1B[0;0H"); // VT100 command for "go to 0,0" 061A 74r0C 2336 mov a,#__str_0 061C C0 E0 2337 push acc 061E 74s00 2338 mov a,#(__str_0 >> 8) 0620 C0 E0 2339 push acc 0622 74 80 2340 mov a,#0x80 0624 C0 E0 2341 push acc 0626 12s00r00 2342 lcall _printf 0629 15 81 2343 dec sp 062B 15 81 2344 dec sp 062D 15 81 2345 dec sp 062F 2346 C$test_spi_can.c$93$3$3 ==. 2347 ; apps/test_spi_can/test_spi_can.c:93: printf("CANCTRL REG = %4d \n",read_can_reg(0x0f)); 062F 75 82 0F 2348 mov dpl,#0x0F 0632 12s00r95 2349 lcall _read_can_reg 0635 AA 82 2350 mov r2,dpl 0637 7B 00 2351 mov r3,#0x00 0639 C0 02 2352 push ar2 063B C0 03 2353 push ar3 063D 74r13 2354 mov a,#__str_1 063F C0 E0 2355 push acc 0641 74s00 2356 mov a,#(__str_1 >> 8) 0643 C0 E0 2357 push acc 0645 74 80 2358 mov a,#0x80 0647 C0 E0 2359 push acc 0649 12s00r00 2360 lcall _printf 064C E5 81 2361 mov a,sp 064E 24 FB 2362 add a,#0xfb 0650 F5 81 2363 mov sp,a 0652 2364 C$test_spi_can.c$94$3$3 ==. 2365 ; apps/test_spi_can/test_spi_can.c:94: printf("CANSTAT REG = %4d \n",read_can_reg(0x0e)); 0652 75 82 0E 2366 mov dpl,#0x0E 0655 12s00r95 2367 lcall _read_can_reg 0658 AA 82 2368 mov r2,dpl 065A 7B 00 2369 mov r3,#0x00 065C C0 02 2370 push ar2 065E C0 03 2371 push ar3 0660 74r27 2372 mov a,#__str_2 0662 C0 E0 2373 push acc 0664 74s00 2374 mov a,#(__str_2 >> 8) 0666 C0 E0 2375 push acc 0668 74 80 2376 mov a,#0x80 066A C0 E0 2377 push acc 066C 12s00r00 2378 lcall _printf 066F E5 81 2379 mov a,sp 0671 24 FB 2380 add a,#0xfb 0673 F5 81 2381 mov sp,a 0675 2382 C$test_spi_can.c$95$3$3 ==. 2383 ; apps/test_spi_can/test_spi_can.c:95: printf("datalen = 0x%x ********\n",msg2.len); 0675 AA*13 2384 mov r2,(_msg2 + 0x0002) 0677 7B 00 2385 mov r3,#0x00 0679 C0 02 2386 push ar2 067B C0 03 2387 push ar3 067D 74r3B 2388 mov a,#__str_3 067F C0 E0 2389 push acc 0681 74s00 2390 mov a,#(__str_3 >> 8) 0683 C0 E0 2391 push acc 0685 74 80 2392 mov a,#0x80 0687 C0 E0 2393 push acc 0689 12s00r00 2394 lcall _printf 068C E5 81 2395 mov a,sp 068E 24 FB 2396 add a,#0xfb 0690 F5 81 2397 mov sp,a 0692 2398 C$test_spi_can.c$96$3$3 ==. 2399 ; apps/test_spi_can/test_spi_can.c:96: printf("SID = 0x%x ********\n",msg2.id); 0692 C0*11 2400 push _msg2 0694 C0*12 2401 push (_msg2 + 1) 0696 74r54 2402 mov a,#__str_4 0698 C0 E0 2403 push acc 069A 74s00 2404 mov a,#(__str_4 >> 8) 069C C0 E0 2405 push acc 069E 74 80 2406 mov a,#0x80 06A0 C0 E0 2407 push acc 06A2 12s00r00 2408 lcall _printf 06A5 E5 81 2409 mov a,sp 06A7 24 FB 2410 add a,#0xfb 06A9 F5 81 2411 mov sp,a 06AB 2412 C$test_spi_can.c$98$3$3 ==. 2413 ; apps/test_spi_can/test_spi_can.c:98: printf("test fun is 0x %x\n ..",i ); 06AB 74 22 2414 mov a,#0x22 06AD C0 E0 2415 push acc 06AF E4 2416 clr a 06B0 C0 E0 2417 push acc 06B2 74r69 2418 mov a,#__str_5 06B4 C0 E0 2419 push acc 06B6 74s00 2420 mov a,#(__str_5 >> 8) 06B8 C0 E0 2421 push acc 06BA 74 80 2422 mov a,#0x80 06BC C0 E0 2423 push acc 06BE 12s00r00 2424 lcall _printf 06C1 E5 81 2425 mov a,sp 06C3 24 FB 2426 add a,#0xfb 06C5 F5 81 2427 mov sp,a 06C7 2428 C$test_spi_can.c$100$3$3 ==. 2429 ; apps/test_spi_can/test_spi_can.c:100: printf("test fun2 is 0x %x\n ..",i ); 06C7 74 20 2430 mov a,#0x20 06C9 C0 E0 2431 push acc 06CB E4 2432 clr a 06CC C0 E0 2433 push acc 06CE 74r80 2434 mov a,#__str_6 06D0 C0 E0 2435 push acc 06D2 74s00 2436 mov a,#(__str_6 >> 8) 06D4 C0 E0 2437 push acc 06D6 74 80 2438 mov a,#0x80 06D8 C0 E0 2439 push acc 06DA 12s00r00 2440 lcall _printf 06DD E5 81 2441 mov a,sp 06DF 24 FB 2442 add a,#0xfb 06E1 F5 81 2443 mov sp,a 06E3 2444 00104$: 06E3 2445 C$test_spi_can.c$111$1$1 ==. 2446 ; apps/test_spi_can/test_spi_can.c:111: if (reportLength > 0) 06E3 E5*0D 2447 mov a,_reportLength 06E5 45*0E 2448 orl a,(_reportLength + 1) 06E7 60 5D 2449 jz 00111$ 06E9 2450 C$test_spi_can.c$113$2$5 ==. 2451 ; apps/test_spi_can/test_spi_can.c:113: bytesToSend = usbComTxAvailable(); 06E9 12s00r00 2452 lcall _usbComTxAvailable 06EC AA 82 2453 mov r2,dpl 06EE 2454 C$test_spi_can.c$114$2$5 ==. 2455 ; apps/test_spi_can/test_spi_can.c:114: if (bytesToSend > reportLength - reportBytesSent) 06EE E5*0D 2456 mov a,_reportLength 06F0 C3 2457 clr c 06F1 95*0F 2458 subb a,_reportBytesSent 06F3 FB 2459 mov r3,a 06F4 E5*0E 2460 mov a,(_reportLength + 1) 06F6 95*10 2461 subb a,(_reportBytesSent + 1) 06F8 FC 2462 mov r4,a 06F9 8A 05 2463 mov ar5,r2 06FB 7E 00 2464 mov r6,#0x00 06FD C3 2465 clr c 06FE EB 2466 mov a,r3 06FF 9D 2467 subb a,r5 0700 EC 2468 mov a,r4 0701 9E 2469 subb a,r6 0702 50 1F 2470 jnc 00107$ 0704 2471 C$test_spi_can.c$117$3$6 ==. 2472 ; apps/test_spi_can/test_spi_can.c:117: usbComTxSend(report+reportBytesSent, reportLength - reportBytesSent); 0704 E5*0F 2473 mov a,_reportBytesSent 0706 24r00 2474 add a,#_report 0708 F5 82 2475 mov dpl,a 070A E5*10 2476 mov a,(_reportBytesSent + 1) 070C 34s00 2477 addc a,#(_report >> 8) 070E F5 83 2478 mov dph,a 0710 AB*0D 2479 mov r3,_reportLength 0712 AC*0F 2480 mov r4,_reportBytesSent 0714 EB 2481 mov a,r3 0715 C3 2482 clr c 0716 9C 2483 subb a,r4 0717 78r00 2484 mov r0,#_usbComTxSend_PARM_2 0719 F2 2485 movx @r0,a 071A 12s00r00 2486 lcall _usbComTxSend 071D 2487 C$test_spi_can.c$118$3$6 ==. 2488 ; apps/test_spi_can/test_spi_can.c:118: reportLength = 0; 071D E4 2489 clr a 071E F5*0D 2490 mov _reportLength,a 0720 F5*0E 2491 mov (_reportLength + 1),a 0722 22 2492 ret 0723 2493 00107$: 0723 2494 C$test_spi_can.c$122$3$7 ==. 2495 ; apps/test_spi_can/test_spi_can.c:122: usbComTxSend(report+reportBytesSent, bytesToSend); 0723 E5*0F 2496 mov a,_reportBytesSent 0725 24r00 2497 add a,#_report 0727 F5 82 2498 mov dpl,a 0729 E5*10 2499 mov a,(_reportBytesSent + 1) 072B 34s00 2500 addc a,#(_report >> 8) 072D F5 83 2501 mov dph,a 072F 78r00 2502 mov r0,#_usbComTxSend_PARM_2 0731 EA 2503 mov a,r2 0732 F2 2504 movx @r0,a 0733 C0 02 2505 push ar2 0735 12s00r00 2506 lcall _usbComTxSend 0738 D0 02 2507 pop ar2 073A 2508 C$test_spi_can.c$123$3$7 ==. 2509 ; apps/test_spi_can/test_spi_can.c:123: reportBytesSent += bytesToSend; 073A 7B 00 2510 mov r3,#0x00 073C EA 2511 mov a,r2 073D 25*0F 2512 add a,_reportBytesSent 073F F5*0F 2513 mov _reportBytesSent,a 0741 EB 2514 mov a,r3 0742 35*10 2515 addc a,(_reportBytesSent + 1) 0744 F5*10 2516 mov (_reportBytesSent + 1),a 0746 2517 00111$: 0746 2518 C$test_spi_can.c$127$2$1 ==. 0746 2519 XG$sendReportIfNeeded$0$0 ==. 0746 22 2520 ret 2521 ;------------------------------------------------------------ 2522 ;Allocation info for local variables in function 'main' 2523 ;------------------------------------------------------------ 2524 ;sloc0 Allocated with name '_main_sloc0_1_0' 2525 ;sloc1 Allocated with name '_main_sloc1_1_0' 2526 ;------------------------------------------------------------ 0747 2527 G$main$0$0 ==. 0747 2528 C$test_spi_can.c$136$2$1 ==. 2529 ; apps/test_spi_can/test_spi_can.c:136: void main() 2530 ; ----------------------------------------- 2531 ; function main 2532 ; ----------------------------------------- 0747 2533 _main: 0747 2534 C$test_spi_can.c$140$1$1 ==. 2535 ; apps/test_spi_can/test_spi_can.c:140: uint32 lastReport = 0; 0747 E4 2536 clr a 0748 F5*20 2537 mov _main_sloc0_1_0,a 074A F5*21 2538 mov (_main_sloc0_1_0 + 1),a 074C F5*22 2539 mov (_main_sloc0_1_0 + 2),a 074E F5*23 2540 mov (_main_sloc0_1_0 + 3),a 0750 2541 C$test_spi_can.c$141$1$1 ==. 2542 ; apps/test_spi_can/test_spi_can.c:141: msg2.id = 0x222; 0750 75*11 22 2543 mov (_msg2 + 0),#0x22 0753 75*12 02 2544 mov (_msg2 + 1),#0x02 0756 2545 C$test_spi_can.c$142$1$1 ==. 2546 ; apps/test_spi_can/test_spi_can.c:142: msg2.len = 2; 0756 75*13 02 2547 mov (_msg2 + 0x0002),#0x02 0759 2548 C$test_spi_can.c$143$1$1 ==. 2549 ; apps/test_spi_can/test_spi_can.c:143: msg1.id = 0x212; 0759 78r1A 2550 mov r0,#_main_msg1_1_1 075B 74 12 2551 mov a,#0x12 075D F2 2552 movx @r0,a 075E 08 2553 inc r0 075F 74 02 2554 mov a,#0x02 0761 F2 2555 movx @r0,a 0762 2556 C$test_spi_can.c$144$1$1 ==. 2557 ; apps/test_spi_can/test_spi_can.c:144: msg1.len = 8; 0762 78r1C 2558 mov r0,#(_main_msg1_1_1 + 0x0002) 0764 74 08 2559 mov a,#0x08 0766 F2 2560 movx @r0,a 0767 2561 C$test_spi_can.c$145$1$1 ==. 2562 ; apps/test_spi_can/test_spi_can.c:145: msg1.dat[1] = 0; 0767 78r1E 2563 mov r0,#(_main_msg1_1_1 + 0x0004) 0769 E4 2564 clr a 076A F2 2565 movx @r0,a 076B 2566 C$test_spi_can.c$146$1$1 ==. 2567 ; apps/test_spi_can/test_spi_can.c:146: msg1.dat[3] = 3; 076B 78r20 2568 mov r0,#(_main_msg1_1_1 + 0x0006) 076D 74 03 2569 mov a,#0x03 076F F2 2570 movx @r0,a 0770 2571 C$test_spi_can.c$147$1$1 ==. 2572 ; apps/test_spi_can/test_spi_can.c:147: msg1.dat[1] = 1; 0770 78r1E 2573 mov r0,#(_main_msg1_1_1 + 0x0004) 0772 74 01 2574 mov a,#0x01 0774 F2 2575 movx @r0,a 0775 2576 C$test_spi_can.c$148$1$1 ==. 2577 ; apps/test_spi_can/test_spi_can.c:148: msg1.dat[2] = 2; 0775 78r1F 2578 mov r0,#(_main_msg1_1_1 + 0x0005) 0777 74 02 2579 mov a,#0x02 0779 F2 2580 movx @r0,a 077A 2581 C$test_spi_can.c$149$1$1 ==. 2582 ; apps/test_spi_can/test_spi_can.c:149: msg1.dat[4] = 4; 077A 78r21 2583 mov r0,#(_main_msg1_1_1 + 0x0007) 077C 74 04 2584 mov a,#0x04 077E F2 2585 movx @r0,a 077F 2586 C$test_spi_can.c$150$1$1 ==. 2587 ; apps/test_spi_can/test_spi_can.c:150: msg1.dat[5] = 5; 077F 78r22 2588 mov r0,#(_main_msg1_1_1 + 0x0008) 0781 74 05 2589 mov a,#0x05 0783 F2 2590 movx @r0,a 0784 2591 C$test_spi_can.c$151$1$1 ==. 2592 ; apps/test_spi_can/test_spi_can.c:151: msg1.dat[6] = 6; 0784 78r23 2593 mov r0,#(_main_msg1_1_1 + 0x0009) 0786 74 06 2594 mov a,#0x06 0788 F2 2595 movx @r0,a 0789 2596 C$test_spi_can.c$152$1$1 ==. 2597 ; apps/test_spi_can/test_spi_can.c:152: msg1.dat[7] = 7; 0789 78r24 2598 mov r0,#(_main_msg1_1_1 + 0x000a) 078B 74 07 2599 mov a,#0x07 078D F2 2600 movx @r0,a 078E 2601 C$test_spi_can.c$155$1$1 ==. 2602 ; apps/test_spi_can/test_spi_can.c:155: systemInit(); 078E 12s00r00 2603 lcall _systemInit 0791 2604 C$test_spi_can.c$156$1$1 ==. 2605 ; apps/test_spi_can/test_spi_can.c:156: usbInit(); 0791 12s00r00 2606 lcall _usbInit 0794 2607 C$test_spi_can.c$160$1$1 ==. 2608 ; apps/test_spi_can/test_spi_can.c:160: Can_init(2); 0794 75 82 02 2609 mov dpl,#0x02 0797 12s00r00 2610 lcall _Can_init 079A 2611 C$test_spi_can.c$161$1$1 ==. 2612 ; apps/test_spi_can/test_spi_can.c:161: Can_setconfigmode(); 079A 12s00r49 2613 lcall _Can_setconfigmode 079D 2614 C$test_spi_can.c$162$1$1 ==. 2615 ; apps/test_spi_can/test_spi_can.c:162: setmask0(0x700); 079D 90 07 00 2616 mov dptr,#0x0700 07A0 12s01r4B 2617 lcall _setmask0 07A3 2618 C$test_spi_can.c$163$1$1 ==. 2619 ; apps/test_spi_can/test_spi_can.c:163: setrxfil0(0x700); 07A3 90 07 00 2620 mov dptr,#0x0700 07A6 12s01r80 2621 lcall _setrxfil0 07A9 2622 C$test_spi_can.c$164$1$1 ==. 2623 ; apps/test_spi_can/test_spi_can.c:164: setrxfil1(0x500); 07A9 90 05 00 2624 mov dptr,#0x0500 07AC 12s01rB5 2625 lcall _setrxfil1 07AF 2626 C$test_spi_can.c$165$1$1 ==. 2627 ; apps/test_spi_can/test_spi_can.c:165: Can_setnormalmode(); 07AF 12s00r35 2628 lcall _Can_setnormalmode 07B2 2629 C$test_spi_can.c$166$1$1 ==. 2630 ; apps/test_spi_can/test_spi_can.c:166: while(1) 07B2 2631 00106$: 07B2 2632 C$test_spi_can.c$168$2$2 ==. 2633 ; apps/test_spi_can/test_spi_can.c:168: boardService(); //Checks to see if the yellow LED line (P2_2) is connected to 3V3. If they are connected, then it starts the bootloader by calling boardStartBootloader. This function is called by boardService. If you call this function regularly, then it provides a relatively easy way to get into bootloader mode if you can't do it with a USB command. Currently this function only works while the yellow LED is off. 07B2 12s00r00 2634 lcall _boardService 07B5 2635 C$test_spi_can.c$169$2$2 ==. 2636 ; apps/test_spi_can/test_spi_can.c:169: updateLeds(); 07B5 12s05r70 2637 lcall _updateLeds 07B8 2638 C$test_spi_can.c$170$2$2 ==. 2639 ; apps/test_spi_can/test_spi_can.c:170: usbComService(); 07B8 12s00r00 2640 lcall _usbComService 07BB 2641 C$test_spi_can.c$171$2$2 ==. 2642 ; apps/test_spi_can/test_spi_can.c:171: if((getMs() - lastReport) >= param_report_period_ms){ 07BB 12s00r00 2643 lcall _getMs 07BE AE 82 2644 mov r6,dpl 07C0 AF 83 2645 mov r7,dph 07C2 AA F0 2646 mov r2,b 07C4 FB 2647 mov r3,a 07C5 EE 2648 mov a,r6 07C6 C3 2649 clr c 07C7 95*20 2650 subb a,_main_sloc0_1_0 07C9 F5*24 2651 mov _main_sloc1_1_0,a 07CB EF 2652 mov a,r7 07CC 95*21 2653 subb a,(_main_sloc0_1_0 + 1) 07CE F5*25 2654 mov (_main_sloc1_1_0 + 1),a 07D0 EA 2655 mov a,r2 07D1 95*22 2656 subb a,(_main_sloc0_1_0 + 2) 07D3 F5*26 2657 mov (_main_sloc1_1_0 + 2),a 07D5 EB 2658 mov a,r3 07D6 95*23 2659 subb a,(_main_sloc0_1_0 + 3) 07D8 F5*27 2660 mov (_main_sloc1_1_0 + 3),a 07DA 90s00r08 2661 mov dptr,#_param_report_period_ms 07DD E4 2662 clr a 07DE 93 2663 movc a,@a+dptr 07DF FC 2664 mov r4,a 07E0 74 01 2665 mov a,#0x01 07E2 93 2666 movc a,@a+dptr 07E3 FD 2667 mov r5,a 07E4 74 02 2668 mov a,#0x02 07E6 93 2669 movc a,@a+dptr 07E7 FA 2670 mov r2,a 07E8 74 03 2671 mov a,#0x03 07EA 93 2672 movc a,@a+dptr 07EB FB 2673 mov r3,a 07EC C3 2674 clr c 07ED E5*24 2675 mov a,_main_sloc1_1_0 07EF 9C 2676 subb a,r4 07F0 E5*25 2677 mov a,(_main_sloc1_1_0 + 1) 07F2 9D 2678 subb a,r5 07F3 E5*26 2679 mov a,(_main_sloc1_1_0 + 2) 07F5 9A 2680 subb a,r2 07F6 E5*27 2681 mov a,(_main_sloc1_1_0 + 3) 07F8 9B 2682 subb a,r3 07F9 40 17 2683 jc 00102$ 07FB 2684 C$test_spi_can.c$172$3$3 ==. 2685 ; apps/test_spi_can/test_spi_can.c:172: lastReport = getMs(); 07FB 12s00r00 2686 lcall _getMs 07FE 85 82*20 2687 mov _main_sloc0_1_0,dpl 0801 85 83*21 2688 mov (_main_sloc0_1_0 + 1),dph 0804 85 F0*22 2689 mov (_main_sloc0_1_0 + 2),b 0807 F5*23 2690 mov (_main_sloc0_1_0 + 3),a 0809 2691 C$test_spi_can.c$173$3$3 ==. 2692 ; apps/test_spi_can/test_spi_can.c:173: send_Canmsg_wait(&msg1); 0809 90s00r1A 2693 mov dptr,#_main_msg1_1_1 080C 75 F0 60 2694 mov b,#0x60 080F 12s03r33 2695 lcall _send_Canmsg_wait 0812 2696 00102$: 0812 2697 C$test_spi_can.c$176$2$2 ==. 2698 ; apps/test_spi_can/test_spi_can.c:176: if(rxbuf0_full()){ // check if rxbuf0 has msg 0812 12s05r56 2699 lcall _rxbuf0_full 0815 E5 82 2700 mov a,dpl 0817 60 09 2701 jz 00104$ 0819 2702 C$test_spi_can.c$177$3$4 ==. 2703 ; apps/test_spi_can/test_spi_can.c:177: get_Canmsg(&msg2); 0819 90s00r11 2704 mov dptr,#_msg2 081C 75 F0 40 2705 mov b,#0x40 081F 12s04r6E 2706 lcall _get_Canmsg 0822 2707 00104$: 0822 2708 C$test_spi_can.c$180$2$2 ==. 2709 ; apps/test_spi_can/test_spi_can.c:180: sendReportIfNeeded(); 0822 12s05r8C 2710 lcall _sendReportIfNeeded 0825 2711 C$test_spi_can.c$183$1$1 ==. 0825 2712 XG$main$0$0 ==. 0825 80 8B 2713 sjmp 00106$ 2714 .area CSEG (CODE) 2715 .area CONST (CODE) 0000 2716 G$param_input_mode$0$0 == . 0000 2717 _param_input_mode: 0000 00 00 00 00 2718 .byte #0x00,#0x00,#0x00,#0x00 ; 0 0004 2719 G$param_bar_graph$0$0 == . 0004 2720 _param_bar_graph: 0004 01 00 00 00 2721 .byte #0x01,#0x00,#0x00,#0x00 ; 1 0008 2722 G$param_report_period_ms$0$0 == . 0008 2723 _param_report_period_ms: 0008 28 00 00 00 2724 .byte #0x28,#0x00,#0x00,#0x00 ; 40 000C 2725 Ftest_spi_can$_str_0$0$0 == . 000C 2726 __str_0: 000C 1B 2727 .db 0x1B 000D 5B 30 3B 30 48 2728 .ascii "[0;0H" 0012 00 2729 .db 0x00 0013 2730 Ftest_spi_can$_str_1$0$0 == . 0013 2731 __str_1: 0013 43 41 4E 43 54 52 2732 .ascii "CANCTRL REG = %4d " 4C 20 52 45 47 20 3D 20 25 34 64 20 0025 0A 2733 .db 0x0A 0026 00 2734 .db 0x00 0027 2735 Ftest_spi_can$_str_2$0$0 == . 0027 2736 __str_2: 0027 43 41 4E 53 54 41 2737 .ascii "CANSTAT REG = %4d " 54 20 52 45 47 20 3D 20 25 34 64 20 0039 0A 2738 .db 0x0A 003A 00 2739 .db 0x00 003B 2740 Ftest_spi_can$_str_3$0$0 == . 003B 2741 __str_3: 003B 64 61 74 61 6C 65 2742 .ascii "datalen = 0x%x ********" 6E 20 3D 20 30 78 25 78 20 2A 2A 2A 2A 2A 2A 2A 2A 0052 0A 2743 .db 0x0A 0053 00 2744 .db 0x00 0054 2745 Ftest_spi_can$_str_4$0$0 == . 0054 2746 __str_4: 0054 53 49 44 20 3D 20 2747 .ascii "SID = 0x%x ********" 30 78 25 78 20 2A 2A 2A 2A 2A 2A 2A 2A 0067 0A 2748 .db 0x0A 0068 00 2749 .db 0x00 0069 2750 Ftest_spi_can$_str_5$0$0 == . 0069 2751 __str_5: 0069 74 65 73 74 20 66 2752 .ascii "test fun is 0x %x" 75 6E 20 69 73 20 30 78 20 25 78 007A 0A 2753 .db 0x0A 007B 20 20 2E 2E 2754 .ascii " .." 007F 00 2755 .db 0x00 0080 2756 Ftest_spi_can$_str_6$0$0 == . 0080 2757 __str_6: 0080 74 65 73 74 20 66 2758 .ascii "test fun2 is 0x %x" 75 6E 32 20 69 73 20 30 78 20 20 25 78 0093 0A 2759 .db 0x0A 0094 20 20 2E 2E 2760 .ascii " .." 0098 00 2761 .db 0x00 2762 .area XINIT (CODE) 0000 2763 Ftest_spi_can$__xinit_txdata2$0$0 == . 0000 2764 __xinit__txdata2: 0000 40 2765 .db #0x40 ; 64 0001 20 2766 .db #0x20 ; 32 0002 20 2767 .db #0x20 ; 32 0003 00 2768 .db #0x00 ; 0 0004 00 2769 .db #0x00 ; 0 0005 04 2770 .db #0x04 ; 4 0006 01 2771 .db #0x01 ; 1 0007 02 2772 .db #0x02 ; 2 0008 03 2773 .db #0x03 ; 3 0009 04 2774 .db #0x04 ; 4 000A 00 2775 .db #0x00 ; 0 000B 00 2776 .db #0x00 ; 0 000C 00 2777 .db #0x00 ; 0 000D 00 2778 .db #0x00 ; 0 000E 2779 Ftest_spi_can$__xinit_rxdata$0$0 == . 000E 2780 __xinit__rxdata: 000E 00 2781 .db #0x00 ; 0 000F 00 2782 .db 0x00 0010 00 2783 .db 0x00 0011 00 2784 .db 0x00 0012 00 2785 .db 0x00 0013 00 2786 .db 0x00 0014 00 2787 .db 0x00 0015 00 2788 .db 0x00 0016 00 2789 .db 0x00 0017 00 2790 .db 0x00 0018 00 2791 .db 0x00 0019 00 2792 .db 0x00 001A 00 2793 .db 0x00 001B 00 2794 .db 0x00 001C 2795 Ftest_spi_can$__xinit_txdata$0$0 == . 001C 2796 __xinit__txdata: 001C 40 2797 .db #0x40 ; 64 001D 20 2798 .db #0x20 ; 32 001E 20 2799 .db #0x20 ; 32 001F 00 2800 .db #0x00 ; 0 0020 00 2801 .db #0x00 ; 0 0021 04 2802 .db #0x04 ; 4 0022 01 2803 .db #0x01 ; 1 0023 02 2804 .db #0x02 ; 2 0024 03 2805 .db #0x03 ; 3 0025 04 2806 .db #0x04 ; 4 0026 00 2807 .db #0x00 ; 0 0027 00 2808 .db #0x00 ; 0 0028 00 2809 .db #0x00 ; 0 0029 00 2810 .db #0x00 ; 0 2811 .area CABS (ABS,CODE)