Tascam RC-10

https://old.ghielectronics.com/community/codeshare/entry/1062

by iamin Nov. 25, 2015 | Snippet | Licensed as Apache 2.0 | 1577 views

You can use this code to emulate Tascam RC-10 wired remote control with a NETMF device. It can be useful if you need to control such Tascam portable audio recording devices as DR-40, DR-100MKII, DR-60DMKII, DR-70D and DR-701D.

The hardest part was to figure out the communication protocol it is using. As far as I know, it is not publicly documented.

• It turns out it is an async serial (9600, 8/E/1).
• Data is sent over 2.5mm TRS connector, where sleeve is GND, ring is 3.3V and tip is signal (internal 10K pull-up is installed, at least in my DR-100MKII).
• If a button is released quickly there will be two bytes sent with a 150 ms sleep period between them (see Short.png). I am attaching a summary of bytes for each button. However, if you keep a button depressed for a longer period of time a repeat byte will be sent multiple times in between those two bytes (see Long.png).
• The data sequence will look like this:
• 1st byte, 99.5 ms sleep time,
• repeat byte, 99.5 ms sleep time,
• repeat byte, 99.5 ms sleep time,
• repeat byte …
• 10.5 ms sleep time, 2nd byte.

• Only 1st and 2nd bytes need to be sent in order to emulate a button press, i. e. you do not need to send repeat byte(s), but you can if you want to.

You can use either SignalGenerator or SerialPort class to send data, either one has its own advantages and disadvantages.

' Emulate Play button using SignalGenerator
Thread.Sleep(3000)
Dim sg As New SignalGenerator(DirectCast(64, Cpu.Pin), True)
sg.SetBlocking(True, New UInteger() {104, 104, 104, 104 * 2, 104, 104 * 3, 104 * 2 + 150 * 1000, 104, 104, 104 * 2, 104, 104 * 5})

' Emulate Play button using SerialPort
Dim uart As New SerialPort("COM1", 9600)
uart.Parity = Parity.Even
uart.Open()
Thread.Sleep(3000)

uart.WriteByte(137)         ' First byte
Thread.Sleep(150)
uart.WriteByte(9)           ' Second byte

TASCAM RC-10 remote control

https://github.com/abbrev/tascam-rc-10-remote

TASCAM RC-10 remote control

This is a replacement for a TASCAM RC-10 remote control running on Arduino.

The RC-10 communicates over a 2.5mm stereo headphone plug. The tip is the signal from the remote control to the device under control (such as an audio recorder), the ring is 3.3V DC from the device, and the sleeve is ground.

The protocol is standard TTL-level UART (mark is 3.3V, space is 0V) running at 9600 baud, 8 data bits, even parity, and 1 stop bit.

The RC-10 sends a start byte when a button is pressed, a repeat byte every 100ms afterward while the button is held down, and an end byte when the button is released. The lower 5 bits of the byte is the command, while the upper 2 bits indicate whether it's a start, repeat, or end byte. A start byte has bit 7 set and bit 6 cleared, a repeat byte has both bits 7 and 6 set, and an end byte has both bits 7 and 6 cleared.

Note: F3 is marked (+) and F4 is marked (-).

This replacement software also supports a “turbo” mode which increases the repeat rate of buttons to 2x the normal rate. This is useful for impatient people. :) Turbo mode can be toggled with a press of the turbo button.

Copyright 2016 Christopher Williams. All Rights Reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY CHRISTOPHER WILLIAMS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Acknowledgments

