di0ib/controller
Archived
1
0
Fork 0
Code Releases Activity

Adding basic ISSI led brightness control capabilities

Browse Source 
- 6 modes
  * Single led: decrease, increase, set
  * All leds: decrease, increase, set
- Currently update speed limited to once every 30 ms
  * Likely an I2C driver or ISSI limitation preventing even faster updates
This commit is contained in:
Jacob Alexander 2015-10-09 22:28:31 -07:00
parent f4da2560c4
commit d9ba60b34e
2 changed files with 219 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Scan/ISSILed/capabilities.kll
View File

@ -1,10 +1,26 @@
Name = ISSILedCapabilities;
Version = 0.1;
Version = 0.2;
Author = "HaaTa (Jacob Alexander) 2015";
KLL = 0.3c;
# Modified Date
Date = 2015-08-02;
Date = 2015-10-09;
# Basic ISSI Capabilities
# Modes
# 0: Decrease single led brightness
# 1: Increase single led brightness
# 2: Set single led brightness
# 3: Decrease brightness of all leds
# 4: Increase brightness of all leds
# 5: Set brightness of all leds
# Amount -> 0 -> 255
# Index:
# Depends on keyboard. At least from from 0 -> 143 (single chip).
# Remember, it may be possible that all leds on a single chip are connected.
# So it may be possible that you may have index gaps.
# i.e. 23 then 144
ledControl => LED_control_capability( mode : 1, amount : 1, index : 2 );
# Defines available to the ISSILed sub-module

232
Scan/ISSILed/led_scan.c
View File

