void EVENT_CHANGE_LED_state (void) {
// NUM LOCK
if (current_LED_state & _BV(HIDKEYBOARD_LEDBIT_NUM_LOCK)) SET_HIGH(LED_NUMLOCK);
else SET_LOW(LED_NUMLOCK);
// CAPS LOCK
if (current_LED_state & _BV(HIDKEYBOARD_LEDBIT_CAPS_LOCK)) SET_HIGH(LED_CAPSLOCK);
else SET_LOW(LED_CAPSLOCK);
// SCROLL LOCK
if (current_LED_state & _BV(HIDKEYBOARD_LEDBIT_SCROLL_LOCK)) SET_HIGH(LED_SCROLLLOCK);
else SET_LOW(LED_SCROLLLOCK);
}
int main(void){
// The following four lines are due to my laziness about breadboard.
SET_OUTPUT(DDRD,3); // +5v
SET_HIGH(PORTD,3); // +5V
SET_OUTPUT(DDRD,4); // GND
SET_LOW(PORTD,4); // GND
// Initial values of channels.
channels[0]=25;
channels[1]=75;
channels[2]=125;
channels[3]=175;
channels[4]=225;
// Set to taste. Start with 0 initially.
pulse_fine_tune=30;
// Start.
init_transmission();
while(1){
// Changing channels
channels[0]++;
_delay_ms(100);
}
return 0;
}
void write_cube(uint8_t ebene)
{
switch (ebene)
{
case 0:
SET_LOW(TOP);SET_LOW(MIDDLE);SET_HIGH(LOW);
break;
case 1:
SET_LOW(TOP);SET_HIGH(MIDDLE);SET_LOW(LOW);
break;
case 2:
SET_HIGH(TOP);SET_LOW(MIDDLE);SET_LOW(LOW);
break;
default:return;
}
set_led(ebene);
//sleep_us(4);
//SET_LOW(TOP);SET_LOW(MIDDLE);SET_LOW(LOW);
}
void set_led (uint8_t ebene)
{
uint8_t offset = ebene*9;
uint8_t i =0;
for (i =0; i<255;i++)
{
if (led_values[0+offset]>i)
{SET_HIGH(LED1);}
else{SET_LOW(LED1);}
if (led_values[1+offset]>i)
{SET_HIGH(LED2);}
else{SET_LOW(LED2);}
if (led_values[2+offset]>i)
{SET_HIGH(LED3);}
else{SET_LOW(LED3);}
if (led_values[3+offset]>i)
{SET_HIGH(LED4);}
else{SET_LOW(LED4);}
if (led_values[4+offset]>i)
{SET_HIGH(LED5);}
else{SET_LOW(LED5);}
if (led_values[5+offset]>i)
{SET_HIGH(LED6);}
else{SET_LOW(LED6);}
if (led_values[6+offset]>i)
{SET_HIGH(LED7);}
else{SET_LOW(LED7);}
if (led_values[7+offset]>i)
{SET_HIGH(LED8);}
else{SET_LOW(LED8);}
if (led_values[8+offset]>i)
{SET_HIGH(LED9);}
else{SET_LOW(LED9);}
// __asm("nop");__asm("nop");__asm("nop");
// __asm("nop");__asm("nop");__asm("nop");
}
}
void I2cInit(uint8_t addr, uint8_t type)
{
current_address = addr;
device_type = type;
// Config IO
SET_HIGH(I2C_DATA);
SET_HIGH(I2C_CLK);
SET_RUP(I2C_DATA);
SET_RUP(I2C_CLK);
MAKE_OUTPUT(I2C_DATA);
//MAKE_INPUT(I2C_CLK);
MAKE_OUTPUT(I2C_CLK);
USICTL0 = USIPE6 + USIPE7 + USISWRST; // Port & USI mode setup
USICTL1 = USII2C + USIIE + USISTTIE; // Enable I2C mode & USI interrupts
USICKCTL = USICKPL; // Setup clock polarity
USICNT |= USIIFGCC; // Disable automatic clear control
USICTL0 &= ~USISWRST; // Enable USI
USICTL1 &= ~USIIFG; // Clear pending flag
}
void ds18b20_write_bit(uint8_t bit){
// synchronize
SET_OUTPUT(DS18B20_DDR, DS18B20_DQ);
SET_LOW(DS18B20_PORT, DS18B20_DQ);
DS18B20_PRECISE_DELAY(2);
// put bit
if(bit){
SET_HIGH(DS18B20_PORT, DS18B20_DQ);
}
DS18B20_PRECISE_DELAY(60);
// release line
SET_INPUT(DS18B20_DDR, DS18B20_DQ);
SET_LOW(DS18B20_PORT, DS18B20_DQ);
DS18B20_PRECISE_DELAY(2);
}
void main(void)
{
WD_STOP();
CAL_CLOCK();
// TimerAInit();
HardwareInit();
I2cInit(0x02, 0x00);
_EINT();
while (1)
{
//LPM0;
//_NOP();
if (GetWriteEndpoint(0))
SET_LOW(RED_LED);
else
SET_HIGH(RED_LED);
SetReadEndpoint(0, READ_IN(LP_SWITCH));
}
}
uint8_t ds18b20_read_temp(double* temp, uint8_t prec){
if(!ds18b20_set_precision(prec)){
return 0;
}
if(!ds18b20_reset()){
return 0;
}
ds18b20_write_byte(DS18B20_SKIP_ROM);
ds18b20_write_byte(DS18B20_CONVERT_T);
// provide power
SET_OUTPUT(DS18B20_DDR, DS18B20_DQ);
SET_HIGH (DS18B20_PORT, DS18B20_DQ);
for(int8_t i=0;i<(1<<prec);i++){
_delay_ms(93.75);
}
if(!ds18b20_reset()){
return 0;
}
ds18b20_write_byte(DS18B20_SKIP_ROM);
ds18b20_write_byte(DS18B20_READ_SCRATCHPAD);
uint8_t crc=0;
uint8_t l=ds18b20_read_byte();
_crc_ibutton_update(crc,l);
uint8_t h=ds18b20_read_byte();
_crc_ibutton_update(crc,h);
for(int8_t i=0;i<7;i++){
_crc_ibutton_update(crc,ds18b20_read_byte());
}
if(crc){
return 0;
}
int16_t t=(h<<8)+l;
*temp=t*0.0625;
return 1;
}
static void smc91c111_writeb(void *opaque, hwaddr offset,
uint32_t value)
{
smc91c111_state *s = (smc91c111_state *)opaque;
if (offset == 14) {
s->bank = value;
return;
}
if (offset == 15)
return;
switch (s->bank) {
case 0:
switch (offset) {
case 0: /* TCR */
SET_LOW(tcr, value);
return;
case 1:
SET_HIGH(tcr, value);
return;
case 4: /* RCR */
SET_LOW(rcr, value);
return;
case 5:
SET_HIGH(rcr, value);
if (s->rcr & RCR_SOFT_RST)
smc91c111_reset(s);
return;
case 10: case 11: /* RPCR */
/* Ignored */
return;
}
break;
case 1:
switch (offset) {
case 0: /* CONFIG */
SET_LOW(cr, value);
return;
case 1:
SET_HIGH(cr,value);
return;
case 2: case 3: /* BASE */
case 4: case 5: case 6: case 7: case 8: case 9: /* IA */
/* Not implemented. */
return;
case 10: /* Genral Purpose */
SET_LOW(gpr, value);
return;
case 11:
SET_HIGH(gpr, value);
return;
case 12: /* Control */
if (value & 1)
fprintf(stderr, "smc91c111:EEPROM store not implemented\n");
if (value & 2)
fprintf(stderr, "smc91c111:EEPROM reload not implemented\n");
value &= ~3;
SET_LOW(ctr, value);
return;
case 13:
SET_HIGH(ctr, value);
return;
}
break;
case 2:
switch (offset) {
case 0: /* MMU Command */
switch (value >> 5) {
case 0: /* no-op */
break;
case 1: /* Allocate for TX. */
s->tx_alloc = 0x80;
s->int_level &= ~INT_ALLOC;
smc91c111_update(s);
smc91c111_tx_alloc(s);
break;
case 2: /* Reset MMU. */
s->allocated = 0;
s->tx_fifo_len = 0;
s->tx_fifo_done_len = 0;
s->rx_fifo_len = 0;
s->tx_alloc = 0;
break;
case 3: /* Remove from RX FIFO. */
smc91c111_pop_rx_fifo(s);
break;
case 4: /* Remove from RX FIFO and release. */
if (s->rx_fifo_len > 0) {
smc91c111_release_packet(s, s->rx_fifo[0]);
}
smc91c111_pop_rx_fifo(s);
break;
case 5: /* Release. */
smc91c111_release_packet(s, s->packet_num);
break;
case 6: /* Add to TX FIFO. */
smc91c111_queue_tx(s, s->packet_num);
break;
case 7: /* Reset TX FIFO. */
s->tx_fifo_len = 0;
s->tx_fifo_done_len = 0;
break;
}
return;
case 1:
/* Ignore. */
return;
case 2: /* Packet Number Register */
s->packet_num = value;
return;
case 3: case 4: case 5:
/* Should be readonly, but linux writes to them anyway. Ignore. */
return;
case 6: /* Pointer */
SET_LOW(ptr, value);
return;
case 7:
SET_HIGH(ptr, value);
return;
case 8: case 9: case 10: case 11: /* Data */
{
int p;
int n;
if (s->ptr & 0x8000)
n = s->rx_fifo[0];
else
n = s->packet_num;
p = s->ptr & 0x07ff;
if (s->ptr & 0x4000) {
s->ptr = (s->ptr & 0xf800) | ((s->ptr + 1) & 0x7ff);
} else {
p += (offset & 3);
}
s->data[n][p] = value;
}
return;
case 12: /* Interrupt ACK. */
s->int_level &= ~(value & 0xd6);
if (value & INT_TX)
smc91c111_pop_tx_fifo_done(s);
smc91c111_update(s);
return;
case 13: /* Interrupt mask. */
s->int_mask = value;
smc91c111_update(s);
return;
}
break;;
case 3:
switch (offset) {
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
/* Multicast table. */
/* Not implemented. */
return;
case 8: case 9: /* Management Interface. */
/* Not implemented. */
return;
case 12: /* Early receive. */
s->ercv = value & 0x1f;
case 13:
/* Ignore. */
return;
}
break;
}
hw_error("smc91c111_write: Bad reg %d:%x\n", s->bank, (int)offset);
}
static void smc91c111_writeb(void *opaque, target_phys_addr_t offset,
uint32_t value)
{
smc91c111_state *s = (smc91c111_state *)opaque;
if (offset == 14) {
s->bank = value;
return;
}
if (offset == 15)
return;
switch (s->bank) {
case 0:
switch (offset) {
case 0:
SET_LOW(tcr, value);
return;
case 1:
SET_HIGH(tcr, value);
return;
case 4:
SET_LOW(rcr, value);
return;
case 5:
SET_HIGH(rcr, value);
if (s->rcr & RCR_SOFT_RST)
smc91c111_reset(s);
return;
case 10: case 11:
return;
}
break;
case 1:
switch (offset) {
case 0:
SET_LOW(cr, value);
return;
case 1:
SET_HIGH(cr,value);
return;
case 2: case 3:
case 4: case 5: case 6: case 7: case 8: case 9:
return;
case 10:
SET_LOW(gpr, value);
return;
case 11:
SET_HIGH(gpr, value);
return;
case 12:
if (value & 1)
fprintf(stderr, "smc91c111:EEPROM store not implemented\n");
if (value & 2)
fprintf(stderr, "smc91c111:EEPROM reload not implemented\n");
value &= ~3;
SET_LOW(ctr, value);
return;
case 13:
SET_HIGH(ctr, value);
return;
}
break;
case 2:
switch (offset) {
case 0:
switch (value >> 5) {
case 0:
break;
case 1:
s->tx_alloc = 0x80;
s->int_level &= ~INT_ALLOC;
smc91c111_update(s);
smc91c111_tx_alloc(s);
break;
case 2:
s->allocated = 0;
s->tx_fifo_len = 0;
s->tx_fifo_done_len = 0;
s->rx_fifo_len = 0;
s->tx_alloc = 0;
break;
case 3:
smc91c111_pop_rx_fifo(s);
break;
case 4:
if (s->rx_fifo_len > 0) {
smc91c111_release_packet(s, s->rx_fifo[0]);
}
smc91c111_pop_rx_fifo(s);
break;
case 5:
smc91c111_release_packet(s, s->packet_num);
break;
case 6:
smc91c111_queue_tx(s, s->packet_num);
break;
case 7:
s->tx_fifo_len = 0;
s->tx_fifo_done_len = 0;
break;
}
return;
case 1:
return;
case 2:
s->packet_num = value;
return;
case 3: case 4: case 5:
return;
case 6:
SET_LOW(ptr, value);
return;
case 7:
SET_HIGH(ptr, value);
return;
case 8: case 9: case 10: case 11:
{
int p;
int n;
if (s->ptr & 0x8000)
n = s->rx_fifo[0];
else
n = s->packet_num;
p = s->ptr & 0x07ff;
if (s->ptr & 0x4000) {
s->ptr = (s->ptr & 0xf800) | ((s->ptr + 1) & 0x7ff);
} else {
p += (offset & 3);
}
s->data[n][p] = value;
}
return;
case 12:
s->int_level &= ~(value & 0xd6);
if (value & INT_TX)
smc91c111_pop_tx_fifo_done(s);
smc91c111_update(s);
return;
case 13:
s->int_mask = value;
smc91c111_update(s);
return;
}
break;;
case 3:
switch (offset) {
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
return;
case 8: case 9:
return;
case 12:
s->ercv = value & 0x1f;
case 13:
return;
}
break;
}
hw_error("smc91c111_write: Bad reg %d:%x\n", s->bank, (int)offset);
}
/* Effects marked with 'special' are handled specifically in itrender.c */
void _dumb_it_xm_convert_effect(int effect, int value, IT_ENTRY *entry)
{
const int log = 0;
if ((!effect && !value) || (effect >= XM_N_EFFECTS))
return;
if (log) printf("%c%02X", (effect<10)?('0'+effect):('A'+effect-10), value);
/* Linearisation of the effect number... */
if (effect == XM_E) {
effect = EBASE + HIGH(value);
value = LOW(value);
} else if (effect == XM_X) {
effect = XBASE + HIGH(value);
value = LOW(value);
}
if (log) printf(" - %2d %02X", effect, value);
#if 0 // This should be handled in itrender.c!
/* update effect memory */
switch (xm_has_memory[effect]) {
case 1:
if (!value)
value = memory[entry->channel][effect];
else
memory[entry->channel][effect] = value;
break;
case 2:
if (!HIGH(value))
SET_HIGH(value, HIGH(memory[entry->channel][effect]));
else
SET_HIGH(memory[entry->channel][effect], HIGH(value));
if (!LOW(value))
SET_LOW(value, LOW(memory[entry->channel][effect]));
else
SET_LOW(memory[entry->channel][effect], LOW(value));
break;
}
#endif
/* convert effect */
entry->mask |= IT_ENTRY_EFFECT;
switch (effect) {
case XM_APPREGIO: effect = IT_ARPEGGIO; break;
case XM_VIBRATO: effect = IT_VIBRATO; break;
case XM_TONE_PORTAMENTO: effect = IT_TONE_PORTAMENTO; break; /** TODO: glissando control */
case XM_TREMOLO: effect = IT_TREMOLO; break;
case XM_SET_PANNING: effect = IT_SET_PANNING; break;
case XM_SAMPLE_OFFSET: effect = IT_SET_SAMPLE_OFFSET; break;
case XM_POSITION_JUMP: effect = IT_JUMP_TO_ORDER; break;
case XM_MULTI_RETRIG: effect = IT_RETRIGGER_NOTE; break;
case XM_TREMOR: effect = IT_TREMOR; break;
case XM_PORTAMENTO_UP: effect = IT_XM_PORTAMENTO_UP; break;
case XM_PORTAMENTO_DOWN: effect = IT_XM_PORTAMENTO_DOWN; break;
case XM_SET_CHANNEL_VOLUME: effect = IT_SET_CHANNEL_VOLUME; break; /* special */
case XM_VOLSLIDE_TONEPORTA: effect = IT_VOLSLIDE_TONEPORTA; break; /* special */
case XM_VOLSLIDE_VIBRATO: effect = IT_VOLSLIDE_VIBRATO; break; /* special */
case XM_PATTERN_BREAK:
effect = IT_BREAK_TO_ROW;
value = BCD_TO_NORMAL(value);
break;
case XM_VOLUME_SLIDE: /* special */
effect = IT_VOLUME_SLIDE;
value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value));
break;
case XM_PANNING_SLIDE:
effect = IT_PANNING_SLIDE;
value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value));
//value = HIGH(value) ? EFFECT_VALUE(0, HIGH(value)) : EFFECT_VALUE(LOW(value), 0);
break;
case XM_GLOBAL_VOLUME_SLIDE: /* special */
effect = IT_GLOBAL_VOLUME_SLIDE;
value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value));
break;
case XM_SET_TEMPO_BPM:
effect = (value < 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO);
break;
case XM_SET_GLOBAL_VOLUME:
effect = IT_SET_GLOBAL_VOLUME;
value *= 2;
break;
case XM_KEY_OFF:
effect = IT_XM_KEY_OFF;
break;
case XM_SET_ENVELOPE_POSITION:
effect = IT_XM_SET_ENVELOPE_POSITION;
break;
case EBASE+XM_E_SET_FILTER: effect = SBASE+IT_S_SET_FILTER; break;
case EBASE+XM_E_SET_GLISSANDO_CONTROL: effect = SBASE+IT_S_SET_GLISSANDO_CONTROL; break; /** TODO */
case EBASE+XM_E_SET_FINETUNE: effect = SBASE+IT_S_FINETUNE; break; /** TODO */
case EBASE+XM_E_SET_LOOP: effect = SBASE+IT_S_PATTERN_LOOP; break;
case EBASE+XM_E_NOTE_CUT: effect = SBASE+IT_S_DELAYED_NOTE_CUT; break;
case EBASE+XM_E_NOTE_DELAY: effect = SBASE+IT_S_NOTE_DELAY; break;
case EBASE+XM_E_PATTERN_DELAY: effect = SBASE+IT_S_PATTERN_DELAY; break;
case EBASE+XM_E_FINE_VOLSLIDE_UP: effect = IT_XM_FINE_VOLSLIDE_UP; break;
case EBASE+XM_E_FINE_VOLSLIDE_DOWN: effect = IT_XM_FINE_VOLSLIDE_DOWN; break;
case EBASE + XM_E_FINE_PORTA_UP:
effect = IT_PORTAMENTO_UP;
value = EFFECT_VALUE(0xF, value);
break;
case EBASE + XM_E_FINE_PORTA_DOWN:
effect = IT_PORTAMENTO_DOWN;
value = EFFECT_VALUE(0xF, value);
break;
case EBASE + XM_E_RETRIG_NOTE:
effect = IT_XM_RETRIGGER_NOTE;
value = EFFECT_VALUE(0, value);
break;
case EBASE + XM_E_SET_VIBRATO_CONTROL:
effect = SBASE+IT_S_SET_VIBRATO_WAVEFORM;
value &= ~4; /** TODO: value&4 -> don't retrig wave */
break;
case EBASE + XM_E_SET_TREMOLO_CONTROL:
effect = SBASE+IT_S_SET_TREMOLO_WAVEFORM;
value &= ~4; /** TODO: value&4 -> don't retrig wave */
break;
case XBASE + XM_X_EXTRAFINE_PORTA_UP:
effect = IT_PORTAMENTO_UP;
value = EFFECT_VALUE(0xE, value);
break;
case XBASE + XM_X_EXTRAFINE_PORTA_DOWN:
effect = IT_PORTAMENTO_DOWN;
value = EFFECT_VALUE(0xE, value);
break;
default:
/* user effect (often used in demos for synchronisation) */
entry->mask &= ~IT_ENTRY_EFFECT;
}
if (log) printf(" - %2d %02X", effect, value);
/* Inverse linearisation... */
if (effect >= SBASE && effect < SBASE+16) {
value = EFFECT_VALUE(effect-SBASE, value);
effect = IT_S;
}
if (log) printf(" - %c%02X\n", 'A'+effect-1, value);
entry->effect = effect;
entry->effectvalue = value;
}
