Working support for Interconnect
- Supports up to 255 slave nodes (you'll run into ScanCode limitations before then) - Requires most recent kll compiler update - Additional debugging output and stats counters - Noise and parity checking - Fixed TxFIFO issue when sending buffers larger than the FIFO - Cleaned up defaultMap.kll - Added ScanCode caching (reduces interconnect traffic significantly) - Interconnect module code is conditionally compiled into PartialMap module if required
This commit is contained in:
Jacob Alexander
parent
ecd9923926
commit
a8caf6e515
6 changed files with 349 additions and 112 deletions
|
|
@ -58,7 +58,6 @@ set ( pathname "${PROJECT_SOURCE_DIR}/${ScanModulePath}" )
|
|||
string ( REPLACE " " ";" MAP_LIST ${BaseMap} ) # Change spaces to semicolons
|
||||
foreach ( MAP ${MAP_LIST} )
|
||||
# Only check the Scan Module for BaseMap .kll files, default to defaultMap.kll
|
||||
message("THIS -> ${pathname} ${MAP}")
|
||||
if ( NOT EXISTS ${pathname}/${MAP}.kll )
|
||||
set ( BaseMap_Args ${BaseMap_Args} ${pathname}/defaultMap.kll )
|
||||
set ( KLL_DEPENDS ${KLL_DEPENDS} ${pathname}/defaultMap.kll )
|
||||
|
|
|
|||
|
|
@ -156,6 +156,13 @@ uint16_t macroLayerIndexStackSize = 0;
|
|||
uint16_t macroResultMacroPendingList[ ResultMacroNum ] = { 0 };
|
||||
uint16_t macroResultMacroPendingListSize = 0;
|
||||
|
||||
// Interconnect ScanCode Cache
|
||||
#if defined(ConnectEnabled_define)
|
||||
// TODO This can be shrunk by the size of the max node 0 ScanCode
|
||||
TriggerGuide macroInterconnectCache[ MaxScanCode ];
|
||||
uint8_t macroInterconnectCacheSize = 0;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// ----- Capabilities -----
|
||||
|
|
@ -424,18 +431,73 @@ nat_ptr_t *Macro_layerLookup( TriggerGuide *guide, uint8_t latch_expire )
|
|||
// Otherwise no defined Trigger Macro
|
||||
erro_msg("Scan Code has no defined Trigger Macro: ");
|
||||
printHex( scanCode );
|
||||
print( NL );
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// Update the scancode using a list of TriggerGuides
|
||||
// TODO Handle led state and analog
|
||||
inline void Macro_triggerState( void *triggers, uint8_t num )
|
||||
// Add an interconnect ScanCode
|
||||
// These are handled differently (less information is sent, hold/off states must be assumed)
|
||||
#if defined(ConnectEnabled_define)
|
||||
inline void Macro_interconnectAdd( void *trigger_ptr )
|
||||
{
|
||||
// Copy each of the TriggerGuides to the TriggerListBuffer
|
||||
for ( uint8_t c = 0; c < num; c++ )
|
||||
macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = ((TriggerGuide*)triggers)[ c ];
|
||||
TriggerGuide *trigger = (TriggerGuide*)trigger_ptr;
|
||||
|
||||
// Error checking
|
||||
uint8_t error = 0;
|
||||
switch ( trigger->type )
|
||||
{
|
||||
case 0x00: // Normal key
|
||||
switch ( trigger->state )
|
||||
{
|
||||
case 0x00:
|
||||
case 0x01:
|
||||
case 0x02:
|
||||
case 0x03:
|
||||
break;
|
||||
default:
|
||||
erro_print("Invalid key state");
|
||||
error = 1;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
// Invalid TriggerGuide type
|
||||
default:
|
||||
erro_print("Invalid type");
|
||||
error = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
// Display TriggerGuide
|
||||
if ( error )
|
||||
{
|
||||
printHex( trigger->type );
|
||||
print(" ");
|
||||
printHex( trigger->state );
|
||||
print(" ");
|
||||
printHex( trigger->scanCode );
|
||||
print( NL );
|
||||
return;
|
||||
}
|
||||
|
||||
// Add trigger to the Interconnect Cache
|
||||
// During each processing loop, a scancode may be re-added depending on it's state
|
||||
for ( uint8_t c = 0; c < macroInterconnectCacheSize; c++ )
|
||||
{
|
||||
// Check if the same ScanCode
|
||||
if ( macroInterconnectCache[ c ].scanCode == trigger->scanCode )
|
||||
{
|
||||
// Update the state
|
||||
macroInterconnectCache[ c ].state = trigger->state;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// If not in the list, add it
|
||||
macroInterconnectCache[ macroInterconnectCacheSize++ ] = *trigger;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
// Update the scancode key state
|
||||
|
|
@ -447,6 +509,20 @@ inline void Macro_triggerState( void *triggers, uint8_t num )
|
|||
// * 0x04 - Unpressed (this is currently ignored)
|
||||
inline void Macro_keyState( uint8_t scanCode, uint8_t state )
|
||||
{
|
||||
#if defined(ConnectEnabled_define)
|
||||
// Only compile in if a Connect node module is available
|
||||
if ( !Connect_master )
|
||||
{
|
||||
// ScanCodes are only added if there was a state change (on/off)
|
||||
switch ( state )
|
||||
{
|
||||
case 0x00: // Off
|
||||
case 0x02: // Held
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
// Only add to macro trigger list if one of three states
|
||||
switch ( state )
|
||||
{
|
||||
|
|
@ -470,6 +546,7 @@ inline void Macro_keyState( uint8_t scanCode, uint8_t state )
|
|||
inline void Macro_analogState( uint8_t scanCode, uint8_t state )
|
||||
{
|
||||
// Only add to macro trigger list if non-off
|
||||
// TODO Handle change for interconnect
|
||||
if ( state != 0x00 )
|
||||
{
|
||||
macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = scanCode;
|
||||
|
|
@ -487,6 +564,7 @@ inline void Macro_analogState( uint8_t scanCode, uint8_t state )
|
|||
inline void Macro_ledState( uint8_t ledCode, uint8_t state )
|
||||
{
|
||||
// Only add to macro trigger list if non-off
|
||||
// TODO Handle change for interconnect
|
||||
if ( state != 0x00 )
|
||||
{
|
||||
macroTriggerListBuffer[ macroTriggerListBufferSize ].scanCode = ledCode;
|
||||
|
|
@ -907,6 +985,10 @@ inline void Macro_updateTriggerMacroPendingList()
|
|||
// Lookup Trigger List
|
||||
nat_ptr_t *triggerList = Macro_layerLookup( ¯oTriggerListBuffer[ key ], latch_expire );
|
||||
|
||||
// If there was an error during lookup, skip
|
||||
if ( triggerList == 0 )
|
||||
continue;
|
||||
|
||||
// Number of Triggers in list
|
||||
nat_ptr_t triggerListSize = triggerList[0];
|
||||
|
||||
|
|
@ -953,10 +1035,7 @@ inline void Macro_process()
|
|||
{
|
||||
if ( macroTriggerListBufferSize > 0 )
|
||||
{
|
||||
dbug_msg("Yuh");
|
||||
printHex( macroTriggerListBufferSize );
|
||||
print( NL );
|
||||
//Connect_send_ScanCode( Connect_id, macroTriggerListBuffer, macroTriggerListBufferSize );
|
||||
Connect_send_ScanCode( Connect_id, macroTriggerListBuffer, macroTriggerListBufferSize );
|
||||
macroTriggerListBufferSize = 0;
|
||||
}
|
||||
return;
|
||||
|
|
@ -967,6 +1046,41 @@ inline void Macro_process()
|
|||
if ( USBKeys_Sent != 0 )
|
||||
return;
|
||||
|
||||
#if defined(ConnectEnabled_define)
|
||||
// Check if there are any ScanCodes in the interconnect cache to process
|
||||
if ( Connect_master && macroInterconnectCacheSize > 0 )
|
||||
{
|
||||
// Iterate over all the cache ScanCodes
|
||||
uint8_t currentInterconnectCacheSize = macroInterconnectCacheSize;
|
||||
macroInterconnectCacheSize = 0;
|
||||
for ( uint8_t c = 0; c < currentInterconnectCacheSize; c++ )
|
||||
{
|
||||
// Add to the trigger list
|
||||
macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = macroInterconnectCache[ c ];
|
||||
|
||||
// TODO Handle other TriggerGuide types (e.g. analog)
|
||||
switch ( macroInterconnectCache[ c ].type )
|
||||
{
|
||||
// Normal (Press/Hold/Release)
|
||||
case 0x00:
|
||||
// Decide what to do based on the current state
|
||||
switch ( macroInterconnectCache[ c ].state )
|
||||
{
|
||||
// Re-add to interconnect cache in hold state
|
||||
case 0x01: // Press
|
||||
//case 0x02: // Hold // XXX Why does this not work? -HaaTa
|
||||
macroInterconnectCache[ c ].state = 0x02;
|
||||
macroInterconnectCache[ macroInterconnectCacheSize++ ] = macroInterconnectCache[ c ];
|
||||
break;
|
||||
case 0x03: // Remove
|
||||
break;
|
||||
// Otherwise, do not re-add
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
// If the pause flag is set, only process if the step counter is non-zero
|
||||
if ( macroPauseMode )
|
||||
{
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ void Macro_layerShift_capability( uint8_t state, uint8_t stateType, uint8_t *arg
|
|||
void Macro_analogState( uint8_t scanCode, uint8_t state );
|
||||
void Macro_keyState( uint8_t scanCode, uint8_t state );
|
||||
void Macro_ledState( uint8_t ledCode, uint8_t state );
|
||||
void Macro_triggerState( void *triggers, uint8_t num ); // triggers is of type TriggerGuide, void* for circular dependencies
|
||||
void Macro_interconnectAdd( void *trigger ); // triggers is of type TriggerGuide, void* for circular dependencies
|
||||
void Macro_process();
|
||||
void Macro_setup();
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ Author = "HaaTa (Jacob Alexander) 2014-2015";
|
|||
KLL = 0.3c;
|
||||
|
||||
# Modified Date
|
||||
Date = 2015-08-05;
|
||||
Date = 2015-08-15;
|
||||
|
||||
########
|
||||
# NOTE #
|
||||
|
|
@ -30,7 +30,6 @@ Date = 2015-08-05;
|
|||
#
|
||||
# Each LED is represented by a single bit
|
||||
# See (http://www.issi.com/WW/pdf/31FL3731C.pdf) for details
|
||||
ISSILedMask1 => ISSILedMask1_define;
|
||||
ISSILedMask1 = "
|
||||
0xFF, 0x00, /* C1-1 -> C1-16 */
|
||||
0xFF, 0x00, /* C2-1 -> C2-16 */
|
||||
|
|
@ -46,7 +45,6 @@ ISSILedMask1 = "
|
|||
# LED Brightness Override
|
||||
#
|
||||
# Each LED channel supports 256 levels (8-bit control)
|
||||
ISSILedBrightness1 => ISSILedBrightness1_define;
|
||||
ISSILedBrightness1 = "
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* C1-1 -> C1-16 */
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* C2-1 -> C2-16 */
|
||||
|
|
|
|||
|
|
@ -33,11 +33,20 @@
|
|||
|
||||
// ----- Macros -----
|
||||
|
||||
#define UART_Master 1
|
||||
#define UART_Slave 0
|
||||
#define uart_lock_m( uartNum ) uart##uartNum##_lock
|
||||
#define uart_buffer_items_m( uartNum ) uart##uartNum##_buffer_items
|
||||
#define uart_buffer_m( uartNum ) uart##uartNum##_buffer
|
||||
#define uart_buffer_head_m( uartNum ) uart##uartNum##_buffer_head
|
||||
#define uart_buffer_tail_m( uartNum ) uart##uartNum##_buffer_tail
|
||||
#define uart_tx_status_m( uartNum ) uart##uartNum##_tx_status
|
||||
|
||||
// Macro for adding to each uart Tx ring buffer
|
||||
#define uart_addTxBuffer( uartNum ) \
|
||||
case uartNum: \
|
||||
/* Delay UART copy until there's some space left */ \
|
||||
while ( uart##uartNum##_buffer_items + count > uart_buffer_size ) \
|
||||
while ( uart_buffer_items_m( uartNum ) + count > uart_buffer_size ) \
|
||||
{ \
|
||||
warn_msg("Too much data to send on UART0, waiting..."); \
|
||||
delay( 1 ); \
|
||||
|
|
@ -50,14 +59,14 @@ case uartNum: \
|
|||
printHex( buffer[ c ] ); \
|
||||
print( " +" #uartNum NL ); \
|
||||
} \
|
||||
uart##uartNum##_buffer[ uart##uartNum##_buffer_tail++ ] = buffer[ c ]; \
|
||||
uart##uartNum##_buffer_items++; \
|
||||
if ( uart##uartNum##_buffer_tail >= uart_buffer_size ) \
|
||||
uart##uartNum##_buffer_tail = 0; \
|
||||
if ( uart##uartNum##_buffer_head == uart##uartNum##_buffer_tail ) \
|
||||
uart##uartNum##_buffer_head++; \
|
||||
if ( uart##uartNum##_buffer_head >= uart_buffer_size ) \
|
||||
uart##uartNum##_buffer_head = 0; \
|
||||
uart_buffer_m( uartNum )[ uart_buffer_tail_m( uartNum )++ ] = buffer[ c ]; \
|
||||
uart_buffer_items_m( uartNum )++; \
|
||||
if ( uart_buffer_tail_m( uartNum ) >= uart_buffer_size ) \
|
||||
uart_buffer_tail_m( uartNum ) = 0; \
|
||||
if ( uart_buffer_head_m( uartNum ) == uart_buffer_tail_m( uartNum ) ) \
|
||||
uart_buffer_head_m( uartNum )++; \
|
||||
if ( uart_buffer_head_m( uartNum ) >= uart_buffer_size ) \
|
||||
uart_buffer_head_m( uartNum ) = 0; \
|
||||
} \
|
||||
break
|
||||
|
||||
|
|
@ -67,7 +76,21 @@ case uartNum: \
|
|||
uint8_t fifoSize = ( ( UART##uartNum##_PFIFO & UART_PFIFO_TXFIFOSIZE ) >> 2 ); \
|
||||
if ( fifoSize == 0 ) \
|
||||
fifoSize = 1; \
|
||||
while ( UART##uartNum##_TCFIFO < fifoSize ) \
|
||||
if ( Connect_debug ) \
|
||||
{ \
|
||||
print( "TxFIFO " #uartNum " - " ); \
|
||||
printHex( fifoSize ); \
|
||||
print("/"); \
|
||||
printHex( UART##uartNum##_TCFIFO ); \
|
||||
print("/"); \
|
||||
printHex( uart##uartNum##_buffer_items ); \
|
||||
print( NL ); \
|
||||
} \
|
||||
/* XXX Doesn't work well */ \
|
||||
/* while ( UART##uartNum##_TCFIFO < fifoSize ) */ \
|
||||
/* More reliable, albeit slower */ \
|
||||
fifoSize -= UART##uartNum##_TCFIFO; \
|
||||
while ( fifoSize-- != 0 ) \
|
||||
{ \
|
||||
if ( uart##uartNum##_buffer_items == 0 ) \
|
||||
break; \
|
||||
|
|
@ -93,6 +116,9 @@ case uartNum: \
|
|||
/* Process each byte in the UART buffer */ \
|
||||
while ( available-- > 0 ) \
|
||||
{ \
|
||||
/* First check if there was noise or Parity issues with current byte */ \
|
||||
uint8_t err_status = UART##uartNum##_ED; \
|
||||
/* Read byte from Rx FIFO */ \
|
||||
uint8_t byteRead = UART##uartNum##_D; \
|
||||
if ( Connect_debug ) \
|
||||
{ \
|
||||
|
|
@ -101,19 +127,38 @@ case uartNum: \
|
|||
printInt8( available ); \
|
||||
print(") <-"); \
|
||||
} \
|
||||
/* Check error status */ \
|
||||
if ( err_status & 0x80 ) \
|
||||
{ \
|
||||
print(" NOISY "); \
|
||||
} \
|
||||
if ( err_status & 0x40 ) \
|
||||
{ \
|
||||
print(" PARITY ERR "); \
|
||||
} \
|
||||
/* Ignore current byte if there was an error */ \
|
||||
if ( err_status ) \
|
||||
{ \
|
||||
uart##uartNum##_rx_status = UARTStatus_Wait; \
|
||||
if ( Connect_debug ) \
|
||||
{ \
|
||||
print( NL ); \
|
||||
} \
|
||||
continue; \
|
||||
} \
|
||||
switch ( uart##uartNum##_rx_status ) \
|
||||
{ \
|
||||
case UARTStatus_Wait: \
|
||||
if ( Connect_debug ) \
|
||||
{ \
|
||||
print(" SYN "); \
|
||||
print(" Wait "); \
|
||||
} \
|
||||
uart##uartNum##_rx_status = byteRead == 0x16 ? UARTStatus_SYN : UARTStatus_Wait; \
|
||||
break; \
|
||||
case UARTStatus_SYN: \
|
||||
if ( Connect_debug ) \
|
||||
{ \
|
||||
print(" SOH "); \
|
||||
print(" SYN "); \
|
||||
} \
|
||||
uart##uartNum##_rx_status = byteRead == 0x01 ? UARTStatus_SOH : UARTStatus_Wait; \
|
||||
break; \
|
||||
|
|
@ -121,10 +166,17 @@ case uartNum: \
|
|||
{ \
|
||||
if ( Connect_debug ) \
|
||||
{ \
|
||||
print(" CMD "); \
|
||||
print(" SOH "); \
|
||||
} \
|
||||
/* Check if this is actually a reserved CMD 0x16 */ \
|
||||
if ( byteRead == Command_SYN ) \
|
||||
{ \
|
||||
uart##uartNum##_rx_status = UARTStatus_SYN; \
|
||||
break; \
|
||||
} \
|
||||
/* Otherwise process the command */ \
|
||||
uint8_t byte = byteRead; \
|
||||
if ( byte <= Animation ) \
|
||||
if ( byte < Command_TOP ) \
|
||||
{ \
|
||||
uart##uartNum##_rx_status = UARTStatus_Command; \
|
||||
uart##uartNum##_rx_command = byte; \
|
||||
|
|
@ -144,6 +196,7 @@ case uartNum: \
|
|||
if ( Connect_debug ) \
|
||||
{ \
|
||||
print(" ### "); \
|
||||
printHex( uart##uartNum##_rx_command ); \
|
||||
} \
|
||||
break; \
|
||||
} \
|
||||
|
|
@ -177,13 +230,32 @@ case uartNum: \
|
|||
// Macros for locking/unlock Tx buffers
|
||||
#define uart_lockTx( uartNum ) \
|
||||
{ \
|
||||
while ( uart##uartNum##_tx_status == UARTStatus_Wait ); \
|
||||
uart##uartNum##_tx_status = UARTStatus_Wait; \
|
||||
/* First, secure place in line for the resource */ \
|
||||
while ( uart_lock_m( uartNum ) ); \
|
||||
uart_lock_m( uartNum ) = 1; \
|
||||
/* Next, wait unit the UART is ready */ \
|
||||
while ( uart_tx_status_m( uartNum ) != UARTStatus_Ready ); \
|
||||
uart_tx_status_m( uartNum ) = UARTStatus_Wait; \
|
||||
}
|
||||
|
||||
#define uart_lockBothTx( uartNum1, uartNum2 ) \
|
||||
{ \
|
||||
/* First, secure place in line for the resource */ \
|
||||
while ( uart_lock_m( uartNum1 ) || uart_lock_m( uartNum2 ) ); \
|
||||
uart_lock_m( uartNum1 ) = 1; \
|
||||
uart_lock_m( uartNum2 ) = 1; \
|
||||
/* Next, wait unit the UARTs are ready */ \
|
||||
while ( uart_tx_status_m( uartNum1 ) != UARTStatus_Ready || uart_tx_status_m( uartNum2 ) != UARTStatus_Ready ); \
|
||||
uart_tx_status_m( uartNum1 ) = UARTStatus_Wait; \
|
||||
uart_tx_status_m( uartNum2 ) = UARTStatus_Wait; \
|
||||
}
|
||||
|
||||
#define uart_unlockTx( uartNum ) \
|
||||
{ \
|
||||
uart##uartNum##_tx_status = UARTStatus_Ready; \
|
||||
/* Ready the UART */ \
|
||||
uart_tx_status_m( uartNum ) = UARTStatus_Ready; \
|
||||
/* Unlock the resource */ \
|
||||
uart_lock_m( uartNum ) = 0; \
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -192,6 +264,7 @@ case uartNum: \
|
|||
|
||||
// CLI Functions
|
||||
void cliFunc_connectCmd ( char *args );
|
||||
void cliFunc_connectDbg ( char *args );
|
||||
void cliFunc_connectIdl ( char *args );
|
||||
void cliFunc_connectLst ( char *args );
|
||||
void cliFunc_connectMst ( char *args );
|
||||
|
|
@ -204,6 +277,7 @@ void cliFunc_connectSts ( char *args );
|
|||
|
||||
// Connect Module command dictionary
|
||||
CLIDict_Entry( connectCmd, "Sends a command via UART Connect, first arg is which uart, next arg is the command, rest are the arguments." );
|
||||
CLIDict_Entry( connectDbg, "Toggle UARTConnect debug mode." );
|
||||
CLIDict_Entry( connectIdl, "Sends N number of Idle commands, 2 is the default value, and should be sufficient in most cases." );
|
||||
CLIDict_Entry( connectLst, "Lists available UARTConnect commands and index id" );
|
||||
CLIDict_Entry( connectMst, "Sets the device as master. Use argument of s to set as slave." );
|
||||
|
|
@ -211,6 +285,7 @@ CLIDict_Entry( connectRst, "Resets both Rx and Tx connect buffers and state var
|
|||
CLIDict_Entry( connectSts, "UARTConnect status." );
|
||||
CLIDict_Def( uartConnectCLIDict, "UARTConnect Module Commands" ) = {
|
||||
CLIDict_Item( connectCmd ),
|
||||
CLIDict_Item( connectDbg ),
|
||||
CLIDict_Item( connectIdl ),
|
||||
CLIDict_Item( connectLst ),
|
||||
CLIDict_Item( connectMst ),
|
||||
|
|
@ -223,11 +298,13 @@ CLIDict_Def( uartConnectCLIDict, "UARTConnect Module Commands" ) = {
|
|||
// -- Connect Device Id Variables --
|
||||
uint8_t Connect_id = 255; // Invalid, unset
|
||||
uint8_t Connect_master = 0;
|
||||
uint8_t Connect_maxId = 0;
|
||||
|
||||
|
||||
// -- Control Variables --
|
||||
uint32_t Connect_lastCheck = 0; // Cable Check scheduler
|
||||
uint8_t Connect_debug = 0; // Set 1 for debug
|
||||
uint8_t Connect_override = 0; // Prevents master from automatically being set
|
||||
|
||||
|
||||
// -- Rx Status Variables --
|
||||
|
|
@ -238,6 +315,8 @@ volatile uint16_t uart0_rx_bytes_waiting;
|
|||
volatile uint16_t uart1_rx_bytes_waiting;
|
||||
volatile Command uart0_rx_command;
|
||||
volatile Command uart1_rx_command;
|
||||
volatile uint8_t uart0_lock;
|
||||
volatile uint8_t uart1_lock;
|
||||
|
||||
|
||||
// -- Tx Status Variables --
|
||||
|
|
@ -275,8 +354,8 @@ void Connect_addBytes( uint8_t *buffer, uint8_t count, uint8_t uart )
|
|||
// Choose the uart
|
||||
switch ( uart )
|
||||
{
|
||||
uart_addTxBuffer( 0 );
|
||||
uart_addTxBuffer( 1 );
|
||||
uart_addTxBuffer( UART_Master );
|
||||
uart_addTxBuffer( UART_Slave );
|
||||
default:
|
||||
erro_msg("Invalid UART to send from...");
|
||||
break;
|
||||
|
|
@ -290,74 +369,73 @@ void Connect_addBytes( uint8_t *buffer, uint8_t count, uint8_t uart )
|
|||
void Connect_send_CableCheck( uint8_t patternLen )
|
||||
{
|
||||
// Wait until the Tx buffers are ready, then lock them
|
||||
uart_lockTx( 0 );
|
||||
uart_lockTx( 1 );
|
||||
uart_lockBothTx( UART_Master, UART_Slave );
|
||||
|
||||
// Prepare header
|
||||
uint8_t header[] = { 0x16, 0x01, CableCheck, patternLen };
|
||||
|
||||
// Send header
|
||||
Connect_addBytes( header, sizeof( header ), 1 ); // Master
|
||||
Connect_addBytes( header, sizeof( header ), 0 ); // Slave
|
||||
Connect_addBytes( header, sizeof( header ), UART_Master );
|
||||
Connect_addBytes( header, sizeof( header ), UART_Slave );
|
||||
|
||||
// Send 0xD2 (11010010) for each argument
|
||||
uint8_t value = 0xD2;
|
||||
for ( uint8_t c = 0; c < patternLen; c++ )
|
||||
{
|
||||
Connect_addBytes( &value, 1, 1 ); // Master
|
||||
Connect_addBytes( &value, 1, 0 ); // Slave
|
||||
Connect_addBytes( &value, 1, UART_Master );
|
||||
Connect_addBytes( &value, 1, UART_Slave );
|
||||
}
|
||||
|
||||
// Release Tx buffers
|
||||
uart_unlockTx( 0 );
|
||||
uart_unlockTx( 1 );
|
||||
uart_unlockTx( UART_Master );
|
||||
uart_unlockTx( UART_Slave );
|
||||
}
|
||||
|
||||
void Connect_send_IdRequest()
|
||||
{
|
||||
// Lock master bound Tx
|
||||
uart_lockTx( 1 );
|
||||
uart_lockTx( UART_Master );
|
||||
|
||||
// Prepare header
|
||||
uint8_t header[] = { 0x16, 0x01, IdRequest };
|
||||
|
||||
// Send header
|
||||
Connect_addBytes( header, sizeof( header ), 1 ); // Master
|
||||
Connect_addBytes( header, sizeof( header ), UART_Master );
|
||||
|
||||
// Unlock Tx
|
||||
uart_unlockTx( 1 );
|
||||
uart_unlockTx( UART_Master );
|
||||
}
|
||||
|
||||
// id is the value the next slave should enumerate as
|
||||
void Connect_send_IdEnumeration( uint8_t id )
|
||||
{
|
||||
// Lock slave bound Tx
|
||||
uart_lockTx( 0 );
|
||||
uart_lockTx( UART_Slave );
|
||||
|
||||
// Prepare header
|
||||
uint8_t header[] = { 0x16, 0x01, IdEnumeration, id };
|
||||
|
||||
// Send header
|
||||
Connect_addBytes( header, sizeof( header ), 0 ); // Slave
|
||||
Connect_addBytes( header, sizeof( header ), UART_Slave );
|
||||
|
||||
// Unlock Tx
|
||||
uart_unlockTx( 0 );
|
||||
uart_unlockTx( UART_Slave );
|
||||
}
|
||||
|
||||
// id is the currently assigned id to the slave
|
||||
void Connect_send_IdReport( uint8_t id )
|
||||
{
|
||||
// Lock master bound Tx
|
||||
uart_lockTx( 1 );
|
||||
uart_lockTx( UART_Master );
|
||||
|
||||
// Prepare header
|
||||
uint8_t header[] = { 0x16, 0x01, IdReport, id };
|
||||
|
||||
// Send header
|
||||
Connect_addBytes( header, sizeof( header ), 1 ); // Master
|
||||
Connect_addBytes( header, sizeof( header ), UART_Master );
|
||||
|
||||
// Unlock Tx
|
||||
uart_unlockTx( 1 );
|
||||
uart_unlockTx( UART_Master );
|
||||
}
|
||||
|
||||
// id is the currently assigned id to the slave
|
||||
|
|
@ -366,19 +444,19 @@ void Connect_send_IdReport( uint8_t id )
|
|||
void Connect_send_ScanCode( uint8_t id, TriggerGuide *scanCodeStateList, uint8_t numScanCodes )
|
||||
{
|
||||
// Lock master bound Tx
|
||||
uart_lockTx( 1 );
|
||||
uart_lockTx( UART_Master );
|
||||
|
||||
// Prepare header
|
||||
uint8_t header[] = { 0x16, 0x01, ScanCode, id, numScanCodes };
|
||||
|
||||
// Send header
|
||||
Connect_addBytes( header, sizeof( header ), 1 ); // Master
|
||||
Connect_addBytes( header, sizeof( header ), UART_Master );
|
||||
|
||||
// Send each of the scan codes
|
||||
Connect_addBytes( (uint8_t*)scanCodeStateList, numScanCodes * TriggerGuideSize, 1 ); // Master
|
||||
Connect_addBytes( (uint8_t*)scanCodeStateList, numScanCodes * TriggerGuideSize, UART_Master );
|
||||
|
||||
// Unlock Tx
|
||||
uart_unlockTx( 1 );
|
||||
uart_unlockTx( UART_Master );
|
||||
}
|
||||
|
||||
// id is the currently assigned id to the slave
|
||||
|
|
@ -387,38 +465,37 @@ void Connect_send_ScanCode( uint8_t id, TriggerGuide *scanCodeStateList, uint8_t
|
|||
void Connect_send_Animation( uint8_t id, uint8_t *paramList, uint8_t numParams )
|
||||
{
|
||||
// Lock slave bound Tx
|
||||
uart_lockTx( 0 );
|
||||
uart_lockTx( UART_Slave );
|
||||
|
||||
// Prepare header
|
||||
uint8_t header[] = { 0x16, 0x01, Animation, id, numParams };
|
||||
|
||||
// Send header
|
||||
Connect_addBytes( header, sizeof( header ), 0 ); // Slave
|
||||
Connect_addBytes( header, sizeof( header ), UART_Slave );
|
||||
|
||||
// Send each of the scan codes
|
||||
Connect_addBytes( paramList, numParams, 0 ); // Slave
|
||||
Connect_addBytes( paramList, numParams, UART_Slave );
|
||||
|
||||
// Unlock Tx
|
||||
uart_unlockTx( 0 );
|
||||
uart_unlockTx( UART_Slave );
|
||||
}
|
||||
|
||||
void Connect_send_Idle( uint8_t num )
|
||||
{
|
||||
// Wait until the Tx buffers are ready, then lock them
|
||||
uart_lockTx( 0 );
|
||||
uart_lockTx( 1 );
|
||||
uart_lockBothTx( UART_Slave, UART_Master );
|
||||
|
||||
// Send n number of idles to reset link status (if in a bad state)
|
||||
uint8_t value = 0x16;
|
||||
for ( uint8_t c = 0; c < num; c++ )
|
||||
{
|
||||
Connect_addBytes( &value, 1, 1 ); // Master
|
||||
Connect_addBytes( &value, 1, 0 ); // Slave
|
||||
Connect_addBytes( &value, 1, UART_Master );
|
||||
Connect_addBytes( &value, 1, UART_Slave );
|
||||
}
|
||||
|
||||
// Release Tx buffers
|
||||
uart_unlockTx( 0 );
|
||||
uart_unlockTx( 1 );
|
||||
uart_unlockTx( UART_Master );
|
||||
uart_unlockTx( UART_Slave );
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -427,10 +504,12 @@ void Connect_send_Idle( uint8_t num )
|
|||
// - Cable Check variables -
|
||||
uint32_t Connect_cableFaultsMaster = 0;
|
||||
uint32_t Connect_cableFaultsSlave = 0;
|
||||
uint32_t Connect_cableChecksMaster = 0;
|
||||
uint32_t Connect_cableChecksSlave = 0;
|
||||
uint8_t Connect_cableOkMaster = 0;
|
||||
uint8_t Connect_cableOkSlave = 0;
|
||||
|
||||
uint8_t Connect_receive_CableCheck( uint8_t byte, uint16_t *pending_bytes, uint8_t to_slave )
|
||||
uint8_t Connect_receive_CableCheck( uint8_t byte, uint16_t *pending_bytes, uint8_t uart_num )
|
||||
{
|
||||
// Check if this is the first byte
|
||||
if ( *pending_bytes == 0xFFFF )
|
||||
|
|
@ -457,36 +536,48 @@ uint8_t Connect_receive_CableCheck( uint8_t byte, uint16_t *pending_bytes, uint8
|
|||
warn_print("Cable Fault!");
|
||||
|
||||
// Check which side of the chain
|
||||
if ( to_slave )
|
||||
{
|
||||
Connect_cableFaultsMaster++;
|
||||
Connect_cableOkMaster = 0;
|
||||
print(" Master ");
|
||||
}
|
||||
else
|
||||
if ( uart_num == UART_Slave )
|
||||
{
|
||||
Connect_cableFaultsSlave++;
|
||||
Connect_cableOkSlave = 0;
|
||||
print(" Slave ");
|
||||
}
|
||||
else
|
||||
{
|
||||
Connect_cableFaultsMaster++;
|
||||
Connect_cableOkMaster = 0;
|
||||
print(" Master ");
|
||||
}
|
||||
printHex( byte );
|
||||
print( NL );
|
||||
|
||||
// Signal that the command should wait for a SYN again
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Check which side of the chain
|
||||
if ( uart_num == UART_Slave )
|
||||
{
|
||||
Connect_cableChecksSlave++;
|
||||
}
|
||||
else
|
||||
{
|
||||
Connect_cableChecksMaster++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If cable check was successful, set cable ok
|
||||
if ( *pending_bytes == 0 )
|
||||
{
|
||||
if ( to_slave )
|
||||
if ( uart_num == UART_Slave )
|
||||
{
|
||||
Connect_cableOkMaster = 1;
|
||||
Connect_cableOkSlave = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
Connect_cableOkSlave = 1;
|
||||
Connect_cableOkMaster = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -503,11 +594,11 @@ uint8_t Connect_receive_CableCheck( uint8_t byte, uint16_t *pending_bytes, uint8
|
|||
return *pending_bytes == 0 ? 1 : 0;
|
||||
}
|
||||
|
||||
uint8_t Connect_receive_IdRequest( uint8_t byte, uint16_t *pending_bytes, uint8_t to_slave )
|
||||
uint8_t Connect_receive_IdRequest( uint8_t byte, uint16_t *pending_bytes, uint8_t uart_num )
|
||||
{
|
||||
dbug_print("IdRequest");
|
||||
// Check the directionality
|
||||
if ( to_slave )
|
||||
if ( uart_num == UART_Master )
|
||||
{
|
||||
erro_print("Invalid IdRequest direction...");
|
||||
}
|
||||
|
|
@ -528,11 +619,11 @@ uint8_t Connect_receive_IdRequest( uint8_t byte, uint16_t *pending_bytes, uint8_
|
|||
return 1;
|
||||
}
|
||||
|
||||
uint8_t Connect_receive_IdEnumeration( uint8_t id, uint16_t *pending_bytes, uint8_t to_slave )
|
||||
uint8_t Connect_receive_IdEnumeration( uint8_t id, uint16_t *pending_bytes, uint8_t uart_num )
|
||||
{
|
||||
dbug_print("IdEnumeration");
|
||||
// Check the directionality
|
||||
if ( !to_slave )
|
||||
if ( uart_num == UART_Slave )
|
||||
{
|
||||
erro_print("Invalid IdEnumeration direction...");
|
||||
}
|
||||
|
|
@ -552,11 +643,11 @@ uint8_t Connect_receive_IdEnumeration( uint8_t id, uint16_t *pending_bytes, uint
|
|||
return 1;
|
||||
}
|
||||
|
||||
uint8_t Connect_receive_IdReport( uint8_t id, uint16_t *pending_bytes, uint8_t to_slave )
|
||||
uint8_t Connect_receive_IdReport( uint8_t id, uint16_t *pending_bytes, uint8_t uart_num )
|
||||
{
|
||||
dbug_print("IdReport");
|
||||
// Check the directionality
|
||||
if ( to_slave )
|
||||
if ( uart_num == UART_Master )
|
||||
{
|
||||
erro_print("Invalid IdRequest direction...");
|
||||
}
|
||||
|
|
@ -564,10 +655,13 @@ uint8_t Connect_receive_IdReport( uint8_t id, uint16_t *pending_bytes, uint8_t t
|
|||
// Track Id response if master
|
||||
if ( Connect_master )
|
||||
{
|
||||
// TODO, setup id's
|
||||
info_msg("Id Reported: ");
|
||||
printHex( id );
|
||||
print( NL );
|
||||
|
||||
// Check if this is the highest ID
|
||||
if ( id > Connect_maxId )
|
||||
Connect_maxId = id;
|
||||
return 1;
|
||||
}
|
||||
// Propagate id if yet another slave
|
||||
|
|
@ -584,11 +678,10 @@ TriggerGuide Connect_receive_ScanCodeBuffer;
|
|||
uint8_t Connect_receive_ScanCodeBufferPos;
|
||||
uint8_t Connect_receive_ScanCodeDeviceId;
|
||||
|
||||
uint8_t Connect_receive_ScanCode( uint8_t byte, uint16_t *pending_bytes, uint8_t to_slave )
|
||||
uint8_t Connect_receive_ScanCode( uint8_t byte, uint16_t *pending_bytes, uint8_t uart_num )
|
||||
{
|
||||
dbug_print("ScanCode");
|
||||
// Check the directionality
|
||||
if ( to_slave )
|
||||
if ( uart_num == UART_Master )
|
||||
{
|
||||
erro_print("Invalid ScanCode direction...");
|
||||
}
|
||||
|
|
@ -612,30 +705,41 @@ uint8_t Connect_receive_ScanCode( uint8_t byte, uint16_t *pending_bytes, uint8_t
|
|||
|
||||
// Reset the BufferPos if higher than sizeof TriggerGuide
|
||||
// And send the TriggerGuide to the Macro Module
|
||||
if ( Connect_receive_ScanCodeBufferPos > sizeof( TriggerGuide ) )
|
||||
if ( Connect_receive_ScanCodeBufferPos >= sizeof( TriggerGuide ) )
|
||||
{
|
||||
Connect_receive_ScanCodeBufferPos = 0;
|
||||
|
||||
// Adjust ScanCode offset
|
||||
if ( Connect_receive_ScanCodeDeviceId > 0 )
|
||||
{
|
||||
// Check if this node is too large
|
||||
if ( Connect_receive_ScanCodeDeviceId >= InterconnectNodeMax )
|
||||
{
|
||||
warn_msg("Not enough interconnect layout nodes configured: ");
|
||||
printHex( Connect_receive_ScanCodeDeviceId );
|
||||
print( NL );
|
||||
break;
|
||||
}
|
||||
|
||||
// This variable is in generatedKeymaps.h
|
||||
extern uint8_t InterconnectOffsetList[];
|
||||
Connect_receive_ScanCodeBuffer.scanCode = Connect_receive_ScanCodeBuffer.scanCode + InterconnectOffsetList[ Connect_receive_ScanCodeDeviceId - 1 ];
|
||||
}
|
||||
|
||||
// ScanCode receive debug
|
||||
dbug_print("");
|
||||
if ( Connect_debug )
|
||||
{
|
||||
dbug_msg("");
|
||||
printHex( Connect_receive_ScanCodeBuffer.type );
|
||||
print(" ");
|
||||
printHex( Connect_receive_ScanCodeBuffer.state );
|
||||
print(" ");
|
||||
printHex( Connect_receive_ScanCodeBuffer.scanCode );
|
||||
print( NL );
|
||||
}
|
||||
|
||||
// Send ScanCode to macro module
|
||||
// TODO
|
||||
//Macro_triggerState( &Connect_receive_ScanCodeBuffer, 1 );
|
||||
Macro_interconnectAdd( &Connect_receive_ScanCodeBuffer );
|
||||
}
|
||||
|
||||
break;
|
||||
|
|
@ -649,11 +753,11 @@ uint8_t Connect_receive_ScanCode( uint8_t byte, uint16_t *pending_bytes, uint8_t
|
|||
Connect_receive_ScanCodeDeviceId = byte;
|
||||
|
||||
// Lock the master Tx buffer
|
||||
uart_lockTx( 1 );
|
||||
uart_lockTx( UART_Master );
|
||||
|
||||
// Send header + Id byte
|
||||
uint8_t header[] = { 0x16, 0x01, ScanCode, byte };
|
||||
Connect_addBytes( header, sizeof( header ), 1 ); // Master
|
||||
Connect_addBytes( header, sizeof( header ), UART_Master );
|
||||
break;
|
||||
}
|
||||
case 0xFFFE: // Number of TriggerGuides in bytes
|
||||
|
|
@ -661,16 +765,16 @@ uint8_t Connect_receive_ScanCode( uint8_t byte, uint16_t *pending_bytes, uint8_t
|
|||
Connect_receive_ScanCodeBufferPos = 0;
|
||||
|
||||
// Pass through byte
|
||||
Connect_addBytes( &byte, 1, 1 ); // Master
|
||||
Connect_addBytes( &byte, 1, UART_Master );
|
||||
break;
|
||||
|
||||
default:
|
||||
// Pass through byte
|
||||
Connect_addBytes( &byte, 1, 1 ); // Master
|
||||
Connect_addBytes( &byte, 1, UART_Master );
|
||||
|
||||
// Unlock Tx Buffer after sending last byte
|
||||
if ( *pending_bytes == 0 )
|
||||
uart_unlockTx( 1 );
|
||||
uart_unlockTx( UART_Master );
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -678,7 +782,7 @@ uint8_t Connect_receive_ScanCode( uint8_t byte, uint16_t *pending_bytes, uint8_t
|
|||
return *pending_bytes == 0 ? 1 : 0;
|
||||
}
|
||||
|
||||
uint8_t Connect_receive_Animation( uint8_t byte, uint16_t *pending_bytes, uint8_t to_slave )
|
||||
uint8_t Connect_receive_Animation( uint8_t byte, uint16_t *pending_bytes, uint8_t uart_num )
|
||||
{
|
||||
dbug_print("Animation");
|
||||
return 1;
|
||||
|
|
@ -730,6 +834,8 @@ void Connect_reset()
|
|||
uart1_rx_status = UARTStatus_Wait;
|
||||
uart0_rx_bytes_waiting = 0;
|
||||
uart1_rx_bytes_waiting = 0;
|
||||
uart0_lock = 0;
|
||||
uart1_lock = 0;
|
||||
|
||||
// Tx Status Variables
|
||||
uart0_tx_status = UARTStatus_Ready;
|
||||
|
|
@ -790,7 +896,6 @@ void Connect_setup( uint8_t master )
|
|||
UART1_C1 = UART_C1_M | UART_C1_PE | UART_C1_ILT;
|
||||
|
||||
// Number of bytes in FIFO before TX Interrupt
|
||||
// TODO Set 0
|
||||
UART0_TWFIFO = 1;
|
||||
UART1_TWFIFO = 1;
|
||||
|
||||
|
|
@ -838,7 +943,7 @@ void Connect_scan()
|
|||
{
|
||||
// Check if initially configured as a slave and usb comes up
|
||||
// Then reconfigure as a master
|
||||
if ( !Connect_master && Output_Available )
|
||||
if ( !Connect_master && Output_Available && !Connect_override )
|
||||
{
|
||||
Connect_setup( Output_Available );
|
||||
}
|
||||
|
|
@ -934,6 +1039,13 @@ void cliFunc_connectCmd( char* args )
|
|||
}
|
||||
}
|
||||
|
||||
void cliFunc_connectDbg( char* args )
|
||||
{
|
||||
print( NL );
|
||||
info_msg("Connect Debug Mode Toggle");
|
||||
Connect_debug = !Connect_debug;
|
||||
}
|
||||
|
||||
void cliFunc_connectIdl( char* args )
|
||||
{
|
||||
// Parse number from argument
|
||||
|
|
@ -988,8 +1100,15 @@ void cliFunc_connectMst( char* args )
|
|||
|
||||
print( NL );
|
||||
|
||||
// Set override
|
||||
Connect_override = 1;
|
||||
|
||||
switch ( arg1Ptr[0] )
|
||||
{
|
||||
// Disable override
|
||||
case 'd':
|
||||
case 'D':
|
||||
Connect_override = 0;
|
||||
case 's':
|
||||
case 'S':
|
||||
info_msg("Setting device as slave.");
|
||||
|
|
@ -1025,10 +1144,14 @@ void cliFunc_connectSts( char* args )
|
|||
print( Connect_master ? "Master" : "Slave" );
|
||||
print( NL "Device Id:\t" );
|
||||
printHex( Connect_id );
|
||||
print( NL "Max Id:\t" );
|
||||
printHex( Connect_maxId );
|
||||
print( NL "Master <=" NL "\tStatus:\t");
|
||||
printHex( Connect_cableOkMaster );
|
||||
print( NL "\tFaults:\t");
|
||||
printHex( Connect_cableFaultsMaster );
|
||||
printHex32( Connect_cableFaultsMaster );
|
||||
print("/");
|
||||
printHex32( Connect_cableChecksMaster );
|
||||
print( NL "\tRx:\t");
|
||||
printHex( uart1_rx_status );
|
||||
print( NL "\tTx:\t");
|
||||
|
|
@ -1036,7 +1159,9 @@ void cliFunc_connectSts( char* args )
|
|||
print( NL "Slave <=" NL "\tStatus:\t");
|
||||
printHex( Connect_cableOkSlave );
|
||||
print( NL "\tFaults:\t");
|
||||
printHex( Connect_cableFaultsSlave );
|
||||
printHex32( Connect_cableFaultsSlave );
|
||||
print("/");
|
||||
printHex32( Connect_cableChecksSlave );
|
||||
print( NL "\tRx:\t");
|
||||
printHex( uart0_rx_status );
|
||||
print( NL "\tTx:\t");
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@ typedef enum Command {
|
|||
RemoteInput, // Remote command to send to a given node's debug cli
|
||||
|
||||
Command_TOP, // Enum bounds
|
||||
Command_SYN = 0x16, // Reserved for error handling
|
||||
} Command;
|
||||
|
||||
// UART Rx/Tx Status
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue