1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
11 * Copyright (C) 2003-2005 Jörg Hohensohn
13 * Alpine CD changer Project
14 * This is a feasibility study for Archos emulating an Alpine M-Bus CD changer.
16 * Currently it will do seeks and change tracks, but nothing like disks.
17 * The debug version shows a dump of the M-Bus communication on screen.
19 * Usage: Start plugin, it will stay in the background and do the emulation.
20 * You need to make an adapter with an 8-pin DIN plug for the radio at one end
21 * and a 4-ring 3.5 mm plug for the Archos headphone jack at the other.
22 * The Archos remote pin connects to the M-Bus, audio as usual.
24 * This program is free software; you can redistribute it and/or
25 * modify it under the terms of the GNU General Public License
26 * as published by the Free Software Foundation; either version 2
27 * of the License, or (at your option) any later version.
29 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
30 * KIND, either express or implied.
32 ****************************************************************************/
36 #ifdef HAVE_LCD_CHARCELLS /* player model */
39 #else /* recorder models */
41 #define COLUMNS 32 /* can't really tell for proportional font */
44 /****************** imports ******************/
49 /****************** constants ******************/
51 /* measured bit time on the M-Bus is 3.075 ms = 325.2 Hz */
52 #define MBUS_BAUDRATE 3252 /* make it 10 * bittime */
53 #define MBUS_STEP_FREQ (MBUS_BAUDRATE/2) /* 5 steps per bit */
54 #define MBUS_BIT_FREQ (MBUS_BAUDRATE/10) /* the true bit frequency again */
56 #define MBUS_MAX_SIZE 16 /* maximum length of an M-Bus packet, incl. checksum */
57 #define MBUS_RCV_QUEUESIZE 4 /* how many packets can be queued by receiver */
59 #define ERI1 (*((volatile unsigned long*)0x090001A0)) /* RX error */
60 #define RXI1 (*((volatile unsigned long*)0x090001A4)) /* RX */
65 #define RX_BUSY 0 /* reception in progress */
66 #define RX_RECEIVED 1 /* valid data available */
67 #define RX_FRAMING 2 /* frame error */
68 #define RX_OVERRUN 3 /* receiver overrun */
69 #define RX_PARITY 4 /* parity error */
70 #define RX_SYMBOL 5 /* invalid bit timing */
71 #define RX_OVERFLOW 6 /* buffer full */
72 #define RX_OVERLAP 7 /* receive interrupt while transmitting */
74 /* timer operation mode */
75 #define TM_OFF 0 /* not in use */
76 #define TM_TRANSMIT 1 /* periodic timer to transmit */
77 #define TM_RX_TIMEOUT 2 /* single shot for receive timeout */
79 /* emulation play state */
81 #define EMU_PREPARING 1
90 /****************** prototypes ******************/
92 void timer_init(unsigned hz
, unsigned to
); /* setup static timer registers and values */
93 void timer_set_mode(int mode
); /* define for what the timer should be used right now */
94 void timer4_isr(void); /* IMIA4 ISR */
96 void transmit_isr(void); /* 2nd level ISR for M-Bus transmission */
98 void uart_init(unsigned baudrate
); /* UART setup */
99 void uart_rx_isr(void) __attribute__((interrupt_handler
)); /* RXI1 ISR */
100 void uart_err_isr(void) __attribute__((interrupt_handler
)); /* ERI1 ISR */
101 void receive_timeout_isr(void); /* 2nd level ISR for receiver timeout */
103 void mbus_init(void); /* prepare the M-Bus layer */
104 int mbus_send(unsigned char* p_msg
, int digits
); /* packet send */
105 int mbus_receive(unsigned char* p_msg
, unsigned bufsize
, int timeout
); /* packet receive */
107 unsigned char calc_checksum(unsigned char* p_msg
, int digits
); /* make M-Bus checksum */
108 bool bit_test(unsigned char* buf
, unsigned bit
); /* test one bit of M-Bus packet */
109 void bit_set(unsigned char* buf
, unsigned bit
, bool val
); /* set/clear one bit of M-Bus packet */
111 void print_scroll(char* string
); /* implements a scrolling screen */
112 void dump_packet(char* dest
, int dst_size
, char* src
, int n
); /* convert packet to ASCII */
114 void emu_init(void); /* init changer emulation */
115 void emu_process_packet(unsigned char* mbus_msg
, int msg_size
); /* feed a received radio packet */
116 void emu_tick(void); /* for regular actions of the emulator */
118 int get_playtime(void); /* return the current track time in seconds */
119 int get_tracklength(void); /* return the total length of the current track */
120 void set_track(int selected
);
121 int get_track(void); /* return the track number */
122 void set_play(void); /* start or resume playback */
123 void set_pause(void); /* pause playback */
124 void set_stop(void); /* stop playback */
125 void set_position(int seconds
); /* seek */
126 void get_playmsg(void); /* update the play message with Rockbox info */
127 void get_diskmsg(void); /* update the disk status message with Rockbox info */
129 void sound_neutral(void); /* set to everything flat and 0 dB volume */
130 void sound_normal(void); /* return to user settings */
132 void thread(void); /* the thread running it all */
133 int main(const void* parameter
); /* main loop */
134 enum plugin_status
plugin_start(const void* parameter
); /* entry */
137 /****************** data types ******************/
139 /* one entry in the receive queue */
142 unsigned char buf
[MBUS_MAX_SIZE
]; /* message buffer */
143 unsigned size
; /* length of data in the buffer */
144 unsigned error
; /* error code from reception */
148 /****************** globals ******************/
151 /* information owned by the timer transmit ISR */
154 unsigned char send_buf
[MBUS_MAX_SIZE
]; /* M-Bus message */
155 unsigned send_size
; /* current length of data in the buffer */
156 unsigned index
; /* index for which byte to send */
157 unsigned byte
; /* which byte to send */
158 unsigned bitmask
; /* which bit to send */
159 unsigned step
; /* where in the pulse are we */
160 bool bit
; /* currently sent bit */
161 bool collision
; /* set if a collision happened */
162 bool busy
; /* flag if in transmission */
166 /* information owned by the UART receive ISR */
169 t_rcv_queue_entry queue
[MBUS_RCV_QUEUESIZE
]; /* M-Bus message queue */
170 unsigned buf_read
; /* readout maintained by the user application */
171 unsigned buf_write
; /* writing maintained by ISR */
172 bool overflow
; /* indicate queue overflow */
173 unsigned byte
; /* currently assembled byte */
174 unsigned bit
; /* which bit to receive */
178 /* information owned by the timer */
181 unsigned mode
; /* off, transmit, receive timout */
182 unsigned transmit
; /* value for transmit */
183 unsigned timeout
; /* value for receive timeout */
187 /* information owned by the changer emulation */
190 unsigned char playmsg
[15]; /* current play state msg */
191 unsigned char changemsg
[11]; /* changing message */
192 unsigned char diskmsg
[12]; /* disk status message */
193 long poll_interval
; /* call the emu each n ticks */
194 int time
; /* seconds within the song */
195 int set_state
; /* the desired state to change into */
199 /* communication to the worker thread */
202 bool foreground
; /* set as long as we're owning the UI */
203 bool exiting
; /* signal to the thread that we want to exit */
204 unsigned int thread
; /* worker thread id */
208 /****************** implementation ******************/
211 /* setup static timer registers and values */
212 void timer_init(unsigned hz
, unsigned to
)
214 rb
->memset(&gTimer
, 0, sizeof(gTimer
));
216 gTimer
.transmit
= TIMER_FREQ
/ hz
; /* time for bit transitions */
217 gTimer
.timeout
= TIMER_FREQ
/ to
; /* time for receive timeout */
221 /* define for what the timer should be used right now */
222 void timer_set_mode(int mode
)
224 TCNT4
= 0; /* start counting at 0 */
225 gTimer
.mode
= mode
; /* store the mode */
227 if (mode
== TM_RX_TIMEOUT
)
229 rb
->timer_register(1, NULL
, gTimer
.timeout
, timer4_isr
IF_COP(, CPU
));
230 IPRD
= (IPRD
& 0xFF0F) | 11 << 4; /* interrupt priority */
232 else if (mode
== TM_TRANSMIT
)
234 rb
->timer_register(1, NULL
, gTimer
.transmit
, timer4_isr
IF_COP(, CPU
));
235 IPRD
= (IPRD
& 0xFF0F) | 14 << 4; /* interrupt priority */
239 rb
->timer_unregister();
244 void timer4_isr(void) /* IMIA4 */
247 { /* distribute the interrupt */
252 receive_timeout_isr();
253 rb
->timer_unregister(); /* single shot */
256 timer_set_mode(TM_OFF
); /* spurious interrupt */
261 /* About Alpine M-Bus
264 * The protocol uses a single wire in half duplex mode.
265 * A bit like I2C, this wire is either pulled low or left floating high.
266 * Bit time is ~3 ms, a "zero" is coded as ~0.6 ms low, a "one" as ~1.8 ms low.
267 * Nice to view in a 0.6 ms grid:
269 * 0 0.6 1.2 1.8 2.4 3.0
271 * __ ___________________
272 * \____/ \ "zero" bit
274 * \______________/ \ "one" bit
276 * So I send out the data in a timer interrupt spawned to 0.6 ms.
277 * In phases where the line is floating high, I can check for collisions.
278 * (happens if the other side driving it low, too.)
280 * Data is transmitted in multiples of 4 bit, to ease BCD representation.
284 /* 2nd level ISR for M-Bus transmission */
285 void transmit_isr(void)
289 TSR4
&= ~0x01; /* clear the interrupt */
291 switch(gSendIRQ
.step
++)
294 and_b(~0x04, &PBDRH
); /* low (read-modify-write access may have changed it while it was input) */
295 or_b(0x04, &PBIORH
); /* drive low (output) */
298 if (!gSendIRQ
.bit
) /* sending "zero"? */
299 and_b(~0x04, &PBIORH
); /* float (input) */
302 if (!gSendIRQ
.bit
&& ((PBDR
& PB10
) == 0))
303 gSendIRQ
.collision
= true;
306 if (gSendIRQ
.bit
) /* sending "one"? */
307 and_b(~0x04, &PBIORH
); /* float (input) */
308 else if ((PBDR
& PB10
) == 0)
309 gSendIRQ
.collision
= true;
312 if ((PBDR
& PB10
) == 0)
313 gSendIRQ
.collision
= true;
315 /* prepare next round */
317 gSendIRQ
.bitmask
>>= 1;
318 if (gSendIRQ
.bitmask
)
320 gSendIRQ
.bit
= (gSendIRQ
.byte
& gSendIRQ
.bitmask
) != 0;
324 if (++gSendIRQ
.index
< gSendIRQ
.send_size
)
326 gSendIRQ
.bitmask
= 0x08;
327 gSendIRQ
.byte
= gSendIRQ
.send_buf
[gSendIRQ
.index
];
328 gSendIRQ
.bit
= (gSendIRQ
.byte
& gSendIRQ
.bitmask
) != 0;
331 exit
= true; /* done */
336 if (exit
|| gSendIRQ
.collision
)
337 { /* stop transmission */
338 or_b(0x20, PBCR1_ADDR
+1); /* RxD1 again for PB10 */
339 timer_set_mode(TM_OFF
); /* stop the timer */
340 gSendIRQ
.busy
= false; /* do this last, to avoid race conditions */
345 /* For receiving, I use the "normal" serial RX feature of the CPU,
346 * so we can receive within an interrupt, no line polling necessary.
347 * Luckily, the M-Bus bit always starts with a falling edge and ends with a high,
348 * this matches with the start bit and the stop bit of a serial transmission.
349 * The baudrate is set such that the M-Bus bit time (ca. 3ms) matches
350 * the serial reception time of one byte, so we receive one byte per
352 * Start bit, 8 data bits and stop bit (total=10) nicely fall into the 5
355 * 0 0.6 1.2 1.8 2.4 3.0 ms
357 * __ _______________________________
358 * \_______/ \ "zero" bit
360 * \_______________________/ \ "one" bit
362 * | | | | | | | | | | | serial sampling interval
363 * Start 0 1 2 3 4 5 6 7 Stop bit (LSB first!)
365 * By looking at the bit pattern in the serial byte we can distinguish
366 * the short low from the longer low, tell "zero" and "one" apart.
367 * So we receive 0xFE for a "zero", 0xE0 for a "one".
368 * It may be necessary to treat the bits next to transitions as don't care,
369 * in case the timing is not so accurate.
370 * Bits are always sent "back-to-back", so I detect the packet end by timeout.
374 void uart_init(unsigned baudrate
)
376 RXI1
= (unsigned long)uart_rx_isr
; /* install ISR */
377 ERI1
= (unsigned long)uart_err_isr
; /* install ISR */
379 SCR1
= 0x00; /* disable everything; select async mode with SCK pin as I/O */
380 SMR1
= 0x00; /* async, 8N1, NoMultiProc, sysclock/1 */
381 BRR1
= ((FREQ
/(32*baudrate
))-1);
383 IPRE
= (IPRE
& ~0xf000) | 0xc000; /* interrupt on level 12 */
385 rb
->sleep(1); /* hardware needs to settle for at least one bit interval */
387 and_b(~(SCI_RDRF
| SCI_ORER
| SCI_FER
| SCI_PER
), &SSR1
); /* clear any receiver flag */
388 or_b(SCI_RE
| SCI_RIE
, &SCR1
); /* enable the receiver with interrupt */
392 void uart_rx_isr(void) /* RXI1 */
395 t_rcv_queue_entry
* p_entry
= &gRcvIRQ
.queue
[gRcvIRQ
.buf_write
]; /* short cut */
397 data
= RDR1
; /* get data */
399 and_b(~SCI_RDRF
, &SSR1
); /* clear data received flag */
401 if (gTimer
.mode
== TM_TRANSMIT
)
402 p_entry
->error
= RX_OVERLAP
; /* oops, we're also transmitting, stop */
404 timer_set_mode(TM_RX_TIMEOUT
); /* (re)spawn timeout */
406 if (p_entry
->error
!= RX_BUSY
)
409 if ((data
& ~0x00) == 0xFE) /* 01111111 in line order (reverse) */
410 { /* "zero" received */
413 else if ((data
& ~0x00) == 0xE0) /* 00000111 in line order (reverse) */
414 { /* "one" received */
415 gRcvIRQ
.byte
= gRcvIRQ
.byte
<< 1 | 0x01;
418 { /* unrecognized pulse */
419 p_entry
->error
= RX_SYMBOL
;
422 if (p_entry
->error
== RX_BUSY
)
424 if (++gRcvIRQ
.bit
>= 4)
425 { /* byte completed */
426 if (p_entry
->size
>= sizeof(p_entry
->buf
))
428 p_entry
->error
= RX_OVERFLOW
; /* buffer full */
432 p_entry
->buf
[p_entry
->size
] = gRcvIRQ
.byte
;
442 void uart_err_isr(void) /* ERI1 */
444 t_rcv_queue_entry
* p_entry
= &gRcvIRQ
.queue
[gRcvIRQ
.buf_write
]; /* short cut */
446 if (p_entry
->error
== RX_BUSY
)
447 { /* terminate reception in case of error */
449 p_entry
->error
= RX_FRAMING
;
450 else if (SSR1
& SCI_ORER
)
451 p_entry
->error
= RX_OVERRUN
;
452 else if (SSR1
& SCI_PER
)
453 p_entry
->error
= RX_PARITY
;
456 /* clear any receiver flag */
457 and_b(~(SCI_RDRF
| SCI_ORER
| SCI_FER
| SCI_PER
), &SSR1
);
461 /* 2nd level ISR for receiver timeout, this finalizes reception */
462 void receive_timeout_isr(void)
464 t_rcv_queue_entry
* p_entry
= &gRcvIRQ
.queue
[gRcvIRQ
.buf_write
]; /* short cut */
466 timer_set_mode(TM_OFF
); /* single shot */
468 if (p_entry
->error
== RX_BUSY
) /* everthing OK so far? */
469 p_entry
->error
= RX_RECEIVED
; /* end with valid data */
471 /* move to next queue entry */
473 if (gRcvIRQ
.buf_write
>= MBUS_RCV_QUEUESIZE
)
474 gRcvIRQ
.buf_write
= 0;
475 p_entry
= &gRcvIRQ
.queue
[gRcvIRQ
.buf_write
];
477 if (gRcvIRQ
.buf_write
== gRcvIRQ
.buf_read
)
478 { /* queue overflow */
479 gRcvIRQ
.overflow
= true;
480 /* what can I do? Continueing overwrites the oldest. */
486 p_entry
->error
= RX_BUSY
; /* enable receive on new entry */
490 /* generate the checksum */
491 unsigned char calc_checksum(unsigned char* p_msg
, int digits
)
496 for (i
=0; i
<digits
; i
++)
506 /****************** high-level M-Bus functions ******************/
510 /* init the send object */
511 rb
->memset(&gSendIRQ
, 0, sizeof(gSendIRQ
));
512 timer_init(MBUS_STEP_FREQ
, (MBUS_BIT_FREQ
*10)/15); /* setup frequency and timeout (1.5 bit) */
515 rb
->memset(&gRcvIRQ
, 0, sizeof(gRcvIRQ
));
516 uart_init(MBUS_BAUDRATE
);
520 /* send out a number of BCD digits (one per byte) with M-Bus protocol */
521 int mbus_send(unsigned char* p_msg
, int digits
)
523 /* wait for previous transmit/receive to end */
524 while(gTimer
.mode
!= TM_OFF
) /* wait for "free line" */
527 /* fill in our part */
528 rb
->memcpy(gSendIRQ
.send_buf
, p_msg
, digits
);
531 gSendIRQ
.send_buf
[digits
] = calc_checksum(p_msg
, digits
);
534 /* debug dump, to be removed */
535 if (gTread
.foreground
)
537 char buf
[MBUS_MAX_SIZE
+1];
538 dump_packet(buf
, sizeof(buf
), gSendIRQ
.send_buf
, digits
);
539 /*print_scroll(buf); */
542 gSendIRQ
.send_size
= digits
;
544 /* prepare everything so the ISR can start right away */
546 gSendIRQ
.byte
= gSendIRQ
.send_buf
[0];
547 gSendIRQ
.bitmask
= 0x08;
549 gSendIRQ
.bit
= (gSendIRQ
.byte
& gSendIRQ
.bitmask
) != 0;
550 gSendIRQ
.collision
= false;
551 gSendIRQ
.busy
= true;
553 /* last chance to wait for a new detected receive to end */
554 while(gTimer
.mode
!= TM_OFF
) /* wait for "free line" */
557 and_b(~0x30, PBCR1_ADDR
+1); /* GPIO for PB10 */
558 timer_set_mode(TM_TRANSMIT
); /* run */
560 /* make the call blocking until sent out */
561 rb
->sleep(digits
*4*HZ
/MBUS_BIT_FREQ
); /* should take this long */
563 while(gSendIRQ
.busy
) /* poll in case it lasts longer */
564 rb
->sleep(1); /* (should not happen) */
566 /* debug output, to be removed */
567 if (gTread
.foreground
)
569 if (gSendIRQ
.collision
)
570 print_scroll("collision");
573 return gSendIRQ
.collision
;
577 /* returns the size of message copy, 0 if timed out, negative on error */
578 int mbus_receive(unsigned char* p_msg
, unsigned bufsize
, int timeout
)
584 if (gRcvIRQ
.buf_read
!= gRcvIRQ
.buf_write
)
585 { /* something in the queue */
586 t_rcv_queue_entry
* p_entry
= &gRcvIRQ
.queue
[gRcvIRQ
.buf_read
]; /* short cut */
588 if (p_entry
->error
== RX_RECEIVED
)
590 rb
->memcpy(p_msg
, p_entry
->buf
, MIN(p_entry
->size
, bufsize
));
591 retval
= p_entry
->size
; /* return message size */
594 { /* an error occured */
595 retval
= - p_entry
->error
; /* return negative number */
598 /* next queue readout position */
600 if (gRcvIRQ
.buf_read
>= MBUS_RCV_QUEUESIZE
)
601 gRcvIRQ
.buf_read
= 0;
603 return retval
; /* exit */
606 if (timeout
!= 0 || gTimer
.mode
!= TM_OFF
) /* also carry on if reception in progress */
608 if (timeout
!= -1 && timeout
!= 0) /* if not infinite or expired */
611 rb
->sleep(1); /* wait a while */
614 } while (timeout
!= 0 || gTimer
.mode
!= TM_OFF
);
616 return 0; /* timeout */
620 /****************** MMI helper fuctions ******************/
623 void print_scroll(char* string
)
625 static char screen
[LINES
][COLUMNS
+1]; /* visible strings */
626 static unsigned pos
= 0; /* next print position */
627 static unsigned screentop
= 0; /* for scrolling */
629 if (!gTread
.foreground
)
630 return; /* just to protect careless callers */
633 { /* need to scroll first */
635 rb
->lcd_clear_display();
637 for (i
=0; i
<LINES
-1; i
++)
638 rb
->lcd_puts(0, i
, screen
[(i
+screentop
) % LINES
]);
643 /* no strncpy avail. */
644 rb
->snprintf(screen
[(pos
+screentop
) % LINES
], sizeof(screen
[0]), "%s", string
);
646 rb
->lcd_puts(0, pos
, screen
[(pos
+screentop
) % LINES
]);
652 void dump_packet(char* dest
, int dst_size
, char* src
, int n
)
655 int len
= MIN(dst_size
-1, n
);
657 for (i
=0; i
<len
; i
++)
658 { /* convert to hex digits */
659 dest
[i
] = src
[i
] < 10 ? '0' + src
[i
] : 'A' + src
[i
] - 10;
661 dest
[i
] = '\0'; /* zero terminate string */
665 /****************** CD changer emulation ******************/
667 bool bit_test(unsigned char* buf
, unsigned bit
)
669 return (buf
[bit
>>2] & BIT_N(bit
&3)) != 0;
673 void bit_set(unsigned char* buf
, unsigned bit
, bool val
)
676 buf
[bit
>>2] |= BIT_N(bit
&3);
678 buf
[bit
>>2] &= ~BIT_N(bit
&3);
684 rb
->memset(&gEmu
, 0, sizeof(gEmu
));
686 gEmu
.poll_interval
= HZ
;
688 /* init the play message to 990000000000000 */
689 gEmu
.playmsg
[0] = gEmu
.playmsg
[1] = 0x9;
691 /* init the changing message to 9B900000001 */
692 gEmu
.changemsg
[0] = gEmu
.changemsg
[2] = 0x9;
693 gEmu
.changemsg
[1] = 0xB;
694 gEmu
.changemsg
[10] = 0x1;
696 /* init the disk status message to 9C1019999990 */
697 rb
->memset(&gEmu
.diskmsg
, 0x9, sizeof(gEmu
.diskmsg
));
698 gEmu
.diskmsg
[1] = 0xC;
699 gEmu
.diskmsg
[2] = gEmu
.diskmsg
[4] = 0x1;
700 gEmu
.diskmsg
[3] = gEmu
.diskmsg
[11] = 0x0;
703 /* feed a radio command into the emulator */
704 void emu_process_packet(unsigned char* mbus_msg
, int msg_size
)
706 bool playmsg_dirty
= false;
707 bool diskmsg_dirty
= false;
709 if (msg_size
== 2 && mbus_msg
[0] == 1 && mbus_msg
[1] == 8)
711 mbus_send("\x09\x08", 2); /* 98: ping OK */
713 else if (msg_size
== 5 && mbus_msg
[0] == 1 && mbus_msg
[1] == 1 && mbus_msg
[2] == 1)
714 { /* set play state */
715 if (bit_test(mbus_msg
, 16))
717 if (gEmu
.set_state
== EMU_FF
|| gEmu
.set_state
== EMU_FR
) /* was seeking? */
718 { /* seek to final position */
719 set_position(gEmu
.time
);
721 else if (gEmu
.set_state
!= EMU_PLAYING
|| gEmu
.set_state
!= EMU_PAUSED
)
722 { /* was not playing yet, better send disk message */
723 diskmsg_dirty
= true;
726 gEmu
.set_state
= EMU_PLAYING
;
727 playmsg_dirty
= true;
730 if (bit_test(mbus_msg
, 17))
732 gEmu
.set_state
= EMU_PAUSED
;
733 playmsg_dirty
= true;
737 if (bit_test(mbus_msg
, 14))
739 gEmu
.set_state
= EMU_STOPPED
;
740 playmsg_dirty
= true;
744 if (bit_test(mbus_msg
, 18))
746 gEmu
.set_state
= EMU_FF
;
747 playmsg_dirty
= true;
751 if (bit_test(mbus_msg
, 19))
753 gEmu
.set_state
= EMU_FR
;
754 playmsg_dirty
= true;
758 if (bit_test(mbus_msg
, 12)) /* scan stop */
760 bit_set(gEmu
.playmsg
, 51, false);
761 playmsg_dirty
= true;
764 if (gEmu
.set_state
== EMU_FF
|| gEmu
.set_state
== EMU_FR
)
765 gEmu
.poll_interval
= HZ
/4; /* faster refresh */
767 gEmu
.poll_interval
= HZ
;
769 else if (msg_size
== 8 && mbus_msg
[0] == 1 && mbus_msg
[1] == 1 && mbus_msg
[2] == 4)
770 { /* set program mode */
771 gEmu
.playmsg
[11] = mbus_msg
[3]; /* copy repeat, random, intro */
772 gEmu
.playmsg
[12] = mbus_msg
[4]; /* ToDo */
773 playmsg_dirty
= true;
775 else if (msg_size
==8 && mbus_msg
[0] == 1 && mbus_msg
[1] == 1 && mbus_msg
[2] == 3)
777 gEmu
.time
= 0; /* reset playtime */
778 playmsg_dirty
= true;
779 if (mbus_msg
[3] == 0)
780 { /* changing track */
781 if (mbus_msg
[4] == 0xA && mbus_msg
[5] == 0x3)
783 gEmu
.playmsg
[3] = rb
->rand() % 10; /* ToDo */
784 gEmu
.playmsg
[4] = rb
->rand() % 10;
786 else if (mbus_msg
[4] == 0xB && mbus_msg
[5] == 0x3)
787 { /* previous random */
788 gEmu
.playmsg
[3] = rb
->rand() % 10; /* ToDo */
789 gEmu
.playmsg
[4] = rb
->rand() % 10;
792 { /* normal track select */
793 set_track(mbus_msg
[4]*10 + mbus_msg
[5]);
797 { /* changing disk */
798 diskmsg_dirty
= true;
799 gEmu
.changemsg
[3] = mbus_msg
[3]; /* copy disk */
800 gEmu
.diskmsg
[2] = mbus_msg
[3];
801 gEmu
.changemsg
[7] = gEmu
.playmsg
[11]; /* copy flags from status */
802 gEmu
.changemsg
[8] = gEmu
.playmsg
[12];
803 /*gEmu.playmsg[3] = 0; */ /* reset to track 1 */
804 /*gEmu.playmsg[4] = 1; */
805 mbus_send(gEmu
.changemsg
, sizeof(gEmu
.changemsg
));
809 { /* if in doubt, send Ack */
810 mbus_send("\x09\x0F\x00\x00\x00\x00\x00", 7);
815 rb
->yield(); /* give the audio thread a chance to process */
816 get_playmsg(); /* force update */
817 mbus_send(gEmu
.playmsg
, sizeof(gEmu
.playmsg
));
822 get_diskmsg(); /* force update */
823 mbus_send(gEmu
.diskmsg
, sizeof(gEmu
.diskmsg
));
828 /* called each second in case the emulator has something to do */
831 get_playmsg(); /* force update */
832 if (bit_test(gEmu
.playmsg
, 56)) /* play bit */
834 unsigned remain
; /* helper as we walk down the digits */
836 switch(gEmu
.set_state
)
845 else if (gEmu
.time
> get_tracklength())
846 gEmu
.time
= get_tracklength();
848 /* convert value to MM:SS */
849 remain
= (unsigned)gEmu
.time
;
850 gEmu
.playmsg
[7] = remain
/ (10*60);
851 remain
-= gEmu
.playmsg
[7] * (10*60);
852 gEmu
.playmsg
[8] = remain
/ 60;
853 remain
-= gEmu
.playmsg
[8] * 60;
854 gEmu
.playmsg
[9] = remain
/ 10;
855 remain
-= gEmu
.playmsg
[9] * 10;
856 gEmu
.playmsg
[10] = remain
;
859 mbus_send(gEmu
.playmsg
, sizeof(gEmu
.playmsg
));
864 /****************** communication with Rockbox playback ******************/
867 /* update the play message with Rockbox info */
868 void get_playmsg(void)
872 if (gEmu
.set_state
!= EMU_FF
&& gEmu
.set_state
!= EMU_FR
)
874 switch(rb
->audio_status())
876 case AUDIO_STATUS_PLAY
:
877 print_scroll("AudioStat Play");
878 if (gEmu
.set_state
== EMU_FF
|| gEmu
.set_state
== EMU_FR
)
879 gEmu
.playmsg
[2] = gEmu
.set_state
; /* set FF/FR */
881 gEmu
.playmsg
[2] = EMU_PLAYING
; /* set normal play */
883 bit_set(gEmu
.playmsg
, 56, true); /* set play */
884 bit_set(gEmu
.playmsg
, 57, false); /* clear pause */
885 bit_set(gEmu
.playmsg
, 59, false); /* clear stop */
888 case AUDIO_STATUS_PLAY
| AUDIO_STATUS_PAUSE
:
889 print_scroll("AudioStat Pause");
890 gEmu
.playmsg
[2] = EMU_PAUSED
;
891 bit_set(gEmu
.playmsg
, 56, false); /* clear play */
892 bit_set(gEmu
.playmsg
, 57, true); /* set pause */
893 bit_set(gEmu
.playmsg
, 59, false); /* clear stop */
897 print_scroll("AudioStat 0");
898 gEmu
.playmsg
[2] = EMU_STOPPED
;
899 bit_set(gEmu
.playmsg
, 56, false); /* clear play */
900 bit_set(gEmu
.playmsg
, 57, false); /* clear pause */
901 bit_set(gEmu
.playmsg
, 59, true); /* set stop */
905 /* convert value to MM:SS */
906 time
= get_playtime();
907 gEmu
.time
= time
; /* copy it */
908 gEmu
.playmsg
[7] = time
/ (10*60);
909 time
-= gEmu
.playmsg
[7] * (10*60);
910 gEmu
.playmsg
[8] = time
/ 60;
911 time
-= gEmu
.playmsg
[8] * 60;
912 gEmu
.playmsg
[9] = time
/ 10;
913 time
-= gEmu
.playmsg
[9] * 10;
914 gEmu
.playmsg
[10] = time
;
918 gEmu
.playmsg
[2] = gEmu
.set_state
; /* in FF/FR, report that instead */
922 gEmu
.playmsg
[3] = track
/ 10;
923 gEmu
.playmsg
[4] = track
% 10;
926 /* update the disk status message with Rockbox info */
927 void get_diskmsg(void)
929 int tracks
= rb
->playlist_amount();
932 gEmu
.diskmsg
[5] = tracks
/ 10;
933 gEmu
.diskmsg
[6] = tracks
% 10;
936 /* return the current track time in seconds */
937 int get_playtime(void)
939 struct mp3entry
* p_mp3entry
;
941 p_mp3entry
= rb
->audio_current_track();
942 if (p_mp3entry
== NULL
)
945 return p_mp3entry
->elapsed
/ 1000;
948 /* return the total length of the current track */
949 int get_tracklength(void)
951 struct mp3entry
* p_mp3entry
;
953 p_mp3entry
= rb
->audio_current_track();
954 if (p_mp3entry
== NULL
)
957 return p_mp3entry
->length
/ 1000;
960 /* change to a new track */
961 void set_track(int selected
)
963 if (selected
> get_track())
965 print_scroll("audio_next");
968 else if (selected
< get_track())
970 print_scroll("audio_prev");
975 /* return the track number */
978 struct mp3entry
* p_mp3entry
;
980 p_mp3entry
= rb
->audio_current_track();
981 if (p_mp3entry
== NULL
)
984 return p_mp3entry
->index
+ 1; /* track numbers start with 1 */
987 /* start or resume playback */
990 if (rb
->audio_status() == AUDIO_STATUS_PLAY
)
993 if (rb
->audio_status() == (AUDIO_STATUS_PLAY
| AUDIO_STATUS_PAUSE
))
995 print_scroll("audio_resume");
1000 print_scroll("audio_play(0)");
1005 /* pause playback */
1006 void set_pause(void)
1008 if (rb
->audio_status() == AUDIO_STATUS_PLAY
)
1010 print_scroll("audio_pause");
1018 if (rb
->audio_status() & AUDIO_STATUS_PLAY
)
1020 print_scroll("audio_stop");
1026 void set_position(int seconds
)
1028 if (rb
->audio_status() & AUDIO_STATUS_PLAY
)
1030 print_scroll("audio_ff_rewind");
1031 rb
->audio_ff_rewind(seconds
* 1000);
1035 /****************** main thread + helper ******************/
1037 /* set to everything flat and 0 dB volume */
1038 void sound_neutral(void)
1039 { /* neutral sound settings */
1040 rb
->sound_set(SOUND_BASS
, 0);
1041 rb
->sound_set(SOUND_TREBLE
, 0);
1042 rb
->sound_set(SOUND_BALANCE
, 0);
1043 rb
->sound_set(SOUND_VOLUME
, 0);
1044 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
1045 rb
->sound_set(SOUND_LOUDNESS
, 0);
1046 rb
->sound_set(SOUND_SUPERBASS
, 0);
1047 rb
->sound_set(SOUND_AVC
, 0);
1051 /* return to user settings */
1052 void sound_normal(void)
1053 { /* restore sound settings */
1054 rb
->sound_set(SOUND_BASS
, rb
->global_settings
->bass
);
1055 rb
->sound_set(SOUND_TREBLE
, rb
->global_settings
->treble
);
1056 rb
->sound_set(SOUND_BALANCE
, rb
->global_settings
->balance
);
1057 rb
->sound_set(SOUND_VOLUME
, rb
->global_settings
->volume
);
1058 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
1059 rb
->sound_set(SOUND_LOUDNESS
, rb
->global_settings
->loudness
);
1060 rb
->sound_set(SOUND_SUPERBASS
, rb
->global_settings
->superbass
);
1061 rb
->sound_set(SOUND_AVC
, rb
->global_settings
->avc
);
1065 /* the thread running it all */
1069 unsigned char mbus_msg
[MBUS_MAX_SIZE
];
1071 bool connected
= false;
1072 long last_tick
= *rb
->current_tick
; /* for 1 sec tick */
1076 msg_size
= mbus_receive(mbus_msg
, sizeof(mbus_msg
), 1);
1078 { /* received something */
1079 if(gTread
.foreground
)
1081 dump_packet(buf
, sizeof(buf
), mbus_msg
, msg_size
);
1082 /*print_scroll(buf); */
1084 if (msg_size
> 2 && mbus_msg
[0] == 1
1085 && mbus_msg
[msg_size
-1] == calc_checksum(mbus_msg
, msg_size
-1))
1086 { /* sanity and checksum OK */
1088 { /* with the first received packet: */
1089 sound_neutral(); /* set to flat and 0dB volume */
1092 emu_process_packet(mbus_msg
, msg_size
-1); /* pass without chksum */
1094 else if(gTread
.foreground
)
1096 print_scroll("bad packet");
1099 else if (msg_size
< 0 && gTread
.foreground
)
1101 rb
->snprintf(buf
, sizeof(buf
), "rcv error %d", msg_size
);
1105 if (*rb
->current_tick
- last_tick
>= gEmu
.poll_interval
)
1106 { /* call the emulation regulary */
1108 last_tick
+= gEmu
.poll_interval
;
1111 } while (!gTread
.exiting
);
1114 /* callback to end the TSR plugin, called before a new one gets loaded */
1115 static bool exit_tsr(bool reenter
)
1118 return false; /* dont let it start again */
1119 gTread
.exiting
= true; /* tell the thread to end */
1120 rb
->thread_wait(gTread
.thread
); /* wait until it did */
1122 uart_init(BAUDRATE
); /* return to standard baudrate */
1123 IPRE
= (IPRE
& ~0xF000); /* UART interrupt off */
1124 timer_set_mode(TM_OFF
); /* timer interrupt off */
1126 sound_normal(); /* restore sound settings */
1130 /****************** main ******************/
1133 int main(const void* parameter
)
1143 mbus_init(); /* init the M-Bus layer */
1144 emu_init(); /* init emulator */
1146 rb
->splash(HZ
/5, "Alpine CDC"); /* be quick on autostart */
1149 print_scroll("Alpine M-Bus Test");
1150 print_scroll("any key to TSR");
1153 /* init the worker thread */
1154 stack
= rb
->plugin_get_buffer(&buf_size
); /* use the rest as stack */
1155 stacksize
= buf_size
;
1156 stack
= (void*)(((unsigned int)stack
+ 100) & ~3); /* a bit away, 32 bit align */
1157 stacksize
= (stacksize
- 100) & ~3;
1158 if (stacksize
< DEFAULT_STACK_SIZE
)
1160 rb
->splash(HZ
*2, "Out of memory");
1164 rb
->memset(&gTread
, 0, sizeof(gTread
));
1165 gTread
.foreground
= true;
1166 gTread
.thread
= rb
->create_thread(thread
, stack
, stacksize
, 0, "CDC"
1167 IF_PRIO(, PRIORITY_BACKGROUND
)
1173 button
= rb
->button_get(true);
1174 } while (button
& BUTTON_REL
);
1177 gTread
.foreground
= false; /* we're in the background now */
1178 rb
->plugin_tsr(exit_tsr
); /* stay resident */
1181 return rb
->default_event_handler(button
);
1188 /***************** Plugin Entry Point *****************/
1191 enum plugin_status
plugin_start(const void* parameter
)
1193 /* now go ahead and have fun! */
1194 return (main(parameter
)==0) ? PLUGIN_OK
: PLUGIN_ERROR
;