void SSP_isr(VOID) { state = i2c_isr_state (); IF ( (state == 0) || (state == 0x80)) i2c_read () ; IF (state >= 0x80) i2c_write (buffer[0]) ; else IF (state > 0)
void ssp_interupt () { led_spp_on; state = i2c_isr_state(); if(state < 0x80) //Master is sending data { if(state == 0) { buffer_pos = i2c_read(); } if(state == 1) //First received byte is address { buffer_pos = i2c_read(); } if(state == 2) //Second received byte is data { buffer_pos = i2c_read(); } } if(state == 0x80) //Master is requesting data { i2c_write (buffer_adc); } led_spp_off; }
void SSP_isr(void) { state = i2c_isr_state(); if((state== 0 ) || (state== 0x80)){ i2c_read(); } if(state >= 0x80){ //response } else if(state > 0){ buffer[state - 1] = i2c_read(); if(buffer[state - 1]=='\0') { hasCommand= TRUE; } } }
void ssp_interrupt() { int state; int inByte; // Output of i2c_isr_state() // // 0 - Address match received with R/W bit clear, perform i2c_read( ) // to read the I2C address. // 1-0x7F - Master has written data; i2c_read() will immediately return the data // 0x80 - Address match received with R/W bit set; perform i2c_read( ) to read // the I2C address, and use i2c_write( ) to pre-load the transmit buffer // for the next transaction (next I2C read performed by master will read // this byte). // 0x81-0xFF - Transmission completed and acknowledged; respond with i2c_write() to // pre-load the transmit buffer for the next transation (the next I2C // read performed by master will read this byte). state = i2c_isr_state(); ////////////////////////////////////////////////////////////////// // Address match with bit 0 clear (master write to slave) ////////////////////////////////////////////////////////////////// if (state == 0) { i2c_read(); // flush the device address in the rx buffer // Fix any errors in the I2C communication // if wrong state -> there must have been an error in the i2c comm if (slaveState1 != READY_FOR_ADDRESS) { // clear the error flag registers and re-enable the i2c bus SSPEN = 0; // disable i2c SSPOV = 0; // clear the receive overflow flag WCOL = 0; // clear the write collision flag SSPEN = 1; // re-enable i2c slaveState1 = READY_FOR_ADDRESS; // reset the state return; } // if no error -> move forward to the next state slaveState1=READY_FOR_CMD; //device moves into command mode } ////////////////////////////////////////////////////////////////// // a byte has been recieved from the Master ////////////////////////////////////////////////////////////////// else if (state < 0x80) { inByte=i2c_read(); switch (slaveState1) { case READY_FOR_CMD: switch (inByte) { case CMD_RECEIVE_A_BYTE_FROM_MASTER: slaveState1=READY_FOR_NUMBER; break; case CMD_SEND_TWO_BYTES_TO_MASTER: slaveState1=READY_TO_SEND; break; // reset the state if received an // unknown command default: slaveState1 = READY_FOR_ADDRESS; break; } break; case READY_FOR_NUMBER: valFromMaster=inByte; slaveState1=READY_FOR_ADDRESS; break; // reset the state if unknown state is detected default: slaveState1=READY_FOR_ADDRESS; break; } } ////////////////////////////////////////////////////////////////// // Address match with bit 0 set (slave write to master) ////////////////////////////////////////////////////////////////// else if (state == 0x80) { i2c_read(); // flush the address byte if (slaveState1 == READY_TO_SEND) { i2c_write(0x61); slaveState1=READY_TO_SEND_BYTE_2; } } ////////////////////////////////////////////////////////////////// // Master is ready to receive the next byte from slave ////////////////////////////////////////////////////////////////// else if (state > 0x80) { if (slaveState1 == READY_TO_SEND_BYTE_2) { //i2c_write(222); char buf [32]; memset(buf, 0, 32); vTemp = vTemp/100; vHumid = vHumid/100; //PC changed /100 from 1000 1:21 vSonic = vSonic/16; vSonic = vSonic/100; vSonic = 6-vSonic; //vTemp = 3.2; sprintf(buf, "T=%.1f&H=%.1f&S=%.2f", vTemp, vHumid, vSonic); int len = 20;//strlen(buf); int i; for(i = 0; i < len; i += 1) { i2c_write(buf[i]); } i2c_write('\0'); i2c_write('\0'); slaveState1=READY_FOR_ADDRESS; sentCount++; } } }
void ssp2_isr(void) { int state; state = i2c_isr_state(I2C_Slave); if((state==0) || (state== 0x80)) //I2C address byte read and ignore i2c_read(I2C_Slave); if(state==1){ //if state == 1 then this is the word address (Host Command written) rcv_buffer[state - 1] = i2c_read(I2C_Slave); switch(rcv_buffer[0]){ case 0x01: //Hard reset of board. Power cycle all except CMC microController { printf("\r\n3715 I2C Hard Reset 0x%x\n", rcv_buffer[0]); SystemReset(1); break; } case 0x02: //Back end reset of 3219 and 3218 { printf("\r\n3715 I2C Reset Back End 0x%x\n", rcv_buffer[0]); output_low(RST3219n); delay_ms(200); output_high(RST3219n); break; } default: //Host issued command that doesn't exist..do nothing { break; } } } if(state >= 0x80){ if (I2CReadEnable) { //This is disabled at the moment. 3715 not supporting clock stretching so read function not working. switch(rcv_buffer[0]){ case 0xA1: //Master asking for status data...write out status byte LSB first (2 bytes) { i2c_write(I2C_Slave, ((StatByte >> ((state-0x80)*8)) & 0xff)); break; } case 0xA2: //Master asking for temp data...write out status byte LSB first (7 bytes) { i2c_write(I2C_Slave,temp_buffer[state-0x80]); //This will write out 7 bytes. Temp format is signed 8 bits break; } case 0xA3: //Master asking for voltage data...write out status byte LSB first (13 bytes) { i2c_write(I2C_Slave,voltage_buffer[state-0x80]); //This will write out 13 bytes. Voltage format is .02V/LSB break; } case 0xA4: //Master asking for current data...write out status byte LSB first (13 bytes) { i2c_write(I2C_Slave,current_buffer[state-0x80]); //This will write out 13 bytes of the voltage across the lower fet. break; //User must know RDSon to calculate current..very low accuracy } default: { i2c_write(I2C_Slave, 0x00); //default response. Host asked for command that doesn't exist break; } } } else printf("\r\nI2C read from micro disabled"); }