USBCAS: seem to have transmit working...

USBCAS/Descriptors.c

@@ -98,7 +98,7 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
 
 			.Class                  = CDC_CSCP_CDCClass,
 			.SubClass               = CDC_CSCP_ACMSubclass,
-			.Protocol               = CDC_CSCP_ATCommandProtocol,
+			.Protocol               = CDC_CSCP_ATCommandProtocol, /* ?? */
 
 			.InterfaceStrIndex      = NO_DESCRIPTOR
 		},
@@ -242,4 +242,3 @@ uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
 	*DescriptorAddress = Address;
 	return Size;
 }
-

USBCAS/Makefile

@@ -18,7 +18,8 @@ F_CPU        = 16000000
 F_USB        = $(F_CPU)
 OPTIMIZATION = s
 TARGET       = usbcas
-SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)
+SRC          = $(TARGET).c Descriptors.c reboot.c fmtx.c \
+	       $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)
 LUFA_PATH    = ../LUFA/LUFA
 CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/
 LD_FLAGS     =

USBCAS/fmnyb.pl

@@ -0,0 +1,21 @@
+#!/usr/bin/perl
+
+use integer;
+use strict;
+
+print "static const uint8_t fm_nyb[16] = {\n";
+
+for (my $i = 0; $i < 16; $i++) {
+    my $pat = 0;
+    my $inc = 0;		# Previous bit
+
+    for (my $j = 0; $j < 4; $j++) {
+	my $bp = ($i & (1 << $j)) ? 0x1 : 0x3;
+	$bp ^= $inc * 3;
+	$inc = $bp >> 1;
+	$pat |= $bp << ($j*2);
+    }
+
+    printf "%s0x%02x", ($i ? ', ' : "\t"), $pat;
+}
+print "\n};\n";

USBCAS/fmtx.c

@@ -0,0 +1,72 @@
+/*
+ * Transmit an FM-modulated signal using the USART in SPI master mode.
+ * As per ABC standard, this signal is transmitted LSB first.
+ */
+
+#include "usbcas.h"
+
+/*
+ * FM nybble patters; these should be transmitted LSB first
+ * and XOR'd with the MSB of the pattern byte last transmitted.
+ */
+static const uint8_t fm_nyb[16] = {
+	0x33, 0xcd, 0xcb, 0x35, 0xd3, 0x2d, 0x2b, 0xd5,
+	0xb3, 0x4d, 0x4b, 0xb5, 0x53, 0xad, 0xab, 0x55
+};
+static uint8_t parity = 0;
+
+/*
+ * Send the least significant nybble of this data item and return
+ * the next nybble, if any. Check with fmtx_send_ready() before
+ * calling this function.
+ */
+uint8_t fmtx_send_nybble(uint8_t d)
+{
+	uint8_t nyb = fm_nyb[d & 15] ^ parity;
+	UCSR1A = (1 << TXC1);
+	UDR1 = nyb;
+	parity = -((int8_t)nyb < 0);
+	return d >> 4;
+}
+
+/*
+ * Synchronize transmitter before reconfiguration
+ */
+void fmtx_drain(void)
+{
+	while (!(UCSR1A & (1 << TXC1)))
+		;
+}
+
+/*
+ * Initialize the USART hardware and set transmission baudrate.
+ * This is mostly the same as SerialSPI_Init().
+ */
+void fmtx_init_speed(uint32_t baudrate)
+{
+	DDRD |= 0x28; /* PD3 = outdata, PD5 = XCK/TXLED */
+	PORTD = (PORTD & ~0x28) | (parity & 0x20) | 0x08;
+
+	UCSR1B = 0;	/* Disable USART */
+	UCSR1A = 0;	/* Clear error bits */
+
+	/*
+	 * SPI master mode, mode 1, LSB first
+	 * UCPHA doesn't matter, but have UCPOL=1 to that the clock
+	 * is 1 when idle and the TXLED is OFF.
+	 */
+	UCSR1C = (3 << UMSEL10) | (1 << UDORD1) | (1 << UCPOL1);
+
+	/* UBRR must be zero when the transmitter is enabled */
+	UBRR1  = 0;
+
+	/* Enable transmitter, but not receiver */
+	UCSR1B = (1 << TXEN1);
+
+	/* Configure baud rate (UBBRVAL is a typo in LUFA) */
+	/* We need two SPI ticks per symbol, hence double... */
+	UBRR1  = SERIAL_SPI_UBBRVAL(baudrate << 1);
+
+	/* Output the current idle state of the line */
+	UDR1   = parity;
+}

