di0ib
/
controller
Watch 1
Star 0
Fork 0
Code Releases 0 Activity
Browse Source

Initial code for ARM UART output module (mainly for CLI)

simple
Jacob Alexander 10 years ago
parent
99d4aaba84
commit
6f563bdc9f
8 changed files with 619 additions and 23 deletions
Split View Show Diff Stats
  1. 3
    3
      CMakeLists.txt
  2. 1
    10
      Output/pjrcUSB/arm/usb_dev.c
  3. 14
    10
      Output/pjrcUSB/output_com.c
  4. 195
    0
      Output/uartOut/arm/uart_serial.c
  5. 40
    0
      Output/uartOut/arm/uart_serial.h
  6. 245
    0
      Output/uartOut/output_com.c
  7. 76
    0
      Output/uartOut/output_com.h
  8. 45
    0
      Output/uartOut/setup.cmake

+ 3
- 3
CMakeLists.txt View File

@@ -21,8 +21,8 @@ set( CHIP
# "atmega32u4" # Teensy 2.0 (avr)
# "at90usb646" # Teensy++ 1.0 (avr)
# "at90usb1286" # Teensy++ 2.0 (avr)
# "mk20dx128" # Teensy 3.0 (arm)
"mk20dx128vlf5" # McHCK mk20dx128vlf5
"mk20dx128" # Teensy 3.0 (arm)
# "mk20dx128vlf5" # McHCK mk20dx128vlf5
# "mk20dx256" # Teensy 3.1 (arm)
)

@@ -53,7 +53,7 @@ set( ScanModule "MDPure" )
set( MacroModule "PartialMap" )

##| Sends the current list of usb key codes through USB HID
set( OutputModule "pjrcUSB" )
set( OutputModule "uartOut" )

##| Debugging source to use, each module has it's own set of defines that it sets
set( DebugModule "full" )

+ 1
- 10
Output/pjrcUSB/arm/usb_dev.c View File

@@ -669,21 +669,12 @@ void usb_tx(uint32_t endpoint, usb_packet_t *packet)
}



void usb_device_reload()
{
asm volatile("bkpt");
}


void _reboot_Teensyduino_(void)
{
// TODO: initialize R0 with a code....
asm volatile("bkpt");
}



