1 ###############################################################################
\r
3 # IAR Atmel AVR C/C++ Compiler V4.30F/W32 12/Mar/2008 23:01:38 #
\r
4 # Copyright 1996-2007 IAR Systems. All rights reserved. #
\r
6 # Source file = C:\home\kevin\pub\src\bc100_cal\IAR\OWI.c #
\r
7 # Command line = C:\home\kevin\pub\src\bc100_cal\IAR\OWI.c --cpu=tiny861 #
\r
8 # -ms -o C:\home\kevin\pub\src\bc100_cal\IAR\Debug\Obj\ #
\r
9 # -lC C:\home\kevin\pub\src\bc100_cal\IAR\Debug\List\ -lB #
\r
10 # C:\home\kevin\pub\src\bc100_cal\IAR\Debug\List\ #
\r
11 # --initializers_in_flash -z2 --no_cse --no_inline #
\r
12 # --no_code_motion --no_cross_call --no_clustering #
\r
13 # --no_tbaa --debug -DENABLE_BIT_DEFINITIONS -e #
\r
14 # --require_prototypes -I "C:\Program Files\IAR #
\r
15 # Systems\Embedded Workbench 4.0\avr\INC\" -I "C:\Program #
\r
16 # Files\IAR Systems\Embedded Workbench 4.0\avr\INC\CLIB\" #
\r
17 # --eeprom_size 512 #
\r
18 # List file = C:\home\kevin\pub\src\bc100_cal\IAR\Debug\List\OWI.lst #
\r
19 # Object file = C:\home\kevin\pub\src\bc100_cal\IAR\Debug\Obj\OWI.r90 #
\r
22 ###############################################################################
\r
24 C:\home\kevin\pub\src\bc100_cal\IAR\OWI.c
\r
25 1 /* This file has been prepared for Doxygen automatic documentation generation.*/
\r
26 2 /*! \file ********************************************************************
\r
29 5 * Functions for 1-Wire(R) bus communication
\r
31 7 * High level functions for transmission of full bytes on the 1-Wire(R)
\r
32 8 * bus and implementations of ROM commands.\n
\r
33 9 * Polled software only implementation of the basic bit-level signalling
\r
34 10 * in the 1-Wire(R) protocol.\n
\r
35 11 * Includes functions for computing and checking CRC8 & 16 values of data
\r
36 12 * sets, and of 64 bit ROM identifiers.
\r
37 13 * Supported devices: All AVRs.
\r
39 15 * \par Application Note:
\r
40 16 * AVR458: Charging Li-Ion Batteries with BC100\n
\r
41 17 * AVR463: Charging NiMH Batteries with BC100\n
\r
42 18 * One-wire protocol based on AVR318 - Dallas 1-Wire(R) master.
\r
44 20 * \par Documentation:
\r
45 21 * For comprehensive code documentation, supported compilers, compiler
\r
46 22 * settings and supported devices see readme.html
\r
49 25 * Atmel Corporation: http://www.atmel.com \n
\r
50 26 * Support email: avr@atmel.com \n
\r
51 27 * Original author: \n
\r
54 30 * $Revision: 2299 $
\r
56 32 * $URL: http://svn.norway.atmel.com/AppsAVR8/avr458_Charging_Li-Ion_Batteries_with_BC100/tag/20070904_release_1.0/code/IAR/OWI.c $
\r
57 33 * $Date: 2007-08-23 12:55:51 +0200 (to, 23 aug 2007) $\n
\r
58 34 ****************************************************************************/
\r
60 36 #include <ioavr.h>
\r
62 \ In segment ABSOLUTE, at 0x3b
\r
63 \ <unnamed> volatile __io _A_PORTA
\r
67 \ In segment ABSOLUTE, at 0x3a
\r
68 \ <unnamed> volatile __io _A_DDRA
\r
72 \ In segment ABSOLUTE, at 0x39
\r
73 \ <unnamed> volatile __io _A_PINA
\r
76 37 #include <inavr.h>
\r
81 42 //******************************************************************************
\r
83 44 //******************************************************************************
\r
84 45 /*! \brief Initialization of the one wire bus(es). (Software only driver)
\r
86 47 * This function initializes the 1-Wire bus(es) by releasing it and
\r
87 48 * waiting until any presence signals are finished.
\r
89 50 * \param pins A bitmask of the buses to initialize.
\r
92 \ In segment CODE, align 2, keep-with-next
\r
93 52 void OWI_Init(unsigned char pins){
\r
95 53 OWI_RELEASE_BUS(pins);
\r
96 \ 00000000 2F10 MOV R17, R16
\r
97 \ 00000002 9510 COM R17
\r
98 \ 00000004 B32A IN R18, 0x1A
\r
99 \ 00000006 2321 AND R18, R17
\r
100 \ 00000008 BB2A OUT 0x1A, R18
\r
101 \ 0000000A 2F10 MOV R17, R16
\r
102 \ 0000000C 9510 COM R17
\r
103 \ 0000000E B32B IN R18, 0x1B
\r
104 \ 00000010 2321 AND R18, R17
\r
105 \ 00000012 BB2B OUT 0x1B, R18
\r
106 54 // The first rising edge can be interpreted by a slave as the end of a
\r
107 55 // Reset-pulse. Delay for the required reset recovery time (H) to be
\r
108 56 // sure that the real reset is interpreted correctly.
\r
109 57 __delay_cycles(OWI_DELAY_H_STD_MODE);
\r
110 \ 00000014 EB2C LDI R18, 188
\r
111 \ 00000016 E033 LDI R19, 3
\r
112 \ 00000018 5021 SUBI R18, 1
\r
113 \ 0000001A 4030 SBCI R19, 0
\r
114 \ 0000001C F7E9 BRNE $-4
\r
115 \ 0000001E C000 RJMP $+2
\r
117 \ 00000020 9508 RET
\r
118 \ 00000022 REQUIRE _A_PORTA
\r
119 \ 00000022 REQUIRE _A_DDRA
\r
122 61 /*! \brief Write a '1' bit to the bus(es). (Software only driver)
\r
124 63 * Generates the waveform for transmission of a '1' bit on the 1-Wire
\r
127 66 * \param pins A bitmask of the buses to write to.
\r
130 \ In segment CODE, align 2, keep-with-next
\r
131 68 void OWI_WriteBit1(unsigned char pins){
\r
133 69 unsigned char intState;
\r
135 71 // Disable interrupts.
\r
136 72 intState = __save_interrupt();
\r
137 \ 00000000 B72F IN R18, 0x3F
\r
138 \ 00000002 2F12 MOV R17, R18
\r
139 73 __disable_interrupt();
\r
140 \ 00000004 94F8 CLI
\r
142 75 // Drive bus low and delay.
\r
143 76 OWI_PULL_BUS_LOW(pins);
\r
144 \ 00000006 B32A IN R18, 0x1A
\r
145 \ 00000008 2B20 OR R18, R16
\r
146 \ 0000000A BB2A OUT 0x1A, R18
\r
147 \ 0000000C 2F20 MOV R18, R16
\r
148 \ 0000000E 9520 COM R18
\r
149 \ 00000010 B33B IN R19, 0x1B
\r
150 \ 00000012 2332 AND R19, R18
\r
151 \ 00000014 BB3B OUT 0x1B, R19
\r
152 77 __delay_cycles(OWI_DELAY_A_STD_MODE);
\r
153 \ 00000016 E02B LDI R18, 11
\r
154 \ 00000018 952A DEC R18
\r
155 \ 0000001A F7F1 BRNE $-2
\r
156 \ 0000001C C000 RJMP $+2
\r
158 79 // Release bus and delay.
\r
159 80 OWI_RELEASE_BUS(pins);
\r
160 \ 0000001E 2F20 MOV R18, R16
\r
161 \ 00000020 9520 COM R18
\r
162 \ 00000022 B33A IN R19, 0x1A
\r
163 \ 00000024 2332 AND R19, R18
\r
164 \ 00000026 BB3A OUT 0x1A, R19
\r
165 \ 00000028 2F20 MOV R18, R16
\r
166 \ 0000002A 9520 COM R18
\r
167 \ 0000002C B33B IN R19, 0x1B
\r
168 \ 0000002E 2332 AND R19, R18
\r
169 \ 00000030 BB3B OUT 0x1B, R19
\r
170 81 __delay_cycles(OWI_DELAY_B_STD_MODE);
\r
171 \ 00000032 EA26 LDI R18, 166
\r
172 \ 00000034 952A DEC R18
\r
173 \ 00000036 F7F1 BRNE $-2
\r
174 \ 00000038 0000 NOP
\r
176 83 // Restore interrupts.
\r
177 84 __restore_interrupt(intState);
\r
178 \ 0000003A BF1F OUT 0x3F, R17
\r
180 \ 0000003C 9508 RET
\r
181 \ 0000003E REQUIRE _A_PORTA
\r
182 \ 0000003E REQUIRE _A_DDRA
\r
184 87 /*! \brief Write a '0' to the bus(es). (Software only driver)
\r
186 89 * Generates the waveform for transmission of a '0' bit on the 1-Wire(R)
\r
189 92 * \param pins A bitmask of the buses to write to.
\r
192 \ In segment CODE, align 2, keep-with-next
\r
193 94 void OWI_WriteBit0(unsigned char pins)
\r
196 96 unsigned char intState;
\r
198 98 // Disable interrupts.
\r
199 99 intState = __save_interrupt();
\r
200 \ 00000000 B72F IN R18, 0x3F
\r
201 \ 00000002 2F12 MOV R17, R18
\r
202 100 __disable_interrupt();
\r
203 \ 00000004 94F8 CLI
\r
205 102 // Drive bus low and delay.
\r
206 103 OWI_PULL_BUS_LOW(pins);
\r
207 \ 00000006 B32A IN R18, 0x1A
\r
208 \ 00000008 2B20 OR R18, R16
\r
209 \ 0000000A BB2A OUT 0x1A, R18
\r
210 \ 0000000C 2F20 MOV R18, R16
\r
211 \ 0000000E 9520 COM R18
\r
212 \ 00000010 B33B IN R19, 0x1B
\r
213 \ 00000012 2332 AND R19, R18
\r
214 \ 00000014 BB3B OUT 0x1B, R19
\r
215 104 __delay_cycles(OWI_DELAY_C_STD_MODE);
\r
216 \ 00000016 E92B LDI R18, 155
\r
217 \ 00000018 952A DEC R18
\r
218 \ 0000001A F7F1 BRNE $-2
\r
219 \ 0000001C C000 RJMP $+2
\r
221 106 // Release bus and delay.
\r
222 107 OWI_RELEASE_BUS(pins);
\r
223 \ 0000001E 2F20 MOV R18, R16
\r
224 \ 00000020 9520 COM R18
\r
225 \ 00000022 B33A IN R19, 0x1A
\r
226 \ 00000024 2332 AND R19, R18
\r
227 \ 00000026 BB3A OUT 0x1A, R19
\r
228 \ 00000028 2F20 MOV R18, R16
\r
229 \ 0000002A 9520 COM R18
\r
230 \ 0000002C B33B IN R19, 0x1B
\r
231 \ 0000002E 2332 AND R19, R18
\r
232 \ 00000030 BB3B OUT 0x1B, R19
\r
233 108 __delay_cycles(OWI_DELAY_D_STD_MODE);
\r
234 \ 00000032 E126 LDI R18, 22
\r
235 \ 00000034 952A DEC R18
\r
236 \ 00000036 F7F1 BRNE $-2
\r
237 \ 00000038 0000 NOP
\r
239 110 // Restore interrupts.
\r
240 111 __restore_interrupt(intState);
\r
241 \ 0000003A BF1F OUT 0x3F, R17
\r
243 \ 0000003C 9508 RET
\r
244 \ 0000003E REQUIRE _A_PORTA
\r
245 \ 0000003E REQUIRE _A_DDRA
\r
247 114 /*! \brief Read a bit from the bus(es). (Software only driver)
\r
249 116 * Generates the waveform for reception of a bit on the 1-Wire(R) bus(es).
\r
251 118 * \param pins A bitmask of the bus(es) to read from.
\r
253 120 * \return A bitmask of the buses where a '1' was read.
\r
256 \ In segment CODE, align 2, keep-with-next
\r
257 122 unsigned char OWI_ReadBit(unsigned char pins)
\r
260 \ 00000000 2F10 MOV R17, R16
\r
261 124 unsigned char intState;
\r
262 125 unsigned char bitsRead;
\r
264 127 // Disable interrupts.
\r
265 128 intState = __save_interrupt();
\r
266 \ 00000002 B73F IN R19, 0x3F
\r
267 \ 00000004 2F23 MOV R18, R19
\r
268 129 __disable_interrupt();
\r
269 \ 00000006 94F8 CLI
\r
271 131 // Drive bus low and delay.
\r
272 132 OWI_PULL_BUS_LOW(pins);
\r
273 \ 00000008 B33A IN R19, 0x1A
\r
274 \ 0000000A 2B31 OR R19, R17
\r
275 \ 0000000C BB3A OUT 0x1A, R19
\r
276 \ 0000000E 2F31 MOV R19, R17
\r
277 \ 00000010 9530 COM R19
\r
278 \ 00000012 B34B IN R20, 0x1B
\r
279 \ 00000014 2343 AND R20, R19
\r
280 \ 00000016 BB4B OUT 0x1B, R20
\r
281 133 __delay_cycles(OWI_DELAY_A_STD_MODE);
\r
282 \ 00000018 E03B LDI R19, 11
\r
283 \ 0000001A 953A DEC R19
\r
284 \ 0000001C F7F1 BRNE $-2
\r
285 \ 0000001E C000 RJMP $+2
\r
287 135 // Release bus and delay.
\r
288 136 OWI_RELEASE_BUS(pins);
\r
289 \ 00000020 2F31 MOV R19, R17
\r
290 \ 00000022 9530 COM R19
\r
291 \ 00000024 B34A IN R20, 0x1A
\r
292 \ 00000026 2343 AND R20, R19
\r
293 \ 00000028 BB4A OUT 0x1A, R20
\r
294 \ 0000002A 2F31 MOV R19, R17
\r
295 \ 0000002C 9530 COM R19
\r
296 \ 0000002E B34B IN R20, 0x1B
\r
297 \ 00000030 2343 AND R20, R19
\r
298 \ 00000032 BB4B OUT 0x1B, R20
\r
299 137 __delay_cycles(OWI_DELAY_E_STD_MODE);
\r
300 \ 00000034 E133 LDI R19, 19
\r
301 \ 00000036 953A DEC R19
\r
302 \ 00000038 F7F1 BRNE $-2
\r
303 \ 0000003A C000 RJMP $+2
\r
305 139 // Sample bus and delay.
\r
306 140 bitsRead = OWI_PIN & pins;
\r
307 \ 0000003C B339 IN R19, 0x19
\r
308 \ 0000003E 2331 AND R19, R17
\r
309 \ 00000040 2F03 MOV R16, R19
\r
310 141 __delay_cycles(OWI_DELAY_F_STD_MODE);
\r
311 \ 00000042 E83E LDI R19, 142
\r
312 \ 00000044 953A DEC R19
\r
313 \ 00000046 F7F1 BRNE $-2
\r
314 \ 00000048 0000 NOP
\r
316 143 // Restore interrupts.
\r
317 144 __restore_interrupt(intState);
\r
318 \ 0000004A BF2F OUT 0x3F, R18
\r
320 146 return bitsRead;
\r
321 \ 0000004C 9508 RET
\r
322 \ 0000004E REQUIRE _A_PORTA
\r
323 \ 0000004E REQUIRE _A_DDRA
\r
324 \ 0000004E REQUIRE _A_PINA
\r
328 150 /*! \brief Send a Reset signal and listen for Presence signal. (software
\r
331 153 * Generates the waveform for transmission of a Reset pulse on the
\r
332 154 * 1-Wire(R) bus and listens for presence signals.
\r
334 156 * \param pins A bitmask of the buses to send the Reset signal on.
\r
336 158 * \return A bitmask of the buses where a presence signal was detected.
\r
339 \ In segment CODE, align 2, keep-with-next
\r
340 160 unsigned char OWI_DetectPresence(unsigned char pins)
\r
341 \ OWI_DetectPresence:
\r
343 \ 00000000 2F10 MOV R17, R16
\r
344 162 unsigned char intState;
\r
345 163 unsigned char presenceDetected;
\r
347 165 // Disable interrupts.
\r
348 166 intState = __save_interrupt();
\r
349 \ 00000002 B73F IN R19, 0x3F
\r
350 \ 00000004 2F23 MOV R18, R19
\r
351 167 __disable_interrupt();
\r
352 \ 00000006 94F8 CLI
\r
354 169 // Drive bus low and delay.
\r
355 170 OWI_PULL_BUS_LOW(pins);
\r
356 \ 00000008 B33A IN R19, 0x1A
\r
357 \ 0000000A 2B31 OR R19, R17
\r
358 \ 0000000C BB3A OUT 0x1A, R19
\r
359 \ 0000000E 2F31 MOV R19, R17
\r
360 \ 00000010 9530 COM R19
\r
361 \ 00000012 B34B IN R20, 0x1B
\r
362 \ 00000014 2343 AND R20, R19
\r
363 \ 00000016 BB4B OUT 0x1B, R20
\r
364 171 __delay_cycles(OWI_DELAY_H_STD_MODE);
\r
365 \ 00000018 EB4C LDI R20, 188
\r
366 \ 0000001A E053 LDI R21, 3
\r
367 \ 0000001C 5041 SUBI R20, 1
\r
368 \ 0000001E 4050 SBCI R21, 0
\r
369 \ 00000020 F7E9 BRNE $-4
\r
370 \ 00000022 C000 RJMP $+2
\r
372 173 // Release bus and delay.
\r
373 174 OWI_RELEASE_BUS(pins);
\r
374 \ 00000024 2F31 MOV R19, R17
\r
375 \ 00000026 9530 COM R19
\r
376 \ 00000028 B34A IN R20, 0x1A
\r
377 \ 0000002A 2343 AND R20, R19
\r
378 \ 0000002C BB4A OUT 0x1A, R20
\r
379 \ 0000002E 2F31 MOV R19, R17
\r
380 \ 00000030 9530 COM R19
\r
381 \ 00000032 B34B IN R20, 0x1B
\r
382 \ 00000034 2343 AND R20, R19
\r
383 \ 00000036 BB4B OUT 0x1B, R20
\r
384 175 __delay_cycles(OWI_DELAY_I_STD_MODE);
\r
385 \ 00000038 EB36 LDI R19, 182
\r
386 \ 0000003A 953A DEC R19
\r
387 \ 0000003C F7F1 BRNE $-2
\r
388 \ 0000003E 0000 NOP
\r
390 177 // Sample bus to detect presence signal and delay.
\r
391 178 presenceDetected = ((~OWI_PIN) & pins);
\r
392 \ 00000040 B339 IN R19, 0x19
\r
393 \ 00000042 9530 COM R19
\r
394 \ 00000044 2331 AND R19, R17
\r
395 \ 00000046 2F03 MOV R16, R19
\r
396 179 __delay_cycles(OWI_DELAY_J_STD_MODE);
\r
397 \ 00000048 E340 LDI R20, 48
\r
398 \ 0000004A E053 LDI R21, 3
\r
399 \ 0000004C 5041 SUBI R20, 1
\r
400 \ 0000004E 4050 SBCI R21, 0
\r
401 \ 00000050 F7E9 BRNE $-4
\r
402 \ 00000052 C000 RJMP $+2
\r
404 181 // Restore interrupts.
\r
405 182 __restore_interrupt(intState);
\r
406 \ 00000054 BF2F OUT 0x3F, R18
\r
408 184 return presenceDetected;
\r
409 \ 00000056 9508 RET
\r
410 \ 00000058 REQUIRE _A_PORTA
\r
411 \ 00000058 REQUIRE _A_DDRA
\r
412 \ 00000058 REQUIRE _A_PINA
\r
416 188 /*! \brief Sends one byte of data on the 1-Wire(R) bus(es).
\r
418 190 * This function automates the task of sending a complete byte
\r
419 191 * of data on the 1-Wire bus(es).
\r
421 193 * \param data The data to send on the bus(es).
\r
423 195 * \param pins A bitmask of the buses to send the data to.
\r
426 \ In segment CODE, align 2, keep-with-next
\r
427 197 void OWI_SendByte(unsigned char data, unsigned char pins)
\r
430 \ 00000000 .... RCALL ?PROLOGUE4_L09
\r
431 \ 00000002 2FA0 MOV R26, R16
\r
432 \ 00000004 2F91 MOV R25, R17
\r
433 199 unsigned char temp;
\r
434 200 unsigned char i;
\r
436 202 // Do once for each bit
\r
437 203 for (i = 0; i < 8; i++) {
\r
438 \ 00000006 E080 LDI R24, 0
\r
439 \ ??OWI_SendByte_0:
\r
440 \ 00000008 3088 CPI R24, 8
\r
441 \ 0000000A F468 BRCC ??OWI_SendByte_1
\r
442 204 // Determine if LSB is '0' or '1' and transmit corresponding
\r
443 205 // waveform on the bus.
\r
444 206 temp = data & 0x01;
\r
445 \ 0000000C 2F0A MOV R16, R26
\r
446 \ 0000000E 7001 ANDI R16, 0x01
\r
447 \ 00000010 2FB0 MOV R27, R16
\r
450 \ 00000012 23BB TST R27
\r
451 \ 00000014 F019 BREQ ??OWI_SendByte_2
\r
452 209 OWI_WriteBit1(pins);
\r
453 \ 00000016 2F09 MOV R16, R25
\r
454 \ 00000018 .... RCALL OWI_WriteBit1
\r
455 \ 0000001A C002 RJMP ??OWI_SendByte_3
\r
457 211 OWI_WriteBit0(pins);
\r
458 \ ??OWI_SendByte_2:
\r
459 \ 0000001C 2F09 MOV R16, R25
\r
460 \ 0000001E .... RCALL OWI_WriteBit0
\r
463 214 data >>= 1; // Right shift the data to get next bit.
\r
464 \ ??OWI_SendByte_3:
\r
465 \ 00000020 95A6 LSR R26
\r
467 \ 00000022 9583 INC R24
\r
468 \ 00000024 CFF1 RJMP ??OWI_SendByte_0
\r
470 \ ??OWI_SendByte_1:
\r
471 \ 00000026 E0E4 LDI R30, 4
\r
472 \ 00000028 .... RJMP ?EPILOGUE_B4_L09
\r
475 219 /*! \brief Receives one byte of data from the 1-Wire(R) bus.
\r
477 221 * This function automates the task of receiving a complete byte
\r
478 222 * of data from the 1-Wire bus.
\r
480 224 * \param pin A bitmask of the bus to read from.
\r
482 226 * \return The byte read from the bus.
\r
485 \ In segment CODE, align 2, keep-with-next
\r
486 228 unsigned char OWI_ReceiveByte(unsigned char pin)
\r
489 \ 00000000 .... RCALL ?PROLOGUE3_L09
\r
490 \ 00000002 2FA0 MOV R26, R16
\r
491 230 unsigned char data;
\r
492 231 unsigned char i;
\r
494 233 // Clear the temporary input variable.
\r
496 \ 00000004 E090 LDI R25, 0
\r
498 236 // Do once for each bit
\r
499 237 for (i = 0; i < 8; i++) {
\r
500 \ 00000006 E080 LDI R24, 0
\r
501 \ ??OWI_ReceiveByte_0:
\r
502 \ 00000008 3088 CPI R24, 8
\r
503 \ 0000000A F448 BRCC ??OWI_ReceiveByte_1
\r
504 238 // Shift temporary input variable right.
\r
506 \ 0000000C 9596 LSR R25
\r
508 241 // Set the MSB if a '1' value is read from the bus.
\r
509 242 // Leave as it is ('0') else.
\r
510 243 if (OWI_ReadBit(pin)) {
\r
511 \ 0000000E 2F0A MOV R16, R26
\r
512 \ 00000010 .... RCALL OWI_ReadBit
\r
513 \ 00000012 2300 TST R16
\r
514 \ 00000014 F011 BREQ ??OWI_ReceiveByte_2
\r
516 \ 00000016 6890 ORI R25, 0x80
\r
517 \ 00000018 E001 LDI R16, 1
\r
520 \ ??OWI_ReceiveByte_2:
\r
521 \ 0000001A 9583 INC R24
\r
522 \ 0000001C CFF5 RJMP ??OWI_ReceiveByte_0
\r
525 \ ??OWI_ReceiveByte_1:
\r
526 \ 0000001E 2F09 MOV R16, R25
\r
527 \ 00000020 E0E3 LDI R30, 3
\r
528 \ 00000022 .... RJMP ?EPILOGUE_B3_L09
\r
532 252 /*! \brief Sends the SKIP ROM command to the 1-Wire bus(es).
\r
534 254 * \param pins A bitmask of the buses to send the SKIP ROM command to.
\r
537 \ In segment CODE, align 2, keep-with-next
\r
538 256 void OWI_SkipRom(unsigned char pins)
\r
541 \ 00000000 938A ST -Y, R24
\r
542 \ 00000002 2F80 MOV R24, R16
\r
543 258 // Send the SKIP ROM command on the bus.
\r
544 259 OWI_SendByte(OWI_ROM_SKIP, pins);
\r
545 \ 00000004 2F18 MOV R17, R24
\r
546 \ 00000006 EC0C LDI R16, 204
\r
547 \ 00000008 .... RCALL OWI_SendByte
\r
549 \ 0000000A 9189 LD R24, Y+
\r
550 \ 0000000C 9508 RET
\r
553 263 /*! \brief Sends the READ ROM command and reads back the ROM id.
\r
555 265 * \param romValue A pointer where the id will be placed.
\r
557 267 * \param pin A bitmask of the bus to read from.
\r
560 \ In segment CODE, align 2, keep-with-next
\r
561 269 void OWI_ReadRom(unsigned char * romValue, unsigned char pin)
\r
564 \ 00000000 .... RCALL ?PROLOGUE4_L09
\r
565 \ 00000002 01D8 MOVW R27:R26, R17:R16
\r
566 \ 00000004 2F92 MOV R25, R18
\r
567 271 unsigned char bytesLeft = 8;
\r
568 \ 00000006 E088 LDI R24, 8
\r
570 273 // Send the READ ROM command on the bus.
\r
571 274 OWI_SendByte(OWI_ROM_READ, pin);
\r
572 \ 00000008 2F19 MOV R17, R25
\r
573 \ 0000000A E303 LDI R16, 51
\r
574 \ 0000000C .... RCALL OWI_SendByte
\r
577 277 while (bytesLeft > 0) {
\r
579 \ 0000000E 3081 CPI R24, 1
\r
580 \ 00000010 F030 BRCS ??OWI_ReadRom_1
\r
581 278 // Place the received data in memory.
\r
582 279 *romValue++ = OWI_ReceiveByte(pin);
\r
583 \ 00000012 2F09 MOV R16, R25
\r
584 \ 00000014 .... RCALL OWI_ReceiveByte
\r
585 \ 00000016 930C ST X, R16
\r
586 \ 00000018 9611 ADIW R27:R26, 1
\r
588 \ 0000001A 958A DEC R24
\r
589 \ 0000001C CFF8 RJMP ??OWI_ReadRom_0
\r
593 \ 0000001E E0E4 LDI R30, 4
\r
594 \ 00000020 .... RJMP ?EPILOGUE_B4_L09
\r
597 285 /*! \brief Sends the MATCH ROM command and the ROM id to match against.
\r
599 287 * \param romValue A pointer to the ID to match against.
\r
601 289 * \param pins A bitmask of the buses to perform the MATCH ROM command on.
\r
604 \ In segment CODE, align 2, keep-with-next
\r
605 291 void OWI_MatchRom(unsigned char * romValue, unsigned char pins)
\r
608 \ 00000000 .... RCALL ?PROLOGUE4_L09
\r
609 \ 00000002 01D8 MOVW R27:R26, R17:R16
\r
610 \ 00000004 2F92 MOV R25, R18
\r
611 293 unsigned char bytesLeft = 8;
\r
612 \ 00000006 E088 LDI R24, 8
\r
614 295 // Send the MATCH ROM command.
\r
615 296 OWI_SendByte(OWI_ROM_MATCH, pins);
\r
616 \ 00000008 2F19 MOV R17, R25
\r
617 \ 0000000A E505 LDI R16, 85
\r
618 \ 0000000C .... RCALL OWI_SendByte
\r
620 298 // Do once for each byte.
\r
621 299 while (bytesLeft > 0) {
\r
622 \ ??OWI_MatchRom_0:
\r
623 \ 0000000E 3081 CPI R24, 1
\r
624 \ 00000010 F030 BRCS ??OWI_MatchRom_1
\r
625 300 // Transmit 1 byte of the ID to match.
\r
626 301 OWI_SendByte(*romValue++, pins);
\r
627 \ 00000012 2F19 MOV R17, R25
\r
628 \ 00000014 910C LD R16, X
\r
629 \ 00000016 .... RCALL OWI_SendByte
\r
630 \ 00000018 9611 ADIW R27:R26, 1
\r
632 \ 0000001A 958A DEC R24
\r
633 \ 0000001C CFF8 RJMP ??OWI_MatchRom_0
\r
636 \ ??OWI_MatchRom_1:
\r
637 \ 0000001E E0E4 LDI R30, 4
\r
638 \ 00000020 .... RJMP ?EPILOGUE_B4_L09
\r
641 307 /*! \brief Sends the SEARCH ROM command and returns 1 id found on the
\r
642 308 * 1-Wire(R) bus.
\r
644 310 * \param bitPattern A pointer to an 8 byte char array where the
\r
645 311 * discovered identifier will be placed. When
\r
646 312 * searching for several slaves, a copy of the
\r
647 313 * last found identifier should be supplied in
\r
648 314 * the array, or the search will fail.
\r
650 316 * \param lastDeviation The bit position where the algorithm made a
\r
651 317 * choice the last time it was run. This argument
\r
652 318 * should be 0 when a search is initiated. Supplying
\r
653 319 * the return argument of this function when calling
\r
654 320 * repeatedly will go through the complete slave
\r
657 323 * \param pin A bit-mask of the bus to perform a ROM search on.
\r
659 325 * \return The last bit position where there was a discrepancy between slave
\r
660 326 * addresses the last time this function was run. Returns OWI_ROM_SEARCH_FAILED
\r
661 327 * if an error was detected (e.g. a device was connected to the bus during the
\r
662 328 * search), or OWI_ROM_SEARCH_FINISHED when there are no more devices to be
\r
665 331 * \note See main.c for an example of how to utilize this function.
\r
668 \ In segment CODE, align 2, keep-with-next
\r
669 333 unsigned char OWI_SearchRom(unsigned char * bitPattern,
\r
671 334 unsigned char lastDeviation, unsigned char pin)
\r
673 \ 00000000 .... RCALL ?PROLOGUE9_L09
\r
674 \ 00000002 REQUIRE ?Register_R4_is_cg_reg
\r
675 \ 00000002 REQUIRE ?Register_R5_is_cg_reg
\r
676 \ 00000002 REQUIRE ?Register_R6_is_cg_reg
\r
677 \ 00000002 REQUIRE ?Register_R7_is_cg_reg
\r
678 \ 00000002 REQUIRE ?Register_R8_is_cg_reg
\r
679 \ 00000002 0128 MOVW R5:R4, R17:R16
\r
680 \ 00000004 2E82 MOV R8, R18
\r
681 \ 00000006 2FB3 MOV R27, R19
\r
682 336 unsigned char currentBit = 1;
\r
683 \ 00000008 E081 LDI R24, 1
\r
684 337 unsigned char newDeviation = 0;
\r
685 \ 0000000A E0A0 LDI R26, 0
\r
686 338 unsigned char bitMask = 0x01;
\r
687 \ 0000000C E091 LDI R25, 1
\r
688 339 unsigned char bitA;
\r
689 340 unsigned char bitB;
\r
691 342 // Send SEARCH ROM command on the bus.
\r
692 343 OWI_SendByte(OWI_ROM_SEARCH, pin);
\r
693 \ 0000000E 2F1B MOV R17, R27
\r
694 \ 00000010 EF00 LDI R16, 240
\r
695 \ 00000012 .... RCALL OWI_SendByte
\r
697 345 // Walk through all 64 bits.
\r
698 346 while (currentBit <= 64) {
\r
699 \ ??OWI_SearchRom_0:
\r
700 \ 00000014 3481 CPI R24, 65
\r
701 \ 00000016 F008 BRCS $+2+2
\r
702 \ 00000018 C04B RJMP ??OWI_SearchRom_1
\r
703 347 // Read bit from bus twice.
\r
704 348 bitA = OWI_ReadBit(pin);
\r
705 \ 0000001A 2F0B MOV R16, R27
\r
706 \ 0000001C .... RCALL OWI_ReadBit
\r
707 \ 0000001E 2E60 MOV R6, R16
\r
708 349 bitB = OWI_ReadBit(pin);
\r
709 \ 00000020 2F0B MOV R16, R27
\r
710 \ 00000022 .... RCALL OWI_ReadBit
\r
711 \ 00000024 2E70 MOV R7, R16
\r
713 351 if (bitA && bitB) {
\r
714 \ 00000026 2066 TST R6
\r
715 \ 00000028 F029 BREQ ??OWI_SearchRom_2
\r
716 \ 0000002A 2077 TST R7
\r
717 \ 0000002C F019 BREQ ??OWI_SearchRom_2
\r
718 352 // Both bits 1 (Error).
\r
719 353 newDeviation = OWI_ROM_SEARCH_FAILED;
\r
720 \ 0000002E EFAF LDI R26, 255
\r
721 354 return newDeviation;
\r
722 \ 00000030 2F0A MOV R16, R26
\r
723 \ 00000032 C03F RJMP ??OWI_SearchRom_3
\r
724 355 } else if (bitA ^ bitB) {
\r
725 \ ??OWI_SearchRom_2:
\r
726 \ 00000034 2D07 MOV R16, R7
\r
727 \ 00000036 2506 EOR R16, R6
\r
728 \ 00000038 2300 TST R16
\r
729 \ 0000003A F071 BREQ ??OWI_SearchRom_4
\r
730 356 // Bits A and B are different. All devices have the same bit here.
\r
731 357 // Set the bit in bitPattern to this value.
\r
733 \ 0000003C 2066 TST R6
\r
734 \ 0000003E F029 BREQ ??OWI_SearchRom_5
\r
735 359 (*bitPattern) |= bitMask;
\r
736 \ 00000040 01F2 MOVW R31:R30, R5:R4
\r
737 \ 00000042 8100 LD R16, Z
\r
738 \ 00000044 2B09 OR R16, R25
\r
739 \ 00000046 8300 ST Z, R16
\r
740 \ 00000048 C01E RJMP ??OWI_SearchRom_6
\r
742 361 (*bitPattern) &= ~bitMask;
\r
743 \ ??OWI_SearchRom_5:
\r
744 \ 0000004A 2F09 MOV R16, R25
\r
745 \ 0000004C 9500 COM R16
\r
746 \ 0000004E 01F2 MOVW R31:R30, R5:R4
\r
747 \ 00000050 8110 LD R17, Z
\r
748 \ 00000052 2310 AND R17, R16
\r
749 \ 00000054 8310 ST Z, R17
\r
750 \ 00000056 C017 RJMP ??OWI_SearchRom_6
\r
753 364 // If this is where a choice was made the last time,
\r
754 365 // a '1' bit is selected this time.
\r
755 366 if (currentBit == lastDeviation) {
\r
756 \ ??OWI_SearchRom_4:
\r
757 \ 00000058 1588 CP R24, R8
\r
758 \ 0000005A F429 BRNE ??OWI_SearchRom_7
\r
759 367 (*bitPattern) |= bitMask;
\r
760 \ 0000005C 01F2 MOVW R31:R30, R5:R4
\r
761 \ 0000005E 8100 LD R16, Z
\r
762 \ 00000060 2B09 OR R16, R25
\r
763 \ 00000062 8300 ST Z, R16
\r
764 \ 00000064 C010 RJMP ??OWI_SearchRom_6
\r
767 370 // For the rest of the id, '0' bits are selected when
\r
768 371 // discrepancies occur.
\r
769 372 else if (currentBit > lastDeviation) {
\r
770 \ ??OWI_SearchRom_7:
\r
771 \ 00000066 1688 CP R8, R24
\r
772 \ 00000068 F440 BRCC ??OWI_SearchRom_8
\r
773 373 (*bitPattern) &= ~bitMask;
\r
774 \ 0000006A 2F09 MOV R16, R25
\r
775 \ 0000006C 9500 COM R16
\r
776 \ 0000006E 01F2 MOVW R31:R30, R5:R4
\r
777 \ 00000070 8110 LD R17, Z
\r
778 \ 00000072 2310 AND R17, R16
\r
779 \ 00000074 8310 ST Z, R17
\r
780 374 newDeviation = currentBit;
\r
781 \ 00000076 2FA8 MOV R26, R24
\r
782 \ 00000078 C006 RJMP ??OWI_SearchRom_6
\r
785 377 // If current bit in bit pattern = 0, then this is
\r
786 378 // out new deviation.
\r
787 379 else if ( !(*bitPattern & bitMask)) {
\r
788 \ ??OWI_SearchRom_8:
\r
789 \ 0000007A 01F2 MOVW R31:R30, R5:R4
\r
790 \ 0000007C 8100 LD R16, Z
\r
791 \ 0000007E 2309 AND R16, R25
\r
792 \ 00000080 2300 TST R16
\r
793 \ 00000082 F409 BRNE ??OWI_SearchRom_6
\r
794 380 newDeviation = currentBit;
\r
795 \ 00000084 2FA8 MOV R26, R24
\r
798 383 // IF the bit is already 1, do nothing.
\r
803 388 // Send the selected bit to the bus.
\r
804 389 if ((*bitPattern) & bitMask) {
\r
805 \ ??OWI_SearchRom_6:
\r
806 \ 00000086 01F2 MOVW R31:R30, R5:R4
\r
807 \ 00000088 8100 LD R16, Z
\r
808 \ 0000008A 2309 AND R16, R25
\r
809 \ 0000008C 2300 TST R16
\r
810 \ 0000008E F019 BREQ ??OWI_SearchRom_9
\r
811 390 OWI_WriteBit1(pin);
\r
812 \ 00000090 2F0B MOV R16, R27
\r
813 \ 00000092 .... RCALL OWI_WriteBit1
\r
814 \ 00000094 C002 RJMP ??OWI_SearchRom_10
\r
816 392 OWI_WriteBit0(pin);
\r
817 \ ??OWI_SearchRom_9:
\r
818 \ 00000096 2F0B MOV R16, R27
\r
819 \ 00000098 .... RCALL OWI_WriteBit0
\r
822 395 // Increment current bit.
\r
824 \ ??OWI_SearchRom_10:
\r
825 \ 0000009A 9583 INC R24
\r
827 398 // Adjust bitMask and bitPattern pointer.
\r
829 \ 0000009C 0F99 LSL R25
\r
830 400 if (!bitMask) {
\r
831 \ 0000009E 2399 TST R25
\r
832 \ 000000A0 F009 BREQ $+2+2
\r
833 \ 000000A2 CFB8 RJMP ??OWI_SearchRom_0
\r
834 401 bitMask = 0x01;
\r
835 \ 000000A4 E091 LDI R25, 1
\r
837 \ 000000A6 E001 LDI R16, 1
\r
838 \ 000000A8 0E40 ADD R4, R16
\r
839 \ 000000AA E000 LDI R16, 0
\r
840 \ 000000AC 1E50 ADC R5, R16
\r
841 \ 000000AE CFB2 RJMP ??OWI_SearchRom_0
\r
845 406 return newDeviation;
\r
846 \ ??OWI_SearchRom_1:
\r
847 \ 000000B0 2F0A MOV R16, R26
\r
848 \ ??OWI_SearchRom_3:
\r
849 \ 000000B2 E0E9 LDI R30, 9
\r
850 \ 000000B4 .... RJMP ?EPILOGUE_B9_L09
\r
854 410 /* Functions for handling CRC */
\r
855 411 /*! \brief Compute the CRC8 value of a data set.
\r
857 413 * This function will compute the CRC8 or DOW-CRC of inData using seed
\r
858 414 * as inital value for the CRC.
\r
860 416 * \param inData One byte of data to compute CRC from.
\r
862 418 * \param seed The starting value of the CRC.
\r
864 420 * \return The CRC8 of inData with seed as initial value.
\r
866 422 * \note Setting seed to 0 computes the crc8 of the inData.
\r
868 424 * \note Constantly passing the return value of this function
\r
869 425 * As the seed argument computes the CRC8 value of a
\r
870 426 * longer string of data.
\r
873 \ In segment CODE, align 2, keep-with-next
\r
874 428 unsigned char OWI_ComputeCRC8(unsigned char inData, unsigned char seed)
\r
877 \ 00000000 2F30 MOV R19, R16
\r
878 \ 00000002 2F01 MOV R16, R17
\r
879 430 unsigned char bitsLeft;
\r
880 431 unsigned char temp;
\r
882 433 for (bitsLeft = 8; bitsLeft > 0; bitsLeft--) {
\r
883 \ 00000004 E018 LDI R17, 8
\r
884 \ ??OWI_ComputeCRC8_0:
\r
885 \ 00000006 3011 CPI R17, 1
\r
886 \ 00000008 F098 BRCS ??OWI_ComputeCRC8_1
\r
887 434 temp = ((seed ^ inData) & 0x01);
\r
888 \ 0000000A 2F50 MOV R21, R16
\r
889 \ 0000000C 7051 ANDI R21, 0x01
\r
890 \ 0000000E 2F23 MOV R18, R19
\r
891 \ 00000010 7021 ANDI R18, 0x01
\r
892 \ 00000012 2725 EOR R18, R21
\r
893 \ 00000014 7021 ANDI R18, 0x01
\r
894 \ 00000016 2F42 MOV R20, R18
\r
896 436 if (temp == 0) {
\r
897 \ 00000018 2344 TST R20
\r
898 \ 0000001A F411 BRNE ??OWI_ComputeCRC8_2
\r
900 \ 0000001C 9506 LSR R16
\r
901 \ 0000001E C005 RJMP ??OWI_ComputeCRC8_3
\r
904 \ ??OWI_ComputeCRC8_2:
\r
905 \ 00000020 E128 LDI R18, 24
\r
906 \ 00000022 2702 EOR R16, R18
\r
908 \ 00000024 9506 LSR R16
\r
910 \ 00000026 6800 ORI R16, 0x80
\r
911 \ 00000028 E021 LDI R18, 1
\r
915 \ ??OWI_ComputeCRC8_3:
\r
916 \ 0000002A 9536 LSR R19
\r
918 \ 0000002C 951A DEC R17
\r
919 \ 0000002E CFEB RJMP ??OWI_ComputeCRC8_0
\r
921 \ ??OWI_ComputeCRC8_1:
\r
922 \ 00000030 9508 RET
\r
926 450 /*! \brief Compute the CRC16 value of a data set.
\r
928 452 * This function will compute the CRC16 of inData using seed
\r
929 453 * as inital value for the CRC.
\r
931 455 * \param inData One byte of data to compute CRC from.
\r
933 457 * \param seed The starting value of the CRC.
\r
935 459 * \return The CRC16 of inData with seed as initial value.
\r
937 461 * \note Setting seed to 0 computes the crc16 of the inData.
\r
939 463 * \note Constantly passing the return value of this function
\r
940 464 * As the seed argument computes the CRC16 value of a
\r
941 465 * longer string of data.
\r
944 \ In segment CODE, align 2, keep-with-next
\r
945 467 unsigned int OWI_ComputeCRC16(unsigned char inData, unsigned int seed)
\r
946 \ OWI_ComputeCRC16:
\r
948 \ 00000000 2F50 MOV R21, R16
\r
949 469 unsigned char bitsLeft;
\r
950 470 unsigned char temp;
\r
952 472 for (bitsLeft = 8; bitsLeft > 0; bitsLeft--) {
\r
953 \ 00000002 E048 LDI R20, 8
\r
954 \ ??OWI_ComputeCRC16_0:
\r
955 \ 00000004 3041 CPI R20, 1
\r
956 \ 00000006 F0C0 BRCS ??OWI_ComputeCRC16_1
\r
957 473 temp = ((seed ^ inData) & 0x01);
\r
958 \ 00000008 2F12 MOV R17, R18
\r
959 \ 0000000A 7011 ANDI R17, 0x01
\r
960 \ 0000000C 2F05 MOV R16, R21
\r
961 \ 0000000E 7001 ANDI R16, 0x01
\r
962 \ 00000010 2701 EOR R16, R17
\r
963 \ 00000012 7001 ANDI R16, 0x01
\r
964 \ 00000014 2F60 MOV R22, R16
\r
966 475 if (temp == 0) {
\r
967 \ 00000016 2366 TST R22
\r
968 \ 00000018 F419 BRNE ??OWI_ComputeCRC16_2
\r
970 \ 0000001A 9536 LSR R19
\r
971 \ 0000001C 9527 ROR R18
\r
972 \ 0000001E C009 RJMP ??OWI_ComputeCRC16_3
\r
974 478 seed ^= 0x4002;
\r
975 \ ??OWI_ComputeCRC16_2:
\r
976 \ 00000020 E002 LDI R16, 2
\r
977 \ 00000022 E410 LDI R17, 64
\r
978 \ 00000024 2720 EOR R18, R16
\r
979 \ 00000026 2731 EOR R19, R17
\r
981 \ 00000028 9536 LSR R19
\r
982 \ 0000002A 9527 ROR R18
\r
983 480 seed |= 0x8000;
\r
984 \ 0000002C 6830 ORI R19, 0x80
\r
985 \ 0000002E E001 LDI R16, 1
\r
986 \ 00000030 E010 LDI R17, 0
\r
990 \ ??OWI_ComputeCRC16_3:
\r
991 \ 00000032 9556 LSR R21
\r
993 \ 00000034 954A DEC R20
\r
994 \ 00000036 CFE6 RJMP ??OWI_ComputeCRC16_0
\r
997 \ ??OWI_ComputeCRC16_1:
\r
998 \ 00000038 0189 MOVW R17:R16, R19:R18
\r
999 \ 0000003A 9508 RET
\r
1003 490 /*! \brief Calculate and check the CRC of a 64 bit ROM identifier.
\r
1005 492 * This function computes the CRC8 value of the first 56 bits of a
\r
1006 493 * 64 bit identifier. It then checks the calculated value against the
\r
1007 494 * CRC value stored in ROM.
\r
1009 496 * \param *romValue A pointer to an array holding a 64 bit identifier.
\r
1011 498 * \retval OWI_CRC_OK The CRC's matched.
\r
1012 499 * \retval OWI_CRC_ERROR Calculated and stored CRC did not match.
\r
1015 \ In segment CODE, align 2, keep-with-next
\r
1016 501 unsigned char OWI_CheckRomCRC(unsigned char *romValue)
\r
1017 \ OWI_CheckRomCRC:
\r
1019 \ 00000000 .... RCALL ?PROLOGUE4_L09
\r
1020 \ 00000002 01D8 MOVW R27:R26, R17:R16
\r
1021 503 unsigned char i;
\r
1022 504 unsigned char crc8 = 0;
\r
1023 \ 00000004 E090 LDI R25, 0
\r
1025 506 for (i = 0; i < 7; i++) {
\r
1026 \ 00000006 E080 LDI R24, 0
\r
1027 \ ??OWI_CheckRomCRC_0:
\r
1028 \ 00000008 3087 CPI R24, 7
\r
1029 \ 0000000A F440 BRCC ??OWI_CheckRomCRC_1
\r
1030 507 crc8 = OWI_ComputeCRC8(*romValue, crc8);
\r
1031 \ 0000000C 2F19 MOV R17, R25
\r
1032 \ 0000000E 01FD MOVW R31:R30, R27:R26
\r
1033 \ 00000010 8100 LD R16, Z
\r
1034 \ 00000012 .... RCALL OWI_ComputeCRC8
\r
1035 \ 00000014 2F90 MOV R25, R16
\r
1037 \ 00000016 9611 ADIW R27:R26, 1
\r
1039 \ 00000018 9583 INC R24
\r
1040 \ 0000001A CFF6 RJMP ??OWI_CheckRomCRC_0
\r
1042 511 if (crc8 == (*romValue)) {
\r
1043 \ ??OWI_CheckRomCRC_1:
\r
1044 \ 0000001C 910C LD R16, X
\r
1045 \ 0000001E 1790 CP R25, R16
\r
1046 \ 00000020 F411 BRNE ??OWI_CheckRomCRC_2
\r
1047 512 return OWI_CRC_OK;
\r
1048 \ 00000022 E000 LDI R16, 0
\r
1049 \ 00000024 C001 RJMP ??OWI_CheckRomCRC_3
\r
1052 515 return OWI_CRC_ERROR;
\r
1053 \ ??OWI_CheckRomCRC_2:
\r
1054 \ 00000026 E001 LDI R16, 1
\r
1055 \ ??OWI_CheckRomCRC_3:
\r
1056 \ 00000028 E0E4 LDI R30, 4
\r
1057 \ 0000002A .... RJMP ?EPILOGUE_B4_L09
\r
1060 Maximum stack usage in bytes:
\r
1062 Function CSTACK RSTACK
\r
1063 -------- ------ ------
\r
1064 OWI_CheckRomCRC 4 2
\r
1065 -> OWI_ComputeCRC8 4 2
\r
1066 OWI_ComputeCRC16 0 2
\r
1067 OWI_ComputeCRC8 0 2
\r
1068 OWI_DetectPresence 0 2
\r
1071 -> OWI_SendByte 4 2
\r
1072 -> OWI_SendByte 4 2
\r
1075 -> OWI_SendByte 4 2
\r
1076 -> OWI_ReceiveByte 4 2
\r
1077 OWI_ReceiveByte 3 2
\r
1078 -> OWI_ReadBit 3 2
\r
1080 -> OWI_SendByte 9 2
\r
1081 -> OWI_ReadBit 9 2
\r
1082 -> OWI_ReadBit 9 2
\r
1083 -> OWI_WriteBit1 9 2
\r
1084 -> OWI_WriteBit0 9 2
\r
1086 -> OWI_WriteBit1 4 2
\r
1087 -> OWI_WriteBit0 4 2
\r
1089 -> OWI_SendByte 1 2
\r
1094 Segment part sizes:
\r
1096 Function/Label Bytes
\r
1097 -------------- -----
\r
1105 OWI_DetectPresence 88
\r
1107 OWI_ReceiveByte 36
\r
1112 OWI_ComputeCRC8 50
\r
1113 OWI_ComputeCRC16 60
\r
1114 OWI_CheckRomCRC 44
\r
1117 3 bytes in segment ABSOLUTE
\r
1118 820 bytes in segment CODE
\r
1120 820 bytes of CODE memory
\r
1121 0 bytes of DATA memory (+ 3 bytes shared)
\r
projects / avr_bc100.git / blob