USBCAS/reboot.c

@@ -0,0 +1,41 @@
+#include "usbcas.h"
+
+/* ATmega32U4 with Caterina bootloader */
+#define FLASH_SIZE_BYTES	32768
+#define BOOTSZ			0
+#define BOOTLOADER_SEC_SIZE	(4096 >> BOOTSZ)
+
+#define MAGIC_BOOT_KEY	0xdc42acca
+#define BOOTLOADER_START_ADDRESS	(FLASH_SIZE_BYTES - BOOTLOADER_SEC_SIZE)
+
+static uint32_t boot_key_magic ATTR_NO_INIT;
+
+static void bootloader_jump_check(void) ATTR_INIT_SECTION(3);
+static void bootloader_jump_check(void)
+{
+	void (* const bootloader)(void) =
+		(void (*)(void))BOOTLOADER_START_ADDRESS;
+	/*
+	 * If the reset source was the watch dog and the boot key magic is set,
+	 * clear the magic and jump into the boot loader
+	 */
+
+	if (boot_key_magic == MAGIC_BOOT_KEY) {
+		boot_key_magic = 0;
+		bootloader();
+	}
+}
+
+/*
+ * Host sent BREAK; reboot into bootloader
+ */
+void EVENT_CDC_Device_BreakSent(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, const uint8_t duration)
+{
+	/* Set the bootloader invocation key */
+	boot_key_magic = MAGIC_BOOT_KEY;
+
+	/* Arm the watchdog to force a hardware reset */
+	wdt_enable(WDTO_250MS);
+
+	/* Return to the main loop so we ack the send break correctly */
+}

USBCAS/usbcas.c

@@ -37,16 +37,16 @@
 #include "usbcas.h"
 
 /** Circular buffer to hold data from the host before it is sent to the device via the serial port. */
-static RingBuffer_t USBtoUSART_Buffer;
+static RingBuffer_t USBtoCAS_Buffer;
 
-/** Underlying data buffer for \ref USBtoUSART_Buffer, where the stored bytes are located. */
-static uint8_t      USBtoUSART_Buffer_Data[128];
+/** Underlying data buffer for \ref USBtoCAS_Buffer, where the stored bytes are located. */
+static uint8_t      USBtoCAS_Buffer_Data[128];
 
 /** Circular buffer to hold data from the serial port before it is sent to the host. */
-static RingBuffer_t USARTtoUSB_Buffer;
+static RingBuffer_t CAStoUSB_Buffer;
 