void usb_isr(void)
{
uint8_t status, stat, t;
@@ -700,7 +691,7 @@ void usb_isr(void)
t = usb_reboot_timer;
if (t) {
usb_reboot_timer = --t;
if (!t) _reboot_Teensyduino_();
if (!t) usb_device_reload();
}
#ifdef CDC_DATA_INTERFACE
t = usb_cdc_transmit_flush_timer;

+ 14
- 10
Output/pjrcUSB/output_com.c View File

@@ -105,6 +105,10 @@ inline void Output_setup()
// If the Teensy is powered without a PC connected to the USB port,
// this will wait forever.
usb_init();
#include <led.h>
init_errorLED();
errorLED( 1 );
while(1);
while ( !usb_configured() ) /* wait */ ;

// Register USB Output CLI dictionary
@@ -119,19 +123,19 @@ inline void Output_setup()
// USB Data Send
inline void Output_send(void)
{
// TODO undo potentially old keys
for ( uint8_t c = USBKeys_Sent; c < USBKeys_MaxSize; c++ )
USBKeys_Array[c] = 0;
// TODO undo potentially old keys
for ( uint8_t c = USBKeys_Sent; c < USBKeys_MaxSize; c++ )
USBKeys_Array[c] = 0;

// Send keypresses
usb_keyboard_send();
// Send keypresses
usb_keyboard_send();

// Clear modifiers and keys
USBKeys_Modifiers = 0;
USBKeys_Sent = 0;
// Clear modifiers and keys
USBKeys_Modifiers = 0;
USBKeys_Sent = 0;

// Signal Scan Module we are finishedA
Scan_finishedWithUSBBuffer( USBKeys_Sent <= USBKeys_MaxSize ? USBKeys_Sent : USBKeys_MaxSize );
// Signal Scan Module we are finishedA
Scan_finishedWithUSBBuffer( USBKeys_Sent <= USBKeys_MaxSize ? USBKeys_Sent : USBKeys_MaxSize );
}



+ 195
- 0
Output/uartOut/arm/uart_serial.c View File

@@ -0,0 +1,195 @@
/* Copyright (C) 2014 by Jacob Alexander
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/

#include "uart_serial.h"
#include <Lib/OutputLib.h>
#include <Lib/Interrupts.h>
#include <string.h> // For memcpy

// ----- Variables -----

#define uart0_buffer_size 32 // 32 byte buffer
volatile uint8_t uart0_buffer_head = 0;
volatile uint8_t uart0_buffer_tail = 0;
volatile uint8_t uart0_buffer_items = 0;
volatile uint8_t uart0_buffer[uart0_buffer_size];


// ----- Interrupt Functions -----

void uart0_status_isr()
{
cli(); // Disable Interrupts

// UART0_S1 must be read for the interrupt to be cleared
if ( UART0_S1 & UART_S1_RDRF )
{
// Read UART0 into buffer until FIFO is empty
while ( !( UART0_SFIFO & UART_SFIFO_RXEMPT ) )
{
uart0_buffer[uart0_buffer_tail++] = UART0_D;
uart0_buffer_items++;

// Wrap-around of tail pointer
if ( uart0_buffer_tail >= uart0_buffer_size )
{
uart0_buffer_tail = 0;
}

// Make sure the head pointer also moves if circular buffer is overwritten
if ( uart0_buffer_head == uart0_buffer_tail )
{
uart0_buffer_head++;
}

// Wrap-around of head pointer
if ( uart0_buffer_head >= uart0_buffer_size )
{
uart0_buffer_head = 0;
}

}
}

sei(); // Re-enable Interrupts
}


// ----- Functions -----

void uart_serial_setup()
{
// Setup the the UART interface for keyboard data input
SIM_SCGC4 |= SIM_SCGC4_UART0; // Disable clock gating

// Pin Setup for UART0
PORTB_PCR16 = PORT_PCR_PE | PORT_PCR_PS | PORT_PCR_PFE | PORT_PCR_MUX(3); // RX Pin
PORTB_PCR17 = PORT_PCR_DSE | PORT_PCR_SRE | PORT_PCR_MUX(3); // TX Pin

// Setup baud rate - 9600 Baud
// 48 MHz / ( 16 * Baud ) = BDH/L
// Baud: 9600 -> 48 MHz / ( 16 * 9600 ) = 312.5
// Thus baud setting = 313
// NOTE: If finer baud adjustment is needed see UARTx_C4 -> BRFA in the datasheet
uint16_t baud = 313; // Max setting of 8191
UART0_BDH = (uint8_t)(baud >> 8);
UART0_BDL = (uint8_t)baud;

// 8 bit, No Parity, Idle Character bit after stop
UART0_C1 = UART_C1_ILT;

// TX FIFO Disabled, TX FIFO Size 1 (Max 8 datawords), RX FIFO Enabled, RX FIFO Size 1 (Max 8 datawords)
// TX/RX FIFO Size:
// 0x0 - 1 dataword
// 0x1 - 4 dataword
// 0x2 - 8 dataword
UART0_PFIFO = UART_PFIFO_TXFE | UART_PFIFO_RXFE;

// Reciever Inversion Disabled, LSBF
// UART_S2_RXINV UART_S2_MSBF
UART0_S2 |= 0x00;

// Transmit Inversion Disabled
// UART_C3_TXINV
UART0_C3 |= 0x00;

// TX Disabled, RX Enabled, RX Interrupt Enabled
// UART_C2_TE UART_C2_RE UART_C2_RIE
UART0_C2 = UART_C2_TE | UART_C2_RE | UART_C2_RIE;

// Add interrupt to the vector table
NVIC_ENABLE_IRQ( IRQ_UART0_STATUS );
}


// Get the next character, or -1 if nothing received
int uart_serial_getchar()
{
unsigned int value = -1;

// Check to see if the FIFO has characters
if ( uart0_buffer_items > 0 )
{
value = uart0_buffer[uart0_buffer_head++];
uart0_buffer_items--;

// Wrap-around of head pointer
if ( uart0_buffer_head >= uart0_buffer_size )
{
uart0_buffer_head = 0;
}
}

return value;
}


// Number of bytes available in the receive buffer
int uart_serial_available()
{
return uart0_buffer_items;
}


// Discard any buffered input
void uart_serial_flush_input()
{
uart0_buffer_head = 0;
uart0_buffer_tail = 0;
uart0_buffer_items = 0;
}


// Transmit a character. 0 returned on success, -1 on error
int uart_serial_putchar( uint8_t c )
{
return uart_serial_write( &c, 1 );
}


int uart_serial_write( const void *buffer, uint32_t size )
{
const uint8_t *data = (const uint8_t *)buffer;
uint32_t position = 0;

// While buffer is not empty and transmit buffer is
while ( position < size )
{
while ( !( UART0_SFIFO & UART_SFIFO_TXEMPT ) ); // Wait till there is room to send
UART0_D = data[position++];
}

return 0;
}


void uart_serial_flush_output()
{
// Delay until buffer has been sent
while ( !( UART0_SFIFO & UART_SFIFO_TXEMPT ) ); // Wait till there is room to send
}


void uart_device_reload()
{
asm volatile("bkpt");
}


+ 40
- 0
Output/uartOut/arm/uart_serial.h View File

@@ -0,0 +1,40 @@
/* Copyright (C) 2014 by Jacob Alexander
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/

#ifndef __uart_serial_h_
#define __uart_serial_h_

#include <inttypes.h>

int uart_serial_getchar();
int uart_serial_available();
int uart_serial_putchar( uint8_t c );
int uart_serial_write( const void *buffer, uint32_t size );

void uart_serial_flush_input();
void uart_serial_flush_output();

void uart_serial_setup();

void uart_device_reload();

#endif // __uart_serial_h_


+ 245
- 0
Output/uartOut/output_com.c View File

@@ -0,0 +1,245 @@
/* Copyright (C) 2014 by Jacob Alexander
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/

// ----- Includes -----

// Compiler Includes
#include <Lib/OutputLib.h>

// Project Includes
#include <cli.h>
#include <print.h>
#include <scan_loop.h>

// USB Includes
#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_)
#include "avr/uart_serial.h"
#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_)
#include "arm/uart_serial.h"
#endif

// Local Includes
#include "output_com.h"



// ----- Function Declarations -----

void cliFunc_kbdProtocol( char* args );
void cliFunc_readLEDs ( char* args );
void cliFunc_sendKeys ( char* args );
void cliFunc_setKeys ( char* args );
void cliFunc_setMod ( char* args );


// ----- Variables -----

// Output Module command dictionary
char* outputCLIDictName = "USB Module Commands - NOT WORKING";
CLIDictItem outputCLIDict[] = {
{ "kbdProtocol", "Keyboard Protocol Mode: 0 - Boot, 1 - OS/NKRO Mode", cliFunc_kbdProtocol },
{ "readLEDs", "Read LED byte:" NL "\t\t1 NumLck, 2 CapsLck, 4 ScrlLck, 16 Kana, etc.", cliFunc_readLEDs },
{ "sendKeys", "Send the prepared list of USB codes and modifier byte.", cliFunc_sendKeys },
{ "setKeys", "Prepare a space separated list of USB codes (decimal). Waits until \033[35msendKeys\033[0m.", cliFunc_setKeys },
{ "setMod", "Set the modfier byte:" NL "\t\t1 LCtrl, 2 LShft, 4 LAlt, 8 LGUI, 16 RCtrl, 32 RShft, 64 RAlt, 128 RGUI", cliFunc_setMod },
{ 0, 0, 0 } // Null entry for dictionary end
};


// Which modifier keys are currently pressed
// 1=left ctrl, 2=left shift, 4=left alt, 8=left gui
// 16=right ctrl, 32=right shift, 64=right alt, 128=right gui
uint8_t USBKeys_Modifiers = 0;
uint8_t USBKeys_ModifiersCLI = 0; // Separate CLI send buffer

// Currently pressed keys, max is defined by USB_MAX_KEY_SEND
uint8_t USBKeys_Array [USB_MAX_KEY_SEND];
uint8_t USBKeys_ArrayCLI[USB_MAX_KEY_SEND]; // Separate CLI send buffer

// The number of keys sent to the usb in the array
uint8_t USBKeys_Sent = 0;
uint8_t USBKeys_SentCLI = 0;

// 1=num lock, 2=caps lock, 4=scroll lock, 8=compose, 16=kana
volatile uint8_t USBKeys_LEDs = 0;

// Protocol setting from the host.
// 0 - Boot Mode (Default, until set by the host)
// 1 - NKRO Mode
volatile uint8_t USBKeys_Protocol = 1;

// the idle configuration, how often we send the report to the
// host (ms * 4) even when it hasn't changed
uint8_t USBKeys_Idle_Config = 125;

// count until idle timeout
uint8_t USBKeys_Idle_Count = 0;


// ----- Functions -----

// USB Module Setup
inline void Output_setup()
{
// Setup UART
uart_serial_setup();

// Register USB Output CLI dictionary
CLI_registerDictionary( outputCLIDict, outputCLIDictName );
}


// USB Data Send
inline void Output_send(void)
{
// TODO
}


// Sets the device into firmware reload mode
inline void Output_firmwareReload()
{
#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_)
uart_debug_reload();
#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_)
uart_device_reload();
#endif
}


// USB Input buffer available
inline unsigned int Output_availablechar()
{
return uart_serial_available();
}


// USB Get Character from input buffer
inline int Output_getchar()
{
#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_)
// XXX Make sure to check output_availablechar() first! Information is lost with the cast (error codes)
return (int)uart_serial_getchar();
#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_)
return uart_serial_getchar();
#endif
}


// USB Send Character to output buffer
inline int Output_putchar( char c )
{
return uart_serial_putchar( c );
}


// USB Send String to output buffer, null terminated
inline int Output_putstr( char* str )
{
#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_) // AVR
uint16_t count = 0;
#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_) // ARM
uint32_t count = 0;
#endif
// Count characters until NULL character, then send the amount counted
while ( str[count] != '\0' )
count++;

return uart_serial_write( str, count );
}


// Soft Chip Reset
inline void Output_softReset()
{
#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_)
uart_debug_software_reset();
#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_)
SOFTWARE_RESET();
#endif
}


// ----- CLI Command Functions -----

void cliFunc_kbdProtocol( char* args )
{
print( NL );
info_msg("Keyboard Protocol: ");
printInt8( USBKeys_Protocol );
}


void cliFunc_readLEDs( char* args )
{
print( NL );
info_msg("LED State (This doesn't work yet...): ");
printInt8( USBKeys_LEDs );
}


void cliFunc_sendKeys( char* args )
{
// Copy USBKeys_ArrayCLI to USBKeys_Array
for ( uint8_t key = 0; key < USBKeys_SentCLI; ++key )
{
USBKeys_Array[key] = USBKeys_ArrayCLI[key];
}
USBKeys_Sent = USBKeys_SentCLI;

// Set modifier byte
USBKeys_Modifiers = USBKeys_ModifiersCLI;
}


void cliFunc_setKeys( char* args )
{
char* curArgs;
char* arg1Ptr;
char* arg2Ptr = args;

// Parse up to USBKeys_MaxSize args (whichever is least)
for ( USBKeys_SentCLI = 0; USBKeys_SentCLI < USBKeys_MaxSize; ++USBKeys_SentCLI )
{
curArgs = arg2Ptr;
CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );

// Stop processing args if no more are found
if ( *arg1Ptr == '\0' )
break;

// Add the USB code to be sent
USBKeys_ArrayCLI[USBKeys_SentCLI] = decToInt( arg1Ptr );
}
}


void cliFunc_setMod( char* args )
{
// Parse number from argument
// NOTE: Only first argument is used
char* arg1Ptr;
char* arg2Ptr;
CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );

USBKeys_ModifiersCLI = decToInt( arg1Ptr );
}


+ 76
- 0
Output/uartOut/output_com.h View File

@@ -0,0 +1,76 @@
/* Copyright (C) 2013-2014 by Jacob Alexander
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/

#ifndef __output_com_h
#define __output_com_h

// ----- Includes -----

// Compiler Includes
#include <stdint.h>

// Local Includes
#include <buildvars.h> // Defines USB Parameters, partially generated by CMake



// ----- Defines -----

// Indicator for other modules through USBKeys_MaxSize for how capable the USB module is when sending large number of keypresses
#define USB_MAX_KEY_SEND 6



// ----- Variables -----

// Variables used to communciate to the output module
// XXX Even if the output module is not USB, this is internally understood keymapping scheme
extern uint8_t USBKeys_Modifiers;
extern uint8_t USBKeys_Array[USB_MAX_KEY_SEND];
extern uint8_t USBKeys_Sent;
extern volatile uint8_t USBKeys_LEDs;

static const uint8_t USBKeys_MaxSize = USB_MAX_KEY_SEND;
extern volatile uint8_t USBKeys_Protocol; // 0 - Boot Mode, 1 - NKRO Mode

// Misc variables (XXX Some are only properly utilized using AVR)
extern uint8_t USBKeys_Idle_Config;
extern uint8_t USBKeys_Idle_Count;



// ----- Functions -----

void Output_setup();
void Output_send();

void Output_firmwareReload();
void Output_softReset();

// Relies on USB serial module
unsigned int Output_availablechar();

int Output_getchar();
int Output_putchar( char c );
int Output_putstr( char* str );

#endif


+ 45
- 0
Output/uartOut/setup.cmake View File

@@ -0,0 +1,45 @@
###| CMake Kiibohd Controller UART Output Module |###
#
# Written by Jacob Alexander in 2014 for the Kiibohd Controller
#
# Released into the Public Domain
#
###


###
# Module C files
#


#| AVR Compiler
if ( ${COMPILER_FAMILY} MATCHES "avr" )

set( OUTPUT_SRCS
output_com.c
avr/uart_serial.c
)

#| ARM Compiler
elseif ( ${COMPILER_FAMILY} MATCHES "arm" )

set( OUTPUT_SRCS
output_com.c
arm/uart_serial.c
)

endif ()


###
# Module Specific Options
#

###
# Compiler Family Compatibility
#
set( OutputModuleCompatibility
arm
# avr # TODO
)