void processTWI( void )
{
uint8_t b,p1,p2;
b = usiTwiReceiveByte();
switch (b) {
case 0x81: // set slave address
p1 = usiTwiReceiveByte();
if(p1 < 128) // Address is 7 bit
{
eeprom_update_byte(&b_slave_address, p1);
usiTwiSlaveInit(eeprom_read_byte(&b_slave_address));
}
break;
case 0x82: // clear led
led_clear();
break;
case 0x83: // set led brightness, p1=led, p2=brightness
p1 = usiTwiReceiveByte();
p2 = usiTwiReceiveByte();
set_led_pulse(p1,0); // Turn off pulsing
set_brightness(p1,p2);
break;
case 0x84: // Set to pulse led, p1=led, p2 = (0 = OFF, 1 = ON)
set_led_pulse(usiTwiReceiveByte(),usiTwiReceiveByte());
break;
case 0x85: // Dim up/down led to specific value, p1=led, p2=value to dim to
dim_led(usiTwiReceiveByte(),usiTwiReceiveByte());
break;
case 0x86: // get firmware revision
usiTwiTransmitByte(FIRMWARE_REVISION);
break;
case 0x90: // get keyUp Event
usiTwiTransmitByte(getKeyUp());
break;
case 0x91: // get KeyDown Event
usiTwiTransmitByte(getKeyDown());
break;
case 0x92: // set keyrepeat
set_keyrepeat(usiTwiReceiveByte(),usiTwiReceiveByte());
break;
case 0xFE: // reset to known state
led_clear();
button_init();
flushTwiBuffers();
break;
case 0xFF: // flush the bus
break;
default:
break;
}
}
/*
* Get ADC Data and put it into output fifo with device ID
*
* input: none
*
* output: data into Rx_buf
*
*/
void dev_adc_1_get_data()
{
// uint8_t data;
usiTwiTransmitByte( DEV_ADC_1_ID );
// data = dev_adc_1_H + test++;
usiTwiTransmitByte( dev_adc_1_H );
// usiTwiTransmitByte( data );
// data = dev_adc_1_L + test++;
usiTwiTransmitByte( dev_adc_1_L );
// usiTwiTransmitByte( data );
// usiTwiTransmitByte( test++ );
// usiTwiTransmitByte( test++ );
return;
}
int main(void)
{
//********** Initiate variables *********
adcArray[0] = 4; // Device ID for Flexiforce 301A
adcArray[1] = 0;
adcArray[2] = 0;
//********** Initialization **********
usiTwiSlaveInit( slaveadress ); // Enable TWI I2C and set static slave address
InitADC(); // Init ADC
sei(); // Init global interupt
//********** Main functions **********
while(1)
{
if(!ADC_flag)
{
adcArray[1] = ADCL;
adcArray[2] = ADCH;
ADC_flag = 0;
}
while(!usiTwiDataInReceiveBuffer()); // Wait for master
usiTwiTransmitByte(adcArray[0]); // Send sensor ID
while(!usiTwiDataInReceiveBuffer()); // Wait for master
usiTwiTransmitByte(adcArray[1]); // Send low part of sensordata
while(!usiTwiDataInReceiveBuffer()); // Wait for master
usiTwiTransmitByte(adcArray[2]); // Send high part of sensordata
}
return 0;
}
int main(void)
{
uint8_t count;
count = 0;
usiTwiSlaveInit( SLAVE_ADRS ); // Initialize TWI hardware for Slave operation.
sei(); // Enable interrupts.
usiTwiSlaveEnable(); // Enable the TWI interface to receive data.
while(1)
{
if( !usiTwiDataInTransmitBuffer() )
{
usiTwiTransmitByte( count ); // stuff count into TxBuf[]
++count; // inc for next value.
}
}
}
void USI_TWI_S::send(uint8_t data){ // send it back to master
usiTwiTransmitByte(data);
}
//
// called infinitely in main() along with handle_script()
//
static void handle_i2c(void)
{
//uint8_t tmp;
//int8_t baddr;
if( usiTwiDataInReceiveBuffer() ) {
cmd = usiTwiReceiveByte();
myaddr = slaveAddressMatched;
slaveAddressMatched = -1;
switch(cmd) {
case('@'): // set addr to send to {'@',freemaddr,i2caddr,0}
case('#'): // script cmd: set ir pwm frequency & duty cycle
case('%'): // IR light on/off
case('&'): // packet_wait_millis, wait_after
read_i2c_vals(3); // all these take 3 args
handle_script_cmd();
break;
case('$'): // script cmd: send ir code
read_i2c_vals(5);
if( cmdargs[0] == 0 ) { // FIXME: 0 == sony command type
//uint32_t data = *(cmdargs+1);
IRsend_sendSony( (cmdargs[1]<<8) | cmdargs[2],12 ); // FIXME
}
else if( cmdargs[0] == 1 ) { // 1 == RC5
IRsend_sendSony( (cmdargs[1]<<8) | cmdargs[2],12 ); // FIXME
}
break;
case('!'): // send arbitrary i2c data
read_i2c_vals(8);
IRsend_sendSonyData64bit( cmdargs );
//fanfare(3, 100 );
break;
case('^'): // set colorspot {'^', 13, r,g,b }
read_i2c_vals(4);
cmdargs[6] = cmdargs[3]; // b
cmdargs[5] = cmdargs[2]; // g
cmdargs[4] = cmdargs[1]; // r
cmdargs[3] = cmdargs[0]; // pos
cmdargs[2] = 0xfe; // 0xfe == set colorspot
cmdargs[1] = freem_addr;
cmdargs[0] = 0x55; // magic start byte
cmdargs[7] = compute_checksum(cmdargs,7);
//IRsend_sendSonyData64bit( cmdargs );
ir_queue( cmdargs );
break;
case('*'): // play colorspot {'*', 13, 0, 0 }
read_i2c_vals(3);
handle_script_cmd();
/*
tmp = blinkm_addr; // FIXME: bit of a hack here
blinkm_addr = 0xfd; // 0xfd == play colorspot
cmd = cmdargs[0];
cmdargs[0] = cmdargs[1];
cmdargs[1] = cmdargs[2];
//cmdargs[2] = cmdargs[3]; // no, only have 3 args to use
handle_script_cmd();
blinkm_addr = tmp;
*/
break;
// stolen from blinkm.c
case('a'): // get address
usiTwiTransmitByte( eeprom_read_byte(&ee_i2c_addr) );
break;
case('A'): // set address
cmdargs[0] = cmdargs[1] = cmdargs[2] = cmdargs[3] = 0;
read_i2c_vals(4); // address, 0xD0, 0x0D, address
if( cmdargs[0] != 0 && cmdargs[0] == cmdargs[3] &&
cmdargs[1] == 0xD0 && cmdargs[2] == 0x0D ) { //
eeprom_write_byte( &ee_i2c_addr, cmdargs[0] ); // write address
i2c_addrs[0] = cmdargs[0];
for( uint8_t i = 1; i<slaveAddressesCount; i++ ) {
i2c_addrs[i] = i2c_addrs[0] + i;
}
usiTwiSlaveInit( i2c_addrs ); // re-init
_delay_ms(5); // wait a bit so the USI can reset
}
break;
case('Z'): // return protocol version
usiTwiTransmitByte( BLINKM_PROTOCOL_VERSION_MAJOR );
usiTwiTransmitByte( BLINKM_PROTOCOL_VERSION_MINOR );
break;
case('P'): // play ctrlm script
read_i2c_vals(3);
play_script(0, cmdargs[1], cmdargs[2]);
break;
// blinkm cmds
case('n'): // script cmd: set rgb color now
case('c'): // script cmd: fade to rgb color
case('C'): // script cmd: fade to random rgb color
case('h'): // script cmd: fade to hsv color
case('H'): // script cmd: fade to random hsv color
case('p'): // script cmd: play script
read_i2c_vals(3);
handle_script_cmd();
break;
case('f'):
case('t'):
read_i2c_vals(1);
handle_script_cmd();
case('o'):
case('O'):
handle_script_cmd();
break;
//
// new v2 commands
//
case('l'): // return script len & reps
read_i2c_vals(1); // script_id
if( cmdargs[0] == 0 ) { // eeprom script
usiTwiTransmitByte( eeprom_read_byte( &ee_script.len ) );
usiTwiTransmitByte( eeprom_read_byte( &ee_script.reps ) );
}
else {
//script* s=(script*)pgm_read_word(&(fl_scripts[cmdargs[1]-1]));
//curr_script_len = pgm_read_byte( (&s->len) );
//curr_script_reps = pgm_read_byte( (&s->reps) );
}
case('i'): // return current input values
//usiTwiTransmitByte( myaddr ); // FIXME FIXME TEST
usiTwiTransmitByte( timesOver ); // FIXME FIXME TEST
//usiTwiTransmitByte( inputs[0] );
usiTwiTransmitByte( inputs[1] );
usiTwiTransmitByte( inputs[2] );
usiTwiTransmitByte( inputs[3] );
break;
} // switch(cmd)
} // if(usiTwi)
}
int main(void)
{
uint8_t data;
uint8_t blinkDelay = BLINK_DELAY;
bool blinkToggle = false;
pState = PS_IDLE;
mCounter = 0;
mod_led_init();
st_init_tmr0();
usiTwiSlaveInit( SLAVE_ADRS ); // Initialize USI hardware for I2C Slave operation.
mod_led_toggle(4);
sei(); // Enable interrupts.
usitwiSlaveEnable(); // Enable the USI interface to receive data.
mod_led_toggle(3);
// A simple loop to check for I2C Commands.
// A state variable is needed to process multi-byte messages.
// 01, 05 are Writes. 04 is a Read.
while(1)
{
#if 0
// Heart Beat LED
if( GPIOR0 & (1<<DEV_1MS_TIC) )
{
GPIOR0 &= ~(1<<DEV_1MS_TIC);
if(--blinkDelay == 0) {
blinkDelay = BLINK_DELAY;
if(blinkToggle) {
mod_led_on();
} else {
mod_led_off();
}
blinkToggle = !blinkToggle;
}
}
#endif
//mod_led_toggle(2);
if( usiTwiDataInReceiveBuffer() )
{
data = usiTwiReceiveByte();
switch (pState)
{
case PS_IDLE:
// Process new message
++mCounter;
switch(data)
{
case 01:
// Writing to the Control Register
pState = PS_CMD01_0; // next byte is Control byte
break;
case 04:
// Reading counter
usiTwiTransmitByte(mCounter); // load up data for following read.
break;
case 05:
// Writing to LED
pState = PS_CMD05_0; // next byte controls LED
break;
default:
break; // Ignore unknown command.
}
break;
case PS_CMD01_0:
// Process Control byte. b0=1 clears counter.
if( (data & 0x01) == 0x01 )
{
mCounter = 0;
}
pState = PS_IDLE; // reset for next message
break;
case PS_CMD05_0:
// Change LED state
// If the data is 00, then turn OFF the LED. Turn it ON for any non-zero value.
// NOTE: LED hardware is wired 'Active LOW'.
if( data == 0)
{
mod_led_off(); // Turn LED OFF.
}
else
{
mod_led_on(); // Turn LED ON.
}
pState = PS_IDLE; // reset for next message
break;
default:
pState = PS_IDLE; // ERROR, restore to know state
break;
}
}
}
}