-/** Underlying data buffer for \ref USARTtoUSB_Buffer, where the stored bytes are located. */
-static uint8_t      USARTtoUSB_Buffer_Data[128];
+/** Underlying data buffer for \ref CAStoUSB_Buffer, where the stored bytes are located. */
+static uint8_t      CAStoUSB_Buffer_Data[128];
 
 /** LUFA CDC Class driver interface configuration and state information. This structure is
  *  passed to all CDC Class driver functions, so that multiple instances of the same class
@@ -79,32 +79,62 @@ USB_ClassInfo_CDC_Device_t VirtualSerial_CDC_Interface =
 	};
 
 
+/*
+ * Transmit an FM-modulated signal using the USART in SPI master mode.
+ * As per ABC standard, this signal is transmitted LSB first.
+ */
+
+#include "usbcas.h"
+
+/*
+ * Probe for modem control status bits and send them if changed,
+ * or if forced...
+ */
+static void update_modem_status(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo, bool forced)
+{
+	uint16_t lines = CDC_CONTROL_LINE_IN_DSR;
+
+	if (!(PINB & (1 << 4))) /* Cassette relay active */
+		lines |= CDC_CONTROL_LINE_IN_DCD;
+
+	if (lines & CDC_CONTROL_LINE_IN_DCD)
+		PORTB &= ~(1U << 0);
+	else
+		PORTB |= (1U << 0);
+
+	if (forced || CDCInterfaceInfo->State.ControlLineStates.DeviceToHost != lines) {
+		CDCInterfaceInfo->State.ControlLineStates.DeviceToHost = lines;
+		CDC_Device_SendControlLineStateChange(CDCInterfaceInfo);
+	}
+}
+
 /** Main program entry point. This routine contains the overall program flow, including initial
  *  setup of all components and the main program loop.
  */
 int main(void)
 {
+	int8_t hinybble = -1;
+
 	SetupHardware();
 
-	RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
-	RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
+	RingBuffer_InitBuffer(&USBtoCAS_Buffer, USBtoCAS_Buffer_Data, sizeof(USBtoCAS_Buffer_Data));
+	RingBuffer_InitBuffer(&CAStoUSB_Buffer, CAStoUSB_Buffer_Data, sizeof(CAStoUSB_Buffer_Data));
 
-	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 	GlobalInterruptEnable();
 
 	for (;;)
 	{
 		/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
-		if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))
+		if (!(RingBuffer_IsFull(&USBtoCAS_Buffer)))
 		{
 			int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
 
 			/* Store received byte into the USART transmit buffer */
 			if (!(ReceivedByte < 0))
-			  RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
+			  RingBuffer_Insert(&USBtoCAS_Buffer, ReceivedByte);
 		}
 
-		uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
+		uint16_t BufferCount = RingBuffer_GetCount(&CAStoUSB_Buffer);
 		if (BufferCount)
 		{
 			Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address);
@@ -122,26 +152,39 @@ int main(void)
 				{
 					/* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
 					if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
-											RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
+								RingBuffer_Peek(&CAStoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
 					{
 						break;
 					}
 
 					/* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
-					RingBuffer_Remove(&USARTtoUSB_Buffer);
+					RingBuffer_Remove(&CAStoUSB_Buffer);
 				}
 			}
 		}
 
-		/* Load the next byte from the USART transmit buffer into the USART if transmit buffer space is available */
-		if (Serial_IsSendReady() && !(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))
-		  Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
+		/* Transmit the next data nybble if we can */
+		if (fmtx_send_ready()) {
+			if (hinybble >= 0) {
+				/* Send high nybble of previous data */
+				fmtx_send_nybble(hinybble);
+				hinybble = -1;
+			} else if (!RingBuffer_IsEmpty(&USBtoCAS_Buffer)) {
+				/* Send low nybble of new data */
+				hinybble = fmtx_send_nybble(RingBuffer_Remove(&USBtoCAS_Buffer));
+			}
+		}
+
+		/* Update modem flags if needed */
+		update_modem_status(&VirtualSerial_CDC_Interface, false);
 
 		CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
 		USB_USBTask();
 	}
 }
 
