2 * Copyright © 2017 Keith Packard <keithp@keithp.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
16 #include <ao_rn4678.h>
20 static uint8_t ao_rn_connected;
25 static void ao_rn_dbg(char *format, ...) {
27 uint32_t irq = ao_arch_irqsave();
28 ao_arch_release_interrupts();
33 ao_arch_irqrestore(irq);
36 static char ao_rn_dir;
39 ao_rn_log_char(char c, char dir)
41 if (dir != ao_rn_dir) {
42 putchar(dir); putchar('\n');
47 putchar('\\'); putchar('r');
50 putchar('\\'); putchar('n');
59 ao_rn_log_out_char(char c)
61 ao_rn_log_char(c, '}');
65 ao_rn_log_in_char(char c)
67 ao_rn_log_char(c, '{');
73 ao_rn_log_out_char(c);
74 ao_serial_rn_putchar(c);
80 int c = _ao_serial_rn_pollchar();
82 if (c != AO_READ_AGAIN) {
83 ao_arch_release_interrupts();
84 ao_rn_log_in_char((char) c);
85 ao_arch_block_interrupts();
90 #define ao_rn_dbg(fmt, ...)
91 #define ao_rn_putchar(c) ao_serial_rn_putchar(c)
92 #define _ao_rn_pollchar() _ao_serial_rn_pollchar()
95 /* For stdio, this skips all status messages *sigh* */
97 #define STATUS_CHAR '%'
99 static const char *status_strings[] = {
107 #define NUM_STATUS_STRING (sizeof status_strings/sizeof status_strings[0])
109 static char ao_rn_buffer[64];
110 static int ao_rn_buf_cnt, ao_rn_buf_ptr;
111 static int ao_rn_draining;
112 static AO_TICK_TYPE ao_rn_buf_time;
114 /* Well, this is annoying. The status strings from the RN4678 can't be
115 * disabled due to a firmware bug. So, this code finds those in the
116 * input and strips them out.
119 _ao_wrap_rn_pollchar(void)
121 int c = AO_READ_AGAIN;
125 while (!done && !ao_rn_draining) {
126 c = _ao_serial_rn_pollchar();
128 if (c == AO_READ_AGAIN) {
129 if (ao_rn_buf_cnt && (ao_time() - ao_rn_buf_time) > AO_MS_TO_TICKS(1000)) {
133 return AO_READ_AGAIN;
137 /* buffering chars */
139 if (c == STATUS_CHAR) {
140 /* End of status string, drop it and carry on */
141 ao_rn_buffer[ao_rn_buf_cnt] = '\0';
142 // ao_rn_dbg("discard %s\n", ao_rn_buffer);
144 } else if (ao_rn_buf_cnt == sizeof(ao_rn_buffer)) {
145 /* If we filled the buffer, just give up */
148 ao_rn_buffer[ao_rn_buf_cnt++] = c;
149 for (i = 0; i < NUM_STATUS_STRING; i++) {
150 int cmp = strlen(status_strings[i]);
151 if (cmp >= ao_rn_buf_cnt)
152 cmp = ao_rn_buf_cnt-1;
153 if (memcmp(ao_rn_buffer+1, status_strings[i], cmp) == 0)
156 if (i == NUM_STATUS_STRING)
159 } else if (c == STATUS_CHAR) {
163 ao_rn_buf_time = ao_time();
167 if (ao_rn_draining) {
168 c = ao_rn_buffer[ao_rn_buf_ptr++] & 0xff;
169 if (ao_rn_buf_ptr == ao_rn_buf_cnt) {
170 ao_rn_buf_ptr = ao_rn_buf_cnt = 0;
191 // ao_rn_dbg("drain...\n");
192 ao_serial_rn_drain();
194 ao_arch_block_interrupts();
195 while (_ao_rn_pollchar() == AO_READ_AGAIN) {
196 if (_ao_serial_rn_sleep_for(AO_MS_TO_TICKS(10))) {
201 ao_arch_release_interrupts();
203 // ao_rn_dbg("drain done\n");
207 ao_rn_send_cmd(char *cmd, char *param)
209 // ao_rn_dbg("send_cmd %s%s\n", cmd, param ? param : "");
218 ao_rn_wait_char(AO_TICK_TYPE giveup_time)
222 ao_arch_block_interrupts();
223 while ((c = _ao_rn_pollchar()) == AO_READ_AGAIN) {
224 AO_TICK_SIGNED delay = (AO_TICK_SIGNED) (giveup_time - ao_time());
226 ao_arch_release_interrupts();
227 return AO_READ_AGAIN;
229 _ao_serial_rn_sleep_for(delay);
231 ao_arch_release_interrupts();
236 ao_rn_wait_for(int timeout, char *match)
238 char reply[AO_RN_MAX_REPLY_LEN + 1];
239 int match_len = strlen(match);
240 AO_TICK_TYPE giveup_time = ao_time() + timeout;
243 // ao_rn_dbg("wait for %d, \"%s\"\n", timeout, match);
244 memset(reply, ' ', sizeof(reply));
245 while (memcmp(reply, match, match_len) != 0) {
246 c = ao_rn_wait_char(giveup_time);
247 if (c == AO_READ_AGAIN) {
248 // ao_rn_dbg("\twait for timeout\n");
249 return AO_RN_TIMEOUT;
251 reply[match_len] = (char) c;
252 memmove(reply, reply+1, match_len);
253 reply[match_len] = '\0';
254 // ao_rn_dbg("\tmatch now \"%s\"\n", reply);
256 // ao_rn_dbg("\twait for ok\n");
261 ao_rn_wait_line(AO_TICK_TYPE giveup_time, char *line, int len)
265 // ao_rn_dbg("wait line\n");
267 int c = ao_rn_wait_char(giveup_time);
270 if (c == AO_READ_AGAIN) {
271 // ao_rn_dbg("\twait line timeout\n");
272 return AO_RN_TIMEOUT;
278 // ao_rn_dbg("\twait line \"%s\"\n", line);
295 ao_rn_wait_status(void)
297 char message[AO_RN_MAX_REPLY_LEN];
298 AO_TICK_TYPE giveup_time = ao_time() + AO_RN_CMD_TIMEOUT;
301 // ao_rn_dbg("wait status\n");
302 status = ao_rn_wait_line(giveup_time, message, sizeof (message));
303 if (status == AO_RN_OK)
304 if (strncmp(message, "AOK", 3) != 0)
305 status = AO_RN_ERROR;
316 // ao_rn_dbg("set name...\n");
318 n = ao_serial_number;
322 ao_rn_send_cmd(AO_RN_SET_NAME_CMD "TeleBT-", s);
323 return ao_rn_wait_status();
327 ao_rn_get_name(char *name, int len)
329 // ao_rn_dbg("get name...\n");
330 ao_rn_send_cmd(AO_RN_GET_NAME_CMD, NULL);
331 return ao_rn_wait_line(ao_time() + AO_RN_CMD_TIMEOUT, name, len);
335 ao_rn_check_link(void)
337 ao_rn_connected = 1 - ao_gpio_get(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN, foo);
344 ao_wakeup(&ao_rn_connected);
348 ao_bt_panic(int where)
352 for (i = 0; i < 50; i++) {
353 ao_led_toggle(AO_BT_LED);
354 ao_delay(AO_MS_TO_TICKS(10));
356 ao_led_off(AO_BT_LED);
357 ao_delay(AO_MS_TO_TICKS(500));
358 for (i = 0; i < where; i++) {
359 ao_led_for(AO_BT_LED, AO_MS_TO_TICKS(200));
360 ao_delay(AO_MS_TO_TICKS(200));
365 static uint8_t ao_rn_stdio;
368 * Set the stdio echo for the bluetooth link
371 ao_rn_echo(uint8_t echo)
373 ao_stdios[ao_rn_stdio].echo = echo;
379 int status = AO_RN_ERROR;
383 ao_rn_dbg("ao_rn top\n");
385 /* Select CMD mode after the device gets out of reset */
386 ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, foo, AO_RN_CMD_CMD);
388 for (i = 0; i < 3; i++) {
389 ao_rn_dbg("reset device\n");
391 ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 0);
392 ao_delay(AO_MS_TO_TICKS(100));
394 /* Reboot the RN4678 and wait for it to start talking */
396 ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 1);
397 status = ao_rn_wait_for(AO_RN_REBOOT_TIMEOUT, AO_RN_REBOOT_MSG);
398 if (status != AO_RN_OK) {
399 ao_rn_dbg("reboot failed\n");
403 /* After it reboots, it can take a moment before it responds
406 status = ao_rn_wait_for(AO_RN_REBOOT_TIMEOUT, "CMD> ");
408 if (status == AO_RN_TIMEOUT) {
410 (void) ao_rn_wait_for(AO_RN_REBOOT_TIMEOUT, "CMD> ");
413 ao_rn_send_cmd(AO_RN_VERSION_CMD, NULL);
414 (void) ao_rn_wait_status();
416 /* Check to see if the name is already set and assume
417 * that the device is ready to go
419 status = ao_rn_get_name(name, sizeof (name));
420 if (status != AO_RN_OK) {
421 ao_rn_dbg("get name failed\n");
422 status = ao_rn_get_name(name, sizeof (name));
423 if (status != AO_RN_OK)
427 if (strncmp(name, "TeleBT-", 7) == 0) {
428 ao_rn_dbg("name is set\n");
433 /* Make the command pin control command/data mode */
434 ao_rn_send_cmd(AO_RN_SET_COMMAND_PIN, NULL);
435 if (ao_rn_wait_status() != AO_RN_OK) {
436 ao_rn_dbg("set command pin failed\n");
440 ao_rn_send_cmd(AO_RN_SET_STATUS_STRING, AO_RN_STATUS_STRING_ENABLE);
441 if (ao_rn_wait_status() != AO_RN_OK) {
442 ao_rn_dbg("set status string\n");
446 /* Select 'fast' mode to ignore command sequence (more or less) */
447 ao_rn_send_cmd(AO_RN_SET_FAST_MODE, NULL);
448 if (ao_rn_wait_status() != AO_RN_OK) {
449 ao_rn_dbg("set fast mode failed\n");
453 /* Finally, set the name. Doing this last makes it possible to check
454 * if the whole sequence has been done
456 if (ao_rn_set_name() != AO_RN_OK) {
457 ao_rn_dbg("set name failed\n");
461 /* After we've configured the device, go back around and reboot it
462 * as that's how we get the new configuration to take effect
465 ao_rn_dbg("ao_rn status %d\n", status);
467 if (status != AO_RN_OK)
470 ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, foo, AO_RN_CMD_DATA);
472 /* Wait for the hardware to finish sending messages, then clear the queue */
473 ao_delay(AO_MS_TO_TICKS(200));
476 ao_exti_enable(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN);
481 * Separate debug code when things aren't working. Just dump
482 * inbound bluetooth characters to stdout
487 ao_arch_block_interrupts();
488 while ((c = _ao_rn_pollchar()) == AO_READ_AGAIN)
489 ao_sleep(&ao_serial_rn_rx_fifo);
490 ao_arch_release_interrupts();
493 ao_rn_stdio = ao_add_stdio(_ao_wrap_rn_pollchar,
494 ao_serial_rn_putchar,
500 * Now just hang around and flash the blue LED when we've got
504 ao_arch_block_interrupts();
505 while (!ao_rn_connected)
506 ao_sleep(&ao_rn_connected);
507 ao_arch_release_interrupts();
508 while (ao_rn_connected) {
509 ao_led_for(AO_BT_LED, AO_MS_TO_TICKS(20));
510 if (ao_rn_buf_cnt != 0)
511 ao_wakeup(&ao_stdin_ready);
512 ao_delay(AO_SEC_TO_TICKS(3));
518 static struct ao_task ao_rn_task;
527 * Factory reset. Flip pin P3_1 5 times within the first five
528 * seconds of power-on
531 /* Select our target output pin */
532 ao_enable_output(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, foo, v);
534 /* Turn off the BT device using the SW_BTN pin */
535 printf("Power down BT\n"); flush();
536 ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, foo, 0);
537 ao_delay(AO_MS_TO_TICKS(1000));
539 /* And turn it back on */
540 printf("Power up BT\n"); flush();
541 ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, foo, 1);
543 /* Right after power on, poke P3_1 five times to force a
546 for (i = 0; i < 20; i++) {
548 ao_delay(AO_MS_TO_TICKS(50));
549 ao_gpio_set(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, foo, v);
550 ao_led_toggle(AO_BT_LED);
553 /* And let P3_1 float again */
554 ao_enable_input(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, AO_EXTI_MODE_PULL_NONE);
556 printf("Reboot BT\n"); flush();
557 ao_delay(AO_MS_TO_TICKS(100));
558 ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 0);
559 ao_delay(AO_MS_TO_TICKS(100));
560 ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 1);
563 static const struct ao_cmds rn_cmds[] = {
564 { ao_rn_factory, "F\0Factory reset rn4678" },
571 (void) ao_rn_set_name;
573 ao_serial_rn_set_speed(AO_SERIAL_SPEED_115200);
576 ao_enable_output(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 0);
579 ao_enable_output(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, foo, 1);
581 /* P3_7 command/data selector */
582 ao_enable_output(AO_RN_CMD_PORT, AO_RN_CMD_PIN, foo, AO_RN_CMD_CMD);
584 ao_enable_input(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN, AO_EXTI_MODE_PULL_NONE);
585 ao_exti_setup(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN,
586 AO_EXTI_MODE_FALLING|AO_EXTI_MODE_RISING|AO_EXTI_PRIORITY_LOW,
589 ao_cmd_register(rn_cmds);
590 ao_add_task(&ao_rn_task, ao_rn, "bluetooth");