| /PIC Stuff/PICX_12F1840_Clock/DS3231.c |
|---|
| 0,0 → 1,113 |
| #include "defines.h" |
| #include "DS3231.h" |
| #include "I2C1.h" |
| void DS3231_Init() { |
| uint8_t reg[3]; |
| reg[0] = DS3231_CONTROL; |
| /* Control Register (0x0E) |
| * Bit 7 - !EOSC |
| * Bit 6 - BBSQW |
| * Bit 5 - CONV |
| * Bit 4 - RS2 |
| * Bit 3 - RS1 |
| * Bit 2 - INTCN |
| * Bit 1 - A2IE |
| * Bit 0 - A1IE |
| */ |
| reg[1] = 0x04; |
| /* Control Register 2 (0x0F) |
| * Bit 3 = EN32kHZ |
| */ |
| reg[2] = 0x00; |
| // Set the configuration registers |
| I2C1_Master_Send(DS3231_ADDRESS, 3, reg); |
| while (!I2C1_Get_Status()); |
| } |
| uint8_t DS3231_Get_Status(void) { |
| /* Status Register (0x0F) |
| * Bit 7 - OSF |
| * Bit 3 - EN32kHz |
| * Bit 2 - BSY |
| * Bit 1 - A2F |
| * Bit 0 - A1F |
| */ |
| uint8_t value; |
| I2C1_Master_Restart(DS3231_ADDRESS, 0x0F, 1); |
| while (!I2C1_Get_Status()); |
| I2C1_Read_Buffer(&value); |
| return value; |
| } |
| void DS3231_Set_Time(DS3231_TIME *time) { |
| // Format the data in a way that the chip expects |
| #ifndef DS3231_TIME_ONLY |
| uint8_t output[8]; |
| #else |
| uint8_t output[4]; |
| #endif |
| output[0] = DS3231_SECONDS; |
| output[1] = ((time->sec / 10) << 4) | (time->sec % 10); |
| output[2] = ((time->min / 10) << 4) | (time->min % 10); |
| output[3] = ((time->hour / 10) << 4) | (time->hour % 10); |
| #ifndef DS3231_TIME_ONLY |
| if (!time->h_mil) { |
| output[3] |= (time->h_am_pm) ? 0x60 : 0x40; |
| } |
| output[4] = time->day; |
| output[5] = ((time->date / 10) << 4) | (time->date % 10); |
| output[6] = ((time->month / 10) << 4) | (time->month % 10); |
| output[7] = ((time->year / 10) << 4) | (time->year % 10); |
| #endif |
| // Check the status to make sure that it isnt currently busy |
| while (DS3231_Get_Status() & 0x04); |
| // Write the data to the chip |
| #ifndef DS3231_TIME_ONLY |
| I2C1_Master_Send(DS3231_ADDRESS, 8, output); |
| #else |
| I2C1_Master_Send(DS3231_ADDRESS, 4, output); |
| #endif |
| while (!I2C1_Get_Status()); |
| } |
| void DS3231_Get_Time(DS3231_TIME *time) { |
| // Check the status to make sure that it isnt currently busy |
| while (DS3231_Get_Status() & 0x04); |
| // Request time data from the chip |
| #ifndef DS3231_TIME_ONLY |
| uint8_t input[7]; |
| I2C1_Master_Restart(DS3231_ADDRESS, 0x00, 7); |
| #else |
| uint8_t input[3]; |
| I2C1_Master_Restart(DS3231_ADDRESS, 0x00, 3); |
| #endif |
| while (!I2C1_Get_Status()); |
| I2C1_Read_Buffer(input); |
| // Parse BCD format into decimal and return |
| time->sec = ((input[0] >> 4) * 10) + (input[0] & 0x0F); |
| time->min = ((input[1] >> 4) * 10) + (input[1] & 0x0F); |
| if (input[2] & 0x40) { |
| time->h_mil = 0; |
| time->h_am_pm = (input[2] & 0x20) ? 1 : 0; |
| time->hour = (((input[2] >> 4) & 0x01) * 10) + (input[2] & 0x0F); |
| } else { |
| time->h_mil = 1; |
| time->hour = ((input[2] >> 4) * 10) + (input[2] & 0x0F); |
| } |
| #ifndef DS3231_TIME_ONLY |
| time->day = input[3]; |
| time->date = ((input[4] >> 4) * 10) + (input[4] & 0x0F); |
| time->month = ((input[5] >> 4) * 10) + (input[5] & 0x0F); |
| time->year = ((input[6] >> 4) * 10) + (input[6] & 0x0F); |
| #endif |
| } |
| /PIC Stuff/PICX_12F1840_Clock/DS3231.h |
|---|
| 0,0 → 1,54 |
| #ifndef RTC_DS3231_H |
| #define RTC_DS3231_H |
| #define DS3231_ADDRESS 0x68 |
| #define DS3231_SECONDS 0x00 |
| #define DS3231_MINUTES 0x01 |
| #define DS3231_HOUR 0x02 |
| #define DS3231_DAY 0x03 |
| #define DS3231_DATE 0x04 |
| #define DS3231_MONTH 0x05 |
| #define DS3231_YEAR 0x06 |
| #define DS3231_ALARM1_SECONDS 0x07 |
| #define DS3231_ALARM1_MINUTES 0x08 |
| #define DS3231_ALARM1_HOUR 0x09 |
| #define DS3231_ALARM1_DAY_DATE 0x0A |
| #define DS3231_ALARM2_MINUTES 0x0B |
| #define DS3231_ALARM2_HOUR 0x0C |
| #define DS3231_ALARM2_DAY_DATE 0x0D |
| #define DS3231_CONTROL 0x0E |
| #define DS3231_STATUS 0x0F |
| #define DS3231_TIME_ONLY |
| typedef struct { |
| uint8_t sec; |
| uint8_t min; |
| uint8_t hour; |
| uint8_t h_mil; |
| uint8_t h_am_pm; |
| #ifndef DS3231_TIME_ONLY |
| uint8_t day; |
| uint8_t date; |
| uint8_t month; |
| uint8_t year; |
| #endif |
| } DS3231_TIME; |
| void DS3231_Init(void); |
| uint8_t DS3231_Get_Status(void); |
| void DS3231_Set_Time(DS3231_TIME *time); |
| void DS3231_Get_Time(DS3231_TIME *time); |
| //void DS3231_Set_Alarm1(uint8_t sec, uint8_t min, uint8_t hour, uint8_t date, bit mil, bit am_pm, bit dt_dy); |
| //void DS3231_Set_Alarm2(uint8_t min, uint8_t hour, uint8_t date, bit mil, bit am_pm, bit dt_dy); |
| #endif |
| /PIC Stuff/PICX_12F1840_Clock/I2C1.c |
|---|
| 0,0 → 1,320 |
| #include "defines.h" |
| #include "I2C1.h" |
| extern I2C1_DATA i2c_data; |
| // Set up the data structures for the base_I2C.code |
| // Should be called once before any i2c routines are called |
| void I2C1_Init(void) { |
| i2c_data.buffer_in_len = 0; |
| i2c_data.buffer_in_read_ind = 0; |
| i2c_data.buffer_in_write_ind = 0; |
| i2c_data.operating_state = I2C_IDLE; |
| i2c_data.return_status = 0; |
| i2c_data.master_dest_addr = 0; |
| i2c_data.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.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) { |
| if (length == 0) |
| return; |
| // Copy message to send into buffer and save length/address |
| for (uint8_t i = 0; i < length; i++) { |
| i2c_data.buffer_in[i] = msg[i]; |
| } |
| i2c_data.buffer_in_len = length; |
| i2c_data.master_dest_addr = address; |
| i2c_data.buffer_in_read_ind = 0; |
| i2c_data.buffer_in_write_ind = 0; |
| // Change status to 'next' operation |
| i2c_data.operating_state = I2C_SEND_ADDR; |
| i2c_data.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.buffer_in_len = length; |
| i2c_data.master_dest_addr = address; |
| i2c_data.buffer_in_read_ind = 0; |
| i2c_data.buffer_in_write_ind = 0; |
| // Change status to 'next' operation |
| i2c_data.operating_state = I2C_SEND_ADDR; |
| i2c_data.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.buffer_in[0] = msg; |
| i2c_data.buffer_in_len = length; |
| i2c_data.master_dest_addr = address; |
| i2c_data.buffer_in_read_ind = 0; |
| i2c_data.buffer_in_write_ind = 0; |
| // Change status to 'next' operation |
| i2c_data.operating_state = I2C_SEND_ADDR; |
| i2c_data.master_status = I2C_MASTER_RESTART; |
| // Generate start condition |
| SSP1CON2bits.SEN = 1; |
| } |
| void I2C1_Interrupt_Handler() { |
| // If we are in the middle of sending data |
| if (i2c_data.master_status == I2C_MASTER_SEND) { |
| switch (i2c_data.operating_state) { |
| case I2C_IDLE: |
| break; |
| case I2C_SEND_ADDR: |
| // Send the address with read bit set |
| i2c_data.operating_state = I2C_CHECK_ACK_SEND; |
| SSP1BUF = (i2c_data.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.buffer_in_read_ind < i2c_data.buffer_in_len) { |
| SSP1BUF = i2c_data.buffer_in[i2c_data.buffer_in_read_ind]; |
| i2c_data.buffer_in_read_ind++; |
| } else { |
| // If no more data is to be sent, send stop bit |
| i2c_data.operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data.master_status = I2C_MASTER_IDLE; |
| i2c_data.return_status = I2C_SEND_OK; |
| } |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data.operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data.master_status = I2C_MASTER_IDLE; |
| i2c_data.return_status = I2C_SEND_FAIL; |
| } |
| break; |
| } |
| // If we are in the middle of receiving data |
| } else if (i2c_data.master_status == I2C_MASTER_RECV) { |
| switch (i2c_data.operating_state) { |
| case I2C_IDLE: |
| break; |
| case I2C_SEND_ADDR: |
| // Send address with write bit set |
| i2c_data.operating_state = I2C_CHECK_ACK_RECV; |
| uint8_t tmp = (i2c_data.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.operating_state = I2C_RCV_DATA; |
| SSP1CON2bits.RCEN = 1; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data.operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data.master_status = I2C_MASTER_IDLE; |
| i2c_data.return_status = I2C_RECV_FAIL; |
| } |
| break; |
| case I2C_RCV_DATA: |
| // On receive, save byte into buffer |
| // TODO: Handle I2C buffer overflow |
| i2c_data.buffer_in[i2c_data.buffer_in_write_ind] = SSP1BUF; |
| i2c_data.buffer_in_write_ind++; |
| if (i2c_data.buffer_in_write_ind < i2c_data.buffer_in_len) { |
| // If we still need to read, send an ACK to the slave |
| i2c_data.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.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.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.operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data.master_status = I2C_MASTER_IDLE; |
| i2c_data.return_status = I2C_RECV_OK; |
| break; |
| } |
| } else if (i2c_data.master_status == I2C_MASTER_RESTART) { |
| switch (i2c_data.operating_state) { |
| case I2C_IDLE: |
| break; |
| case I2C_SEND_ADDR: |
| // Send the address with read bit set |
| i2c_data.operating_state = I2C_CHECK_ACK_SEND; |
| SSP1BUF = (i2c_data.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.buffer_in[0]; |
| i2c_data.operating_state = I2C_CHECK_ACK_RESTART; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data.operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data.master_status = I2C_MASTER_IDLE; |
| i2c_data.return_status = I2C_SEND_FAIL; |
| } |
| break; |
| case I2C_CHECK_ACK_RESTART: |
| if (!SSP1CON2bits.ACKSTAT) { |
| SSP1CON2bits.RSEN = 1; |
| i2c_data.operating_state = I2C_SEND_ADDR_2; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data.operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data.master_status = I2C_MASTER_IDLE; |
| i2c_data.return_status = I2C_SEND_FAIL; |
| } |
| break; |
| case I2C_SEND_ADDR_2: |
| // Send the address with read bit set |
| i2c_data.operating_state = I2C_CHECK_ACK_RECV; |
| uint8_t tmp = (i2c_data.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.operating_state = I2C_RCV_DATA; |
| SSP1CON2bits.RCEN = 1; |
| } else { |
| // If a NACK is received, stop transmission and send error |
| i2c_data.operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data.master_status = I2C_MASTER_IDLE; |
| i2c_data.return_status = I2C_RECV_FAIL; |
| } |
| break; |
| case I2C_RCV_DATA: |
| // On receive, save byte into buffer |
| // TODO: Handle I2C buffer overflow |
| i2c_data.buffer_in[i2c_data.buffer_in_write_ind] = SSP1BUF; |
| i2c_data.buffer_in_write_ind++; |
| if (i2c_data.buffer_in_write_ind < i2c_data.buffer_in_len) { |
| // If we still need to read, send an ACK to the slave |
| i2c_data.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.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.operating_state = I2C_RCV_DATA; |
| SSP1CON2bits.RCEN = 1; |
| break; |
| case I2C_SEND_STOP: |
| // Send the stop bit |
| i2c_data.operating_state = I2C_IDLE; |
| SSP1CON2bits.PEN = 1; |
| i2c_data.master_status = I2C_MASTER_IDLE; |
| i2c_data.return_status = I2C_RECV_OK; |
| break; |
| } |
| } |
| } |
| /* Returns 0 if I2C module is currently busy, otherwise returns status code */ |
| uint8_t I2C1_Get_Status() { |
| // if (i2c_data.operating_mode == I2C_MODE_MASTER) { |
| if (i2c_data.master_status != I2C_MASTER_IDLE || i2c_data.buffer_in_len == 0) { |
| return 0; |
| } else { |
| return i2c_data.return_status; |
| } |
| } |
| uint8_t I2C1_Buffer_Len() { |
| return i2c_data.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.buffer_in_len != 0) { |
| buffer[i] = i2c_data.buffer_in[i2c_data.buffer_in_read_ind]; |
| i++; |
| if (i2c_data.buffer_in_read_ind == MAXI2C1BUF-1) { |
| i2c_data.buffer_in_read_ind = 0; |
| } else { |
| i2c_data.buffer_in_read_ind++; |
| } |
| i2c_data.buffer_in_len--; |
| } |
| return i; |
| } |
| /PIC Stuff/PICX_12F1840_Clock/I2C1.h |
|---|
| 0,0 → 1,69 |
| #ifndef I2C1_H |
| #define I2C1_H |
| #define MAXI2C1BUF 8 |
| // 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_read_ind; |
| uint8_t buffer_in_write_ind; |
| uint8_t operating_state; |
| uint8_t return_status; |
| uint8_t master_dest_addr; |
| uint8_t master_status; |
| } I2C1_DATA; |
| void I2C1_Init(void); |
| void I2C1_Interrupt_Handler(void); |
| 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); |
| #endif |
| /PIC Stuff/PICX_12F1840_Clock/INTERRUPTS.c |
|---|
| 1,6 → 1,6 |
| #include <xc.h> |
| #include "defines.h" |
| #include "INTERRUPTS.h" |
| #include "I2C1.h" |
| void Interrupt_Enable() { |
| INTCONbits.GIE = 1; |
| 14,11 → 14,11 |
| void interrupt InterruptHandler(void) { |
| // // Check to see if we have an I2C interrupt |
| // if (PIR1bits.SSPIF) { |
| // I2C_Interrupt_Handler(); |
| // PIR1bits.SSPIF = 0; |
| // } |
| // Check to see if we have an I2C1 interrupt |
| if (PIR1bits.SSP1IF) { |
| I2C1_Interrupt_Handler(); |
| PIR1bits.SSP1IF = 0; |
| } |
| //#ifndef UART_TX_ONLY |
| // // Check to see if we have an interrupt on USART1 RX |
| /PIC Stuff/PICX_12F1840_Clock/NEOPIXEL.c |
|---|
| 1,17 → 1,17 |
| #include <xc.h> |
| #include "defines.h" |
| #include "NEOPIXEL.h" |
| static NEOPIXEL_DATA* neopixel_data_ptr; |
| extern NEOPIXEL_DATA neopixel_data; |
| void NeoPixel_Init(NEOPIXEL_DATA *data) { |
| neopixel_data_ptr = data; |
| void NeoPixel_Init(void) { |
| // Clear buffer |
| for (char i = 0; i < NEOPIXEL_LENGTH * 3; i++) { |
| neopixel_data_ptr->values[i] = 0x0; |
| for (uint8_t i = 0; i < NEOPIXEL_LENGTH * 3; i++) { |
| neopixel_data.values[i] = 0x0; |
| } |
| neopixel_data.offset = 0; |
| // Output pin initially blocked |
| NEOPIXEL_TRIS = 1; |
| 34,23 → 34,42 |
| NEOPIXEL_TRIS = 0; |
| } |
| void NeoPixel_Set(char index, char R, char G, char B) { |
| if (index >= NEOPIXEL_LENGTH) return; |
| void NeoPixel_Offet(uint8_t value) { |
| neopixel_data.offset = value; |
| } |
| neopixel_data_ptr->values[(index * 3) + 0] = G; |
| neopixel_data_ptr->values[(index * 3) + 1] = R; |
| neopixel_data_ptr->values[(index * 3) + 2] = B; |
| void NeoPixel_Clear(void) { |
| // Clear buffer |
| for (uint8_t i = 0; i < NEOPIXEL_LENGTH * 3; i++) { |
| neopixel_data.values[i] = 0x0; |
| } |
| } |
| void NeoPixel_Set(uint8_t index, uint8_t R, uint8_t G, uint8_t B) { |
| uint8_t i = ((index + neopixel_data.offset) % NEOPIXEL_LENGTH); |
| neopixel_data.values[(i * 3) + 0] = G; |
| neopixel_data.values[(i * 3) + 1] = R; |
| neopixel_data.values[(i * 3) + 2] = B; |
| } |
| void NeoPixel_Or(uint8_t index, uint8_t R, uint8_t G, uint8_t B) { |
| uint8_t i = ((index + neopixel_data.offset) % NEOPIXEL_LENGTH); |
| neopixel_data.values[(i * 3) + 0] |= G; |
| neopixel_data.values[(i * 3) + 1] |= R; |
| neopixel_data.values[(i * 3) + 2] |= B; |
| } |
| void NeoPixel_Write_All(void) { |
| for (char i = 0; i < NEOPIXEL_LENGTH * 3; i++) { |
| NeoPixel_Write_One(neopixel_data_ptr->values[i]); |
| for (uint8_t i = 0; i < NEOPIXEL_LENGTH * 3; i++) { |
| NeoPixel_Write_One(neopixel_data.values[i]); |
| } |
| // Delay for 50us to latch data |
| __delay_us(50); |
| } |
| void NeoPixel_Write_One(char value) { |
| void NeoPixel_Write_One(uint8_t value) { |
| // Enable timer and wait for it to overflow |
| T2CONbits.TMR2ON = 1; |
| while (!PIR1bits.TMR2IF); |
| /PIC Stuff/PICX_12F1840_Clock/NEOPIXEL.h |
|---|
| 18,13 → 18,17 |
| #define WHITE 0x6F,0x6F,0x6F |
| typedef struct { |
| char values[NEOPIXEL_LENGTH * 3]; |
| uint8_t values[NEOPIXEL_LENGTH * 3]; |
| uint8_t offset; |
| } NEOPIXEL_DATA; |
| void NeoPixel_Init(NEOPIXEL_DATA *data); |
| void NeoPixel_Set(char index, char R, char G, char B); |
| void NeoPixel_Init(void); |
| void NeoPixel_Offet(uint8_t value); |
| void NeoPixel_Clear(void); |
| void NeoPixel_Set(uint8_t index, uint8_t R, uint8_t G, uint8_t B); |
| void NeoPixel_Or(uint8_t index, uint8_t R, uint8_t G, uint8_t B); |
| void NeoPixel_Write_All(void); |
| void NeoPixel_Write_One(char value); |
| void NeoPixel_Write_One(uint8_t value); |
| #endif /* NEOPIXEL_H */ |
| /PIC Stuff/PICX_12F1840_Clock/TSL2561.c |
|---|
| 0,0 → 1,216 |
| #include "defines.h" |
| #include "I2C1.h" |
| #include "TSL2561.h" |
| extern TSL2561_DATA tsl2561_data; |
| void TSL2561_Init(uint8_t address) { |
| tsl2561_data.address = address; |
| tsl2561_data.integration = TSL2561_INTEGRATIONTIME_13MS; |
| tsl2561_data.gain = TSL2561_GAIN_16X; |
| uint8_t buffer[1]; |
| I2C1_Master_Restart(tsl2561_data.address, TSL2561_REGISTER_ID, 1); |
| while (!I2C1_Get_Status()); |
| I2C1_Read_Buffer(buffer); |
| // Set default integration time and gain |
| TSL2561_Set_Timing(tsl2561_data.integration); |
| TSL2561_Set_Gain(tsl2561_data.gain); |
| // Start the chip in power-down mode |
| TSL2561_Disable(); |
| } |
| void TSL2561_Enable() { |
| TSL2561_Write_2_Bytes(TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL, TSL2561_CONTROL_POWERON); |
| } |
| void TSL2561_Disable() { |
| TSL2561_Write_2_Bytes(TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL, TSL2561_CONTROL_POWEROFF); |
| } |
| void TSL2561_Set_Gain(tsl2561Gain_t gain) { |
| TSL2561_Enable(); |
| tsl2561_data.gain = gain; |
| TSL2561_Write_2_Bytes(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING, |
| tsl2561_data.integration | tsl2561_data.gain); |
| TSL2561_Disable(); |
| } |
| void TSL2561_Set_Timing(tsl2561IntegrationTime_t integration) { |
| TSL2561_Enable(); |
| tsl2561_data.integration = integration; |
| TSL2561_Write_2_Bytes(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING, |
| tsl2561_data.integration | tsl2561_data.gain); |
| TSL2561_Disable(); |
| } |
| uint32_t TSL2561_Calculate_Lux(uint16_t ch0, uint16_t ch1) { |
| uint32_t chScale, channel0, channel1, ratio1, ratio, temp, lux; |
| uint16_t b, m; |
| switch (tsl2561_data.integration) { |
| case TSL2561_INTEGRATIONTIME_13MS: |
| chScale = TSL2561_LUX_CHSCALE_TINT0; |
| break; |
| case TSL2561_INTEGRATIONTIME_101MS: |
| chScale = TSL2561_LUX_CHSCALE_TINT1; |
| break; |
| default: // No scaling ... integration time = 402ms |
| chScale = (1 << TSL2561_LUX_CHSCALE); |
| break; |
| } |
| // Scale for gain (1x or 16x) |
| if (!tsl2561_data.gain) |
| chScale = chScale << 4; |
| // scale the channel values |
| channel0 = (ch0 * chScale) >> TSL2561_LUX_CHSCALE; |
| channel1 = (ch1 * chScale) >> TSL2561_LUX_CHSCALE; |
| // find the ratio of the channel values (Channel1/Channel0) |
| ratio1 = 0; |
| if (channel0 != 0) |
| ratio1 = (channel1 << (TSL2561_LUX_RATIOSCALE+1)) / channel0; |
| // round the ratio value |
| ratio = (ratio1 + 1) >> 1; |
| #ifdef TSL2561_PACKAGE_CS |
| if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1C)) { |
| b = TSL2561_LUX_B1C; m = TSL2561_LUX_M1C; |
| } else if (ratio <= TSL2561_LUX_K2C) { |
| b = TSL2561_LUX_B2C; m = TSL2561_LUX_M2C; |
| } else if (ratio <= TSL2561_LUX_K3C) { |
| b = TSL2561_LUX_B3C; m = TSL2561_LUX_M3C; |
| } else if (ratio <= TSL2561_LUX_K4C) { |
| b = TSL2561_LUX_B4C; m = TSL2561_LUX_M4C; |
| } else if (ratio <= TSL2561_LUX_K5C) { |
| b = TSL2561_LUX_B5C; m = TSL2561_LUX_M5C; |
| } else if (ratio <= TSL2561_LUX_K6C) { |
| b = TSL2561_LUX_B6C; m = TSL2561_LUX_M6C; |
| } else if (ratio <= TSL2561_LUX_K7C) { |
| b = TSL2561_LUX_B7C; m = TSL2561_LUX_M7C; |
| } else if (ratio > TSL2561_LUX_K8C) { |
| b = TSL2561_LUX_B8C; m = TSL2561_LUX_M8C; |
| } |
| #else |
| // if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1T)) { |
| if ((ratio <= TSL2561_LUX_K1T)) { |
| b = TSL2561_LUX_B1T; m = TSL2561_LUX_M1T; |
| } else if (ratio <= TSL2561_LUX_K2T) { |
| b = TSL2561_LUX_B2T; m = TSL2561_LUX_M2T; |
| } else if (ratio <= TSL2561_LUX_K3T) { |
| b = TSL2561_LUX_B3T; m = TSL2561_LUX_M3T; |
| } else if (ratio <= TSL2561_LUX_K4T) { |
| b = TSL2561_LUX_B4T; m = TSL2561_LUX_M4T; |
| } else if (ratio <= TSL2561_LUX_K5T) { |
| b = TSL2561_LUX_B5T; m = TSL2561_LUX_M5T; |
| } else if (ratio <= TSL2561_LUX_K6T) { |
| b = TSL2561_LUX_B6T; m = TSL2561_LUX_M6T; |
| } else if (ratio <= TSL2561_LUX_K7T) { |
| b = TSL2561_LUX_B7T; m = TSL2561_LUX_M7T; |
| } else if (ratio > TSL2561_LUX_K8T) { |
| b = TSL2561_LUX_B8T; m = TSL2561_LUX_M8T; |
| } |
| #endif |
| // temp = ((channel0 * b) - (channel1 * m)); |
| // TODO: Change this back once they fix compiler |
| temp = (channel0 * b); |
| temp -= (channel1 * m); |
| // // do not allow negative lux value |
| // if (temp < 0) |
| // temp = 0; |
| // round lsb (2^(LUX_SCALE-1)) |
| temp += (1 << (TSL2561_LUX_LUXSCALE-1)); |
| // strip off fractional portion |
| lux = temp >> TSL2561_LUX_LUXSCALE; |
| return lux; |
| } |
| uint32_t TSL2561_Get_Full_Luminosity() { |
| uint32_t x; |
| // Enable the device by setting the control bit to 0x03 |
| TSL2561_Enable(); |
| // Wait x ms for ADC to complete |
| switch (tsl2561_data.integration) { |
| case TSL2561_INTEGRATIONTIME_13MS: |
| __delay_ms(15); |
| break; |
| case TSL2561_INTEGRATIONTIME_101MS: |
| __delay_ms(105); |
| break; |
| default: |
| __delay_ms(405); |
| break; |
| } |
| x = TSL2561_Read_2_Bytes(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN1_LOW); |
| x <<= 16; |
| x |= TSL2561_Read_2_Bytes(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN0_LOW); |
| TSL2561_Disable(); |
| return x; |
| } |
| uint16_t TSL2561_Get_Luminosity(uint8_t channel) { |
| // Enable the device by setting the control bit to 0x03 |
| TSL2561_Enable(); |
| // Wait x ms for ADC to complete |
| switch (tsl2561_data.integration) { |
| case TSL2561_INTEGRATIONTIME_13MS: |
| __delay_ms(15); |
| break; |
| case TSL2561_INTEGRATIONTIME_101MS: |
| __delay_ms(105); |
| break; |
| default: |
| __delay_ms(405); |
| break; |
| } |
| if (channel == 0) { |
| // Reads two byte value from channel 0 (visible + infrared) |
| return TSL2561_Read_2_Bytes(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN1_LOW); |
| } else if (channel == 1) { |
| // Reads two byte value from channel 1 (infrared) |
| return TSL2561_Read_2_Bytes(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN0_LOW); |
| } |
| TSL2561_Disable(); |
| // Unknown channel! |
| return 0; |
| } |
| void TSL2561_Write_2_Bytes(uint8_t reg, uint8_t value) { |
| uint8_t buffer[2]; |
| buffer[0] = reg; |
| buffer[1] = value; |
| I2C1_Master_Send(tsl2561_data.address, 2, buffer); |
| while (!I2C1_Get_Status()); |
| } |
| uint16_t TSL2561_Read_2_Bytes(uint8_t reg) { |
| uint8_t buffer[2]; |
| uint16_t ret; |
| I2C1_Master_Restart(tsl2561_data.address, reg, 2); |
| while (!I2C1_Get_Status()); |
| I2C1_Read_Buffer(buffer); |
| ret = buffer[1] << 8; |
| ret |= buffer[0]; |
| return ret; |
| } |
| /PIC Stuff/PICX_12F1840_Clock/TSL2561.h |
|---|
| 0,0 → 1,131 |
| #ifndef LUX_TSL2561_H |
| #define LUX_TSL2561_H |
| #define TSL2561_VISIBLE 2 // channel 0 - channel 1 |
| #define TSL2561_INFRARED 1 // channel 1 |
| #define TSL2561_FULLSPECTRUM 0 // channel 0 |
| // 3 i2c address options! |
| #define TSL2561_ADDR_LOW 0x29 |
| #define TSL2561_ADDR_FLOAT 0x39 |
| #define TSL2561_ADDR_HIGH 0x49 |
| // Lux calculations differ slightly for CS package |
| //#define TSL2561_PACKAGE_CS |
| #define TSL2561_PACKAGE_T_FN_CL |
| #define TSL2561_READBIT (0x01) |
| #define TSL2561_COMMAND_BIT (0x80) // Must be 1 |
| #define TSL2561_CLEAR_BIT (0x40) // Clears any pending interrupt (write 1 to clear) |
| #define TSL2561_WORD_BIT (0x20) // 1 = read/write word (rather than byte) |
| #define TSL2561_BLOCK_BIT (0x10) // 1 = using block read/write |
| #define TSL2561_CONTROL_POWERON (0x03) |
| #define TSL2561_CONTROL_POWEROFF (0x00) |
| #define TSL2561_LUX_LUXSCALE (14) // Scale by 2^14 |
| #define TSL2561_LUX_RATIOSCALE (9) // Scale ratio by 2^9 |
| #define TSL2561_LUX_CHSCALE (10) // Scale channel values by 2^10 |
| #define TSL2561_LUX_CHSCALE_TINT0 (0x7517) // 322/11 * 2^TSL2561_LUX_CHSCALE |
| #define TSL2561_LUX_CHSCALE_TINT1 (0x0FE7) // 322/81 * 2^TSL2561_LUX_CHSCALE |
| // T, FN and CL package values |
| #define TSL2561_LUX_K1T (0x0040) // 0.125 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B1T (0x01f2) // 0.0304 * 2^LUX_SCALE |
| #define TSL2561_LUX_M1T (0x01be) // 0.0272 * 2^LUX_SCALE |
| #define TSL2561_LUX_K2T (0x0080) // 0.250 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B2T (0x0214) // 0.0325 * 2^LUX_SCALE |
| #define TSL2561_LUX_M2T (0x02d1) // 0.0440 * 2^LUX_SCALE |
| #define TSL2561_LUX_K3T (0x00c0) // 0.375 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B3T (0x023f) // 0.0351 * 2^LUX_SCALE |
| #define TSL2561_LUX_M3T (0x037b) // 0.0544 * 2^LUX_SCALE |
| #define TSL2561_LUX_K4T (0x0100) // 0.50 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B4T (0x0270) // 0.0381 * 2^LUX_SCALE |
| #define TSL2561_LUX_M4T (0x03fe) // 0.0624 * 2^LUX_SCALE |
| #define TSL2561_LUX_K5T (0x0138) // 0.61 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B5T (0x016f) // 0.0224 * 2^LUX_SCALE |
| #define TSL2561_LUX_M5T (0x01fc) // 0.0310 * 2^LUX_SCALE |
| #define TSL2561_LUX_K6T (0x019a) // 0.80 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B6T (0x00d2) // 0.0128 * 2^LUX_SCALE |
| #define TSL2561_LUX_M6T (0x00fb) // 0.0153 * 2^LUX_SCALE |
| #define TSL2561_LUX_K7T (0x029a) // 1.3 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B7T (0x0018) // 0.00146 * 2^LUX_SCALE |
| #define TSL2561_LUX_M7T (0x0012) // 0.00112 * 2^LUX_SCALE |
| #define TSL2561_LUX_K8T (0x029a) // 1.3 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B8T (0x0000) // 0.000 * 2^LUX_SCALE |
| #define TSL2561_LUX_M8T (0x0000) // 0.000 * 2^LUX_SCALE |
| // CS package values |
| #define TSL2561_LUX_K1C (0x0043) // 0.130 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B1C (0x0204) // 0.0315 * 2^LUX_SCALE |
| #define TSL2561_LUX_M1C (0x01ad) // 0.0262 * 2^LUX_SCALE |
| #define TSL2561_LUX_K2C (0x0085) // 0.260 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B2C (0x0228) // 0.0337 * 2^LUX_SCALE |
| #define TSL2561_LUX_M2C (0x02c1) // 0.0430 * 2^LUX_SCALE |
| #define TSL2561_LUX_K3C (0x00c8) // 0.390 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B3C (0x0253) // 0.0363 * 2^LUX_SCALE |
| #define TSL2561_LUX_M3C (0x0363) // 0.0529 * 2^LUX_SCALE |
| #define TSL2561_LUX_K4C (0x010a) // 0.520 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B4C (0x0282) // 0.0392 * 2^LUX_SCALE |
| #define TSL2561_LUX_M4C (0x03df) // 0.0605 * 2^LUX_SCALE |
| #define TSL2561_LUX_K5C (0x014d) // 0.65 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B5C (0x0177) // 0.0229 * 2^LUX_SCALE |
| #define TSL2561_LUX_M5C (0x01dd) // 0.0291 * 2^LUX_SCALE |
| #define TSL2561_LUX_K6C (0x019a) // 0.80 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B6C (0x0101) // 0.0157 * 2^LUX_SCALE |
| #define TSL2561_LUX_M6C (0x0127) // 0.0180 * 2^LUX_SCALE |
| #define TSL2561_LUX_K7C (0x029a) // 1.3 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B7C (0x0037) // 0.00338 * 2^LUX_SCALE |
| #define TSL2561_LUX_M7C (0x002b) // 0.00260 * 2^LUX_SCALE |
| #define TSL2561_LUX_K8C (0x029a) // 1.3 * 2^RATIO_SCALE |
| #define TSL2561_LUX_B8C (0x0000) // 0.000 * 2^LUX_SCALE |
| #define TSL2561_LUX_M8C (0x0000) // 0.000 * 2^LUX_SCALE |
| enum { |
| TSL2561_REGISTER_CONTROL = 0x00, |
| TSL2561_REGISTER_TIMING = 0x01, |
| TSL2561_REGISTER_THRESHHOLDL_LOW = 0x02, |
| TSL2561_REGISTER_THRESHHOLDL_HIGH = 0x03, |
| TSL2561_REGISTER_THRESHHOLDH_LOW = 0x04, |
| TSL2561_REGISTER_THRESHHOLDH_HIGH = 0x05, |
| TSL2561_REGISTER_INTERRUPT = 0x06, |
| TSL2561_REGISTER_CRC = 0x08, |
| TSL2561_REGISTER_ID = 0x0A, |
| TSL2561_REGISTER_CHAN0_LOW = 0x0C, |
| TSL2561_REGISTER_CHAN0_HIGH = 0x0D, |
| TSL2561_REGISTER_CHAN1_LOW = 0x0E, |
| TSL2561_REGISTER_CHAN1_HIGH = 0x0F |
| }; |
| typedef enum { |
| TSL2561_INTEGRATIONTIME_13MS = 0x00, // 13.7ms |
| TSL2561_INTEGRATIONTIME_101MS = 0x01, // 101ms |
| TSL2561_INTEGRATIONTIME_402MS = 0x02 // 402ms |
| } tsl2561IntegrationTime_t; |
| typedef enum { |
| TSL2561_GAIN_0X = 0x00, // No gain |
| TSL2561_GAIN_16X = 0x10 // 16x gain |
| } tsl2561Gain_t; |
| typedef struct __TSL25611_DATA { |
| uint8_t address; |
| tsl2561IntegrationTime_t integration; |
| tsl2561Gain_t gain; |
| } TSL2561_DATA; |
| void TSL2561_Init(uint8_t address); |
| void TSL2561_Enable(void); |
| void TSL2561_Disable(void); |
| void TSL2561_Set_Timing(tsl2561IntegrationTime_t integration); |
| void TSL2561_Set_Gain(tsl2561Gain_t gain); |
| uint32_t TSL2561_Calculate_Lux(uint16_t ch0, uint16_t ch1); |
| uint32_t TSL2561_Get_Full_Luminosity(void); |
| uint16_t TSL2561_Get_Luminosity(uint8_t channel); |
| void TSL2561_Write_2_Bytes(uint8_t reg, uint8_t value); |
| uint16_t TSL2561_Read_2_Bytes(uint8_t reg); |
| #endif /* LUX_TSL2561_H */ |
| /PIC Stuff/PICX_12F1840_Clock/defines.h |
|---|
| 1,10 → 1,15 |
| #ifndef DEFINES_H |
| #define DEFINES_H |
| #include <xc.h> |
| #include <stdint.h> |
| // Preprocessor define for __delay_ms() and __delay_us() |
| #define _XTAL_FREQ 32000000 |
| #define NEOPIXEL_TRIS TRISAbits.TRISA5 |
| #define NEOPIXEL_TRIS TRISAbits.TRISA5 |
| #define I2C_1_CLK_TRIS TRISAbits.TRISA1 |
| #define I2C_1_DAT_TRIS TRISAbits.TRISA2 |
| #endif /* DEFINES_H */ |
| /PIC Stuff/PICX_12F1840_Clock/funclist |
|---|
| 1,10 → 1,31 |
| ___awmod: CODE, 404 0 71 |
| _main: CODE, 13 0 185 |
| _InterruptHandler: CODE, 4 0 7 |
| __initialization: CODE, 591 0 12 |
| _NeoPixel_Set: CODE, 198 0 105 |
| _NeoPixel_Init: CODE, 475 0 55 |
| _NeoPixel_Write_One: CODE, 303 0 101 |
| ___wmul: CODE, 562 0 29 |
| _NeoPixel_Write_All: CODE, 530 0 32 |
| Total: 597 |
| _DS3231_Init: CODE, 1584 0 29 |
| _I2C1_Init: CODE, 1766 0 15 |
| _I2C1_Read_Buffer: CODE, 1456 0 38 |
| _TSL2561_Set_Timing: CODE, 1688 0 22 |
| _I2C1_Master_Restart: CODE, 1367 0 45 |
| ___awmod: CODE, 1195 0 72 |
| _TSL2561_Disable: CODE, 1824 0 6 |
| _main: CODE, 410 0 273 |
| _Interrupt_Enable: CODE, 1830 0 3 |
| _InterruptHandler: CODE, 4 0 13 |
| _TSL2561_Write_2_Bytes: CODE, 1555 0 29 |
| __initialization: CODE, 1641 0 21 |
| _DS3231_Get_Status: CODE, 1665 0 23 |
| _I2C1_Configure_Master: CODE, 1494 0 32 |
| _NeoPixel_Or: CODE, 972 0 122 |
| _DS3231_Get_Time: CODE, 683 0 155 |
| _NeoPixel_Set: CODE, 838 0 134 |
| _I2C1_Master_Send: CODE, 1267 0 50 |
| _I2C1_Interrupt_Handler: CODE, 19 0 391 |
| _NeoPixel_Init: CODE, 1317 0 50 |
| _TSL2561_Init: CODE, 1412 0 44 |
| _NeoPixel_Clear: CODE, 1732 0 17 |
| _TSL2561_Set_Gain: CODE, 1710 0 22 |
| _NeoPixel_Offet: CODE, 1805 0 10 |
| _NeoPixel_Write_One: CODE, 1094 0 101 |
| _I2C1_Get_Status: CODE, 1793 0 12 |
| ___wmul: CODE, 1526 0 29 |
| _NeoPixel_Write_All: CODE, 1613 0 28 |
| ___bmul: CODE, 1749 0 17 |
| _TSL2561_Enable: CODE, 1815 0 9 |
| Total: 1812 |
| /PIC Stuff/PICX_12F1840_Clock/l.obj |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /PIC Stuff/PICX_12F1840_Clock/main.c |
|---|
| 1,7 → 1,9 |
| #include <xc.h> |
| #include "defines.h" |
| #include "INTERRUPTS.h" |
| #include "I2C1.h" |
| #include "NEOPIXEL.h" |
| #include "DS3231.h" |
| #include "TSL2561.h" |
| // <editor-fold defaultstate="collapsed" desc="Configuration Registers"> |
| /* Config Register CONFIGL @ 0x8007 */ |
| 24,10 → 26,12 |
| #pragma config LVP = OFF // High-voltage on MCLR/VPP must be used for programming |
| // </editor-fold> |
| I2C1_DATA i2c_data; |
| NEOPIXEL_DATA neopixel_data; |
| TSL2561_DATA tsl2561_data; |
| DS3231_TIME time; |
| int main() { |
| // Oscillator configuration (32Mhz HFINTOSC) |
| OSCCONbits.SCS = 0b00; |
| OSCCONbits.IRCF = 0b1110; |
| 38,26 → 42,64 |
| // Wait for HFINTOSC to be within 0.5% of target 32Mhz |
| while (!OSCSTATbits.HFIOFS); |
| // Interrupt_Enable(); |
| Interrupt_Enable(); |
| NeoPixel_Init(&neopixel_data); |
| I2C1_Init(); |
| I2C1_Configure_Master(I2C_1MHZ); |
| for (char i = 0; i < 60; i++) { |
| if (i % 6 == 0) |
| NeoPixel_Set(i, RED); |
| else if (i % 6 == 1) |
| NeoPixel_Set(i, ORANGE); |
| else if (i % 6 == 2) |
| NeoPixel_Set(i, YELLOW); |
| else if (i % 6 == 3) |
| NeoPixel_Set(i, GREEN); |
| else if (i % 6 == 4) |
| NeoPixel_Set(i, BLUE); |
| else |
| NeoPixel_Set(i, PURPLE); |
| } |
| NeoPixel_Init(); |
| NeoPixel_Offet(30); |
| DS3231_Init(); |
| TSL2561_Init(TSL2561_ADDR_FLOAT); |
| // You can change the gain on the fly, to adapt to brighter/dimmer light situations |
| TSL2561_Set_Gain(TSL2561_GAIN_0X); // set no gain (for bright situtations) |
| // TSL2561_Set_Gain(TSL2561_GAIN_16X); // set 16x gain (for dim situations) |
| // Changing the integration time gives you a longer time over which to sense light |
| // longer timelines are slower, but are good in very low light situtations! |
| // TSL2561_Set_Timing(TSL2561_INTEGRATIONTIME_13MS); // shortest integration time (bright light) |
| TSL2561_Set_Timing(TSL2561_INTEGRATIONTIME_101MS); // medium integration time (medium light) |
| // TSL2561_Set_Timing(TSL2561_INTEGRATIONTIME_402MS); // longest integration time (dim light) |
| // uint16_t full, ir, vis; |
| while(1) { |
| // full = TSL2561_Get_Luminosity(0); |
| // ir = TSL2561_Get_Luminosity(1); |
| // vis = full - ir; |
| // |
| // NeoPixel_Clear(); |
| // for (uint8_t i = 0; i < (vis >> 11); i++) { |
| // NeoPixel_Set(i, 0x10, 0x00, 0x00); |
| // } |
| // NeoPixel_Write_All(); |
| // |
| // __delay_ms(100); |
| DS3231_Get_Time(&time); |
| NeoPixel_Clear(); |
| // Draw markers |
| NeoPixel_Set(0, 0x10, 0x00, 0x00); |
| NeoPixel_Set(5, 0x08, 0x02, 0x00); |
| NeoPixel_Set(10, 0x08, 0x08, 0x00); |
| NeoPixel_Set(15, 0x00, 0x10, 0x00); |
| NeoPixel_Set(20, 0x00, 0x00, 0x10); |
| NeoPixel_Set(25, 0x08, 0x00, 0x08); |
| NeoPixel_Set(30, 0x10, 0x00, 0x00); |
| NeoPixel_Set(35, 0x08, 0x02, 0x00); |
| NeoPixel_Set(40, 0x08, 0x08, 0x00); |
| NeoPixel_Set(45, 0x00, 0x10, 0x00); |
| NeoPixel_Set(50, 0x00, 0x00, 0x10); |
| NeoPixel_Set(55, 0x08, 0x00, 0x08); |
| // Draw time |
| NeoPixel_Or((time.hour * 5) % 60, BLUE); |
| NeoPixel_Or(time.min, GREEN); |
| NeoPixel_Or(time.sec, RED); |
| NeoPixel_Write_All(); |
| } |
| } |
| /PIC Stuff/PICX_12F1840_Clock/nbproject/Makefile-default.mk |
|---|
| 45,17 → 45,17 |
| DISTDIR=dist/${CND_CONF}/${IMAGE_TYPE} |
| # Source Files Quoted if spaced |
| SOURCEFILES_QUOTED_IF_SPACED=main.c NEOPIXEL.c INTERRUPTS.c |
| SOURCEFILES_QUOTED_IF_SPACED=main.c NEOPIXEL.c INTERRUPTS.c I2C1.c DS3231.c TSL2561.c |
| # Object Files Quoted if spaced |
| OBJECTFILES_QUOTED_IF_SPACED=${OBJECTDIR}/main.p1 ${OBJECTDIR}/NEOPIXEL.p1 ${OBJECTDIR}/INTERRUPTS.p1 |
| POSSIBLE_DEPFILES=${OBJECTDIR}/main.p1.d ${OBJECTDIR}/NEOPIXEL.p1.d ${OBJECTDIR}/INTERRUPTS.p1.d |
| OBJECTFILES_QUOTED_IF_SPACED=${OBJECTDIR}/main.p1 ${OBJECTDIR}/NEOPIXEL.p1 ${OBJECTDIR}/INTERRUPTS.p1 ${OBJECTDIR}/I2C1.p1 ${OBJECTDIR}/DS3231.p1 ${OBJECTDIR}/TSL2561.p1 |
| POSSIBLE_DEPFILES=${OBJECTDIR}/main.p1.d ${OBJECTDIR}/NEOPIXEL.p1.d ${OBJECTDIR}/INTERRUPTS.p1.d ${OBJECTDIR}/I2C1.p1.d ${OBJECTDIR}/DS3231.p1.d ${OBJECTDIR}/TSL2561.p1.d |
| # Object Files |
| OBJECTFILES=${OBJECTDIR}/main.p1 ${OBJECTDIR}/NEOPIXEL.p1 ${OBJECTDIR}/INTERRUPTS.p1 |
| OBJECTFILES=${OBJECTDIR}/main.p1 ${OBJECTDIR}/NEOPIXEL.p1 ${OBJECTDIR}/INTERRUPTS.p1 ${OBJECTDIR}/I2C1.p1 ${OBJECTDIR}/DS3231.p1 ${OBJECTDIR}/TSL2561.p1 |
| # Source Files |
| SOURCEFILES=main.c NEOPIXEL.c INTERRUPTS.c |
| SOURCEFILES=main.c NEOPIXEL.c INTERRUPTS.c I2C1.c DS3231.c TSL2561.c |
| CFLAGS= |
| 102,6 → 102,30 |
| @-${MV} ${OBJECTDIR}/INTERRUPTS.d ${OBJECTDIR}/INTERRUPTS.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/INTERRUPTS.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=ignore --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}/DS3231.p1: DS3231.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/DS3231.p1.d |
| @${RM} ${OBJECTDIR}/DS3231.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=ignore --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}/DS3231.p1 DS3231.c |
| @-${MV} ${OBJECTDIR}/DS3231.d ${OBJECTDIR}/DS3231.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/DS3231.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/TSL2561.p1: TSL2561.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/TSL2561.p1.d |
| @${RM} ${OBJECTDIR}/TSL2561.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=ignore --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}/TSL2561.p1 TSL2561.c |
| @-${MV} ${OBJECTDIR}/TSL2561.d ${OBJECTDIR}/TSL2561.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/TSL2561.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| else |
| ${OBJECTDIR}/main.p1: main.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| 127,6 → 151,30 |
| @-${MV} ${OBJECTDIR}/INTERRUPTS.d ${OBJECTDIR}/INTERRUPTS.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/INTERRUPTS.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=ignore --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}/DS3231.p1: DS3231.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/DS3231.p1.d |
| @${RM} ${OBJECTDIR}/DS3231.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=ignore --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}/DS3231.p1 DS3231.c |
| @-${MV} ${OBJECTDIR}/DS3231.d ${OBJECTDIR}/DS3231.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/DS3231.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| ${OBJECTDIR}/TSL2561.p1: TSL2561.c nbproject/Makefile-${CND_CONF}.mk |
| @${MKDIR} ${OBJECTDIR} |
| @${RM} ${OBJECTDIR}/TSL2561.p1.d |
| @${RM} ${OBJECTDIR}/TSL2561.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=ignore --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}/TSL2561.p1 TSL2561.c |
| @-${MV} ${OBJECTDIR}/TSL2561.d ${OBJECTDIR}/TSL2561.p1.d |
| @${FIXDEPS} ${OBJECTDIR}/TSL2561.p1.d $(SILENT) -rsi ${MP_CC_DIR}../ |
| endif |
| # ------------------------------------------------------------------------------------ |
| /PIC Stuff/PICX_12F1840_Clock/nbproject/Makefile-genesis.properties |
|---|
| 1,5 → 1,5 |
| # |
| #Sat Mar 29 17:34:07 EDT 2014 |
| #Sun Mar 30 00:42:55 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 |
| /PIC Stuff/PICX_12F1840_Clock/nbproject/configurations.xml |
|---|
| 7,6 → 7,9 |
| <itemPath>defines.h</itemPath> |
| <itemPath>NEOPIXEL.h</itemPath> |
| <itemPath>INTERRUPTS.h</itemPath> |
| <itemPath>I2C1.h</itemPath> |
| <itemPath>DS3231.h</itemPath> |
| <itemPath>TSL2561.h</itemPath> |
| </logicalFolder> |
| <logicalFolder name="LinkerScript" |
| displayName="Linker Files" |
| 18,6 → 21,9 |
| <itemPath>main.c</itemPath> |
| <itemPath>NEOPIXEL.c</itemPath> |
| <itemPath>INTERRUPTS.c</itemPath> |
| <itemPath>I2C1.c</itemPath> |
| <itemPath>DS3231.c</itemPath> |
| <itemPath>TSL2561.c</itemPath> |
| </logicalFolder> |
| <logicalFolder name="ExternalFiles" |
| displayName="Important Files" |