+static uint32_t current_baudrate = CAS_BAUDRATE_ABC80;
+
 /** Configures the board hardware and chip peripherals for the demo's functionality. */
 void SetupHardware(void)
 {
@@ -155,30 +198,34 @@ void SetupHardware(void)
 #endif
 
 	/* Hardware Initialization */
-	LEDs_Init();
 	USB_Init();
+
+	/* PORTB: PB0 - RXLED, PB4 - Relay, PB5 - relay out */
+	PORTB = (1 << 0) | (1 << 4);
+	DDRB  = ~(1 << 4);
+
+	/* Initialize transmitter (and receiver) */
+	fmtx_init_speed(current_baudrate);
 }
 
 /** Event handler for the library USB Connection event. */
 void EVENT_USB_Device_Connect(void)
 {
-	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 }
 
 /** Event handler for the library USB Disconnection event. */
 void EVENT_USB_Device_Disconnect(void)
 {
-	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 }
 
 /** Event handler for the library USB Configuration Changed event. */
 void EVENT_USB_Device_ConfigurationChanged(void)
 {
-	bool ConfigSuccess = true;
-
-	ConfigSuccess &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
+	bool success = true;
 
-	LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
+	success &= CDC_Device_ConfigureEndpoints(&VirtualSerial_CDC_Interface);
+	if (success)
+		update_modem_status(&VirtualSerial_CDC_Interface, true);
 }
 
 /** Event handler for the library USB Control Request reception event. */
@@ -187,6 +234,7 @@ void EVENT_USB_Device_ControlRequest(void)
 	CDC_Device_ProcessControlRequest(&VirtualSerial_CDC_Interface);
 }
 
+#if 0
 /** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
  *  for later transmission to the host.
  */
@@ -194,9 +242,11 @@ ISR(USART1_RX_vect, ISR_BLOCK)
 {
 	uint8_t ReceivedByte = UDR1;
 
-	if ((USB_DeviceState == DEVICE_STATE_Configured) && !(RingBuffer_IsFull(&USARTtoUSB_Buffer)))
-	  RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
+	if ((USB_DeviceState == DEVICE_STATE_Configured) &&
+	    !(RingBuffer_IsFull(&CAStoUSB_Buffer)))
+		RingBuffer_Insert(&CAStoUSB_Buffer, ReceivedByte);
 }