@ -49,6 +49,8 @@ typedef struct I2C_Buffer {
} I2C_Buffer;
typedef struct LED_Buffer {
uint8_t i2c_addr;
uint8_t reg_addr;
uint8_t buffer[LED_BufferLength];
} LED_Buffer;
@ -59,6 +61,7 @@ typedef struct LED_Buffer {
// CLI Functions
void cliFunc_i2cRecv ( char* args );
void cliFunc_i2cSend ( char* args );
void cliFunc_ledCtrl ( char* args );
void cliFunc_ledRPage( char* args );
void cliFunc_ledStart( char* args );
void cliFunc_ledTest ( char* args );
@ -77,6 +80,7 @@ uint8_t I2C_Send( uint8_t *data, uint8_t sendLen, uint8_t recvLen );
// Scan Module command dictionary
CLIDict_Entry( i2cRecv, "Send I2C sequence of bytes and expect a reply of 1 byte on the last sequence." NL "\t\tUse |'s to split sequences with a stop." );
CLIDict_Entry( i2cSend, "Send I2C sequence of bytes. Use |'s to split sequences with a stop." );
CLIDict_Entry( ledCtrl, "Basic LED control. Args: <mode> <amount> [<index>]" );
CLIDict_Entry( ledRPage, "Read the given register page." );
CLIDict_Entry( ledStart, "Disable software shutdown." );
CLIDict_Entry( ledTest, "Test out the led pages." );
@ -86,6 +90,7 @@ CLIDict_Entry( ledZero, "Zero out LED register pages (non-configuration)." )
CLIDict_Def( ledCLIDict, "ISSI LED Module Commands" ) = {
CLIDict_Item( i2cRecv ),
CLIDict_Item( i2cSend ),
CLIDict_Item( ledCtrl ),
CLIDict_Item( ledRPage ),
CLIDict_Item( ledStart ),
CLIDict_Item( ledTest ),
@ -178,7 +183,9 @@ void i2c0_isr()
}
else
{
dbug_print("Attempting to read byte");
dbug_msg("Attempting to read byte - ");
printHex( I2C_RxBuffer.sequencePos );
print( NL );
I2C0_C1 = I2C_RxBuffer.sequencePos == 1
? I2C_C1_IICEN | I2C_C1_IICIE | I2C_C1_MST | I2C_C1_TXAK // Single byte read
: I2C_C1_IICEN | I2C_C1_IICIE | I2C_C1_MST; // Multi-byte read
@ -309,34 +316,6 @@ void LED_sendPage( uint8_t *buffer, uint8_t len, uint8_t page )
}
void LED_readPage( uint8_t len, uint8_t page )
{
// Page Setup
uint8_t pageSetup[] = { 0xE8, 0xFD, page };
// Setup page
while ( I2C_Send( pageSetup, sizeof( pageSetup ), 0 ) == 0 )
delay(1);
// Register Setup
uint8_t regSetup[] = { 0xE8, 0x00 };
// Setup starting register
while ( I2C_Send( regSetup, sizeof( regSetup ), 0 ) == 0 )
delay(1);
// Register Read Command
uint8_t regReadCmd[] = { 0xE9 };
// Read each register in the page
for ( uint8_t reg = 0; reg < len; reg++ )
{
// Request register data
while ( I2C_Send( regReadCmd, sizeof( regReadCmd ), 0 ) == 0 )
delay(1);
}
}
void LED_writeReg( uint8_t reg, uint8_t val, uint8_t page )
{
// Page Setup
@ -353,6 +332,44 @@ void LED_writeReg( uint8_t reg, uint8_t val, uint8_t page )
delay(1);
}
void LED_readPage( uint8_t len, uint8_t page )
{
// Software shutdown must be enabled to read registers
LED_writeReg( 0x0A, 0x00, 0x0B );
// Page Setup
uint8_t pageSetup[] = { 0xE8, 0xFD, page };
// Setup page
while ( I2C_Send( pageSetup, sizeof( pageSetup ), 0 ) == 0 )
delay(1);
// Register Setup
uint8_t regSetup[] = { 0xE8, 0x00 };
// Read each register in the page
for ( uint8_t reg = 0; reg < len; reg++ )
{
// Update register to read
regSetup[1] = reg;
// Configure register
while ( I2C_Send( regSetup, sizeof( regSetup ), 0 ) == 0 )
delay(1);
// Register Read Command
uint8_t regReadCmd[] = { 0xE9 };
// Request single register byte
while ( I2C_Send( regReadCmd, sizeof( regReadCmd ), 1 ) == 0 )
delay(1);
dbug_print("NEXT");
}
// Disable software shutdown
LED_writeReg( 0x0A, 0x01, 0x0B );
}
// Setup
inline void LED_setup()
{
@ -619,8 +636,122 @@ inline uint8_t LED_scan()
// ----- Capabilities -----
// Basic LED Control Capability
typedef enum LedControlMode {
// Single LED Modes
LedControlMode_brightness_decrease,
LedControlMode_brightness_increase,
LedControlMode_brightness_set,
// Set all LEDs (index argument not required)
LedControlMode_brightness_decrease_all,
LedControlMode_brightness_increase_all,
LedControlMode_brightness_set_all,
} LedControlMode;
typedef struct LedControl {
LedControlMode mode; // XXX Make sure to adjust the .kll capability if this variable is larger than 8 bits
uint8_t amount;
uint16_t index;
} LedControl;
uint8_t LED_control_timer = 0;
void LED_control( LedControl *control )
{
// Only send if we've completed all other transactions
if ( I2C_TxBuffer.sequencePos > 0 )
return;
// XXX
// ISSI Chip locks up if we spam updates too quickly (might be an I2C bug on this side too -HaaTa)
// Make sure we only send an update every 30 milliseconds at most
// It may be possible to optimize speed even further, but will likely require serious time with a logic analyzer
uint8_t currentTime = (uint8_t)systick_millis_count;
int8_t compare = (int8_t)(currentTime - LED_control_timer) & 0x7F;
if ( compare < 30 )
{
return;
}
LED_control_timer = currentTime;
// Configure based upon the given mode
// TODO Handle multiple issi chips per node
// TODO Perhaps do gamma adjustment?
switch ( control->mode )
{
case LedControlMode_brightness_decrease:
// Don't worry about rolling over, the cycle is quick
LED_pageBuffer.buffer[ control->index ] -= control->amount;
break;
case LedControlMode_brightness_increase:
// Don't worry about rolling over, the cycle is quick
LED_pageBuffer.buffer[ control->index ] += control->amount;
break;
case LedControlMode_brightness_set:
LED_pageBuffer.buffer[ control->index ] = control->amount;
break;
case LedControlMode_brightness_decrease_all:
for ( uint8_t channel = 0; channel < LED_BufferLength; channel++ )
{
// Don't worry about rolling over, the cycle is quick
LED_pageBuffer.buffer[ channel ] -= control->amount;
}
break;
case LedControlMode_brightness_increase_all:
for ( uint8_t channel = 0; channel < LED_BufferLength; channel++ )
{
// Don't worry about rolling over, the cycle is quick
LED_pageBuffer.buffer[ channel ] += control->amount;
}
break;
case LedControlMode_brightness_set_all:
for ( uint8_t channel = 0; channel < LED_BufferLength; channel++ )
{
LED_pageBuffer.buffer[ channel ] = control->amount;
}
break;
}
// Sync LED buffer with ISSI chip buffer
// TODO Support multiple frames
LED_pageBuffer.i2c_addr = 0xE8; // Chip 1
LED_pageBuffer.reg_addr = 0x24; // Brightness section
LED_sendPage( (uint8_t*)&LED_pageBuffer, sizeof( LED_Buffer ), 0 );
}
void LED_control_capability( uint8_t state, uint8_t stateType, uint8_t *args )
{
// Display capability name
if ( stateType == 0xFF && state == 0xFF )
{
print("LED_control_capability(mode,amount,index)");
return;
}
// Only use capability on press
// TODO Analog
if ( stateType == 0x00 && state == 0x03 ) // Not on release
return;
// Set the input structure
LedControl *control = (LedControl*)args;
// TODO broadcast to rest of interconnect nodes if necessary
LED_control( control );
}
// ----- CLI Command Functions -----
// TODO Currently not working correctly
void cliFunc_i2cSend( char* args )
{
char* curArgs;
@ -717,6 +848,7 @@ void cliFunc_i2cRecv( char* args )
I2C_Send( buffer, bufferLen, 1 ); // Only 1 byte is ever read at a time with the ISSI chip
}
// TODO Currently not working correctly
void cliFunc_ledRPage( char* args )
{
// Parse number from argument
@ -730,13 +862,14 @@ void cliFunc_ledRPage( char* args )
if ( arg1Ptr[0] != '\0' )
{
page = (uint8_t)numToInt( arg1Ptr );
page = (uint8_t)numToInt( arg1Ptr );
}
// No \r\n by default after the command is entered
print( NL );
LED_readPage( 0xB4, page );
LED_readPage( 0x1, page );
//LED_readPage( 0xB4, page );
}
void cliFunc_ledWPage( char* args )
@ -809,3 +942,40 @@ void cliFunc_ledZero( char* args )
LED_zeroPages( 0x00, 8, 0x24, 0xB4 ); // Only PWMs
}
void cliFunc_ledCtrl( char* args )
{
char* curArgs;
char* arg1Ptr;
char* arg2Ptr = args;
LedControl control;
// First process mode
curArgs = arg2Ptr;
CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
// Stop processing args if no more are found
if ( *arg1Ptr == '\0' )
return;
control.mode = numToInt( arg1Ptr );
// Next process amount
curArgs = arg2Ptr;
CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
// Stop processing args if no more are found
if ( *arg1Ptr == '\0' )
return;
control.amount = numToInt( arg1Ptr );
// Finally process led index, if it exists
// Default to 0
curArgs = arg2Ptr;
CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
control.index = *arg1Ptr == '\0' ? 0 : numToInt( arg1Ptr );
// Process request
LED_control( &control );
}