Special thanks to user iamin on www.ghielectronics.com for posting information about the RC-10 protocol. (See https://www.ghielectronics.com/community/codeshare/entry/1062)

RC10.ino

/*
 * Replacement for TASCAM RC-10 remote control.
 *
 * Copyright 2016 Christopher Williams. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY CHRISTOPHER WILLIAMS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/*
 * Button mapping:
 *  1 stop
 *  2 play
 *  3 record
 *  4 forward
 *  5 back
 *  6 mark
 *  7 1/2 [SOLO]
 *  8 3/4 [SOLO]
 *  9 mic input level +
 * 10 mic input level -
 * 11 turbo
 *
 * (The actual pin mapping is currently up in the air.)
 *
 * Connector: 2.5mm stereo phone plug.
 *    _
 *   <_>    tip: data (from remote control)
 *   |_|   ring: 3.3VDC (to remote control)
 *   | | sleeve: gnd
 *  _|_|_
 *  |   |
 */
 
/*
 * N.B. This program is limited to one button press at a time because I
 * don't know how the TASCAM DR-40 (or other models) responds to interleaved
 * buttons, so I just avoid it in the first place. There's no function that
 * requires two or more simultaneous button presses anyway.
 */
 
/**** START OF CONFIGURABLES ****/
 
struct function {
	uint8_t pin;
	uint8_t value;
};
 
// map of pin numbers and values to send in response to a button
// press/release/repeat (ORed with start/repeat/end mask)
/*
 * XXX buttons are numbered 1..10 so we can return the negative value to
 * indicate that the button was released. So we have a dummy button at
 * index 0 to account for that.
 */
static const struct function functions[] = {
	{  0,  0, }, // dummy
	{ 12,  8, }, //  1 stop
	{ 14,  9, }, //  2 play
	{ 15, 11, }, //  3 record
	{ 16, 14, }, //  4 forward
	{ 17, 15, }, //  5 back
	{ 18, 24, }, //  6 mark
	{ 19, 28, }, //  7 1/2 [SOLO]
	{ 20, 29, }, //  8 3/4 [SOLO]
	{ 21, 30, }, //  9 mic input level +
	{ 22, 31, }, // 10 mic input level -
	{ 23,  0, }, // 11 turbo
};
 
#define TURBO_LED_PIN 13
#define TURBO_BUTTON_PIN 23
 
#define FIRST_REPEAT_PERIOD 100
#define REPEAT_PERIOD 100
 
#define TURBO_FIRST_REPEAT_PERIOD 100
#define TURBO_REPEAT_PERIOD 50
 
/**** END OF CONFIGURABLES ****/
 
#define SIZEOF_ARRAY(a) (sizeof a / sizeof a[0])
static const uint8_t numButtonInputPins = SIZEOF_ARRAY(functions);
 
static uint8_t firstRepeatPeriod = FIRST_REPEAT_PERIOD;
static uint8_t repeatPeriod = REPEAT_PERIOD;
static bool turboRepeat = false;
 
#define EACHBUTTON(b) (uint8_t b = 1; b < numButtonInputPins; ++b)
 
void setup()
{
	Serial.begin(9600, SERIAL_8E1);
	for EACHBUTTON(b) {
		pinMode(functions[b].pin, INPUT_PULLUP);
	}
	pinMode(TURBO_LED_PIN, OUTPUT);
 
	setTurbo(false);
}
 
void loop()
{
	static unsigned long lastRepeatTime;
	static int8_t currentButton = 0;
	static unsigned long repeat;
 
	int8_t button = scanButtons();
	if (button) {
		lastRepeatTime = millis();
		repeat = firstRepeatPeriod;
		currentButton = button;
		if (button > 0) {
			handleButtonPress(button);
		} else {
			handleButtonRelease(-button);
		}
	} else if (currentButton > 0 &&
	           millis() - lastRepeatTime >= repeat) {
		lastRepeatTime += repeat;
		repeat = repeatPeriod;
	        handleButtonRepeat(currentButton);
	}
}
 
/**** Button event handlers ****/
 
#define START_MASK  0x80
#define REPEAT_MASK 0xC0
#define END_MASK    0x00
 
static void setTurbo(bool turbo)
{
	turboRepeat = turbo;
	if (turboRepeat) {
		repeatPeriod = TURBO_REPEAT_PERIOD;
		firstRepeatPeriod = TURBO_FIRST_REPEAT_PERIOD;
		digitalWrite(TURBO_LED_PIN, HIGH);
	} else {
		repeatPeriod = REPEAT_PERIOD;
		firstRepeatPeriod = FIRST_REPEAT_PERIOD;
		digitalWrite(TURBO_LED_PIN, LOW);
	}
}
 
static void handleButtonPress(uint8_t b)
{
	if (functions[b].value) {
		Serial.write(functions[b].value | START_MASK);
	} else if (functions[b].pin == TURBO_BUTTON_PIN) {
		setTurbo(!turboRepeat);
	}
}
 
static void handleButtonRelease(uint8_t b)
{
	if (functions[b].value) {
		Serial.write(functions[b].value | END_MASK);
	}
}
 
static void handleButtonRepeat(uint8_t b)
{
	if (functions[b].value) {
		Serial.write(functions[b].value | REPEAT_MASK);
	}
}
 
/**** Debounced button scanner ****/
 
#define DEBOUNCE_PERIOD 50
 
// return zero if no change in button presses
// return button number if button is now pressed
// return negative button number if button is now released
static int8_t scanButtons(void)
{
	static int8_t currentButton = 0;
 
	static bool debouncing = false;
	static unsigned long debounceTime = 0;
 
	if (debouncing && millis() - debounceTime < DEBOUNCE_PERIOD) {
		return 0;
	}
	debouncing = false;
 
	if (currentButton <= 0) {
		// no buttons currently pressed
		// scan all buttons
		for EACHBUTTON(b) {
			if (readButtonState(b)) {
				debouncing = true;
				debounceTime = millis();
				currentButton = b;
				return currentButton;
			}
		}
	} else {
		// scan only this button
		bool pressed = readButtonState(currentButton);
		if (!pressed) {
			// button is released
			debouncing = true;
			debounceTime = millis();
			currentButton = -currentButton;
			return currentButton;
		}
	}
	return 0;
}
 
// return true if button 'b' is pressed
static bool readButtonState(uint8_t b)
{
	return digitalRead(functions[b].pin) == LOW;
}