+#endif
 
 /** Event handler for the CDC Class driver Line Encoding Changed event.
  *
@@ -204,51 +254,29 @@ ISR(USART1_RX_vect, ISR_BLOCK)
  */
 void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
 {
-	uint8_t ConfigMask = 0;
+	uint32_t baudrate = CDCInterfaceInfo->State.LineEncoding.BaudRateBPS;
 
-	switch (CDCInterfaceInfo->State.LineEncoding.ParityType)
-	{
-		case CDC_PARITY_Odd:
-			ConfigMask = ((1 << UPM11) | (1 << UPM10));
-			break;
-		case CDC_PARITY_Even:
-			ConfigMask = (1 << UPM11);
-			break;
-	}
-
-	if (CDCInterfaceInfo->State.LineEncoding.CharFormat == CDC_LINEENCODING_TwoStopBits)
-	  ConfigMask |= (1 << USBS1);
+	/* Hack to map ABC80 standard speed to a common baud rate */
+	if (baudrate == CAS_BAUDRATE_ABC80_FAKE)
+		baudrate = CAS_BAUDRATE_ABC80;
 
-	switch (CDCInterfaceInfo->State.LineEncoding.DataBits)
-	{
-		case 6:
-			ConfigMask |= (1 << UCSZ10);
-			break;
-		case 7:
-			ConfigMask |= (1 << UCSZ11);
-			break;
-		case 8:
-			ConfigMask |= ((1 << UCSZ11) | (1 << UCSZ10));
-			break;
+	if (baudrate != current_baudrate) {
+		current_baudrate = baudrate;
+		fmtx_drain();
+		fmtx_init_speed(baudrate);
 	}
-
-	/* Keep the TX line held high (idle) while the USART is reconfigured */
-	PORTD |= (1 << 3);
-
-	/* Must turn off USART before reconfiguring it, otherwise incorrect operation may occur */
-	UCSR1B = 0;
-	UCSR1A = 0;
-	UCSR1C = 0;
-
-	/* Set the new baud rate before configuring the USART */
-	UBRR1  = SERIAL_2X_UBBRVAL(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS);
-
-	/* Reconfigure the USART in double speed mode for a wider baud rate range at the expense of accuracy */
-	UCSR1C = ConfigMask;
-	UCSR1A = (1 << U2X1);
-	UCSR1B = ((1 << RXCIE1) | (1 << TXEN1) | (1 << RXEN1));
-
-	/* Release the TX line after the USART has been reconfigured */
-	PORTD &= ~(1 << 3);
 }
 
+/*
+ * Control lines changed
+ */
+void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
+{
+	/* Indicate the DTR line via RXLED for now */
+#if 0
+	if (CDCInterfaceInfo->State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR)
+		PORTB &= ~(1U << 0);
+	else
+		PORTB |= (1U << 0);
+#endif
+}

USBCAS/usbcas.h

@@ -30,48 +30,49 @@
 
 /** \file
  *
- *  Header file for USBtoSerial.c.
+ *  Header file for usbcas.c (USB serial to ABC cassette)
  */
 
-#ifndef _USB_SERIAL_H_
-#define _USB_SERIAL_H_
+#ifndef _USB_CAS_H_
+#define _USB_CAS_H_
 
-	/* Includes: */
-		#include <avr/io.h>
-		#include <avr/wdt.h>
-		#include <avr/interrupt.h>
-		#include <avr/power.h>
+/* Includes: */
+#include <avr/io.h>
+#include <avr/wdt.h>
+#include <avr/interrupt.h>
+#include <avr/power.h>
 
-		#include "Descriptors.h"
+#include "Descriptors.h"
 
-		#include <LUFA/Drivers/Board/LEDs.h>
-		#include <LUFA/Drivers/Peripheral/Serial.h>
-		#include <LUFA/Drivers/Misc/RingBuffer.h>
-		#include <LUFA/Drivers/USB/USB.h>
-		#include <LUFA/Platform/Platform.h>
+#include <LUFA/Drivers/Peripheral/SerialSPI.h>
+#include <LUFA/Drivers/Misc/RingBuffer.h>
+#include <LUFA/Drivers/USB/USB.h>
+#include <LUFA/Platform/Platform.h>
 
-	/* Macros: */
-		/** LED mask for the library LED driver, to indicate that the USB interface is not ready. */
-		#define LEDMASK_USB_NOTREADY      (LEDS_LED1 | LEDS_LED2)
 
-		/** LED mask for the library LED driver, to indicate that the USB interface is enumerating. */
-		#define LEDMASK_USB_ENUMERATING  (LEDS_LED1)
+/* Function Prototypes: */
+void SetupHardware(void);
 
-		/** LED mask for the library LED driver, to indicate that the USB interface is ready. */
-		#define LEDMASK_USB_READY        (LEDS_LED2)
+void EVENT_USB_Device_Connect(void);
+void EVENT_USB_Device_Disconnect(void);
+void EVENT_USB_Device_ConfigurationChanged(void);
+void EVENT_USB_Device_ControlRequest(void);
 
-		/** LED mask for the library LED driver, to indicate that an error has occurred in the USB interface. */
-		#define LEDMASK_USB_ERROR        (LEDS_LED1 | LEDS_LED3)
+void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
+void EVENT_CDC_Device_ControLineStateChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
 
-	/* Function Prototypes: */
-		void SetupHardware(void);
+uint8_t fmtx_send_nybble(uint8_t byte);
+void fmtx_drain(void);
+void fmtx_init_speed(uint32_t baudrate);
+static inline bool fmtx_send_ready(void) ATTR_ALWAYS_INLINE;
+static inline bool fmtx_send_ready(void)
+{
+	return !!(UCSR1A & (1 << UDRE1));
+}
 
-		void EVENT_USB_Device_Connect(void);
-		void EVENT_USB_Device_Disconnect(void);
-		void EVENT_USB_Device_ConfigurationChanged(void);
-		void EVENT_USB_Device_ControlRequest(void);
-
-		void EVENT_CDC_Device_LineEncodingChanged(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo);
+/* Parameters */
+#define CAS_BAUDRATE_ABC80_FAKE	600
+#define CAS_BAUDRATE_ABC80	720
+#define CAS_BAUDRATE_ABC800	2400
 
 #endif
-