| //PIC Projects/PICX_16F1829_Controller/CPS.c |
|---|
| 0,0 → 1,129 |
| #include "defines.h" |
| #include "CPS.h" |
| static CPS_DATA *cps_data_p; |
| void CPS_Init(CPS_DATA* data) { |
| cps_data_p = data; |
| for (uint8_t i = 0; i < 4; i++) { |
| cps_data_p->btn_pressed[i] = 0; |
| cps_data_p->btn_last_value[i] = 0; |
| cps_data_p->btn_avg_value[i] = 0; |
| cps_data_p->btn_pct_value[i] = 0; |
| } |
| cps_data_p->channels[0] = 8; |
| cps_data_p->channels[1] = 9; |
| /* Initialize FVR for the upper threshold (Ref+) */ |
| FVRCONbits.CDAFVR = 0b01; // Gain of 1x (1.024V) |
| FVRCONbits.FVREN = 1; // Enable FVR module |
| /* Initialize DAC for the lower threshold (Ref-) to Vss */ |
| DACCON0bits.DACEN = 0; // Disable DAC |
| DACCON0bits.DACLPS = 0; // Negative reference source selected |
| DACCON0bits.DACOE = 0; // Output not routed to DACOUT pin |
| DACCON0bits.DACPSS = 0b00; // Vss used as positive source |
| // DACCON0bits.DACNSS = 0; // Vss used as negative source |
| // Output voltage formula: |
| // V_out = ((V_source+ - V_source-) * (DACR / 32)) + V_source- |
| DACCON1bits.DACR = 0b00000; // Voltage output set to 0v |
| // /* Initialize DAC for the lower threshold (Ref-) to variable setting */ |
| // DACCON0bits.DACEN = 1; // Enable DAC |
| // DACCON0bits.DACLPS = 1; // Positive reference source selected |
| // DACCON0bits.DACOE = 0; // Output not routed to DACOUT pin |
| // DACCON0bits.DACPSS = 0b10; // FVR buffer2 used as positive source |
| //// DACCON0bits.DACNSS = 0; // Vss used as negative source |
| // // Output voltage formula: |
| // // V_out = ((V_source+ - V_source-) * (DACR / 32)) + V_source- |
| // DACCON1bits.DACR = 0b10000; // Voltage output set to 0.512v |
| /* Initialize Timer 0 */ |
| OPTION_REGbits.TMR0CS = 0; // Clock source is FOSC/4 |
| OPTION_REGbits.PSA = 0; // Prescaler enabled |
| OPTION_REGbits.PS = 0b110; // Prescaler of 1:128 |
| /* Initialize Timer 1 */ |
| T1CONbits.TMR1CS = 0b11; // Clock source is Capacitive Sensing Oscillator |
| T1CONbits.T1CKPS = 0b00; // 1:1 Prescale value |
| T1GCONbits.TMR1GE = 1; // Counting is controlled by the gate function |
| T1GCONbits.T1GPOL = 1; // Gate is active high |
| T1GCONbits.T1GTM = 1; // Gate toggle mode is enabled |
| T1GCONbits.T1GSPM = 0; // Gate single-pulse mode is disabled |
| T1GCONbits.T1GSS = 0b01; // Gate source is Timer 0 overflow |
| T1CONbits.TMR1ON = 1; // Enables timer 1 |
| /* Initialize CPS Module */ |
| CPSCON0bits.CPSRM = 1; // DAC and FVR used for Vref- and Vref+ |
| CPSCON0bits.CPSRNG = 0b11; // Osc in high range (100uA) |
| CPSCON0bits.T0XCS = 0; // Timer 0 clock runs at FOSC/4 |
| CPSCON1 = cps_data_p->channels[0]; |
| cps_data_p->channel = 0; |
| CPSCON0bits.CPSON = 1; // CPS module is enabled |
| /* Initialize timer interrupts and clear timers */ |
| INTCONbits.TMR0IE = 1; // Timer 0 interrupt enabled |
| PIE1bits.TMR1IE = 0; // Timer 1 interrupt disabled |
| CPS_Reset(); |
| } |
| void CPS_Timer_0_Interrupt_Handler() { |
| uint16_t value = TMR1; |
| int32_t percent; |
| if (value < 10) { |
| return; |
| } |
| // Calculate percentage change |
| percent = (int32_t)cps_data_p->btn_avg_value[cps_data_p->channel]-(int32_t)value; |
| if (percent < 0) |
| percent = 0; |
| else { |
| percent *= 100; |
| percent /= cps_data_p->btn_avg_value[cps_data_p->channel]; |
| } |
| cps_data_p->btn_last_value[cps_data_p->channel] = value; |
| cps_data_p->btn_pct_value[cps_data_p->channel] = percent; |
| if (percent < CPS_PCT_OFF) { |
| // Calculate average |
| cps_data_p->btn_avg_value[cps_data_p->channel] += |
| // ((int32_t)value - (int32_t)cps_data_p->btn_avg_value[cps_data_p->channel])/CPS_AVG_COUNT; |
| ((int32_t)value - (int32_t)cps_data_p->btn_avg_value[cps_data_p->channel]) >> 4; |
| // Set flag to indicate that button is not pressed |
| cps_data_p->btn_pressed[cps_data_p->channel] = 0; |
| } else if (percent > CPS_PCT_ON) { |
| // Set flag to indicate that button was pressed |
| cps_data_p->btn_pressed[cps_data_p->channel] = 1; |
| } |
| cps_data_p->channel = cps_data_p->channel + 1; |
| if (cps_data_p->channel == CPS_NUM_CHANNELS) |
| cps_data_p->channel = 0; |
| CPSCON1 = cps_data_p->channels[cps_data_p->channel]; |
| CPS_Reset(); |
| } |
| void CPS_Reset() { |
| TMR1 = 0; |
| TMR0 = 0; |
| } |
| void CPS_Enable() { |
| INTCONbits.TMR0IE = 1; // Timer 0 interrupt enabled |
| T1CONbits.TMR1ON = 1; |
| CPSCON0bits.CPSON = 1; |
| CPS_Reset(); |
| } |
| void CPS_Disable() { |
| INTCONbits.TMR0IE = 0; |
| CPSCON0bits.CPSON = 0; |
| T1CONbits.TMR1ON = 0; |
| } |
| //PIC Projects/PICX_16F1829_Controller/CPS.h |
|---|
| 0,0 → 1,31 |
| #ifndef CPS_H |
| #define CPS_H |
| // Size of rolling average buffer |
| #define CPS_AVG_COUNT 16 |
| // Number of capacitance button inputs |
| #define CPS_NUM_CHANNELS 2 |
| // Value of capacitance change to register button press |
| #define CPS_PCT_ON 40 |
| #define CPS_PCT_OFF 40 |
| typedef struct { |
| uint8_t channel; |
| uint8_t channels[CPS_NUM_CHANNELS]; |
| uint8_t btn_pressed[CPS_NUM_CHANNELS]; |
| uint16_t btn_last_value[CPS_NUM_CHANNELS]; |
| uint16_t btn_avg_value[CPS_NUM_CHANNELS]; |
| uint8_t btn_pct_value[CPS_NUM_CHANNELS]; |
| } CPS_DATA; |
| void CPS_Init(CPS_DATA *data); |
| void CPS_Timer_0_Interrupt_Handler(void); |
| void CPS_Reset(void); |
| void CPS_Enable(void); |
| void CPS_Disable(void); |
| #endif |
| //PIC Projects/PICX_16F1829_Controller/I2C1.c |
|---|
| 0,0 → 1,544 |
| #include "defines.h" |
| #include "I2C1.h" |
| static I2C1_DATA *i2c_data_p; |
| extern BTN_STATUS btns; |
| // Set up the data structures for the base_I2C.code |
| // Should be called once before any i2c routines are called |
| void I2C1_Init(I2C1_DATA *data) { |
| i2c_data_p = data; |
| i2c_data_p->buffer_in_len = 0; |
| i2c_data_p->buffer_in_len_tmp = 0; |
| i2c_data_p->buffer_in_read_ind = 0; |
| i2c_data_p->buffer_in_write_ind = 0; |
| i2c_data_p->buffer_out_ind = 0; |
| i2c_data_p->buffer_out_len = 0; |
| i2c_data_p->operating_mode = 0; |
| i2c_data_p->operating_state = I2C_IDLE; |
| i2c_data_p->return_status = 0; |
| i2c_data_p->slave_in_last_byte = 0; |
| i2c_data_p->slave_sending_data = 0; |
| i2c_data_p->master_dest_addr = 0; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| // Enable I2C interrupt |
| PIE1bits.SSP1IE = 1; |
| } |
| // Setup the PIC to operate as a master. |
| void I2C1_Configure_Master(uint8_t speed) { |
| i2c_data_p->operating_mode = I2C_MODE_MASTER; |
| I2C_1_CLK_TRIS = 1; |
| I2C_1_DAT_TRIS = 1; |
| SSP1STAT = 0x0; |
| SSP1CON1 = 0x0; |
| SSP1CON2 = 0x0; |
| SSP1CON3 = 0x0; |
| SSP1CON1bits.SSPM = 0x8; // I2C Master Mode |
| if (speed == 0x01) { |
| SSP1ADD = 0x13; // Operate at 400KHz (32MHz) |
| SSP1STATbits.SMP = 1; // Disable Slew Rate Control |
| } else if (speed == 0x02) { |
| SSP1ADD = 0x07; // Operate at 1Mhz (32Mhz) |
| SSP1STATbits.SMP = 1; // Disable Slew Rate Control |
| } else { |
| SSP1ADD = 0x4F; // Operate at 100KHz (32MHz) |
| SSP1STATbits.SMP = 0; // Enable Slew Rate Control |
| } |
| SSP1CON1bits.SSPEN = 1; // Enable MSSP1 Module |
| } |
| // Sends length number of bytes in msg to specified address (no R/W bit) |
| void I2C1_Master_Send(uint8_t address, uint8_t length, uint8_t *msg) { |
| uint8_t i; |
| if (length == 0) |
| return; |
| // Copy message to send into buffer and save length/address |
| for (i = 0; i < length; i++) { |
| i2c_data_p->buffer_in[i] = msg[i]; |
| } |
| i2c_data_p->buffer_in_len = length; |
| i2c_data_p->master_dest_addr = address; |
| i2c_data_p->buffer_in_read_ind = 0; |
| i2c_data_p->buffer_in_write_ind = 0; |
| // Change status to 'next' operation |
| i2c_data_p->operating_state = I2C_SEND_ADDR; |
| i2c_data_p->master_status = I2C_MASTER_SEND; |
| // Generate start condition |
| SSP1CON2bits.SEN = 1; |
| } |
| // Reads length number of bytes from address (no R/W bit) |
| void I2C1_Master_Recv(uint8_t address, uint8_t length) { |
| if (length == 0) |
| return; |
| // Save length and address to get data from |
| i2c_data_p->buffer_in_len = length; |
| i2c_data_p->master_dest_addr = address; |
| i2c_data_p->buffer_in_read_ind = 0; |
| i2c_data_p->buffer_in_write_ind = 0; |
| // Change status to 'next' operation |
| i2c_data_p->operating_state = I2C_SEND_ADDR; |
| i2c_data_p->master_status = I2C_MASTER_RECV; |
| // Generate start condition |
| SSP1CON2bits.SEN = 1; |
| } |
| // Writes msg to address then reads length number of bytes from address |
| void I2C1_Master_Restart(uint8_t address, uint8_t msg, uint8_t length) { |
| uint8_t c; |
| if (length == 0) { |
| c = msg; |
| I2C1_Master_Send(address, 1, &c); |
| return; |
| } |
| // Save length and address to get data from |
| i2c_data_p->buffer_in[0] = msg; |
| i2c_data_p->buffer_in_len = length; |
| i2c_data_p->master_dest_addr = address; |
| i2c_data_p->buffer_in_read_ind = 0; |
| i2c_data_p->buffer_in_write_ind = 0; |
| // Change status to 'next' operation |
| i2c_data_p->operating_state = I2C_SEND_ADDR; |
| i2c_data_p->master_status = I2C_MASTER_RESTART; |
| // Generate start condition |
| SSP1CON2bits.SEN = 1; |
| } |
| // Setup the PIC to operate as a slave. The address must not include the R/W bit |
| void I2C1_Configure_Slave(uint8_t addr) { |
| i2c_data_p->operating_mode = I2C_MODE_SLAVE; |
| // Ensure the two lines are set for input (we are a slave) |
| I2C_1_CLK_TRIS = 1; |
| I2C_1_DAT_TRIS = 1; |
| SSP1ADD = addr << 1; // Set the slave address |
| SSP1STAT = 0x0; |
| SSP1CON1 = 0x0; |
| SSP1CON2 = 0x0; |
| SSP1CON3 = 0x0; |
| SSP1CON1bits.SSPM = 0x6; // Enable Slave 7-bit address |
| SSP1STATbits.SMP = 1; // Slew Off |
| SSP1CON2bits.SEN = 1; // Enable clock-stretching |
| SSP1CON3bits.PCIE = 1; // Interrupt on stop condition |
| SSP1CON3bits.SCIE = 0; // Disable interrupt on start condition |
| SSP1CON1bits.SSPEN = 1; // Enable MSSP1 Module |
| } |
| void I2C1_Interrupt_Handler() { |
| // Call interrupt depending on which mode we are operating in |
| if (i2c_data_p->operating_mode == I2C_MODE_MASTER) { |
| I2C1_Interrupt_Master(); |
| } else if (i2c_data_p->operating_mode == I2C_MODE_SLAVE) { |
| I2C1_Interrupt_Slave(); |
| } |
| } |
| // An internal subroutine used in the master version of the i2c_interrupt_handler |
| void I2C1_Interrupt_Master() { |
| // If we are in the middle of sending data |
| if (i2c_data_p->master_status == I2C_MASTER_SEND) { |
| switch (i2c_data_p->operating_state) { |
| case I2C_IDLE: |
| break; |
| case I2C_SEND_ADDR: |
| // Send the address with read bit set |
| i2c_data_p->operating_state = I2C_CHECK_ACK_SEND; |
| SSP1BUF = (i2c_data_p->master_dest_addr << 1) | 0x0; |
| break; |
| case I2C_CHECK_ACK_SEND: |
| // Check if ACK is received or not |
| if (!SSP1CON2bits.ACKSTAT) { |
| // If an ACK is received, send next byte of data |
| if (i2c_data_p->buffer_in_read_ind < i2c_data_p->buffer_in_len) { |
| SSP1BUF = i2c_data_p->buffer_in[i2c_data_p->buffer_in_read_ind]; |
| i2c_data_p->buffer_in_read_ind++; |
| } else { |
| // If no more data is to be sent, send stop bit |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_SEND_OK; |
| } |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_SEND_FAIL; |
| } |
| break; |
| } |
| // If we are in the middle of receiving data |
| } else if (i2c_data_p->master_status == I2C_MASTER_RECV) { |
| switch (i2c_data_p->operating_state) { |
| case I2C_IDLE: |
| break; |
| case I2C_SEND_ADDR: |
| // Send address with write bit set |
| i2c_data_p->operating_state = I2C_CHECK_ACK_RECV; |
| uint8_t tmp = (i2c_data_p->master_dest_addr << 1); |
| tmp |= 0x01; |
| SSP1BUF = tmp; |
| break; |
| case I2C_CHECK_ACK_RECV: |
| // Check if ACK is received |
| if (!SSP1CON2bits.ACKSTAT) { |
| // If an ACK is received, set module to receive 1 byte of data |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| SSP1CON2bits.RCEN = 1; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_RECV_FAIL; |
| } |
| break; |
| case I2C_RCV_DATA: |
| // On receive, save byte into buffer |
| // TODO: Handle I2C buffer overflow |
| i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = SSP1BUF; |
| i2c_data_p->buffer_in_write_ind++; |
| if (i2c_data_p->buffer_in_write_ind < i2c_data_p->buffer_in_len) { |
| // If we still need to read, send an ACK to the slave |
| i2c_data_p->operating_state = I2C_REQ_DATA; |
| SSP1CON2bits.ACKDT = 0; // ACK |
| SSP1CON2bits.ACKEN = 1; |
| } else { |
| // If we are done reading, send an NACK to the slave |
| i2c_data_p->operating_state = I2C_SEND_STOP; |
| SSP1CON2bits.ACKDT = 1; // NACK |
| SSP1CON2bits.ACKEN = 1; |
| } |
| break; |
| case I2C_REQ_DATA: |
| // Set module to receive one byte of data |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| SSP1CON2bits.RCEN = 1; |
| break; |
| case I2C_SEND_STOP: |
| // Send the stop bit and copy message to send to Main() |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_RECV_OK; |
| break; |
| } |
| } else if (i2c_data_p->master_status == I2C_MASTER_RESTART) { |
| switch (i2c_data_p->operating_state) { |
| case I2C_IDLE: |
| break; |
| case I2C_SEND_ADDR: |
| // Send the address with read bit set |
| i2c_data_p->operating_state = I2C_CHECK_ACK_SEND; |
| SSP1BUF = (i2c_data_p->master_dest_addr << 1) | 0x0; |
| break; |
| case I2C_CHECK_ACK_SEND: |
| // Check if ACK is received or not |
| if (!SSP1CON2bits.ACKSTAT) { |
| // If an ACK is received, send first byte of data |
| SSP1BUF = i2c_data_p->buffer_in[0]; |
| i2c_data_p->operating_state = I2C_CHECK_ACK_RESTART; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_SEND_FAIL; |
| } |
| break; |
| case I2C_CHECK_ACK_RESTART: |
| if (!SSP1CON2bits.ACKSTAT) { |
| SSP1CON2bits.RSEN = 1; |
| i2c_data_p->operating_state = I2C_SEND_ADDR_2; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_SEND_FAIL; |
| } |
| break; |
| case I2C_SEND_ADDR_2: |
| // Send the address with read bit set |
| i2c_data_p->operating_state = I2C_CHECK_ACK_RECV; |
| uint8_t tmp = (i2c_data_p->master_dest_addr << 1); |
| tmp |= 0x01; |
| SSP1BUF = tmp; |
| break; |
| case I2C_CHECK_ACK_RECV: |
| // Check if ACK is received |
| if (!SSP1CON2bits.ACKSTAT) { |
| // If an ACK is received, set module to receive 1 byte of data |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| SSP1CON2bits.RCEN = 1; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_RECV_FAIL; |
| } |
| break; |
| case I2C_RCV_DATA: |
| // On receive, save byte into buffer |
| // TODO: Handle I2C buffer overflow |
| i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = SSP1BUF; |
| i2c_data_p->buffer_in_write_ind++; |
| if (i2c_data_p->buffer_in_write_ind < i2c_data_p->buffer_in_len) { |
| // If we still need to read, send an ACK to the slave |
| i2c_data_p->operating_state = I2C_REQ_DATA; |
| SSP1CON2bits.ACKDT = 0; // ACK |
| SSP1CON2bits.ACKEN = 1; |
| } else { |
| // If we are done reading, send an NACK to the slave |
| i2c_data_p->operating_state = I2C_SEND_STOP; |
| SSP1CON2bits.ACKDT = 1; // NACK |
| SSP1CON2bits.ACKEN = 1; |
| } |
| break; |
| case I2C_REQ_DATA: |
| // Set module to receive one byte of data |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| SSP1CON2bits.RCEN = 1; |
| break; |
| case I2C_SEND_STOP: |
| // Send the stop bit |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_RECV_OK; |
| break; |
| } |
| } |
| } |
| void I2C1_Interrupt_Slave() { |
| uint8_t received_data; |
| uint8_t data_read_from_buffer = 0; |
| uint8_t data_written_to_buffer = 0; |
| uint8_t overrun_error = 0; |
| // Clear SSPOV (overflow bit) |
| if (SSP1CON1bits.SSPOV == 1) { |
| SSP1CON1bits.SSPOV = 0; |
| // We failed to read the buffer in time, so we know we |
| // can't properly receive this message, just put us in the |
| // a state where we are looking for a new message |
| i2c_data_p->operating_state = I2C_IDLE; |
| overrun_error = 1; |
| i2c_data_p->return_status = I2C_ERR_OVERRUN; |
| } |
| // Read SPPxBUF if it is full |
| if (SSP1STATbits.BF == 1) { |
| received_data = SSP1BUF; |
| data_read_from_buffer = 1; |
| } |
| if (!overrun_error) { |
| switch (i2c_data_p->operating_state) { |
| case I2C_IDLE: |
| { |
| // // Ignore anything except a start |
| // if (SSP1STATbits.S == 1) { |
| // i2c_data_p->buffer_in_len_tmp = 0; |
| // i2c_data_p->operating_state = I2C_STARTED; |
| // } |
| // break; |
| // } |
| // case I2C_STARTED: |
| // { |
| // In this case, we expect either an address or a stop bit |
| if (SSP1STATbits.P == 1) { |
| // Return to idle mode |
| i2c_data_p->operating_state = I2C_IDLE; |
| } else if (data_read_from_buffer) { |
| i2c_data_p->buffer_in_len_tmp = 0; |
| if (SSP1STATbits.D_nA == 0) { |
| // Address received |
| if (SSP1STATbits.R_nW == 0) { |
| // Slave write mode |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| } else { |
| // Slave read mode |
| i2c_data_p->operating_state = I2C_SEND_DATA; |
| // Process the first byte immediatly if sending data |
| goto send; |
| } |
| } else { |
| i2c_data_p->operating_state = I2C_IDLE; |
| i2c_data_p->return_status = I2C_ERR_NOADDR; |
| } |
| } |
| break; |
| } |
| send: |
| case I2C_SEND_DATA: |
| { |
| if (!i2c_data_p->slave_sending_data) { |
| // If we are not currently sending data, figure out what to reply with |
| if (I2C1_Process_Receive(i2c_data_p->slave_in_last_byte)) { |
| // Data exists to be returned, send first byte |
| SSP1BUF = i2c_data_p->buffer_out[0]; |
| i2c_data_p->buffer_out_ind = 1; |
| i2c_data_p->slave_sending_data = 1; |
| data_written_to_buffer = 1; |
| } else { |
| // Unknown request |
| i2c_data_p->slave_sending_data = 0; |
| i2c_data_p->operating_state = I2C_IDLE; |
| } |
| } else { |
| // Sending remaining data back to master |
| if (i2c_data_p->buffer_out_ind < i2c_data_p->buffer_out_len) { |
| SSP1BUF = i2c_data_p->buffer_out[i2c_data_p->buffer_out_ind]; |
| i2c_data_p->buffer_out_ind++; |
| data_written_to_buffer = 1; |
| } else { |
| // Nothing left to send |
| i2c_data_p->slave_sending_data = 0; |
| i2c_data_p->operating_state = I2C_IDLE; |
| } |
| } |
| break; |
| } |
| case I2C_RCV_DATA: |
| { |
| // We expect either data or a stop bit or a (if a restart, an addr) |
| if (SSP1STATbits.P == 1) { |
| // Stop bit detected, we need to check to see if we also read data |
| if (data_read_from_buffer) { |
| if (SSP1STATbits.D_nA == 1) { |
| // Data received with stop bit |
| // TODO: Handle I2C buffer overflow |
| i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = received_data; |
| if (i2c_data_p->buffer_in_write_ind == MAXI2C1BUF-1) { |
| i2c_data_p->buffer_in_write_ind = 0; |
| } else { |
| i2c_data_p->buffer_in_write_ind++; |
| } |
| i2c_data_p->buffer_in_len_tmp++; |
| // Save the last byte received |
| i2c_data_p->slave_in_last_byte = received_data; |
| i2c_data_p->return_status = I2C_DATA_AVAL; |
| } else { |
| i2c_data_p->operating_state = I2C_IDLE; |
| i2c_data_p->return_status = I2C_ERR_NODATA; |
| } |
| } |
| i2c_data_p->buffer_in_len += i2c_data_p->buffer_in_len_tmp; |
| i2c_data_p->operating_state = I2C_IDLE; |
| } else if (data_read_from_buffer) { |
| if (SSP1STATbits.D_nA == 1) { |
| // Data received |
| i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = received_data; |
| if (i2c_data_p->buffer_in_write_ind == MAXI2C1BUF-1) { |
| i2c_data_p->buffer_in_write_ind = 0; |
| } else { |
| i2c_data_p->buffer_in_write_ind++; |
| } |
| i2c_data_p->buffer_in_len_tmp++; |
| // Save the last byte received |
| i2c_data_p->slave_in_last_byte = received_data; |
| i2c_data_p->return_status = I2C_DATA_AVAL; |
| } else { |
| // Restart bit detected |
| if (SSP1STATbits.R_nW == 1) { |
| i2c_data_p->buffer_in_len += i2c_data_p->buffer_in_len_tmp; |
| i2c_data_p->operating_state = I2C_SEND_DATA; |
| // Process the first byte immediatly if sending data |
| goto send; |
| } else { |
| // Bad to recv an address again, we aren't ready |
| i2c_data_p->operating_state = I2C_IDLE; |
| i2c_data_p->return_status = I2C_ERR_NODATA; |
| } |
| } |
| } |
| break; |
| } |
| } |
| } |
| // Release the clock stretching bit (if we should) |
| if (data_read_from_buffer || data_written_to_buffer) { |
| // Release the clock |
| if (SSP1CON1bits.CKP == 0) { |
| SSP1CON1bits.CKP = 1; |
| } |
| } |
| } |
| /* Returns 0 if I2C module is currently busy, otherwise returns status code */ |
| uint8_t I2C1_Get_Status() { |
| if (i2c_data_p->operating_mode == I2C_MODE_MASTER) { |
| if (i2c_data_p->master_status != I2C_MASTER_IDLE || i2c_data_p->buffer_in_len == 0) { |
| return 0; |
| } else { |
| return i2c_data_p->return_status; |
| } |
| } else { |
| if (i2c_data_p->operating_state != I2C_IDLE || i2c_data_p->buffer_in_len == 0) { |
| return 0; |
| } else { |
| return i2c_data_p->return_status; |
| } |
| } |
| } |
| uint8_t I2C1_Buffer_Len() { |
| return i2c_data_p->buffer_in_len; |
| } |
| /* Returns 0 if I2C module is currently busy, otherwise returns buffer length */ |
| uint8_t I2C1_Read_Buffer(uint8_t *buffer) { |
| uint8_t i = 0; |
| while (i2c_data_p->buffer_in_len != 0) { |
| buffer[i] = i2c_data_p->buffer_in[i2c_data_p->buffer_in_read_ind]; |
| i++; |
| if (i2c_data_p->buffer_in_read_ind == MAXI2C1BUF-1) { |
| i2c_data_p->buffer_in_read_ind = 0; |
| } else { |
| i2c_data_p->buffer_in_read_ind++; |
| } |
| i2c_data_p->buffer_in_len--; |
| } |
| return i; |
| } |
| /* Put data to be returned here */ |
| uint8_t I2C1_Process_Receive(uint8_t c) { |
| uint8_t ret = 0; |
| switch (c) { |
| case CMD_QUERY_BTN: |
| i2c_data_p->buffer_out[0] = btns.w; |
| i2c_data_p->buffer_out_len = 1; |
| ret = 1; |
| break; |
| default: |
| break; |
| } |
| return ret; |
| } |
| //PIC Projects/PICX_16F1829_Controller/I2C2.c |
|---|
| 0,0 → 1,534 |
| #include "defines.h" |
| #include "I2C2.h" |
| static I2C2_DATA *i2c_data_p; |
| // Set up the data structures for the base_I2C.code |
| // Should be called once before any i2c routines are called |
| void I2C2_Init(I2C2_DATA *data) { |
| i2c_data_p = data; |
| i2c_data_p->buffer_in_len = 0; |
| i2c_data_p->buffer_in_len_tmp = 0; |
| i2c_data_p->buffer_in_read_ind = 0; |
| i2c_data_p->buffer_in_write_ind = 0; |
| i2c_data_p->buffer_out_ind = 0; |
| i2c_data_p->buffer_out_len = 0; |
| i2c_data_p->operating_mode = 0; |
| i2c_data_p->operating_state = I2C_IDLE; |
| i2c_data_p->return_status = 0; |
| i2c_data_p->slave_in_last_byte = 0; |
| i2c_data_p->slave_sending_data = 0; |
| i2c_data_p->master_dest_addr = 0; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| // Enable I2C interrupt |
| PIE4bits.SSP2IE = 1; |
| } |
| // Setup the PIC to operate as a master. |
| void I2C2_Configure_Master(uint8_t speed) { |
| i2c_data_p->operating_mode = I2C_MODE_MASTER; |
| I2C_2_CLK_TRIS = 1; |
| I2C_2_DAT_TRIS = 1; |
| SSP2STAT = 0x0; |
| SSP2CON1 = 0x0; |
| SSP2CON2 = 0x0; |
| SSP2CON3 = 0x0; |
| SSP2CON1bits.SSPM = 0x8; // I2C Master Mode |
| if (speed == 0x01) { |
| SSP2ADD = 0x13; // Operate at 400KHz (32MHz) |
| SSP2STATbits.SMP = 1; // Disable Slew Rate Control |
| } else if (speed == 0x02) { |
| SSP2ADD = 0x07; // Operate at 1Mhz (32Mhz) |
| SSP2STATbits.SMP = 1; // Disable Slew Rate Control |
| } else { |
| SSP2ADD = 0x4F; // Operate at 100KHz (32MHz) |
| SSP2STATbits.SMP = 0; // Enable Slew Rate Control |
| } |
| SSP2CON1bits.SSPEN = 1; // Enable MSSP2 Module |
| } |
| // Sends length number of bytes in msg to specified address (no R/W bit) |
| void I2C2_Master_Send(uint8_t address, uint8_t length, uint8_t *msg) { |
| uint8_t i; |
| if (length == 0) |
| return; |
| // Copy message to send into buffer and save length/address |
| for (i = 0; i < length; i++) { |
| i2c_data_p->buffer_in[i] = msg[i]; |
| } |
| i2c_data_p->buffer_in_len = length; |
| i2c_data_p->master_dest_addr = address; |
| i2c_data_p->buffer_in_read_ind = 0; |
| i2c_data_p->buffer_in_write_ind = 0; |
| // Change status to 'next' operation |
| i2c_data_p->operating_state = I2C_SEND_ADDR; |
| i2c_data_p->master_status = I2C_MASTER_SEND; |
| // Generate start condition |
| SSP2CON2bits.SEN = 1; |
| } |
| // Reads length number of bytes from address (no R/W bit) |
| void I2C2_Master_Recv(uint8_t address, uint8_t length) { |
| if (length == 0) |
| return; |
| // Save length and address to get data from |
| i2c_data_p->buffer_in_len = length; |
| i2c_data_p->master_dest_addr = address; |
| i2c_data_p->buffer_in_read_ind = 0; |
| i2c_data_p->buffer_in_write_ind = 0; |
| // Change status to 'next' operation |
| i2c_data_p->operating_state = I2C_SEND_ADDR; |
| i2c_data_p->master_status = I2C_MASTER_RECV; |
| // Generate start condition |
| SSP2CON2bits.SEN = 1; |
| } |
| // Writes msg to address then reads length number of bytes from address |
| void I2C2_Master_Restart(uint8_t address, uint8_t msg, uint8_t length) { |
| uint8_t c; |
| if (length == 0) { |
| c = msg; |
| I2C2_Master_Send(address, 1, &c); |
| return; |
| } |
| // Save length and address to get data from |
| i2c_data_p->buffer_in[0] = msg; |
| i2c_data_p->buffer_in_len = length; |
| i2c_data_p->master_dest_addr = address; |
| i2c_data_p->buffer_in_read_ind = 0; |
| i2c_data_p->buffer_in_write_ind = 0; |
| // Change status to 'next' operation |
| i2c_data_p->operating_state = I2C_SEND_ADDR; |
| i2c_data_p->master_status = I2C_MASTER_RESTART; |
| // Generate start condition |
| SSP2CON2bits.SEN = 1; |
| } |
| // Setup the PIC to operate as a slave. The address must not include the R/W bit |
| void I2C2_Configure_Slave(uint8_t addr) { |
| i2c_data_p->operating_mode = I2C_MODE_SLAVE; |
| // Ensure the two lines are set for input (we are a slave) |
| I2C_2_CLK_TRIS = 1; |
| I2C_2_DAT_TRIS = 1; |
| SSP2ADD = addr << 1; // Set the slave address |
| SSP2STAT = 0x0; |
| SSP2CON1 = 0x0; |
| SSP2CON2 = 0x0; |
| SSP2CON3 = 0x0; |
| SSP2CON1bits.SSPM = 0xE; // Enable Slave 7-bit w/ start/stop interrupts |
| SSP2STATbits.SMP = 1; // Slew Off |
| SSP2CON2bits.SEN = 1; // Enable clock-stretching |
| SSP1CON3bits.PCIE = 1; // Interrupt on stop condition |
| SSP1CON3bits.SCIE = 0; // Disable interrupt on start condition |
| SSP2CON1bits.SSPEN = 1; // Enable MSSP2 Module |
| } |
| void I2C2_Interrupt_Handler() { |
| // Call interrupt depending on which mode we are operating in |
| if (i2c_data_p->operating_mode == I2C_MODE_MASTER) { |
| I2C2_Interrupt_Master(); |
| } else if (i2c_data_p->operating_mode == I2C_MODE_SLAVE) { |
| I2C2_Interrupt_Slave(); |
| } |
| } |
| // An internal subroutine used in the master version of the i2c_interrupt_handler |
| void I2C2_Interrupt_Master() { |
| // If we are in the middle of sending data |
| if (i2c_data_p->master_status == I2C_MASTER_SEND) { |
| switch (i2c_data_p->operating_state) { |
| case I2C_IDLE: |
| break; |
| case I2C_SEND_ADDR: |
| // Send the address with read bit set |
| i2c_data_p->operating_state = I2C_CHECK_ACK_SEND; |
| SSP2BUF = (i2c_data_p->master_dest_addr << 1) | 0x0; |
| break; |
| case I2C_CHECK_ACK_SEND: |
| // Check if ACK is received or not |
| if (!SSP2CON2bits.ACKSTAT) { |
| // If an ACK is received, send next byte of data |
| if (i2c_data_p->buffer_in_read_ind < i2c_data_p->buffer_in_len) { |
| SSP2BUF = i2c_data_p->buffer_in[i2c_data_p->buffer_in_read_ind]; |
| i2c_data_p->buffer_in_read_ind++; |
| } else { |
| // If no more data is to be sent, send stop bit |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP2CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_SEND_OK; |
| } |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP2CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_SEND_FAIL; |
| } |
| break; |
| } |
| // If we are in the middle of receiving data |
| } else if (i2c_data_p->master_status == I2C_MASTER_RECV) { |
| switch (i2c_data_p->operating_state) { |
| case I2C_IDLE: |
| break; |
| case I2C_SEND_ADDR: |
| // Send address with write bit set |
| i2c_data_p->operating_state = I2C_CHECK_ACK_RECV; |
| uint8_t tmp = (i2c_data_p->master_dest_addr << 1); |
| tmp |= 0x01; |
| SSP2BUF = tmp; |
| break; |
| case I2C_CHECK_ACK_RECV: |
| // Check if ACK is received |
| if (!SSP2CON2bits.ACKSTAT) { |
| // If an ACK is received, set module to receive 1 byte of data |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| SSP2CON2bits.RCEN = 1; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP2CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_RECV_FAIL; |
| } |
| break; |
| case I2C_RCV_DATA: |
| // On receive, save byte into buffer |
| // TODO: Handle I2C buffer overflow |
| i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = SSP2BUF; |
| i2c_data_p->buffer_in_write_ind++; |
| if (i2c_data_p->buffer_in_write_ind < i2c_data_p->buffer_in_len) { |
| // If we still need to read, send an ACK to the slave |
| i2c_data_p->operating_state = I2C_REQ_DATA; |
| SSP2CON2bits.ACKDT = 0; // ACK |
| SSP2CON2bits.ACKEN = 1; |
| } else { |
| // If we are done reading, send an NACK to the slave |
| i2c_data_p->operating_state = I2C_SEND_STOP; |
| SSP2CON2bits.ACKDT = 1; // NACK |
| SSP2CON2bits.ACKEN = 1; |
| } |
| break; |
| case I2C_REQ_DATA: |
| // Set module to receive one byte of data |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| SSP2CON2bits.RCEN = 1; |
| break; |
| case I2C_SEND_STOP: |
| // Send the stop bit and copy message to send to Main() |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP2CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_RECV_OK; |
| break; |
| } |
| } else if (i2c_data_p->master_status == I2C_MASTER_RESTART) { |
| switch (i2c_data_p->operating_state) { |
| case I2C_IDLE: |
| break; |
| case I2C_SEND_ADDR: |
| // Send the address with read bit set |
| i2c_data_p->operating_state = I2C_CHECK_ACK_SEND; |
| SSP2BUF = (i2c_data_p->master_dest_addr << 1) | 0x0; |
| break; |
| case I2C_CHECK_ACK_SEND: |
| // Check if ACK is received or not |
| if (!SSP2CON2bits.ACKSTAT) { |
| // If an ACK is received, send first byte of data |
| SSP2BUF = i2c_data_p->buffer_in[0]; |
| i2c_data_p->operating_state = I2C_CHECK_ACK_RESTART; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP2CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_SEND_FAIL; |
| } |
| break; |
| case I2C_CHECK_ACK_RESTART: |
| if (!SSP2CON2bits.ACKSTAT) { |
| SSP2CON2bits.RSEN = 1; |
| i2c_data_p->operating_state = I2C_SEND_ADDR_2; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP2CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_SEND_FAIL; |
| } |
| break; |
| case I2C_SEND_ADDR_2: |
| // Send the address with read bit set |
| i2c_data_p->operating_state = I2C_CHECK_ACK_RECV; |
| uint8_t tmp = (i2c_data_p->master_dest_addr << 1); |
| tmp |= 0x01; |
| SSP2BUF = tmp; |
| break; |
| case I2C_CHECK_ACK_RECV: |
| // Check if ACK is received |
| if (!SSP2CON2bits.ACKSTAT) { |
| // If an ACK is received, set module to receive 1 byte of data |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| SSP2CON2bits.RCEN = 1; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP2CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_RECV_FAIL; |
| } |
| break; |
| case I2C_RCV_DATA: |
| // On receive, save byte into buffer |
| // TODO: Handle I2C buffer overflow |
| i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = SSP2BUF; |
| i2c_data_p->buffer_in_write_ind++; |
| if (i2c_data_p->buffer_in_write_ind < i2c_data_p->buffer_in_len) { |
| // If we still need to read, send an ACK to the slave |
| i2c_data_p->operating_state = I2C_REQ_DATA; |
| SSP2CON2bits.ACKDT = 0; // ACK |
| SSP2CON2bits.ACKEN = 1; |
| } else { |
| // If we are done reading, send an NACK to the slave |
| i2c_data_p->operating_state = I2C_SEND_STOP; |
| SSP2CON2bits.ACKDT = 1; // NACK |
| SSP2CON2bits.ACKEN = 1; |
| } |
| break; |
| case I2C_REQ_DATA: |
| // Set module to receive one byte of data |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| SSP2CON2bits.RCEN = 1; |
| break; |
| case I2C_SEND_STOP: |
| // Send the stop bit |
| i2c_data_p->operating_state = I2C_IDLE; |
| SSP2CON2bits.PEN = 1; |
| i2c_data_p->master_status = I2C_MASTER_IDLE; |
| i2c_data_p->return_status = I2C_RECV_OK; |
| break; |
| } |
| } |
| } |
| void I2C2_Interrupt_Slave() { |
| uint8_t received_data; |
| uint8_t data_read_from_buffer = 0; |
| uint8_t data_written_to_buffer = 0; |
| uint8_t overrun_error = 0; |
| // Clear SSP2OV (overflow bit) |
| if (SSP2CON1bits.SSPOV == 1) { |
| SSP2CON1bits.SSPOV = 0; |
| // We failed to read the buffer in time, so we know we |
| // can't properly receive this message, just put us in the |
| // a state where we are looking for a new message |
| i2c_data_p->operating_state = I2C_IDLE; |
| overrun_error = 1; |
| i2c_data_p->return_status = I2C_ERR_OVERRUN; |
| } |
| // Read SPPxBUF if it is full |
| if (SSP2STATbits.BF == 1) { |
| received_data = SSP2BUF; |
| // DBG_PRINT_I2C("I2C: data read from buffer: %x\r\n", SSP2BUF); |
| data_read_from_buffer = 1; |
| } |
| if (!overrun_error) { |
| switch (i2c_data_p->operating_state) { |
| case I2C_IDLE: |
| // { |
| // // Ignore anything except a start |
| // if (SSP2STATbits.S == 1) { |
| // i2c_data_p->buffer_in_len_tmp = 0; |
| // i2c_data_p->operating_state = I2C_STARTED; |
| // } |
| // break; |
| // } |
| // case I2C_STARTED: |
| { |
| // In this case, we expect either an address or a stop bit |
| if (SSP2STATbits.P == 1) { |
| // Return to idle mode |
| i2c_data_p->operating_state = I2C_IDLE; |
| } else if (data_read_from_buffer) { |
| if (SSP2STATbits.D_nA == 0) { |
| // Address received |
| if (SSP2STATbits.R_nW == 0) { |
| // Slave write mode |
| i2c_data_p->operating_state = I2C_RCV_DATA; |
| } else { |
| // Slave read mode |
| i2c_data_p->operating_state = I2C_SEND_DATA; |
| // Process the first byte immediatly if sending data |
| goto send; |
| } |
| } else { |
| i2c_data_p->operating_state = I2C_IDLE; |
| i2c_data_p->return_status = I2C_ERR_NOADDR; |
| } |
| } |
| break; |
| } |
| send: |
| case I2C_SEND_DATA: |
| { |
| if (!i2c_data_p->slave_sending_data) { |
| // If we are not currently sending data, figure out what to reply with |
| if (I2C2_Process_Receive(i2c_data_p->slave_in_last_byte)) { |
| // Data exists to be returned, send first byte |
| SSP2BUF = i2c_data_p->buffer_out[0]; |
| i2c_data_p->buffer_out_ind = 1; |
| i2c_data_p->slave_sending_data = 1; |
| data_written_to_buffer = 1; |
| } else { |
| // Unknown request |
| i2c_data_p->slave_sending_data = 0; |
| i2c_data_p->operating_state = I2C_IDLE; |
| } |
| } else { |
| // Sending remaining data back to master |
| if (i2c_data_p->buffer_out_ind < i2c_data_p->buffer_out_len) { |
| SSP2BUF = i2c_data_p->buffer_out[i2c_data_p->buffer_out_ind]; |
| i2c_data_p->buffer_out_ind++; |
| data_written_to_buffer = 1; |
| } else { |
| // Nothing left to send |
| i2c_data_p->slave_sending_data = 0; |
| i2c_data_p->operating_state = I2C_IDLE; |
| } |
| } |
| break; |
| } |
| case I2C_RCV_DATA: |
| { |
| // We expect either data or a stop bit or a (if a restart, an addr) |
| if (SSP2STATbits.P == 1) { |
| // Stop bit detected, we need to check to see if we also read data |
| if (data_read_from_buffer) { |
| if (SSP2STATbits.D_nA == 1) { |
| // Data received with stop bit |
| // TODO: Handle I2C buffer overflow |
| i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = received_data; |
| if (i2c_data_p->buffer_in_write_ind == MAXI2C2BUF-1) { |
| i2c_data_p->buffer_in_write_ind = 0; |
| } else { |
| i2c_data_p->buffer_in_write_ind++; |
| } |
| i2c_data_p->buffer_in_len_tmp++; |
| // Save the last byte received |
| i2c_data_p->slave_in_last_byte = received_data; |
| i2c_data_p->return_status = I2C_DATA_AVAL; |
| } else { |
| i2c_data_p->operating_state = I2C_IDLE; |
| i2c_data_p->return_status = I2C_ERR_NODATA; |
| } |
| } |
| i2c_data_p->buffer_in_len += i2c_data_p->buffer_in_len_tmp; |
| i2c_data_p->operating_state = I2C_IDLE; |
| } else if (data_read_from_buffer) { |
| if (SSP2STATbits.D_nA == 1) { |
| // Data received |
| i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = received_data; |
| if (i2c_data_p->buffer_in_write_ind == MAXI2C2BUF-1) { |
| i2c_data_p->buffer_in_write_ind = 0; |
| } else { |
| i2c_data_p->buffer_in_write_ind++; |
| } |
| i2c_data_p->buffer_in_len_tmp++; |
| // Save the last byte received |
| i2c_data_p->slave_in_last_byte = received_data; |
| i2c_data_p->return_status = I2C_DATA_AVAL; |
| } else { |
| // Restart bit detected |
| if (SSP2STATbits.R_nW == 1) { |
| i2c_data_p->buffer_in_len += i2c_data_p->buffer_in_len_tmp; |
| i2c_data_p->operating_state = I2C_SEND_DATA; |
| // Process the first byte immediatly if sending data |
| goto send; |
| } else { |
| // Bad to recv an address again, we aren't ready |
| i2c_data_p->operating_state = I2C_IDLE; |
| i2c_data_p->return_status = I2C_ERR_NODATA; |
| } |
| } |
| } |
| break; |
| } |
| } |
| } |
| // Release the clock stretching bit (if we should) |
| if (data_read_from_buffer || data_written_to_buffer) { |
| // Release the clock |
| if (SSP2CON1bits.CKP == 0) { |
| SSP2CON1bits.CKP = 1; |
| } |
| } |
| } |
| /* Returns 0 if I2C module is currently busy, otherwise returns status code */ |
| uint8_t I2C2_Get_Status() { |
| if (i2c_data_p->operating_mode == I2C_MODE_MASTER) { |
| if (i2c_data_p->master_status != I2C_MASTER_IDLE || i2c_data_p->buffer_in_len == 0) { |
| return 0; |
| } else { |
| return i2c_data_p->return_status; |
| } |
| } else { |
| if (i2c_data_p->operating_state != I2C_IDLE || i2c_data_p->buffer_in_len == 0) { |
| return 0; |
| } else { |
| return i2c_data_p->return_status; |
| } |
| } |
| } |
| uint8_t I2C2_Buffer_Len() { |
| return i2c_data_p->buffer_in_len; |
| } |
| /* Returns 0 if I2C module is currently busy, otherwise returns buffer length */ |
| uint8_t I2C2_Read_Buffer(uint8_t *buffer) { |
| uint8_t i = 0; |
| while (i2c_data_p->buffer_in_len != 0) { |
| buffer[i] = i2c_data_p->buffer_in[i2c_data_p->buffer_in_read_ind]; |
| i++; |
| if (i2c_data_p->buffer_in_read_ind == MAXI2C2BUF-1) { |
| i2c_data_p->buffer_in_read_ind = 0; |
| } else { |
| i2c_data_p->buffer_in_read_ind++; |
| } |
| i2c_data_p->buffer_in_len--; |
| } |
| return i; |
| } |
| /* Put data to be returned here */ |
| uint8_t I2C2_Process_Receive(uint8_t c) { |
| uint8_t ret = 0; |
| return ret; |
| } |
| //PIC Projects/PICX_16F1829_Controller/INTERRUPTS.c |
|---|
| 0,0 → 1,120 |
| #include "defines.h" |
| #include "INTERRUPTS.h" |
| #include "I2C1.h" |
| #include "I2C2.h" |
| #include "IO.h" |
| #include "CPS.h" |
| void Interrupt_Init() { |
| } |
| void Interrupt_Enable() { |
| // Enable global and peripheral interrupts |
| INTCONbits.PEIE = 1; |
| INTCONbits.GIE = 1; |
| } |
| void Interrupt_Disable() { |
| INTCONbits.PEIE = 0; |
| INTCONbits.GIE = 0; |
| } |
| void interrupt InterruptHandler(void) { |
| uint8_t tmr0_rollover = 0; |
| // We need to check the interrupt flag of each enabled high-priority interrupt to |
| // see which device generated this interrupt. Then we can call the correct handler. |
| // // Check to see if we have an SPI2 interrupt |
| // if (PIR3bits.SSP2IF) { |
| // // Call the handler |
| // SPI2_Recv_Interrupt_Handler(); |
| // |
| // // Clear the interrupt flag |
| // PIR3bits.SSP2IF = 0; |
| // |
| // return; |
| // } |
| // Check to see if we have an interrupt on Timer 0 (CPS) |
| if (INTCONbits.TMR0IF) { |
| CPS_Timer_0_Interrupt_Handler(); |
| INTCONbits.TMR0IF = 0; |
| return; |
| } |
| // Check to see if we have an I2C1 interrupt |
| if (PIR1bits.SSP1IF) { |
| // Call the handler |
| I2C1_Interrupt_Handler(); |
| // Clear the interrupt flag |
| PIR1bits.SSP1IF = 0; |
| if (INTCONbits.TMR0IF) { |
| tmr0_rollover = 1; |
| } |
| } |
| // Check to see if we have an I2C2 interrupt |
| if (PIR4bits.SSP2IF) { |
| // Call the handler |
| I2C2_Interrupt_Handler(); |
| // Clear the interrupt flag |
| PIR4bits.SSP2IF = 0; |
| if (INTCONbits.TMR0IF) { |
| tmr0_rollover = 1; |
| } |
| } |
| // If Timer 0 rolls over while servicing another interrupt handler, |
| // reset the timers as the sample will be inaccurate. |
| if (tmr0_rollover) { |
| INTCONbits.TMR0IF = 0; |
| CPS_Reset(); |
| } |
| // // Check to see if we have an IO interrupt |
| // if (INTCONbits.IOCIF) { |
| // // Call the handler |
| // IO_Interrupt(); |
| // |
| // return; |
| // } |
| // // Check to see if we have an interrupt on USART1 RX |
| // if (PIR1bits.RC1IF) { |
| // // Call the interrupt handler |
| // UART1_Recv_Interrupt_Handler(); |
| // |
| // // Clear the interrupt flag |
| // PIR1bits.RC1IF = 0; |
| // |
| // return; |
| // } |
| // // Check to see if we have an interrupt on USART1 TX |
| // if (PIR1bits.TX1IF) { |
| // // Call the interrupt handler |
| // UART1_Send_Interrupt_Handler(); |
| // |
| // // Clear the interrupt flag |
| // PIR1bits.TX1IF = 0; |
| // |
| // return; |
| // } |
| // // Check to see if we have an interrupt on USART2 RX |
| // if (PIR3bits.RC2IF) { |
| // DBG_PRINT_INT("INT: UART2 RX\r\n"); |
| // // Call the interrupt handler |
| // uart_2_recv_interrupt_handler(); |
| // |
| // // Clear the interrupt flag |
| // PIR3bits.RC2IF = 0; |
| // } |
| } |
| //PIC Projects/PICX_16F1829_Controller/IO.c |
|---|
| 0,0 → 1,63 |
| #include "defines.h" |
| #include "IO.h" |
| #include "MCP23009.h" |
| void IO_Init(void) { |
| // Set all pins to digital I/O |
| ANSELA = 0x0; |
| ANSELB = 0x0; |
| ANSELC = 0x0; |
| // Enable weak pull-up if WPU bit is set |
| OPTION_REGbits.nWPUEN = 0; |
| // Initialize interrupt inputs |
| LSM303_INT_TRIS = 1; |
| L3GD20_INT_TRIS = 1; |
| BTN_INT_TRIS = 1; |
| // Initialize UART pins |
| UART_RX_TRIS = 1; |
| UART_TX_TRIS = 0; |
| // Initialize I2C address pins |
| I2C_ADDR_0_TRIS = 1; |
| I2C_ADDR_1_TRIS = 1; |
| I2C_ADDR_2_TRIS = 1; |
| I2C_ADDR_3_TRIS = 1; |
| // Enable the weak-pullup on the address pins |
| I2C_ADDR_0_WPU = 1; |
| I2C_ADDR_1_WPU = 1; |
| I2C_ADDR_2_WPU = 1; |
| I2C_ADDR_3_WPU = 1; |
| // Initialize I2C pins (dont really need to as the I2C code does it) |
| I2C_1_CLK_TRIS = 1; |
| I2C_1_DAT_TRIS = 1; |
| I2C_2_CLK_TRIS = 1; |
| I2C_2_DAT_TRIS = 1; |
| // Set the CPS pins |
| CPS_L_TRIS = 1; |
| CPS_R_TRIS = 1; |
| CPS_L_ANSL = 1; |
| CPS_R_ANSL = 1; |
| CPS_R_WPU = 0; |
| CPS_L_WPU = 0; |
| } |
| void IO_IOC_Enable(void) { |
| // Clear all IOC flags |
| IOCAF = 0x0; |
| IOCBF = 0x0; |
| // Trigger interrupt on BTN_INT on falling edge |
| IOCANbits.IOCAN2 = 1; |
| // Enable IOC interrupts |
| INTCONbits.IOCIE = 1; |
| } |
| void IO_Interrupt(void) { |
| Reset_Board(OP_STATE_ACTIVE); |
| } |
| //PIC Projects/PICX_16F1829_Controller/TLC59116.c |
|---|
| 0,0 → 1,93 |
| #include "defines.h" |
| #include "TLC59116.h" |
| #include "I2C2.h" |
| void TLC59116_Init(void) { |
| uint8_t buffer[25]; |
| buffer[0] = TLC59116_AUTO_INCR_ALL | 0x00; // Register Select |
| buffer[1] = TLC59116_AUTO_INCR_ALL | 0x00; // MODE1 |
| buffer[2] = 0x00; // MODE2 |
| buffer[3] = 0x00; // PWM0 |
| buffer[4] = 0x00; // PWM1 |
| buffer[5] = 0x00; // PWM2 |
| buffer[6] = 0x00; // PWM3 |
| buffer[7] = 0x00; // PWM4 |
| buffer[8] = 0x00; // PWM5 |
| buffer[9] = 0x00; // PWM6 |
| buffer[10] = 0x00; // PWM7 |
| buffer[11] = 0x00; // PWM8 |
| buffer[12] = 0x00; // PWM9 |
| buffer[13] = 0x00; // PWM10 |
| buffer[14] = 0x00; // PWM11 |
| buffer[15] = 0x00; // PWM12 |
| buffer[16] = 0x00; // PWM13 |
| buffer[17] = 0x00; // PWM14 |
| buffer[18] = 0x00; // PWM15 |
| buffer[19] = 0xFF; // GRPPWM (maximum brightness) |
| buffer[20] = 0x00; // GRPFREQ (not used) |
| buffer[21] = 0xFF; // LEDOUT0 (brightness and group dimming enabled) |
| buffer[22] = 0xFF; // LEDOUT1 |
| buffer[23] = 0xFF; // LEDOUT2 |
| buffer[24] = 0xFF; // LEDOUT3 |
| I2C2_Master_Send(TLC59116_ADDR, 25, buffer); |
| uint8_t result; |
| do { |
| result = I2C2_Get_Status(); |
| } while (!result); |
| } |
| //void TLC59116_Write(uint8_t led, uint8_t brightness) { |
| // uint8_t buffer[2]; |
| // |
| // buffer[0] = led + 0x02; // Register Select |
| // buffer[1] = brightness; |
| // |
| // I2C2_Master_Send(TLC59116_ADDR, 2, buffer); |
| // uint8_t result; |
| // do { |
| // result = I2C2_Get_Status(); |
| // } while (!result); |
| //} |
| void TLC59116_Write_All(LED_VALUES *values) { |
| uint8_t buffer[17]; |
| buffer[0] = TLC59116_AUTO_INCR_ALL | TLC59116_REG_PWM0; // Register Select |
| buffer[1] = values->w[0]; |
| buffer[2] = values->w[1]; |
| buffer[3] = values->w[2]; |
| buffer[4] = values->w[3]; |
| buffer[5] = values->w[4]; |
| buffer[6] = values->w[5]; |
| buffer[7] = values->w[6]; |
| buffer[8] = values->w[7]; |
| buffer[9] = values->w[8]; |
| buffer[10] = values->w[9]; |
| buffer[11] = values->w[10]; |
| buffer[12] = values->w[11]; |
| buffer[13] = values->w[12]; |
| buffer[14] = values->w[13]; |
| buffer[15] = values->w[14]; |
| buffer[16] = values->w[15]; |
| I2C2_Master_Send(TLC59116_ADDR, 17, buffer); |
| uint8_t result; |
| do { |
| result = I2C2_Get_Status(); |
| } while (!result); |
| } |
| void TLC59116_Write_BC(uint8_t brightness) { |
| uint8_t buffer[2]; |
| buffer[0] = TLC59116_REG_GRPPWM; // Register Select |
| buffer[1] = brightness; |
| I2C2_Master_Send(TLC59116_ADDR, 2, buffer); |
| uint8_t result; |
| do { |
| result = I2C2_Get_Status(); |
| } while (!result); |
| } |
| //PIC Projects/PICX_16F1829_Controller/defines.h |
|---|
| 0,0 → 1,133 |
| #ifndef DEFINES_H |
| #define DEFINES_H |
| #include <xc.h> |
| #include <stdint.h> |
| // <editor-fold defaultstate="collapsed" desc="I/O Pins"> |
| /* Pins Mapping |
| * 2 - RA5 - LSM303_DRDY |
| * 3 - RA4 - L3GD20_DRDY |
| * 5 - RC5 - UART_RX |
| * 6 - RC4 - UART TX |
| * 7 - RC3 - ADDR_3 |
| * 8 - RC6 - BTN_CAP_0 |
| * 9 - RC7 - BTN_CAP_1 |
| * 10 - RB7 - SCL_2 |
| * 11 - RB6 - SCL_1 |
| * 12 - RB5 - SDA_2 |
| * 13 - RB4 - SDA_1 |
| * 14 - RC2 - ADDR_2 |
| * 15 - RC1 - ADDR_1 |
| * 16 - RC0 - ADDR_0 |
| * 17 - RA2 - BTN_INT |
| */ |
| #define LSM303_INT_TRIS TRISAbits.TRISA5 |
| #define L3GD20_INT_TRIS TRISAbits.TRISA4 |
| #define UART_RX_TRIS TRISCbits.TRISC5 |
| #define UART_TX_TRIS TRISCbits.TRISC4 |
| #define BTN_INT_TRIS TRISAbits.TRISA2 |
| #define I2C_ADDR_3_TRIS TRISCbits.TRISC3 |
| #define I2C_ADDR_2_TRIS TRISCbits.TRISC2 |
| #define I2C_ADDR_1_TRIS TRISCbits.TRISC1 |
| #define I2C_ADDR_0_TRIS TRISCbits.TRISC0 |
| #define I2C_ADDR_3_WPU WPUCbits.WPUC3 |
| #define I2C_ADDR_2_WPU WPUCbits.WPUC2 |
| #define I2C_ADDR_1_WPU WPUCbits.WPUC1 |
| #define I2C_ADDR_0_WPU WPUCbits.WPUC0 |
| #define I2C_ADDR_3_PORT PORTCbits.RC3 |
| #define I2C_ADDR_2_PORT PORTCbits.RC2 |
| #define I2C_ADDR_1_PORT PORTCbits.RC1 |
| #define I2C_ADDR_0_PORT PORTCbits.RC0 |
| #define I2C_1_CLK_TRIS TRISBbits.TRISB6 |
| #define I2C_1_DAT_TRIS TRISBbits.TRISB4 |
| #define I2C_2_CLK_TRIS TRISBbits.TRISB7 |
| #define I2C_2_DAT_TRIS TRISBbits.TRISB5 |
| #define CPS_R_TRIS TRISCbits.TRISC6 |
| #define CPS_L_TRIS TRISCbits.TRISC7 |
| #define CPS_R_ANSL ANSELCbits.ANSC6 |
| #define CPS_L_ANSL ANSELCbits.ANSC7 |
| #define CPS_R_WPU WPUCbits.WPUC6 |
| #define CPS_L_WPU WPUCbits.WPUC7 |
| // </editor-fold> |
| #define _XTAL_FREQ 32000000 |
| #define CMD_QUERY_BTN 0x0A |
| #define CMD_SET_LEDS 0x0B |
| #define CMD_RESET 0x0C |
| #define CMD_ACTIVE 0x0D |
| #define OP_STATE_IDLE 0x10 |
| #define OP_STATE_ACTIVE 0x20 |
| #define RESET_POR 0x0 |
| #define RESET_BOR 0x1 |
| #define RESET_MCLR 0x2 |
| #define RESET_WDT 0x3 |
| #define RESET_RST 0x4 |
| #define RESET_STK 0x5 |
| #define I2C1_SLAVE_PREFIX 0x10 |
| #define DIR_BRIGHTNESS 0x40 |
| #define DIR_S 0x00 |
| #define DIR_W 0x01 |
| #define DIR_N 0x02 |
| #define DIR_E 0x03 |
| typedef union { |
| struct { |
| unsigned BTN_L_N :1; |
| unsigned BTN_L_E :1; |
| unsigned BTN_R_E :1; |
| unsigned BTN_R_N :1; |
| unsigned BTN_R_S :1; |
| unsigned BTN_R_W :1; |
| unsigned BTN_L_S :1; |
| unsigned BTN_L_W :1; |
| }; |
| uint8_t w; |
| } BTN_STATUS; |
| typedef union { |
| struct { |
| uint8_t LED_0; |
| uint8_t LED_1; |
| uint8_t LED_2; |
| uint8_t LED_3; |
| uint8_t LED_4; |
| uint8_t LED_5; |
| uint8_t LED_6; |
| uint8_t LED_7; |
| uint8_t LED_N; |
| uint8_t LED_W; |
| uint8_t LED_E; |
| uint8_t LED_S; |
| uint8_t LED_A; |
| uint8_t LED_B; |
| uint8_t LED_C; |
| uint8_t LED_D; |
| } single; |
| uint8_t w[16]; |
| } LED_VALUES; |
| void Reset_Board(uint8_t next_state); |
| uint8_t Get_Last_Reset(void); |
| void Check_I2C_Idle(void); |
| void Idle_Animation(void); |
| uint8_t Direction_Rotate_Clockwise(uint8_t); |
| uint8_t Direction_Rotate_CClockwise(uint8_t); |
| #endif /* DEFINES_H */ |
| //PIC Projects/PICX_16F1829_Controller/funclist |
|---|
| 0,0 → 1,42 |
| _I2C2_Interrupt_Master: CODE, 50 0 706 |
| _Get_Last_Reset: CODE, 5000 0 43 |
| ___aldiv: CODE, 6014 0 130 |
| _I2C1_Init: CODE, 2079 0 91 |
| _I2C1_Interrupt_Slave: CODE, 3072 0 426 |
| _I2C1_Read_Buffer: CODE, 5565 0 78 |
| _CPS_Reset: CODE, 4772 0 5 |
| _I2C2_Init: CODE, 1928 0 91 |
| _I2C2_Interrupt_Slave: CODE, 2653 0 419 |
| _I2C2_Read_Buffer: CODE, 5487 0 78 |
| _main: CODE, 1462 0 466 |
| _Interrupt_Enable: CODE, 2045 0 3 |
| _Direction_Rotate_Clockwise: CODE, 5421 0 66 |
| _I2C2_Master_Restart: CODE, 5643 0 79 |
| _Direction_Rotate_CClockwise: CODE, 5355 0 66 |
| _InterruptHandler: CODE, 4 0 44 |
| ___lmul: CODE, 5135 0 47 |
| _Check_I2C_Idle: CODE, 5182 0 49 |
| _Read_Address: CODE, 4798 0 15 |
| _I2C1_Process_Receive: CODE, 2048 0 31 |
| _Interrupt_Init: CODE, 3 0 1 |
| __initialization: CODE, 4929 0 31 |
| _MCP23009_Init: CODE, 5089 0 46 |
| _I2C2_Process_Receive: CODE, 4764 0 3 |
| _TLC59116_Init: CODE, 5805 0 85 |
| _CPS_Timer_0_Interrupt_Handler: CODE, 2312 0 341 |
| _I2C2_Configure_Master: CODE, 5043 0 46 |
| _I2C1_Interrupt_Handler: CODE, 4837 0 26 |
| _MCP23009_Query: CODE, 4963 0 37 |
| _IO_Init: CODE, 4895 0 34 |
| _I2C2_Master_Send: CODE, 5722 0 83 |
| _I2C1_Configure_Slave: CODE, 4863 0 32 |
| _I2C2_Interrupt_Handler: CODE, 2019 0 26 |
| _TLC59116_Write_All: CODE, 2170 0 142 |
| _Reset_Board: CODE, 4789 0 9 |
| i1_CPS_Reset: CODE, 4767 0 5 |
| _I2C1_Get_Status: CODE, 5293 0 62 |
| _CPS_Init: CODE, 5890 0 124 |
| _I2C1_Interrupt_Master: CODE, 756 0 706 |
| _I2C2_Get_Status: CODE, 5231 0 62 |
| _Idle_Animation: CODE, 3498 0 598 |
| Total: 5432 |
| //PIC Projects/PICX_16F1829_Controller/l.obj |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| //PIC Projects/PICX_16F1829_Controller/l.obj |
|---|
| Property changes: |
| Added: svn:mime-type |
| +application/octet-stream |
| \ No newline at end of property |
| //PIC Projects/PICX_16F1829_Controller/main.c |
|---|
| 0,0 → 1,376 |
| // <editor-fold defaultstate="collapsed" desc="Configuration Bits"> |
| // PIC16F1825 Configuration Bit Settings |
| // CONFIG1 |
| #pragma config FOSC = INTOSC // Oscillator Selection (INTOSC oscillator: I/O function on CLKIN pin) |
| #pragma config WDTE = OFF // Watchdog Timer Enable (WDT software controlled) |
| #pragma config PWRTE = OFF // Power-up Timer Enable (PWRT disabled) |
| #pragma config MCLRE = ON // MCLR Pin Function Select (MCLR/VPP pin function is digital input) |
| #pragma config CP = OFF // Flash Program Memory Code Protection (Program memory code protection is disabled) |
| #pragma config CPD = OFF // Data Memory Code Protection (Data memory code protection is disabled) |
| #pragma config BOREN = ON // Brown-out Reset Enable (Brown-out Reset enabled) |
| #pragma config CLKOUTEN = OFF // Clock Out Enable (CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin) |
| #pragma config IESO = ON // Internal/External Switchover (Internal/External Switchover mode is enabled) |
| #pragma config FCMEN = ON // Fail-Safe Clock Monitor Enable (Fail-Safe Clock Monitor is enabled) |
| // CONFIG2 |
| #pragma config WRT = OFF // Flash Memory Self-Write Protection (Write protection off) |
| #pragma config PLLEN = ON // PLL Enable (4x PLL enabled) |
| #pragma config STVREN = ON // Stack Overflow/Underflow Reset Enable (Stack Overflow or Underflow will cause a Reset) |
| #pragma config BORV = LO // Brown-out Reset Voltage Selection (Brown-out Reset Voltage (Vbor), low trip point selected.) |
| #pragma config LVP = OFF // Low-Voltage Programming Enable (High-voltage on MCLR/VPP must be used for programming) |
| // </editor-fold> |
| #include "defines.h" |
| #include "INTERRUPTS.h" |
| #include "IO.h" |
| #include "I2C1.h" |
| #include "I2C2.h" |
| #include "CPS.h" |
| #include "TLC59116.h" |
| #include "MCP23009.h" |
| persistent uint8_t op_state; |
| void Reset_Board(uint8_t next_state) { |
| op_state = next_state; |
| RESET(); |
| } |
| uint8_t Get_Last_Reset(void) { |
| uint8_t ret; |
| if (PCONbits.nPOR == 0) { |
| ret = RESET_POR; |
| } else if (PCONbits.nBOR == 0) { |
| ret = RESET_BOR; |
| } else if (STATUSbits.nTO == 0) { |
| ret = RESET_WDT; |
| } else if (PCONbits.nRMCLR == 0) { |
| ret = RESET_MCLR; |
| } else if (PCONbits.STKOVF || PCONbits.STKUNF) { |
| ret = RESET_STK; |
| } else if (PCONbits.nRI == 0) { |
| ret = RESET_RST; |
| } else { |
| ret = RESET_POR; |
| } |
| PCON = 0x0F; |
| STATUSbits.nPD = 1; |
| STATUSbits.nTO = 1; |
| return ret; |
| } |
| uint8_t Read_Address(void) { |
| uint8_t ret = I2C1_SLAVE_PREFIX; |
| if (!I2C_ADDR_3_PORT) |
| ret |= 0x08; |
| if (!I2C_ADDR_2_PORT) |
| ret |= 0x04; |
| if (!I2C_ADDR_1_PORT) |
| ret |= 0x02; |
| if (!I2C_ADDR_0_PORT) |
| ret |= 0x01; |
| return ret; |
| } |
| BTN_STATUS btns; |
| LED_VALUES leds = {0x00}; |
| int main(void) { |
| uint8_t buffer[32]; |
| uint8_t result, length; |
| uint8_t i2c_slave_addr; |
| // uint8_t op_state; |
| uint8_t i; |
| // Set internal oscillator speed to 32MHz |
| OSCCONbits.SPLLEN = 1; // 4x PLL enable (overwritten by config bits) |
| OSCCONbits.IRCF = 0xE; // Base frequency @ 8MHz |
| OSCCONbits.SCS = 0b00; // System clock determined by config bits |
| // Initialize I/O |
| IO_Init(); |
| uint8_t last_reset = Get_Last_Reset(); |
| if (last_reset == RESET_POR || last_reset == RESET_BOR || |
| last_reset == RESET_MCLR || last_reset == RESET_WDT || |
| last_reset == RESET_STK) { |
| op_state = OP_STATE_IDLE; |
| } |
| // if (last_reset == RESET_RST) { |
| // op_state = OP_STATE_ACTIVE; |
| // } |
| i2c_slave_addr = Read_Address(); |
| // Delay a bit to allow I2C lines to stabilize |
| __delay_ms(10); |
| // Initialize I2C1 in slave mode |
| I2C1_DATA i2c1_data; |
| I2C1_Init(&i2c1_data); |
| I2C1_Configure_Slave(i2c_slave_addr); |
| // Initialize I2C2 in master mode |
| I2C2_DATA i2c2_data; |
| I2C2_Init(&i2c2_data); |
| I2C2_Configure_Master(I2C_1MHZ); |
| CPS_DATA cps_data; |
| CPS_Init(&cps_data); |
| // Initialize interrupts |
| Interrupt_Init(); |
| Interrupt_Enable(); |
| MCP23009_Init(&btns); |
| MCP23009_Query(); |
| TLC59116_Init(); |
| // TLC59116_Write_All(&leds); |
| if (op_state == OP_STATE_IDLE) { |
| // IO_IOC_Enable(); |
| Idle_Animation(); |
| } else if (op_state == OP_STATE_ACTIVE) { |
| uint8_t button_R = 0, button_L = 0; |
| uint8_t dir_state = DIR_S; |
| leds.single.LED_S = DIR_BRIGHTNESS; |
| TLC59116_Write_All(&leds); |
| while (1) { |
| // Check if an I2C message was received |
| do { |
| result = I2C1_Get_Status(); |
| } while (!result); |
| length = I2C1_Read_Buffer(buffer); |
| if (length == 1 && buffer[0] == CMD_RESET) { |
| Reset_Board(OP_STATE_IDLE); |
| } else if (length == 1 && buffer[0] == CMD_ACTIVE) { |
| Reset_Board(OP_STATE_ACTIVE); |
| } else if (length == 17 && buffer[0] == CMD_SET_LEDS) { |
| for (i = 0; i < 16; i++) { |
| leds.w[i] = buffer[i + 1]; |
| } |
| // Reset the direction LEDs |
| if (dir_state == DIR_S) |
| leds.single.LED_S = DIR_BRIGHTNESS; |
| else if (dir_state == DIR_W) |
| leds.single.LED_W = DIR_BRIGHTNESS; |
| else if (dir_state == DIR_N) |
| leds.single.LED_N = DIR_BRIGHTNESS; |
| else if (dir_state == DIR_E) |
| leds.single.LED_E = DIR_BRIGHTNESS; |
| TLC59116_Write_All(&leds); |
| } |
| // Check if either capacitive buttons were pressed |
| if (cps_data.btn_pressed[0] && button_R == 0) { |
| // Right button went from unpressed -> pressed |
| dir_state = Direction_Rotate_CClockwise(dir_state); |
| TLC59116_Write_All(&leds); |
| } |
| if (cps_data.btn_pressed[1] && button_L == 0) { |
| // Left button went from unpressed -> pressed |
| dir_state = Direction_Rotate_Clockwise(dir_state); |
| TLC59116_Write_All(&leds); |
| } |
| // Save the previous button state |
| button_R = cps_data.btn_pressed[0]; |
| button_L = cps_data.btn_pressed[1]; |
| // Poll the hardware buttons |
| I2C2_Master_Restart(MCP23009_ADDR, MCP23009_GPIOA, 1); |
| do { |
| result = I2C2_Get_Status(); |
| } while (!result); |
| length = I2C2_Read_Buffer(buffer); |
| btns.w = buffer[0]; |
| // Change the direction according to the user's perspective |
| if (dir_state == DIR_W) { |
| uint8_t tmp = btns.BTN_R_S; |
| btns.BTN_R_S = btns.BTN_R_W; |
| btns.BTN_R_W = btns.BTN_R_N; |
| btns.BTN_R_N = btns.BTN_R_E; |
| btns.BTN_R_E = tmp; |
| } else if (dir_state == DIR_E) { |
| uint8_t tmp = btns.BTN_R_S; |
| btns.BTN_R_S = btns.BTN_R_E; |
| btns.BTN_R_E = btns.BTN_R_N; |
| btns.BTN_R_N = btns.BTN_R_W; |
| btns.BTN_R_W = tmp; |
| } else if (dir_state == DIR_N) { |
| uint8_t tmp = btns.BTN_R_S; |
| btns.BTN_R_S = btns.BTN_R_N; |
| btns.BTN_R_N = tmp; |
| tmp = btns.BTN_R_E; |
| btns.BTN_R_E = btns.BTN_R_W; |
| btns.BTN_R_W = tmp; |
| } |
| } |
| } |
| } |
| uint8_t Direction_Rotate_Clockwise(uint8_t dir_state) { |
| uint8_t ret; |
| switch (dir_state) { |
| case DIR_S: |
| leds.single.LED_S = 0x00; |
| leds.single.LED_W = DIR_BRIGHTNESS; |
| ret = DIR_W; |
| break; |
| case DIR_W: |
| leds.single.LED_W = 0x00; |
| leds.single.LED_N = DIR_BRIGHTNESS; |
| ret = DIR_N; |
| break; |
| case DIR_N: |
| leds.single.LED_N = 0x00; |
| leds.single.LED_E = DIR_BRIGHTNESS; |
| ret = DIR_E; |
| break; |
| case DIR_E: |
| leds.single.LED_E = 0x00; |
| leds.single.LED_S = DIR_BRIGHTNESS; |
| ret = DIR_S; |
| break; |
| } |
| return ret; |
| } |
| uint8_t Direction_Rotate_CClockwise(uint8_t dir_state) { |
| uint8_t ret; |
| switch (dir_state) { |
| case DIR_S: |
| leds.single.LED_S = 0x00; |
| leds.single.LED_E = DIR_BRIGHTNESS; |
| ret = DIR_E; |
| break; |
| case DIR_E: |
| leds.single.LED_E = 0x00; |
| leds.single.LED_N = DIR_BRIGHTNESS; |
| ret = DIR_N; |
| break; |
| case DIR_N: |
| leds.single.LED_N = 0x00; |
| leds.single.LED_W = DIR_BRIGHTNESS; |
| ret = DIR_W; |
| break; |
| case DIR_W: |
| leds.single.LED_W = 0x00; |
| leds.single.LED_S = DIR_BRIGHTNESS; |
| ret = DIR_S; |
| break; |
| } |
| return ret; |
| } |
| void Check_I2C_Idle(void) { |
| uint8_t buffer[32]; |
| uint8_t result, length, i; |
| // Check if an I2C message was received |
| result = I2C1_Get_Status(); |
| if (result) { |
| length = I2C1_Read_Buffer(buffer); |
| if (length == 1 && buffer[0] == CMD_RESET) { |
| Reset_Board(OP_STATE_IDLE); |
| } else if (length == 1 && buffer[0] == CMD_ACTIVE) { |
| Reset_Board(OP_STATE_ACTIVE); |
| } |
| } |
| } |
| void Idle_Animation(void) { |
| LED_VALUES leds = {0}; |
| uint8_t led_direction_bar[8] = {1,0,0,0,0,0,0,0}; |
| uint8_t led_direction_dir[8] = {1,0,0,0}; |
| uint8_t led_direction_ind[8] = {1,0,0,0}; |
| uint8_t led_8_high_thres = 0x80; // Max brightness of the middle section |
| uint8_t led_8_next_thresh = 0x40; // Threshold to start the next LED |
| uint8_t led_4_high_thres = 0x80; // Max brightness of the side sections |
| uint8_t led_4_next_thresh = 0x74; // Threshold to start the next LED |
| uint8_t i, next_led; |
| for (i = 0; i < 16; i++) leds.w[i] = 0x00; |
| while (1) { |
| // Check to see if a new message was received |
| Check_I2C_Idle(); |
| // Update the LEDs in the middle section |
| for (i = 0; i < 8; i++) { |
| // Change the LED brightness depending on its direction |
| if (led_direction_bar[i] == 1) { |
| leds.w[i]++; |
| } else if (led_direction_bar[i] == 2) { |
| leds.w[i]--; |
| } |
| // Change direction if peak brightness is reached |
| // When the brightness reaches a middle threshold, start |
| // increasing the brightness of the next LED |
| if (led_direction_bar[i] == 1 && leds.w[i] == led_8_high_thres) { |
| led_direction_bar[i] = 2; |
| } else if (led_direction_bar[i] == 1 && leds.w[i] == led_8_next_thresh) { |
| next_led = (i == 7) ? 0 : i + 1; |
| led_direction_bar[next_led] = 1; |
| } else if (led_direction_bar[i] == 2 && leds.w[i] == 0x00) { |
| led_direction_bar[i] = 0; |
| } |
| } |
| // Update the LEDs in the right section |
| for (i = 0; i < 4; i++) { |
| // Change the LED brightness depending on its direction |
| if (led_direction_dir[i] == 1) { |
| leds.w[i+8]++; |
| } else if (led_direction_dir[i] == 2) { |
| leds.w[i+8]--; |
| } |
| // Change direction if peak brightness is reached |
| // When the brightness reaches a middle threshold, start |
| // increasing the brightness of the next LED |
| if (led_direction_dir[i] == 1 && leds.w[i+8] == led_4_high_thres) { |
| led_direction_dir[i] = 2; |
| } else if (led_direction_dir[i] == 1 && leds.w[i+8] == led_4_next_thresh) { |
| next_led = (i == 3) ? 0 : i + 1; |
| led_direction_dir[next_led] = 1; |
| } else if (led_direction_dir[i] == 2 && leds.w[i+8] == 0x00) { |
| led_direction_dir[i] = 0; |
| } |
| } |
| // Update the LEDs in the left section |
| for (i = 0; i < 4; i++) { |
| // Change the LED brightness depending on its direction |
| if (led_direction_ind[i] == 1) { |
| leds.w[i+12]++; |
| } else if (led_direction_ind[i] == 2) { |
| leds.w[i+12]--; |
| } |
| // Change direction if peak brightness is reached |
| // When the brightness reaches a middle threshold, start |
| // increasing the brightness of the next LED |
| if (led_direction_ind[i] == 1 && leds.w[i+12] == led_4_high_thres) { |
| led_direction_ind[i] = 2; |
| } else if (led_direction_ind[i] == 1 && leds.w[i+12] == led_4_next_thresh) { |
| next_led = (i == 3) ? 0 : i + 1; |
| led_direction_ind[next_led] = 1; |
| } else if (led_direction_ind[i] == 2 && leds.w[i+12] == 0x00) { |
| led_direction_ind[i] = 0; |
| } |
| } |
| // Write the LED values to the controller |
| TLC59116_Write_All(&leds); |
| // Delay a bit to slow down the animation |
| __delay_ms(1); |
| } |
| } |
| //PIC Projects/PICX_16F1829_Controller/nbproject/Makefile-default.mk |
|---|
| 0,0 → 1,252 |
| # |
| # Generated Makefile - do not edit! |
| # |
| # Edit the Makefile in the project folder instead (../Makefile). Each target |
| # has a -pre and a -post target defined where you can add customized code. |
| # |
| # This makefile implements configuration specific macros and targets. |
| # Include project Makefile |
| ifeq "${IGNORE_LOCAL}" "TRUE" |
| # do not include local makefile. User is passing all local related variables already |
| else |
| include Makefile |
| # Include makefile containing local settings |
| ifeq "$(wildcard nbproject/Makefile-local-default.mk)" "nbproject/Makefile-local-default.mk" |
| include nbproject/Makefile-local-default.mk |
| endif |
| endif |
| # Environment |
| MKDIR=gnumkdir -p |
| RM=rm -f |
| MV=mv |
| CP=cp |
| # Macros |
| CND_CONF=default |
| ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
| IMAGE_TYPE=debug |
| OUTPUT_SUFFIX=elf |
| DEBUGGABLE_SUFFIX=elf |
| FINAL_IMAGE=dist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
| else |
| IMAGE_TYPE=production |
| OUTPUT_SUFFIX=hex |
| DEBUGGABLE_SUFFIX=elf |
| FINAL_IMAGE=dist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
| endif |
| # Object Directory |
| OBJECTDIR=build/${CND_CONF}/${IMAGE_TYPE} |
| # Distribution Directory |
| DISTDIR=dist/${CND_CONF}/${IMAGE_TYPE} |
| # Source Files Quoted if spaced |
| SOURCEFILES_QUOTED_IF_SPACED=main.c I2C1.c INTERRUPTS.c I2C2.c TLC59116.c MCP23009.c IO.c CPS.c |
| # Object Files Quoted if spaced |
| OBJECTFILES_QUOTED_IF_SPACED=${OBJECTDIR}/main.p1 ${OBJECTDIR}/I2C1.p1 ${OBJECTDIR}/INTERRUPTS.p1 ${OBJECTDIR}/I2C2.p1 ${OBJECTDIR}/TLC59116.p1 ${OBJECTDIR}/MCP23009.p1 ${OBJECTDIR}/IO.p1 ${OBJECTDIR}/CPS.p1 |
| POSSIBLE_DEPFILES=${OBJECTDIR}/main.p1.d ${OBJECTDIR}/I2C1.p1.d ${OBJECTDIR}/INTERRUPTS.p1.d ${OBJECTDIR}/I2C2.p1.d ${OBJECTDIR}/TLC59116.p1.d ${OBJECTDIR}/MCP23009.p1.d ${OBJECTDIR}/IO.p1.d ${OBJECTDIR}/CPS.p1.d |
| # Object Files |
| OBJECTFILES=${OBJECTDIR}/main.p1 ${OBJECTDIR}/I2C1.p1 ${OBJECTDIR}/INTERRUPTS.p1 ${OBJECTDIR}/I2C2.p1 ${OBJECTDIR}/TLC59116.p1 ${OBJECTDIR}/MCP23009.p1 ${OBJECTDIR}/IO.p1 ${OBJECTDIR}/CPS.p1 |
| # Source Files |
| SOURCEFILES=main.c I2C1.c INTERRUPTS.c I2C2.c TLC59116.c MCP23009.c IO.c CPS.c |
| CFLAGS= |
| ASFLAGS= |
| LDLIBSOPTIONS= |
| ############# Tool locations ########################################## |
| # If you copy a project from one host to another, the path where the # |
| # compiler is installed may be different. # |
| # If you open this project with MPLAB X in the new host, this # |
| # makefile will be regenerated and the paths will be corrected. # |
| ####################################################################### |
| # fixDeps replaces a bunch of sed/cat/printf statements that slow down the build |
| FIXDEPS=fixDeps |
| .build-conf: ${BUILD_SUBPROJECTS} |
| ${MAKE} ${MAKE_OPTIONS} -f nbproject/Makefile-default.mk dist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
| MP_PROCESSOR_OPTION=16LF1829 |
| # ------------------------------------------------------------------------------------ |
| # Rules for buildStep: compile |
| ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
| ${OBJECTDIR}/main.p1: main.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/main.p1.d |
| @${RM} ${OBJECTDIR}/main.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G -D__DEBUG=1 --debugger=pickit3 --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/main.p1 main.c |
| @-${MV} ${OBJECTDIR}/main.d ${OBJECTDIR}/main.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/main.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/I2C1.p1: I2C1.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/I2C1.p1.d |
| @${RM} ${OBJECTDIR}/I2C1.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G -D__DEBUG=1 --debugger=pickit3 --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/I2C1.p1 I2C1.c |
| @-${MV} ${OBJECTDIR}/I2C1.d ${OBJECTDIR}/I2C1.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/I2C1.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/INTERRUPTS.p1: INTERRUPTS.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/INTERRUPTS.p1.d |
| @${RM} ${OBJECTDIR}/INTERRUPTS.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G -D__DEBUG=1 --debugger=pickit3 --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/INTERRUPTS.p1 INTERRUPTS.c |
| @-${MV} ${OBJECTDIR}/INTERRUPTS.d ${OBJECTDIR}/INTERRUPTS.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/INTERRUPTS.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/I2C2.p1: I2C2.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/I2C2.p1.d |
| @${RM} ${OBJECTDIR}/I2C2.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G -D__DEBUG=1 --debugger=pickit3 --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/I2C2.p1 I2C2.c |
| @-${MV} ${OBJECTDIR}/I2C2.d ${OBJECTDIR}/I2C2.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/I2C2.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/TLC59116.p1: TLC59116.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/TLC59116.p1.d |
| @${RM} ${OBJECTDIR}/TLC59116.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G -D__DEBUG=1 --debugger=pickit3 --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/TLC59116.p1 TLC59116.c |
| @-${MV} ${OBJECTDIR}/TLC59116.d ${OBJECTDIR}/TLC59116.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/TLC59116.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/MCP23009.p1: MCP23009.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/MCP23009.p1.d |
| @${RM} ${OBJECTDIR}/MCP23009.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G -D__DEBUG=1 --debugger=pickit3 --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/MCP23009.p1 MCP23009.c |
| @-${MV} ${OBJECTDIR}/MCP23009.d ${OBJECTDIR}/MCP23009.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/MCP23009.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/IO.p1: IO.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/IO.p1.d |
| @${RM} ${OBJECTDIR}/IO.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G -D__DEBUG=1 --debugger=pickit3 --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/IO.p1 IO.c |
| @-${MV} ${OBJECTDIR}/IO.d ${OBJECTDIR}/IO.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/IO.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/CPS.p1: CPS.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/CPS.p1.d |
| @${RM} ${OBJECTDIR}/CPS.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G -D__DEBUG=1 --debugger=pickit3 --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/CPS.p1 CPS.c |
| @-${MV} ${OBJECTDIR}/CPS.d ${OBJECTDIR}/CPS.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/CPS.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| else |
| ${OBJECTDIR}/main.p1: main.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/main.p1.d |
| @${RM} ${OBJECTDIR}/main.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/main.p1 main.c |
| @-${MV} ${OBJECTDIR}/main.d ${OBJECTDIR}/main.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/main.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/I2C1.p1: I2C1.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/I2C1.p1.d |
| @${RM} ${OBJECTDIR}/I2C1.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/I2C1.p1 I2C1.c |
| @-${MV} ${OBJECTDIR}/I2C1.d ${OBJECTDIR}/I2C1.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/I2C1.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/INTERRUPTS.p1: INTERRUPTS.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/INTERRUPTS.p1.d |
| @${RM} ${OBJECTDIR}/INTERRUPTS.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/INTERRUPTS.p1 INTERRUPTS.c |
| @-${MV} ${OBJECTDIR}/INTERRUPTS.d ${OBJECTDIR}/INTERRUPTS.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/INTERRUPTS.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/I2C2.p1: I2C2.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/I2C2.p1.d |
| @${RM} ${OBJECTDIR}/I2C2.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/I2C2.p1 I2C2.c |
| @-${MV} ${OBJECTDIR}/I2C2.d ${OBJECTDIR}/I2C2.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/I2C2.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/TLC59116.p1: TLC59116.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/TLC59116.p1.d |
| @${RM} ${OBJECTDIR}/TLC59116.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/TLC59116.p1 TLC59116.c |
| @-${MV} ${OBJECTDIR}/TLC59116.d ${OBJECTDIR}/TLC59116.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/TLC59116.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/MCP23009.p1: MCP23009.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/MCP23009.p1.d |
| @${RM} ${OBJECTDIR}/MCP23009.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/MCP23009.p1 MCP23009.c |
| @-${MV} ${OBJECTDIR}/MCP23009.d ${OBJECTDIR}/MCP23009.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/MCP23009.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/IO.p1: IO.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/IO.p1.d |
| @${RM} ${OBJECTDIR}/IO.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/IO.p1 IO.c |
| @-${MV} ${OBJECTDIR}/IO.d ${OBJECTDIR}/IO.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/IO.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/CPS.p1: CPS.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/CPS.p1.d |
| @${RM} ${OBJECTDIR}/CPS.p1 |
| ${MP_CC} --pass1 $(MP_EXTRA_CC_PRE) --chip=$(MP_PROCESSOR_OPTION) -Q -G --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: (%%n) %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -o${OBJECTDIR}/CPS.p1 CPS.c |
| @-${MV} ${OBJECTDIR}/CPS.d ${OBJECTDIR}/CPS.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/CPS.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| endif |
| # ------------------------------------------------------------------------------------ |
| # Rules for buildStep: assemble |
| ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
| else |
| endif |
| # ------------------------------------------------------------------------------------ |
| # Rules for buildStep: link |
| ifeq ($(TYPE_IMAGE), DEBUG_RUN) |
| dist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.${OUTPUT_SUFFIX}: ${OBJECTFILES} nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} dist/${CND_CONF}/${IMAGE_TYPE} |
| ${MP_CC} $(MP_EXTRA_LD_PRE) --chip=$(MP_PROCESSOR_OPTION) -G -mdist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.map -D__DEBUG=1 --debugger=pickit3 --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -odist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.${DEBUGGABLE_SUFFIX} ${OBJECTFILES_QUOTED_IF_SPACED} |
| @${RM} dist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.hex |
| else |
| dist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.${OUTPUT_SUFFIX}: ${OBJECTFILES} nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} dist/${CND_CONF}/${IMAGE_TYPE} |
| ${MP_CC} $(MP_EXTRA_LD_PRE) --chip=$(MP_PROCESSOR_OPTION) -G -mdist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.map --double=24 --float=24 --opt=default,+asm,+asmfile,+speed,-space,-debug --addrqual=require --mode=free -P -N255 --warn=0 --asmlist --summary=default,-psect,-class,+mem,-hex,-file --output=default,-inhx032 --runtime=default,+clear,+init,-keep,-no_startup,+osccal,-resetbits,-download,-stackcall,+clib --output=-mcof,+elf "--errformat=%%f:%%l: error: %%s" "--warnformat=%%f:%%l: warning: (%%n) %%s" "--msgformat=%%f:%%l: advisory: (%%n) %%s" -odist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.${DEBUGGABLE_SUFFIX} ${OBJECTFILES_QUOTED_IF_SPACED} |
| endif |
| # Subprojects |
| .build-subprojects: |
| # Subprojects |
| .clean-subprojects: |
| # Clean Targets |
| .clean-conf: ${CLEAN_SUBPROJECTS} |
| ${RM} -r build/default |
| ${RM} -r dist/default |
| # Enable dependency checking |
| .dep.inc: .depcheck-impl |
| DEPFILES=$(shell mplabwildcard ${POSSIBLE_DEPFILES}) |
| ifneq (${DEPFILES},) |
| include ${DEPFILES} |
| endif |
| //PIC Projects/PICX_16F1829_Controller/nbproject/Makefile-genesis.properties |
|---|
| 0,0 → 1,8 |
| # |
| #Wed Mar 19 00:58:38 EDT 2014 |
| default.languagetoolchain.dir=C\:\\Program Files (x86)\\Microchip\\xc8\\v1.20\\bin |
| com-microchip-mplab-nbide-embedded-makeproject-MakeProject.md5=1f98a0eed69cb2a45c12981fa9470927 |
| default.languagetoolchain.version=1.20 |
| host.platform=windows |
| conf.ids=default |
| default.com-microchip-mplab-nbide-toolchainXC8-XC8LanguageToolchain.md5=52258db7536b2d1fec300cefc7ed9230 |
| //PIC Projects/PICX_16F1829_Controller/nbproject/configurations.xml |
|---|
| 0,0 → 1,173 |
| <?xml version="1.0" encoding="UTF-8"?> |
| <configurationDescriptor version="62"> |
| <logicalFolder name="root" displayName="root" projectFiles="true"> |
| <logicalFolder name="HeaderFiles" |
| displayName="Header Files" |
| projectFiles="true"> |
| <itemPath>defines.h</itemPath> |
| <itemPath>I2C1.h</itemPath> |
| <itemPath>INTERRUPTS.h</itemPath> |
| <itemPath>I2C2.h</itemPath> |
| <itemPath>TLC59116.h</itemPath> |
| <itemPath>MCP23009.h</itemPath> |
| <itemPath>IO.h</itemPath> |
| <itemPath>CPS.h</itemPath> |
| </logicalFolder> |
| <logicalFolder name="LinkerScript" |
| displayName="Linker Files" |
| projectFiles="true"> |
| </logicalFolder> |
| <logicalFolder name="SourceFiles" |
| displayName="Source Files" |
| projectFiles="true"> |
| <itemPath>main.c</itemPath> |
| <itemPath>I2C1.c</itemPath> |
| <itemPath>INTERRUPTS.c</itemPath> |
| <itemPath>I2C2.c</itemPath> |
| <itemPath>TLC59116.c</itemPath> |
| <itemPath>MCP23009.c</itemPath> |
| <itemPath>IO.c</itemPath> |
| <itemPath>CPS.c</itemPath> |
| </logicalFolder> |
| <logicalFolder name="ExternalFiles" |
| displayName="Important Files" |
| projectFiles="false"> |
| <itemPath>Makefile</itemPath> |
| </logicalFolder> |
| </logicalFolder> |
| <projectmakefile>Makefile</projectmakefile> |
| <confs> |
| <conf name="default" type="2"> |
| <toolsSet> |
| <developmentServer>localhost</developmentServer> |
| <targetDevice>PIC16LF1829</targetDevice> |
| <targetHeader></targetHeader> |
| <targetPluginBoard></targetPluginBoard> |
| <platformTool>PICkit3PlatformTool</platformTool> |
| <languageToolchain>XC8</languageToolchain> |
| <languageToolchainVersion>1.20</languageToolchainVersion> |
| <platform>3</platform> |
| </toolsSet> |
| <compileType> |
| <linkerTool> |
| <linkerLibItems> |
| </linkerLibItems> |
| </linkerTool> |
| <loading> |
| <useAlternateLoadableFile>false</useAlternateLoadableFile> |
| <alternateLoadableFile></alternateLoadableFile> |
| </loading> |
| </compileType> |
| <makeCustomizationType> |
| <makeCustomizationPreStepEnabled>false</makeCustomizationPreStepEnabled> |
| <makeCustomizationPreStep></makeCustomizationPreStep> |
| <makeCustomizationPostStepEnabled>false</makeCustomizationPostStepEnabled> |
| <makeCustomizationPostStep></makeCustomizationPostStep> |
| <makeCustomizationPutChecksumInUserID>false</makeCustomizationPutChecksumInUserID> |
| <makeCustomizationEnableLongLines>false</makeCustomizationEnableLongLines> |
| <makeCustomizationNormalizeHexFile>false</makeCustomizationNormalizeHexFile> |
| </makeCustomizationType> |
| <HI-TECH-COMP> |
| <property key="asmlist" value="true"/> |
| <property key="define-macros" value=""/> |
| <property key="extra-include-directories" value=""/> |
| <property key="identifier-length" value="255"/> |
| <property key="operation-mode" value="free"/> |
| <property key="opt-xc8-compiler-strict_ansi" value="false"/> |
| <property key="optimization-assembler" value="true"/> |
| <property key="optimization-assembler-files" value="true"/> |
| <property key="optimization-debug" value="false"/> |
| <property key="optimization-global" value="true"/> |
| <property key="optimization-level" value="9"/> |
| <property key="optimization-set" value="default"/> |
| <property key="optimization-speed" value="true"/> |
| <property key="preprocess-assembler" value="true"/> |
| <property key="undefine-macros" value=""/> |
| <property key="use-cci" value="false"/> |
| <property key="use-iar" value="false"/> |
| <property key="verbose" value="false"/> |
| <property key="warning-level" value="0"/> |
| <property key="what-to-do" value="require"/> |
| </HI-TECH-COMP> |
| <HI-TECH-LINK> |
| <property key="additional-options-checksum" value=""/> |
| <property key="additional-options-code-offset" value=""/> |
| <property key="additional-options-command-line" value=""/> |
| <property key="additional-options-errata" value=""/> |
| <property key="additional-options-extend-address" value="false"/> |
| <property key="additional-options-trace-type" value=""/> |
| <property key="additional-options-use-response-files" value="false"/> |
| <property key="backup-reset-condition-flags" value="false"/> |
| <property key="calibrate-oscillator" value="true"/> |
| <property key="calibrate-oscillator-value" value=""/> |
| <property key="clear-bss" value="true"/> |
| <property key="code-model-external" value="wordwrite"/> |
| <property key="code-model-rom" value=""/> |
| <property key="create-html-files" value="false"/> |
| <property key="data-model-ram" value=""/> |
| <property key="data-model-size-of-double" value="24"/> |
| <property key="data-model-size-of-float" value="24"/> |
| <property key="display-class-usage" value="false"/> |
| <property key="display-hex-usage" value="false"/> |
| <property key="display-overall-usage" value="true"/> |
| <property key="display-psect-usage" value="false"/> |
| <property key="fill-flash-options-addr" value=""/> |
| <property key="fill-flash-options-const" value=""/> |
| <property key="fill-flash-options-how" value="0"/> |
| <property key="fill-flash-options-inc-const" value="1"/> |
| <property key="fill-flash-options-increment" value=""/> |
| <property key="fill-flash-options-seq" value=""/> |
| <property key="fill-flash-options-what" value="0"/> |
| <property key="format-hex-file-for-download" value="false"/> |
| <property key="initialize-data" value="true"/> |
| <property key="keep-generated-startup.as" value="false"/> |
| <property key="link-in-c-library" value="true"/> |
| <property key="link-in-peripheral-library" value="true"/> |
| <property key="managed-stack" value="false"/> |
| <property key="opt-xc8-linker-file" value="false"/> |
| <property key="opt-xc8-linker-link_startup" value="false"/> |
| <property key="opt-xc8-linker-serial" value=""/> |
| <property key="program-the-device-with-default-config-words" value="true"/> |
| </HI-TECH-LINK> |
| <PICkit3PlatformTool> |
| <property key="AutoSelectMemRanges" value="auto"/> |
| <property key="Freeze Peripherals" value="true"/> |
| <property key="SecureSegment.SegmentProgramming" value="FullChipProgramming"/> |
| <property key="ToolFirmwareFilePath" |
| value="Press to browse for a specific firmware version"/> |
| <property key="ToolFirmwareOption.UseLatestFirmware" value="true"/> |
| <property key="hwtoolclock.frcindebug" value="false"/> |
| <property key="memories.aux" value="false"/> |
| <property key="memories.bootflash" value="false"/> |
| <property key="memories.configurationmemory" value="false"/> |
| <property key="memories.eeprom" value="false"/> |
| <property key="memories.flashdata" value="true"/> |
| <property key="memories.id" value="false"/> |
| <property key="memories.programmemory" value="true"/> |
| <property key="memories.programmemory.end" value="0x1fff"/> |
| <property key="memories.programmemory.start" value="0x0"/> |
| <property key="poweroptions.powerenable" value="true"/> |
| <property key="programmertogo.imagename" value=""/> |
| <property key="programoptions.eraseb4program" value="true"/> |
| <property key="programoptions.pgmspeed" value="2"/> |
| <property key="programoptions.preserveeeprom" value="false"/> |
| <property key="programoptions.preserveprogramrange" value="false"/> |
| <property key="programoptions.preserveprogramrange.end" value="0x1fff"/> |
| <property key="programoptions.preserveprogramrange.start" value="0x0"/> |
| <property key="programoptions.preserveuserid" value="false"/> |
| <property key="programoptions.testmodeentrymethod" value="VPPFirst"/> |
| <property key="programoptions.usehighvoltageonmclr" value="false"/> |
| <property key="programoptions.uselvpprogramming" value="false"/> |
| <property key="voltagevalue" value="3.25"/> |
| </PICkit3PlatformTool> |
| <XC8-config-global> |
| <property key="advanced-elf" value="true"/> |
| <property key="output-file-format" value="-mcof,+elf"/> |
| <property key="stack-size-high" value="auto"/> |
| <property key="stack-size-low" value="auto"/> |
| <property key="stack-size-main" value="auto"/> |
| <property key="stack-type" value="compiled"/> |
| </XC8-config-global> |
| </conf> |
| </confs> |
| </configurationDescriptor> |
| //PIC Projects/PICX_16F1829_Controller/nbproject/Makefile-impl.mk |
|---|
| 0,0 → 1,69 |
| # |
| # Generated Makefile - do not edit! |
| # |
| # Edit the Makefile in the project folder instead (../Makefile). Each target |
| # has a pre- and a post- target defined where you can add customization code. |
| # |
| # This makefile implements macros and targets common to all configurations. |
| # |
| # NOCDDL |
| # Building and Cleaning subprojects are done by default, but can be controlled with the SUB |
| # macro. If SUB=no, subprojects will not be built or cleaned. The following macro |
| # statements set BUILD_SUB-CONF and CLEAN_SUB-CONF to .build-reqprojects-conf |
| # and .clean-reqprojects-conf unless SUB has the value 'no' |
| SUB_no=NO |
| SUBPROJECTS=${SUB_${SUB}} |
| BUILD_SUBPROJECTS_=.build-subprojects |
| BUILD_SUBPROJECTS_NO= |
| BUILD_SUBPROJECTS=${BUILD_SUBPROJECTS_${SUBPROJECTS}} |
| CLEAN_SUBPROJECTS_=.clean-subprojects |
| CLEAN_SUBPROJECTS_NO= |
| CLEAN_SUBPROJECTS=${CLEAN_SUBPROJECTS_${SUBPROJECTS}} |
| # Project Name |
| PROJECTNAME=PICX_16F1829_Controller |
| # Active Configuration |
| DEFAULTCONF=default |
| CONF=${DEFAULTCONF} |
| # All Configurations |
| ALLCONFS=default |
| # build |
| .build-impl: .build-pre |
| ${MAKE} -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .build-conf |
| # clean |
| .clean-impl: .clean-pre |
| ${MAKE} -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .clean-conf |
| # clobber |
| .clobber-impl: .clobber-pre .depcheck-impl |
| ${MAKE} SUBPROJECTS=${SUBPROJECTS} CONF=default clean |
| # all |
| .all-impl: .all-pre .depcheck-impl |
| ${MAKE} SUBPROJECTS=${SUBPROJECTS} CONF=default build |
| # dependency checking support |
| .depcheck-impl: |
| # @echo "# This code depends on make tool being used" >.dep.inc |
| # @if [ -n "${MAKE_VERSION}" ]; then \ |
| # echo "DEPFILES=\$$(wildcard \$$(addsuffix .d, \$${OBJECTFILES}))" >>.dep.inc; \ |
| # echo "ifneq (\$${DEPFILES},)" >>.dep.inc; \ |
| # echo "include \$${DEPFILES}" >>.dep.inc; \ |
| # echo "endif" >>.dep.inc; \ |
| # else \ |
| # echo ".KEEP_STATE:" >>.dep.inc; \ |
| # echo ".KEEP_STATE_FILE:.make.state.\$${CONF}" >>.dep.inc; \ |
| # fi |
| //PIC Projects/PICX_16F1829_Controller/nbproject/Makefile-local-default.mk |
|---|
| 0,0 → 1,37 |
| # |
| # Generated Makefile - do not edit! |
| # |
| # |
| # This file contains information about the location of compilers and other tools. |
| # If you commmit this file into your revision control server, you will be able to |
| # to checkout the project and build it from the command line with make. However, |
| # if more than one person works on the same project, then this file might show |
| # conflicts since different users are bound to have compilers in different places. |
| # In that case you might choose to not commit this file and let MPLAB X recreate this file |
| # for each user. The disadvantage of not commiting this file is that you must run MPLAB X at |
| # least once so the file gets created and the project can be built. Finally, you can also |
| # avoid using this file at all if you are only building from the command line with make. |
| # You can invoke make with the values of the macros: |
| # $ makeMP_CC="/opt/microchip/mplabc30/v3.30c/bin/pic30-gcc" ... |
| # |
| SHELL=cmd.exe |
| PATH_TO_IDE_BIN=C:/Program Files (x86)/Microchip/MPLABX/mplab_ide/mplab_ide/modules/../../bin/ |
| # Adding MPLAB X bin directory to path. |
| PATH:=C:/Program Files (x86)/Microchip/MPLABX/mplab_ide/mplab_ide/modules/../../bin/:$(PATH) |
| # Path to java used to run MPLAB X when this makefile was created |
| MP_JAVA_PATH="C:\Program Files (x86)\Microchip\MPLABX\sys\java\jre1.7.0_25-windows-x64\java-windows/bin/" |
| OS_CURRENT="$(shell uname -s)" |
| MP_CC="C:\Program Files (x86)\Microchip\xc8\v1.20\bin\xc8.exe" |
| # MP_CPPC is not defined |
| # MP_BC is not defined |
| # MP_AS is not defined |
| # MP_LD is not defined |
| # MP_AR is not defined |
| DEP_GEN=${MP_JAVA_PATH}java -jar "C:/Program Files (x86)/Microchip/MPLABX/mplab_ide/mplab_ide/modules/../../bin/extractobjectdependencies.jar" |
| MP_CC_DIR="C:\Program Files (x86)\Microchip\xc8\v1.20\bin" |
| # MP_CPPC_DIR is not defined |
| # MP_BC_DIR is not defined |
| # MP_AS_DIR is not defined |
| # MP_LD_DIR is not defined |
| # MP_AR_DIR is not defined |
| # MP_BC_DIR is not defined |
| //PIC Projects/PICX_16F1829_Controller/nbproject/Makefile-variables.mk |
|---|
| 0,0 → 1,13 |
| # |
| # Generated - do not edit! |
| # |
| # NOCDDL |
| # |
| CND_BASEDIR=`pwd` |
| # default configuration |
| CND_ARTIFACT_DIR_default=dist/default/production |
| CND_ARTIFACT_NAME_default=PICX_16F1829_Controller.production.hex |
| CND_ARTIFACT_PATH_default=dist/default/production/PICX_16F1829_Controller.production.hex |
| CND_PACKAGE_DIR_default=${CND_DISTDIR}/default/package |
| CND_PACKAGE_NAME_default=picx16f1829controller.tar |
| CND_PACKAGE_PATH_default=${CND_DISTDIR}/default/package/picx16f1829controller.tar |
| //PIC Projects/PICX_16F1829_Controller/nbproject/Package-default.bash |
|---|
| 0,0 → 1,73 |
| #!/bin/bash -x |
| # |
| # Generated - do not edit! |
| # |
| # Macros |
| TOP=`pwd` |
| CND_CONF=default |
| CND_DISTDIR=dist |
| TMPDIR=build/${CND_CONF}/${IMAGE_TYPE}/tmp-packaging |
| TMPDIRNAME=tmp-packaging |
| OUTPUT_PATH=dist/${CND_CONF}/${IMAGE_TYPE}/PICX_16F1829_Controller.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
| OUTPUT_BASENAME=PICX_16F1829_Controller.${IMAGE_TYPE}.${OUTPUT_SUFFIX} |
| PACKAGE_TOP_DIR=picx16f1829controller/ |
| # Functions |
| function checkReturnCode |
| { |
| rc=$? |
| if [ $rc != 0 ] |
| then |
| exit $rc |
| fi |
| } |
| function makeDirectory |
| # $1 directory path |
| # $2 permission (optional) |
| { |
| mkdir -p "$1" |
| checkReturnCode |
| if [ "$2" != "" ] |
| then |
| chmod $2 "$1" |
| checkReturnCode |
| fi |
| } |
| function copyFileToTmpDir |
| # $1 from-file path |
| # $2 to-file path |
| # $3 permission |
| { |
| cp "$1" "$2" |
| checkReturnCode |
| if [ "$3" != "" ] |
| then |
| chmod $3 "$2" |
| checkReturnCode |
| fi |
| } |
| # Setup |
| cd "${TOP}" |
| mkdir -p ${CND_DISTDIR}/${CND_CONF}/package |
| rm -rf ${TMPDIR} |
| mkdir -p ${TMPDIR} |
| # Copy files and create directories and links |
| cd "${TOP}" |
| makeDirectory ${TMPDIR}/picx16f1829controller/bin |
| copyFileToTmpDir "${OUTPUT_PATH}" "${TMPDIR}/${PACKAGE_TOP_DIR}bin/${OUTPUT_BASENAME}" 0755 |
| # Generate tar file |
| cd "${TOP}" |
| rm -f ${CND_DISTDIR}/${CND_CONF}/package/picx16f1829controller.tar |
| cd ${TMPDIR} |
| tar -vcf ../../../../${CND_DISTDIR}/${CND_CONF}/package/picx16f1829controller.tar * |
| checkReturnCode |
| # Cleanup |
| cd "${TOP}" |
| rm -rf ${TMPDIR} |
| //PIC Projects/PICX_16F1829_Controller/nbproject/project.properties |
|---|
| --- nbproject/project.xml (nonexistent) |
| +++ nbproject/project.xml (revision 342) |
| @@ -0,0 +1,16 @@ |
| +<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://www.netbeans.org/ns/project/1"> |
| + <type>com.microchip.mplab.nbide.embedded.makeproject</type> |
| + <configuration> |
| + <data xmlns="http://www.netbeans.org/ns/make-project/1"> |
| + <name>PICX_16F1829_Controller</name> |
| + <creation-uuid>a37f9b7c-e474-41b7-9a5b-bc6808e97a44</creation-uuid> |
| + <make-project-type>0</make-project-type> |
| + <c-extensions>c</c-extensions> |
| + <cpp-extensions/> |
| + <header-extensions>h</header-extensions> |
| + <sourceEncoding>ISO-8859-1</sourceEncoding> |
| + <asminc-extensions/> |
| + <make-dep-projects/> |
| + </data> |
| + </configuration> |
| +</project> |
| //PIC Projects/PICX_16F1829_Controller/I2C1.h |
|---|
| 0,0 → 1,82 |
| #ifndef I2C1_H |
| #define I2C1_H |
| #define MAXI2C1BUF 32 |
| // I2C Operating Speed |
| #define I2C_100KHZ 0x0 |
| #define I2C_400KHZ 0x1 |
| #define I2C_1MHZ 0x2 |
| // Operating State |
| #define I2C_IDLE 0x1 |
| #define I2C_STARTED 0x2 |
| #define I2C_RCV_DATA 0x3 |
| #define I2C_SEND_DATA 0x4 |
| #define I2C_SEND_ADDR 0x5 |
| #define I2C_SEND_ADDR_2 0x6 |
| #define I2C_CHECK_ACK_SEND 0x7 |
| #define I2C_CHECK_ACK_RECV 0x8 |
| #define I2C_CHECK_ACK_RESTART 0x9 |
| #define I2C_REQ_DATA 0xA |
| #define I2C_SEND_STOP 0xB |
| #define I2C_SEND_START 0xC |
| // Operating Mode |
| #define I2C_MODE_SLAVE 0x10 |
| #define I2C_MODE_MASTER 0x11 |
| // Master Status |
| #define I2C_MASTER_SEND 0x20 |
| #define I2C_MASTER_RECV 0x21 |
| #define I2C_MASTER_RESTART 0x22 |
| #define I2C_MASTER_IDLE 0x23 |
| // Return Status |
| #define I2C_SEND_OK 0x30 |
| #define I2C_SEND_FAIL 0x31 |
| #define I2C_RECV_OK 0x32 |
| #define I2C_RECV_FAIL 0x33 |
| #define I2C_DATA_AVAL 0x34 |
| #define I2C_ERR_NOADDR 0x35 |
| #define I2C_ERR_OVERRUN 0x36 |
| #define I2C_ERR_NODATA 0x37 |
| #define I2C_ERR_BUFFER_OVERRUN 0x38 |
| typedef struct { |
| uint8_t buffer_in[MAXI2C1BUF]; |
| uint8_t buffer_in_len; |
| uint8_t buffer_in_len_tmp; |
| uint8_t buffer_in_read_ind; |
| uint8_t buffer_in_write_ind; |
| uint8_t buffer_out[MAXI2C1BUF]; |
| uint8_t buffer_out_len; |
| uint8_t buffer_out_ind; |
| uint8_t operating_mode; |
| uint8_t operating_state; |
| uint8_t return_status; |
| uint8_t master_dest_addr; |
| uint8_t master_status; |
| uint8_t slave_in_last_byte; |
| uint8_t slave_sending_data; |
| } I2C1_DATA; |
| void I2C1_Init(I2C1_DATA *data); |
| void I2C1_Interrupt_Handler(void); |
| void I2C1_Interrupt_Slave(void); |
| void I2C1_Interrupt_Master(void); |
| void I2C1_Configure_Slave(uint8_t address); |
| void I2C1_Configure_Master(uint8_t speed); |
| void I2C1_Master_Send(uint8_t address, uint8_t length, uint8_t *msg); |
| void I2C1_Master_Recv(uint8_t address, uint8_t length); |
| void I2C1_Master_Restart(uint8_t address, uint8_t msg, uint8_t length); |
| uint8_t I2C1_Get_Status(void); |
| uint8_t I2C1_Buffer_Len(void); |
| uint8_t I2C1_Read_Buffer(uint8_t *buffer); |
| uint8_t I2C1_Process_Receive(uint8_t); |
| #endif |
| //PIC Projects/PICX_16F1829_Controller/I2C2.h |
|---|
| 0,0 → 1,82 |
| #ifndef I2C2_H |
| #define I2C2_H |
| #define MAXI2C2BUF 32 |
| // I2C Operating Speed |
| #define I2C_100KHZ 0x0 |
| #define I2C_400KHZ 0x1 |
| #define I2C_1MHZ 0x2 |
| // Operating State |
| #define I2C_IDLE 0x1 |
| #define I2C_STARTED 0x2 |
| #define I2C_RCV_DATA 0x3 |
| #define I2C_SEND_DATA 0x4 |
| #define I2C_SEND_ADDR 0x5 |
| #define I2C_SEND_ADDR_2 0x6 |
| #define I2C_CHECK_ACK_SEND 0x7 |
| #define I2C_CHECK_ACK_RECV 0x8 |
| #define I2C_CHECK_ACK_RESTART 0x9 |
| #define I2C_REQ_DATA 0xA |
| #define I2C_SEND_STOP 0xB |
| #define I2C_SEND_START 0xC |
| // Operating Mode |
| #define I2C_MODE_SLAVE 0x10 |
| #define I2C_MODE_MASTER 0x11 |
| // Master Status |
| #define I2C_MASTER_SEND 0x20 |
| #define I2C_MASTER_RECV 0x21 |
| #define I2C_MASTER_RESTART 0x22 |
| #define I2C_MASTER_IDLE 0x23 |
| // Return Status |
| #define I2C_SEND_OK 0x30 |
| #define I2C_SEND_FAIL 0x31 |
| #define I2C_RECV_OK 0x32 |
| #define I2C_RECV_FAIL 0x33 |
| #define I2C_DATA_AVAL 0x34 |
| #define I2C_ERR_NOADDR 0x35 |
| #define I2C_ERR_OVERRUN 0x36 |
| #define I2C_ERR_NODATA 0x37 |
| #define I2C_ERR_BUFFER_OVERRUN 0x38 |
| typedef struct { |
| uint8_t buffer_in[MAXI2C2BUF]; |
| uint8_t buffer_in_len; |
| uint8_t buffer_in_len_tmp; |
| uint8_t buffer_in_read_ind; |
| uint8_t buffer_in_write_ind; |
| uint8_t buffer_out[MAXI2C2BUF]; |
| uint8_t buffer_out_len; |
| uint8_t buffer_out_ind; |
| uint8_t operating_mode; |
| uint8_t operating_state; |
| uint8_t return_status; |
| uint8_t master_dest_addr; |
| uint8_t master_status; |
| uint8_t slave_in_last_byte; |
| uint8_t slave_sending_data; |
| } I2C2_DATA; |
| void I2C2_Init(I2C2_DATA *data); |
| void I2C2_Interrupt_Handler(void); |
| void I2C2_Interrupt_Slave(void); |
| void I2C2_Interrupt_Master(void); |
| void I2C2_Configure_Slave(uint8_t address); |
| void I2C2_Configure_Master(uint8_t speed); |
| void I2C2_Master_Send(uint8_t address, uint8_t length, uint8_t *msg); |
| void I2C2_Master_Recv(uint8_t address, uint8_t length); |
| void I2C2_Master_Restart(uint8_t address, uint8_t msg, uint8_t length); |
| uint8_t I2C2_Get_Status(void); |
| uint8_t I2C2_Buffer_Len(void); |
| uint8_t I2C2_Read_Buffer(uint8_t *buffer); |
| uint8_t I2C2_Process_Receive(uint8_t); |
| #endif |
| //PIC Projects/PICX_16F1829_Controller/MCP23009.c |
|---|
| 0,0 → 1,40 |
| #include "defines.h" |
| #include "MCP23009.h" |
| #include "I2C2.h" |
| static BTN_STATUS *status_ptr; |
| void MCP23009_Init(BTN_STATUS *status) { |
| status_ptr = status; |
| uint8_t buffer[8]; |
| buffer[0] = 0x00; // Starting register address |
| buffer[1] = 0xFF; // IODIR, Set all pins as inputs |
| buffer[2] = 0xFF; // IPOL, Reported values are inverted |
| // buffer[3] = 0xFF; // GPINTEN, Enable interrupt-on-change |
| buffer[3] = 0x00; // GPINTEN, Disable interrupt-on-change |
| buffer[4] = 0x00; // DEFVAL, IOC default values |
| buffer[5] = 0x00; // INTCON, IOC compare to previous value |
| buffer[6] = 0x00; // IOCON, Incrementing address, active-low interrupt cleared on GPIO read |
| buffer[7] = 0xFF; // GPPU, Enable pull-ups on all pins |
| I2C2_Master_Send(MCP23009_ADDR, 8, buffer); |
| uint8_t result; |
| do { |
| result = I2C2_Get_Status(); |
| } while (!result); |
| } |
| void MCP23009_Query(void) { |
| uint8_t buffer[2]; |
| I2C2_Master_Restart(MCP23009_ADDR, MCP23009_GPIOA, 1); |
| uint8_t result; |
| do { |
| result = I2C2_Get_Status(); |
| } while (!result); |
| I2C2_Read_Buffer(buffer); |
| status_ptr->w = buffer[0]; |
| } |
| //PIC Projects/PICX_16F1829_Controller/IO.h |
|---|
| 0,0 → 1,13 |
| #ifndef IO_H |
| #define IO_H |
| typedef struct { |
| uint8_t btn_change; |
| } IO_DATA; |
| void IO_Init(void); |
| void IO_IOC_Enable(void); |
| void IO_Interrupt(void); |
| #endif /* IO_H */ |
| //PIC Projects/PICX_16F1829_Controller/MCP23009.h |
|---|
| 0,0 → 1,23 |
| #ifndef MCP23009_H |
| #define MCP23009_H |
| #define MCP23009_ADDR 0x20 |
| #define MCP23009_IODIRA 0x00 |
| #define MCP23009_IPOLA 0x01 |
| #define MCP23009_GPINTENA 0x02 |
| #define MCP23009_DEFVALA 0x03 |
| #define MCP23009_INTCONA 0x04 |
| #define MCP23009_IOCON 0x05 |
| #define MCP23009_GPPUA 0x06 |
| #define MCP23009_INTFA 0x07 |
| #define MCP23009_INTCAPA 0x08 |
| #define MCP23009_GPIOA 0x09 |
| #define MCP23009_OLATA 0x0A |
| void MCP23009_Init(BTN_STATUS *status); |
| void MCP23009_Query(void); |
| void MSP23009_Interrupt(void); |
| #endif /* MCP23009_H */ |
| //PIC Projects/PICX_16F1829_Controller/TLC59116.h |
|---|
| 0,0 → 1,56 |
| #ifndef TLC59116_H |
| #define TLC59116_H |
| #define TLC59116_ADDR 0x60 |
| #define TLC59116_ALLCALL 0x68 |
| // Write to this register to reset chip |
| #define TLC59116_RESET 0x6B |
| // Increment all registers, rollover from 00000 to 11011 |
| #define TLC59116_AUTO_INCR_ALL 0x80 |
| // Increment brightness registers, rollover from 00010 to 10001 |
| #define TLC59116_AUTO_INCR_BRIGHTNESS 0xA0 |
| // Increment global control registers, rollover from 10010 to 10011 |
| #define TLC59116_AUTO_INCR_GLBL_CTRL 0xC0 |
| // Increment individual and global registers, rollover from 00010 to 10011 |
| #define TLC59116_AUTO_INCR_INDV_CTRL 0xE0 |
| #define TLC59116_REG_MODE1 0x00 |
| #define TLC59116_REG_MODE2 0x01 |
| #define TLC59116_REG_PWM0 0x02 |
| #define TLC59116_REG_PWM1 0x03 |
| #define TLC59116_REG_PWM2 0x04 |
| #define TLC59116_REG_PWM3 0x05 |
| #define TLC59116_REG_PWM4 0x06 |
| #define TLC59116_REG_PWM5 0x07 |
| #define TLC59116_REG_PWM6 0x08 |
| #define TLC59116_REG_PWM7 0x09 |
| #define TLC59116_REG_PWM8 0x0A |
| #define TLC59116_REG_PWM9 0x0B |
| #define TLC59116_REG_PWM10 0x0C |
| #define TLC59116_REG_PWM11 0x0D |
| #define TLC59116_REG_PWM12 0x0E |
| #define TLC59116_REG_PWM13 0x0F |
| #define TLC59116_REG_PWM14 0x10 |
| #define TLC59116_REG_PWM15 0x11 |
| #define TLC59116_REG_GRPPWM 0x12 |
| #define TLC59116_REG_GRPFREQ 0x13 |
| #define TLC59116_REG_LEDOUT0 0x14 |
| #define TLC59116_REG_LEDOUT1 0x15 |
| #define TLC59116_REG_LEDOUT2 0x16 |
| #define TLC59116_REG_LEDOUT3 0x17 |
| #define TLC59116_REG_SUBADR1 0x18 |
| #define TLC59116_REG_SUBADR2 0x19 |
| #define TLC59116_REG_SUBADR3 0x1A |
| #define TLC59116_REG_ALLCALLADR 0x1B |
| #define TLC59116_REG_IREF 0x1C |
| #define TLC59116_REG_EFLAG1 0x1D |
| #define TLC59116_REG_EFLAG2 0x1E |
| void TLC59116_Init(void); |
| void TLC59116_Write_All(LED_VALUES *values); |
| void TLC59116_Write_BC(uint8_t brightness); |
| #endif /* TLC59116_H */ |
| //PIC Projects/PICX_16F1829_Controller/INTERRUPTS.h |
|---|
| 0,0 → 1,15 |
| #ifndef INTERRUPTS_H |
| #define INTERRUPTS_H |
| // Initialize the interrupts |
| void Interrupt_Init(void); |
| // Enable all interrupts (high and low priority) |
| void Interrupt_Enable(void); |
| // Disable all interrupts (high and low priority) |
| void Interrupt_Disable(void); |
| void interrupt InterruptHandler(void); |
| #endif |
| //PIC Projects/PICX_16F1829_Controller/Makefile |
|---|
| 0,0 → 1,113 |
| # |
| # There exist several targets which are by default empty and which can be |
| # used for execution of your targets. These targets are usually executed |
| # before and after some main targets. They are: |
| # |
| # .build-pre: called before 'build' target |
| # .build-post: called after 'build' target |
| # .clean-pre: called before 'clean' target |
| # .clean-post: called after 'clean' target |
| # .clobber-pre: called before 'clobber' target |
| # .clobber-post: called after 'clobber' target |
| # .all-pre: called before 'all' target |
| # .all-post: called after 'all' target |
| # .help-pre: called before 'help' target |
| # .help-post: called after 'help' target |
| # |
| # Targets beginning with '.' are not intended to be called on their own. |
| # |
| # Main targets can be executed directly, and they are: |
| # |
| # build build a specific configuration |
| # clean remove built files from a configuration |
| # clobber remove all built files |
| # all build all configurations |
| # help print help mesage |
| # |
| # Targets .build-impl, .clean-impl, .clobber-impl, .all-impl, and |
| # .help-impl are implemented in nbproject/makefile-impl.mk. |
| # |
| # Available make variables: |
| # |
| # CND_BASEDIR base directory for relative paths |
| # CND_DISTDIR default top distribution directory (build artifacts) |
| # CND_BUILDDIR default top build directory (object files, ...) |
| # CONF name of current configuration |
| # CND_ARTIFACT_DIR_${CONF} directory of build artifact (current configuration) |
| # CND_ARTIFACT_NAME_${CONF} name of build artifact (current configuration) |
| # CND_ARTIFACT_PATH_${CONF} path to build artifact (current configuration) |
| # CND_PACKAGE_DIR_${CONF} directory of package (current configuration) |
| # CND_PACKAGE_NAME_${CONF} name of package (current configuration) |
| # CND_PACKAGE_PATH_${CONF} path to package (current configuration) |
| # |
| # NOCDDL |
| # Environment |
| MKDIR=mkdir |
| CP=cp |
| CCADMIN=CCadmin |
| RANLIB=ranlib |
| # build |
| build: .build-post |
| .build-pre: |
| # Add your pre 'build' code here... |
| .build-post: .build-impl |
| # Add your post 'build' code here... |
| # clean |
| clean: .clean-post |
| .clean-pre: |
| # Add your pre 'clean' code here... |
| # WARNING: the IDE does not call this target since it takes a long time to |
| # simply run make. Instead, the IDE removes the configuration directories |
| # under build and dist directly without calling make. |
| # This target is left here so people can do a clean when running a clean |
| # outside the IDE. |
| .clean-post: .clean-impl |
| # Add your post 'clean' code here... |
| # clobber |
| clobber: .clobber-post |
| .clobber-pre: |
| # Add your pre 'clobber' code here... |
| .clobber-post: .clobber-impl |
| # Add your post 'clobber' code here... |
| # all |
| all: .all-post |
| .all-pre: |
| # Add your pre 'all' code here... |
| .all-post: .all-impl |
| # Add your post 'all' code here... |
| # help |
| help: .help-post |
| .help-pre: |
| # Add your pre 'help' code here... |
| .help-post: .help-impl |
| # Add your post 'help' code here... |
| # include project implementation makefile |
| include nbproject/Makefile-impl.mk |
| # include project make variables |
| include nbproject/Makefile-variables.mk |