12 static uint32_t station_id = 0x12345678;
13 static uint8_t feedback_threshold = 30;
15 void mfx_set_station_id(uint32_t id)
20 static OutputPacket *mfx_create_packet(MfxEncodingState *state)
22 OutputPacket *packet = output_create_packet();
23 packet->bit_duration = 4;
24 packet->repeat_count = 1;
25 packet->final_delay = 128;
27 packet->data[0] = 0x9B;
29 state->ones_count = 0;
34 static inline void mfx_update_crc8(MfxEncodingState *state, uint8_t bits, uint8_t length)
36 for(uint8_t i=length; i--; )
38 uint8_t bit = (bits>>i)&1;
39 if(bit^(state->crc8>>7))
40 state->crc8 = (state->crc8<<1)^7;
46 static inline uint8_t mfx_get_output_level(const OutputPacket *packet)
48 uint8_t b = packet->length-1;
49 return (packet->data[b>>3]>>(b&7))&1;
52 static inline void mfx_ensure_low_level(OutputPacket *packet)
54 if(mfx_get_output_level(packet))
56 // Motorola decoders require a low logic level when idle.
57 uint8_t out_bit = packet->length;
59 packet->data[out_bit>>3] = 0;
64 static inline void mfx_encode_flag_pairs(OutputPacket *packet, uint8_t count)
66 static const uint8_t flag_bits[5] = { 0x9B, 0x6C, 0xB2, 0xC9, 0x26 };
68 uint8_t invert = mfx_get_output_level(packet)*0xFF;
69 uint8_t shift = packet->length&7;
70 uint8_t total_bits = count*10;
71 uint8_t tail_bits = (total_bits+shift)&7;
72 uint8_t out_byte = packet->length>>3;
75 uint8_t head_bits = 8-shift;
76 packet->data[out_byte++] |= (flag_bits[0]^invert)<<shift;
79 uint8_t bytes = (total_bits-head_bits)>>3;
80 uint8_t carry = flag_bits[0]>>head_bits;
83 packet->data[out_byte++] = (carry|(flag_bits[i]<<shift))^invert;
84 carry = flag_bits[i]>>head_bits;
86 if(++i>=sizeof(flag_bits))
87 i -= sizeof(flag_bits);
91 packet->data[out_byte] = ((carry|(flag_bits[i]<<shift))^invert)&((1<<tail_bits)-1);
96 uint8_t bytes = total_bits>>3;
99 packet->data[out_byte++] = flag_bits[i]^invert;
101 if(++i>=sizeof(flag_bits))
102 i -= sizeof(flag_bits);
105 uint8_t tail_bits = (total_bits+shift)&7;
107 packet->data[out_byte] = (flag_bits[i]^invert)&((1<<tail_bits)-1);
110 packet->length += total_bits;
113 static inline void mfx_encode_bits8_raw(OutputPacket *packet, MfxEncodingState *state, uint8_t bits, uint8_t length)
115 uint8_t out_bit = packet->length;
116 uint8_t out_level = mfx_get_output_level(packet);
117 uint8_t ones_count = state->ones_count;
119 for(uint8_t i=length; i--; )
121 uint8_t bit = (bits>>i)&1;
131 // out_bit is always even at this point
133 packet->data[out_bit>>3] = bit;
135 packet->data[out_bit>>3] |= bit<<(out_bit&7);
146 state->ones_count = ones_count;
147 packet->length = out_bit;
150 static inline void mfx_encode_bits8(OutputPacket *packet, MfxEncodingState *state, uint8_t bits, uint8_t length)
152 mfx_encode_bits8_raw(packet, state, bits, length);
153 mfx_update_crc8(state, bits, length);
156 static inline void mfx_encode_bits16(OutputPacket *packet, MfxEncodingState *state, uint16_t bits, uint8_t length)
158 mfx_encode_bits8(packet, state, bits>>8, length-8);
159 mfx_encode_bits8(packet, state, bits, 8);
162 static inline void mfx_encode_bits32(OutputPacket *packet, MfxEncodingState *state, uint32_t bits, uint8_t length)
166 mfx_encode_bits8(packet, state, bits>>24, length-24);
167 mfx_encode_bits8(packet, state, bits>>16, 8);
170 mfx_encode_bits8(packet, state, bits>>16, length-16);
171 mfx_encode_bits8(packet, state, bits>>8, 8);
172 mfx_encode_bits8(packet, state, bits, 8);
175 static inline void mfx_address_field(OutputPacket *packet, MfxEncodingState *state, uint16_t address)
178 mfx_encode_bits16(packet, state, 0x100|address, 9);
179 else if(address<0x200)
180 mfx_encode_bits16(packet, state, 0xC00|address, 12);
181 else if(address<0x800)
182 mfx_encode_bits16(packet, state, 0x7000|address, 15);
185 mfx_encode_bits8(packet, state, 0xF, 4);
186 mfx_encode_bits16(packet, state, address, 14);
190 void mfx_speed_field(OutputPacket *packet, MfxEncodingState *state, uint8_t speed_dir)
195 mfx_encode_bits8(packet, state, 0x1, 3);
196 mfx_encode_bits8(packet, state, speed_dir, 8);
200 mfx_encode_bits8(packet, state, speed_dir>>4, 7);
203 static void mfx_finish_packet(OutputPacket *packet, MfxEncodingState *state)
205 mfx_encode_bits8_raw(packet, state, state->crc8, 8);
206 mfx_encode_flag_pairs(packet, 2);
207 mfx_ensure_low_level(packet);
210 static void mfx_finish_packet_feedback(OutputPacket *packet, MfxEncodingState *state)
212 mfx_encode_bits8_raw(packet, state, state->crc8, 8);
213 mfx_encode_flag_pairs(packet, 11);
214 mfx_encode_bits8_raw(packet, state, 0x3, 4);
215 packet->final_delay = 0;
216 uint8_t fill = (1-mfx_get_output_level(packet))*0xFF;
218 for(uint8_t i=0; i<2; ++i)
220 packet = output_create_chained_packet();
221 packet->bit_duration = 4;
222 packet->repeat_count = 1;
223 packet->final_delay = 0;
224 packet->trigger_position = 112;
225 packet->trigger_value = i+1;
227 for(uint8_t j=0; j<16; ++j)
228 packet->data[j] = fill;
229 packet->length = 128;
230 mfx_encode_flag_pairs(packet, 1+i);
234 mfx_ensure_low_level(packet);
235 packet->final_delay = 128;
238 static void mfx_receive_feedback(uint8_t type)
240 /* The decoder should activate a 52.6 kHz carrier to indicate positive
241 acknowledgement, but so far I've been unable to build a circuit that detects
242 it. The increased current draw can nevertheless be measured. */
245 current[0] = monitor_track_current();
248 uint8_t trig = output_get_trigger();
251 current[trig] = monitor_track_current();
259 if(current[1]>feedback_threshold)
261 current[1] -= feedback_threshold;
262 reply[1] = (current[1]>current[0] && current[1]>current[2]);
266 interface_send(reply, 2);
269 void mfx_announce_packet(uint16_t serial)
271 MfxEncodingState state;
272 OutputPacket *packet = mfx_create_packet(&state);
273 mfx_address_field(packet, &state, 0);
274 // Packet type: 111101
275 mfx_encode_bits8(packet, &state, 0x3D, 6);
276 mfx_encode_bits32(packet, &state, station_id, 32);
277 mfx_encode_bits16(packet, &state, serial, 16);
278 mfx_finish_packet(packet, &state);
279 output_send_packet();
282 void mfx_search_packet(uint32_t mask_bits, uint8_t mask_size)
284 MfxEncodingState state;
285 OutputPacket *packet = mfx_create_packet(&state);
286 mfx_address_field(packet, &state, 0);
287 // Packet type: 111010
288 mfx_encode_bits8(packet, &state, 0x3A, 6);
289 mfx_encode_bits8(packet, &state, mask_size, 6);
290 mfx_encode_bits32(packet, &state, mask_bits, 32);
291 mfx_finish_packet_feedback(packet, &state);
292 output_send_packet();
295 void mfx_assign_address_packet(uint16_t addr, uint32_t id)
297 MfxEncodingState state;
298 OutputPacket *packet = mfx_create_packet(&state);
299 mfx_address_field(packet, &state, 0);
300 // Packet type: 111011
301 mfx_encode_bits8(packet, &state, 0x3B, 6);
302 mfx_encode_bits16(packet, &state, addr, 14);
303 mfx_encode_bits32(packet, &state, id, 32);
304 mfx_finish_packet(packet, &state);
305 output_send_packet();
308 void mfx_ping_packet(uint16_t addr, uint32_t id)
310 MfxEncodingState state;
311 OutputPacket *packet = mfx_create_packet(&state);
312 mfx_address_field(packet, &state, addr);
313 // Packet type: 111100
314 mfx_encode_bits8(packet, &state, 0x3C, 6);
315 mfx_encode_bits32(packet, &state, id, 32);
316 mfx_finish_packet_feedback(packet, &state);
317 output_send_packet();
320 void mfx_speed_packet(uint16_t addr, uint8_t speed_dir)
322 MfxEncodingState state;
323 OutputPacket *packet = mfx_create_packet(&state);
324 mfx_address_field(packet, &state, addr);
325 mfx_speed_field(packet, &state, speed_dir);
326 mfx_finish_packet(packet, &state);
327 output_send_packet();
330 void mfx_speed_funcs8_packet(uint16_t addr, uint8_t speed_dir, uint8_t funcs)
332 MfxEncodingState state;
333 OutputPacket *packet = mfx_create_packet(&state);
334 mfx_address_field(packet, &state, addr);
335 mfx_speed_field(packet, &state, speed_dir);
339 mfx_encode_bits8(packet, &state, 0x6, 4);
340 mfx_encode_bits8(packet, &state, funcs, 8);
344 mfx_encode_bits8(packet, &state, 0x20|funcs, 7);
345 mfx_finish_packet(packet, &state);
346 output_send_packet();
349 void mfx_speed_funcs16_packet(uint16_t addr, uint8_t speed_dir, uint16_t funcs)
351 MfxEncodingState state;
352 OutputPacket *packet = mfx_create_packet(&state);
353 mfx_address_field(packet, &state, addr);
354 mfx_speed_field(packet, &state, speed_dir);
356 mfx_encode_bits8(packet, &state, 0x7, 4);
357 mfx_encode_bits16(packet, &state, funcs, 16);
358 mfx_finish_packet(packet, &state);
359 output_send_packet();
362 uint8_t mfx_command(const uint8_t *cmd, uint8_t length)
364 if(cmd[0]==MFX_SET_STATION_ID)
369 uint32_t id = (cmd[1]<<8)|cmd[2];
371 id |= (uint16_t)(cmd[3]<<8)|cmd[4];
372 mfx_set_station_id(id);
374 else if(cmd[0]==MFX_ANNOUNCE)
379 mfx_announce_packet((cmd[1]<<8)|cmd[2]);
381 else if(cmd[0]==MFX_SEARCH)
386 uint8_t mask_size = cmd[5];
388 return INVALID_VALUE;
390 uint32_t mask_bits = (cmd[1]<<8)|cmd[2];
392 mask_bits |= (uint16_t)(cmd[3]<<8)|cmd[4];
393 mfx_search_packet(mask_bits, mask_size);
394 mfx_receive_feedback(MFX_SEARCH_FEEDBACK);
396 else if(cmd[0]==MFX_ASSIGN_ADDRESS || cmd[0]==MFX_PING)
401 uint16_t addr = (cmd[1]<<8)|cmd[2];
402 if(addr==0 || addr>0x3FFF)
403 return INVALID_VALUE;
405 uint32_t id = (cmd[3]<<8)|cmd[4];
407 id |= (uint16_t)(cmd[5]<<8)|cmd[6];
408 if(cmd[0]==MFX_ASSIGN_ADDRESS)
409 mfx_assign_address_packet(addr, id);
412 mfx_ping_packet(addr, id);
413 mfx_receive_feedback(MFX_PING_FEEDBACK);
416 else if(cmd[0]==MFX_SPEED || cmd[0]==MFX_SPEED_FUNCS8 || cmd[0]==MFX_SPEED_FUNCS16)
418 if(cmd[0]==MFX_SPEED && length!=4)
420 else if(cmd[0]==MFX_SPEED_FUNCS8 && length!=5)
422 else if(cmd[0]==MFX_SPEED_FUNCS16 && length!=6)
425 uint16_t addr = (cmd[1]<<8)|cmd[2];
426 if(addr==0 || addr>0x3FFF)
427 return INVALID_VALUE;
429 uint8_t speed_dir = cmd[3];
430 if((speed_dir&0x7F)==0x7F)
431 return INVALID_VALUE;
432 // Skip emergency stop
436 if(cmd[0]==MFX_SPEED)
437 mfx_speed_packet(addr, speed_dir);
438 else if(cmd[0]==MFX_SPEED_FUNCS8)
439 mfx_speed_funcs8_packet(addr, speed_dir, cmd[4]);
440 else if(cmd[0]==MFX_SPEED_FUNCS16)
441 mfx_speed_funcs8_packet(addr, speed_dir, (cmd[4]<<8)|cmd[5]);
444 return INVALID_COMMAND;