]>
Commit | Line | Data |
---|---|---|
51990c45 IJ |
1 | ## |
2 | ## This file is part of the sigrok project. | |
3 | ## | |
4 | ## Copyright (C) 2011-2012 Uwe Hermann <uwe@hermann-uwe.de> | |
5 | ## | |
6 | ## This program is free software; you can redistribute it and/or modify | |
7 | ## it under the terms of the GNU General Public License as published by | |
8 | ## the Free Software Foundation; either version 2 of the License, or | |
9 | ## (at your option) any later version. | |
10 | ## | |
11 | ## This program is distributed in the hope that it will be useful, | |
12 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | ## GNU General Public License for more details. | |
15 | ## | |
16 | ## You should have received a copy of the GNU General Public License | |
17 | ## along with this program; if not, write to the Free Software | |
18 | ## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
19 | ## | |
20 | ||
21 | # 1-Wire protocol decoder | |
22 | ||
23 | import sigrokdecode as srd | |
24 | ||
25 | # Annotation feed formats | |
13329e2d IJ |
26 | ANN_LINK = 0 |
27 | ANN_NETWORK = 1 | |
28 | ANN_TRANSPORT = 2 | |
51990c45 | 29 | |
a2b13347 IJ |
30 | # a dictionary of ROM commands and their names |
31 | rom_command = {0x33: "READ ROM", | |
32 | 0x0f: "CONDITIONAL READ ROM", | |
33 | 0xcc: "SKIP ROM", | |
34 | 0x55: "MATCH ROM", | |
35 | 0xf0: "SEARCH ROM", | |
36 | 0xec: "CONDITIONAL SEARCH ROM", | |
37 | 0x3c: "OVERDRIVE SKIP ROM", | |
38 | 0x6d: "OVERDRIVE MATCH ROM"} | |
39 | ||
51990c45 IJ |
40 | class Decoder(srd.Decoder): |
41 | api_version = 1 | |
42 | id = 'onewire' | |
43 | name = '1-Wire' | |
44 | longname = '' | |
45 | desc = '1-Wire bus and MicroLan' | |
46 | license = 'gplv2+' | |
47 | inputs = ['logic'] | |
48 | outputs = ['onewire'] | |
49 | probes = [ | |
50 | {'id': 'owr', 'name': 'OWR', 'desc': '1-Wire bus'}, | |
51 | ] | |
52 | optional_probes = [ | |
53 | {'id': 'pwr', 'name': 'PWR', 'desc': '1-Wire power'}, | |
54 | ] | |
55 | options = { | |
41e5c645 IJ |
56 | 'overdrive' : ['Overdrive', 1], |
57 | 'cnt_normal_bit' : ['Time (in samplerate periods) for normal mode sample bit' , 0], | |
58 | 'cnt_normal_presence' : ['Time (in samplerate periods) for normal mode sample presence', 0], | |
c08aea7e | 59 | 'cnt_normal_reset' : ['Time (in samplerate periods) for normal mode reset' , 0], |
41e5c645 IJ |
60 | 'cnt_overdrive_bit' : ['Time (in samplerate periods) for overdrive mode sample bit' , 0], |
61 | 'cnt_overdrive_presence': ['Time (in samplerate periods) for overdrive mode sample presence', 0], | |
c08aea7e | 62 | 'cnt_overdrive_reset' : ['Time (in samplerate periods) for overdrive mode reset' , 0], |
51990c45 IJ |
63 | } |
64 | annotations = [ | |
0bd62eb1 IJ |
65 | ['Link', 'Link layer events (reset, presence, bit slots)'], |
66 | ['Network', 'Network layer events (device addressing)'], | |
13329e2d | 67 | ['Transport', 'Transport layer events'], |
51990c45 IJ |
68 | ] |
69 | ||
51990c45 IJ |
70 | def __init__(self, **kwargs): |
71 | # Common variables | |
72 | self.samplenum = 0 | |
73 | # Link layer variables | |
af623785 IJ |
74 | self.lnk_state = 'WAIT FOR FALLING EDGE' |
75 | self.lnk_event = 'NONE' | |
af623785 IJ |
76 | self.lnk_present = 0 |
77 | self.lnk_bit = 0 | |
c08aea7e IJ |
78 | self.lnk_overdrive = 0 |
79 | # Event timing variables | |
80 | self.lnk_fall = 0 | |
81 | self.lnk_rise = 0 | |
82 | self.net_beg = 0 | |
83 | self.net_end = 0 | |
f4d0363d | 84 | self.net_len = 0 |
51990c45 | 85 | # Network layer variables |
af5ec813 | 86 | self.net_state = 'IDLE' |
af623785 | 87 | self.net_cnt = 0 |
d2b6e141 IJ |
88 | self.net_search = "P" |
89 | self.net_data_p = 0x0 | |
90 | self.net_data_n = 0x0 | |
91 | self.net_data = 0x0 | |
af5ec813 | 92 | self.net_rom = 0x0000000000000000 |
51990c45 IJ |
93 | |
94 | def start(self, metadata): | |
51990c45 | 95 | self.out_proto = self.add(srd.OUTPUT_PROTO, 'onewire') |
4fe36ec3 | 96 | self.out_ann = self.add(srd.OUTPUT_ANN , 'onewire') |
51990c45 | 97 | |
41e5c645 IJ |
98 | # check if samplerate is appropriate |
99 | self.samplerate = metadata['samplerate'] | |
100 | if (self.options['overdrive']): | |
f4d0363d IJ |
101 | self.put(0, 0, self.out_ann, [ANN_LINK, |
102 | ['NOTE: Sample rate checks assume overdrive mode.']]) | |
41e5c645 | 103 | if (self.samplerate < 2000000): |
f4d0363d IJ |
104 | self.put(0, 0, self.out_ann, [ANN_LINK, |
105 | ['ERROR: Sampling rate is too low must be above 2MHz for proper overdrive mode decoding.']]) | |
41e5c645 | 106 | elif (self.samplerate < 5000000): |
f4d0363d IJ |
107 | self.put(0, 0, self.out_ann, [ANN_LINK, |
108 | ['WARNING: Sampling rate is suggested to be above 5MHz for proper overdrive mode decoding.']]) | |
41e5c645 | 109 | else: |
f4d0363d IJ |
110 | self.put(0, 0, self.out_ann, [ANN_LINK, |
111 | ['NOTE: Sample rate checks assume normal mode only.']]) | |
41e5c645 | 112 | if (self.samplerate < 400000): |
f4d0363d IJ |
113 | self.put(0, 0, self.out_ann, [ANN_LINK, |
114 | ['ERROR: Sampling rate is too low must be above 400kHz for proper normal mode decoding.']]) | |
41e5c645 | 115 | elif (self.samplerate < 1000000): |
f4d0363d IJ |
116 | self.put(0, 0, self.out_ann, [ANN_LINK, |
117 | ['WARNING: Sampling rate is suggested to be above 1MHz for proper normal mode decoding.']]) | |
41e5c645 IJ |
118 | |
119 | # The default 1-Wire time base is 30us, this is used to calculate sampling times. | |
f4d0363d IJ |
120 | if (self.options['cnt_normal_bit']): |
121 | self.cnt_normal_bit = self.options['cnt_normal_bit'] | |
122 | else: | |
123 | self.cnt_normal_bit = int(float(self.samplerate) * 0.000015) - 1 # 15ns | |
124 | if (self.options['cnt_normal_presence']): | |
125 | self.cnt_normal_presence = self.options['cnt_normal_presence'] | |
126 | else: | |
127 | self.cnt_normal_presence = int(float(self.samplerate) * 0.000075) - 1 # 75ns | |
128 | if (self.options['cnt_normal_reset']): | |
129 | self.cnt_normal_reset = self.options['cnt_normal_reset'] | |
130 | else: | |
131 | self.cnt_normal_reset = int(float(self.samplerate) * 0.000480) - 1 # 480ns | |
132 | if (self.options['cnt_overdrive_bit']): | |
133 | self.cnt_overdrive_bit = self.options['cnt_overdrive_bit'] | |
134 | else: | |
135 | self.cnt_overdrive_bit = int(float(self.samplerate) * 0.000002) - 1 # 2ns | |
136 | if (self.options['cnt_overdrive_presence']): | |
137 | self.cnt_overdrive_presence = self.options['cnt_overdrive_presence'] | |
138 | else: | |
139 | self.cnt_overdrive_presence = int(float(self.samplerate) * 0.000010) - 1 # 10ns | |
140 | if (self.options['cnt_overdrive_reset']): | |
141 | self.cnt_overdrive_reset = self.options['cnt_overdrive_reset'] | |
142 | else: | |
143 | self.cnt_overdrive_reset = int(float(self.samplerate) * 0.000048) - 1 # 48ns | |
144 | ||
145 | # calculating the slot size | |
146 | self.cnt_normal_slot = int(float(self.samplerate) * 0.000060) - 1 # 60ns | |
147 | self.cnt_overdrive_slot = int(float(self.samplerate) * 0.000006) - 1 # 6ns | |
148 | ||
149 | # organize values into lists | |
150 | self.cnt_bit = [self.cnt_normal_bit , self.cnt_overdrive_bit ] | |
151 | self.cnt_presence = [self.cnt_normal_presence, self.cnt_overdrive_presence] | |
152 | self.cnt_reset = [self.cnt_normal_reset , self.cnt_overdrive_reset ] | |
153 | self.cnt_slot = [self.cnt_normal_slot , self.cnt_overdrive_slot ] | |
c08aea7e | 154 | |
41e5c645 | 155 | # Check if sample times are in the allowed range |
c08aea7e IJ |
156 | time_min = float(self.cnt_normal_bit ) / self.samplerate |
157 | time_max = float(self.cnt_normal_bit+1) / self.samplerate | |
158 | if ( (time_min < 0.000005) or (time_max > 0.000015) ) : | |
f4d0363d IJ |
159 | self.put(0, 0, self.out_ann, [ANN_LINK, |
160 | ['WARNING: The normal mode data sample time interval (%2.1fus-%2.1fus) should be inside (5.0us, 15.0us).' | |
161 | % (time_min*1000000, time_max*1000000)]]) | |
c08aea7e IJ |
162 | time_min = float(self.cnt_normal_presence ) / self.samplerate |
163 | time_max = float(self.cnt_normal_presence+1) / self.samplerate | |
164 | if ( (time_min < 0.0000681) or (time_max > 0.000075) ) : | |
f4d0363d IJ |
165 | self.put(0, 0, self.out_ann, [ANN_LINK, |
166 | ['WARNING: The normal mode presence sample time interval (%2.1fus-%2.1fus) should be inside (68.1us, 75.0us).' | |
167 | % (time_min*1000000, time_max*1000000)]]) | |
c08aea7e IJ |
168 | time_min = float(self.cnt_overdrive_bit ) / self.samplerate |
169 | time_max = float(self.cnt_overdrive_bit+1) / self.samplerate | |
170 | if ( (time_min < 0.000001) or (time_max > 0.000002) ) : | |
f4d0363d IJ |
171 | self.put(0, 0, self.out_ann, [ANN_LINK, |
172 | ['WARNING: The overdrive mode data sample time interval (%2.1fus-%2.1fus) should be inside (1.0us, 2.0us).' | |
173 | % (time_min*1000000, time_max*1000000)]]) | |
c08aea7e IJ |
174 | time_min = float(self.cnt_overdrive_presence ) / self.samplerate |
175 | time_max = float(self.cnt_overdrive_presence+1) / self.samplerate | |
176 | if ( (time_min < 0.0000073) or (time_max > 0.000010) ) : | |
f4d0363d IJ |
177 | self.put(0, 0, self.out_ann, [ANN_LINK, |
178 | ['WARNING: The overdrive mode presence sample time interval (%2.1fus-%2.1fus) should be inside (7.3us, 10.0us).' | |
179 | % (time_min*1000000, time_max*1000000)]]) | |
51990c45 IJ |
180 | |
181 | def report(self): | |
182 | pass | |
183 | ||
51990c45 | 184 | def decode(self, ss, es, data): |
af623785 | 185 | for (self.samplenum, (owr, pwr)) in data: |
51990c45 | 186 | |
51990c45 | 187 | # Data link layer |
39a0219a IJ |
188 | |
189 | # Clear events. | |
af623785 | 190 | self.lnk_event = "NONE" |
39a0219a | 191 | # State machine. |
51990c45 IJ |
192 | if self.lnk_state == 'WAIT FOR FALLING EDGE': |
193 | # The start of a cycle is a falling edge. | |
39a0219a IJ |
194 | if (owr == 0): |
195 | # Save the sample number for the falling edge. | |
196 | self.lnk_fall = self.samplenum | |
51990c45 | 197 | # Go to waiting for sample time |
39a0219a IJ |
198 | self.lnk_state = 'WAIT FOR DATA SAMPLE' |
199 | elif self.lnk_state == 'WAIT FOR DATA SAMPLE': | |
c08aea7e | 200 | # Sample data bit |
f4d0363d | 201 | if (self.samplenum - self.lnk_fall == self.cnt_bit[self.lnk_overdrive]): |
51990c45 | 202 | self.lnk_bit = owr & 0x1 |
39a0219a | 203 | self.lnk_event = "DATA BIT" |
c08aea7e IJ |
204 | if (self.lnk_bit): self.lnk_state = 'WAIT FOR FALLING EDGE' |
205 | else : self.lnk_state = 'WAIT FOR RISING EDGE' | |
f4d0363d | 206 | self.put(self.lnk_fall, self.cnt_bit[self.lnk_overdrive], self.out_ann, [ANN_LINK, ['BIT: %01x' % self.lnk_bit]]) |
51990c45 IJ |
207 | elif self.lnk_state == 'WAIT FOR RISING EDGE': |
208 | # The end of a cycle is a rising edge. | |
39a0219a | 209 | if (owr == 1): |
c08aea7e IJ |
210 | # Check if this was a reset cycle |
211 | if (self.samplenum - self.lnk_fall > self.cnt_normal_reset): | |
39a0219a IJ |
212 | # Save the sample number for the falling edge. |
213 | self.lnk_rise = self.samplenum | |
af623785 | 214 | # Send a reset event to the next protocol layer. |
39a0219a IJ |
215 | self.lnk_event = "RESET" |
216 | self.lnk_state = "WAIT FOR PRESENCE DETECT" | |
f4d0363d IJ |
217 | self.put(self.lnk_fall, self.lnk_rise, self.out_proto, ['RESET']) |
218 | self.put(self.lnk_fall, self.lnk_rise, self.out_ann, [ANN_LINK , ['RESET']]) | |
219 | self.put(self.lnk_fall, self.lnk_rise, self.out_ann, [ANN_NETWORK , ['RESET']]) | |
af623785 IJ |
220 | # Reset the timer. |
221 | self.lnk_fall = self.samplenum | |
c08aea7e IJ |
222 | elif ((self.samplenum - self.lnk_fall > self.cnt_overdrive_reset) and (self.lnk_overdrive)): |
223 | # Save the sample number for the falling edge. | |
224 | self.lnk_rise = self.samplenum | |
225 | # Send a reset event to the next protocol layer. | |
226 | self.lnk_event = "RESET" | |
227 | self.lnk_state = "WAIT FOR PRESENCE DETECT" | |
f4d0363d IJ |
228 | self.put(self.lnk_fall, self.lnk_rise, self.out_proto, ['RESET OVERDRIVE']) |
229 | self.put(self.lnk_fall, self.lnk_rise, self.out_ann, [ANN_LINK , ['RESET OVERDRIVE']]) | |
230 | self.put(self.lnk_fall, self.lnk_rise, self.out_ann, [ANN_NETWORK , ['RESET OVERDRIVE']]) | |
c08aea7e IJ |
231 | # Reset the timer. |
232 | self.lnk_fall = self.samplenum | |
af623785 IJ |
233 | # Otherwise this is assumed to be a data bit. |
234 | else : | |
235 | self.lnk_state = "WAIT FOR FALLING EDGE" | |
39a0219a | 236 | elif self.lnk_state == 'WAIT FOR PRESENCE DETECT': |
c08aea7e | 237 | # Sample presence status |
f4d0363d | 238 | if (self.samplenum - self.lnk_rise == self.cnt_presence[self.lnk_overdrive]): |
af623785 | 239 | self.lnk_present = owr & 0x1 |
cf0f9df0 IJ |
240 | # Save the sample number for the falling edge. |
241 | if not (self.lnk_present) : self.lnk_fall = self.samplenum | |
242 | # create presence detect event | |
af623785 | 243 | #self.lnk_event = "PRESENCE DETECT" |
cf0f9df0 IJ |
244 | if (self.lnk_present) : self.lnk_state = 'WAIT FOR FALLING EDGE' |
245 | else : self.lnk_state = 'WAIT FOR RISING EDGE' | |
0bd62eb1 | 246 | present_str = "False" if self.lnk_present else "True" |
f4d0363d IJ |
247 | self.put(self.samplenum, 0, self.out_ann, [ANN_LINK , ['PRESENCE: ' + present_str]]) |
248 | self.put(self.samplenum, 0, self.out_ann, [ANN_NETWORK, ['PRESENCE: ' + present_str]]) | |
39a0219a | 249 | else: |
0631e33d | 250 | raise Exception('Invalid lnk_state: %d' % self.lnk_state) |
39a0219a IJ |
251 | |
252 | # Network layer | |
a2b13347 | 253 | |
39a0219a | 254 | # State machine. |
4fe36ec3 | 255 | if (self.lnk_event == "RESET"): |
af5ec813 | 256 | self.net_state = "COMMAND" |
d2b6e141 IJ |
257 | self.net_search = "P" |
258 | self.net_cnt = 0 | |
af5ec813 IJ |
259 | elif (self.net_state == "IDLE"): |
260 | pass | |
261 | elif (self.net_state == "COMMAND"): | |
c08aea7e IJ |
262 | # Receiving and decoding a ROM command |
263 | if (self.onewire_collect(8)): | |
f4d0363d IJ |
264 | self.put(self.net_beg, self.net_len, self.out_ann, [ANN_NETWORK, |
265 | ['ROM COMMAND: 0x%02x \'%s\'' % (self.net_data, rom_command[self.net_data])]]) | |
a2b13347 | 266 | if (self.net_data == 0x33): # READ ROM |
af5ec813 | 267 | self.net_state = "GET ROM" |
a2b13347 | 268 | elif (self.net_data == 0x0f): # CONDITIONAL READ ROM |
af5ec813 | 269 | self.net_state = "GET ROM" |
a2b13347 | 270 | elif (self.net_data == 0xcc): # SKIP ROM |
41e5c645 | 271 | self.net_state = "TRANSPORT" |
a2b13347 | 272 | elif (self.net_data == 0x55): # MATCH ROM |
af5ec813 | 273 | self.net_state = "GET ROM" |
a2b13347 | 274 | elif (self.net_data == 0xf0): # SEARCH ROM |
af5ec813 | 275 | self.net_state = "SEARCH ROM" |
a2b13347 | 276 | elif (self.net_data == 0xec): # CONDITIONAL SEARCH ROM |
13329e2d | 277 | self.net_state = "SEARCH ROM" |
a2b13347 | 278 | elif (self.net_data == 0x3c): # OVERDRIVE SKIP ROM |
c08aea7e | 279 | self.lnk_overdrive = 1 |
41e5c645 | 280 | self.net_state = "TRANSPORT" |
a2b13347 | 281 | elif (self.net_data == 0x69): # OVERDRIVE MATCH ROM |
c08aea7e | 282 | self.lnk_overdrive = 1 |
af5ec813 IJ |
283 | self.net_state = "GET ROM" |
284 | elif (self.net_state == "GET ROM"): | |
c08aea7e | 285 | # A 64 bit device address is selected |
af5ec813 | 286 | # family code (1B) + serial number (6B) + CRC (1B) |
c08aea7e | 287 | if (self.onewire_collect(64)): |
af5ec813 | 288 | self.net_rom = self.net_data & 0xffffffffffffffff |
f4d0363d | 289 | self.put(self.net_beg, self.net_len, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_rom]]) |
41e5c645 | 290 | self.net_state = "TRANSPORT" |
af5ec813 | 291 | elif (self.net_state == "SEARCH ROM"): |
c08aea7e | 292 | # A 64 bit device address is searched for |
af5ec813 | 293 | # family code (1B) + serial number (6B) + CRC (1B) |
c08aea7e | 294 | if (self.onewire_search(64)): |
af5ec813 | 295 | self.net_rom = self.net_data & 0xffffffffffffffff |
f4d0363d | 296 | self.put(self.net_beg, self.net_len, self.out_ann, [ANN_NETWORK, ['ROM: 0x%016x' % self.net_rom]]) |
41e5c645 | 297 | self.net_state = "TRANSPORT" |
c08aea7e IJ |
298 | elif (self.net_state == "TRANSPORT"): |
299 | # The transport layer is handled in byte sized units | |
300 | if (self.onewire_collect(8)): | |
f4d0363d IJ |
301 | self.put(self.net_beg, self.net_len, self.out_ann, [ANN_NETWORK , ['TRANSPORT: 0x%02x' % self.net_data]]) |
302 | self.put(self.net_beg, self.net_len, self.out_ann, [ANN_TRANSPORT, ['TRANSPORT: 0x%02x' % self.net_data]]) | |
303 | self.put(self.net_beg, self.net_len, self.out_proto, ['transfer', self.net_data]) | |
c08aea7e | 304 | # TODO: Sending translort layer data to 1-Wire device models |
af5ec813 IJ |
305 | else: |
306 | raise Exception('Invalid net_state: %s' % self.net_state) | |
51990c45 | 307 | |
51990c45 | 308 | |
d2b6e141 | 309 | # Link/Network layer data collector |
c08aea7e | 310 | def onewire_collect (self, length): |
af5ec813 | 311 | if (self.lnk_event == "DATA BIT"): |
c08aea7e IJ |
312 | # Storing the sampe this sequence begins with |
313 | if (self.net_cnt == 1): | |
f4d0363d | 314 | self.net_beg = self.lnk_fall |
af5ec813 IJ |
315 | self.net_data = self.net_data & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt) |
316 | self.net_cnt = self.net_cnt + 1 | |
c08aea7e IJ |
317 | # Storing the sampe this sequence ends with |
318 | # In case the full length of the sequence is received, return 1 | |
af5ec813 | 319 | if (self.net_cnt == length): |
f4d0363d IJ |
320 | self.net_end = self.lnk_fall + self.cnt_slot[self.lnk_overdrive] |
321 | self.net_len = self.net_end - self.net_beg | |
af5ec813 IJ |
322 | self.net_data = self.net_data & ((1<<length)-1) |
323 | self.net_cnt = 0 | |
324 | return (1) | |
325 | else: | |
326 | return (0) | |
d2b6e141 IJ |
327 | else: |
328 | return (0) | |
329 | ||
330 | # Link/Network layer search collector | |
c08aea7e | 331 | def onewire_search (self, length): |
af5ec813 | 332 | if (self.lnk_event == "DATA BIT"): |
c08aea7e IJ |
333 | # Storing the sampe this sequence begins with |
334 | if ((self.net_cnt == 0) and (self.net_search == "P")): | |
f4d0363d | 335 | self.net_beg = self.lnk_fall |
c08aea7e | 336 | # Master receives an original address bit |
af5ec813 IJ |
337 | if (self.net_search == "P"): |
338 | self.net_data_p = self.net_data_p & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt) | |
339 | self.net_search = "N" | |
c08aea7e | 340 | # Master receives a complemented address bit |
af5ec813 IJ |
341 | elif (self.net_search == "N"): |
342 | self.net_data_n = self.net_data_n & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt) | |
343 | self.net_search = "D" | |
c08aea7e | 344 | # Master transmits an address bit |
af5ec813 IJ |
345 | elif (self.net_search == "D"): |
346 | self.net_data = self.net_data & ~(1 << self.net_cnt) | (self.lnk_bit << self.net_cnt) | |
347 | self.net_search = "P" | |
348 | self.net_cnt = self.net_cnt + 1 | |
c08aea7e IJ |
349 | # Storing the sampe this sequence ends with |
350 | # In case the full length of the sequence is received, return 1 | |
af5ec813 | 351 | if (self.net_cnt == length): |
f4d0363d IJ |
352 | self.net_end = self.lnk_fall + self.cnt_slot[self.lnk_overdrive] |
353 | self.net_len = self.net_end - self.net_beg | |
af5ec813 IJ |
354 | self.net_data_p = self.net_data_p & ((1<<length)-1) |
355 | self.net_data_n = self.net_data_n & ((1<<length)-1) | |
356 | self.net_data = self.net_data & ((1<<length)-1) | |
357 | self.net_search = "P" | |
358 | self.net_cnt = 0 | |
359 | return (1) | |
360 | else: | |
361 | return (0) | |
d2b6e141 IJ |
362 | else: |
363 | return (0) |