/PIC Stuff/PIC_27J13/Adafruit_GFX.c |
---|
7,18 → 7,19 |
#include <stdio.h> |
static GFX_DATA gfx_data; |
static GFX_DATA *gfx_data_p = &gfx_data; |
void GFX_Init(int w, int h) { |
gfx_data._width = gfx_data.WIDTH = w; |
gfx_data._height = gfx_data.HEIGHT = h; |
gfx_data.rotation = 0; |
gfx_data.cursor_x = gfx_data.cursor_y = 0; |
gfx_data.textsize = 1; |
gfx_data.textcolor = gfx_data.textbgcolor = 0xFFFF; |
gfx_data.wrap = 1; |
gfx_data_p->_width = gfx_data_p->WIDTH = w; |
gfx_data_p->_height = gfx_data_p->HEIGHT = h; |
gfx_data_p->rotation = 0; |
gfx_data_p->cursor_x = gfx_data_p->cursor_y = 0; |
gfx_data_p->textsize = 1; |
gfx_data_p->textcolor = gfx_data_p->textbgcolor = 0xFFFF; |
gfx_data_p->wrap = 1; |
memset(gfx_data.lcd_buffer, 0, GFX_LCD_BUFFER_SIZE); |
memset(gfx_data.buffer, 0, GFX_STRING_BUFFER_SIZE); |
memset(gfx_data_p->lcd_buffer, 0, GFX_LCD_BUFFER_SIZE); |
memset(gfx_data_p->buffer, 0, GFX_STRING_BUFFER_SIZE); |
} |
int GFX_Abs(int i) { |
111,7 → 112,7 |
} |
void GFX_fillScreen(unsigned int color) { |
GFX_fillRect(0, 0, gfx_data._width, gfx_data._height, color); |
GFX_fillRect(0, 0, gfx_data_p->_width, gfx_data_p->_height, color); |
} |
void GFX_clearScreen() { |
388,8 → 389,8 |
int i, j; |
unsigned int line; |
if ((x >= gfx_data._width) || // Clip right |
(y >= gfx_data._height) || // Clip bottom |
if ((x >= gfx_data_p->_width) || // Clip right |
(y >= gfx_data_p->_height) || // Clip bottom |
((x + 5 * size - 1) < 0) || // Clip left |
((y + 8 * size - 1) < 0)) // Clip top |
return; |
430,16 → 431,16 |
void GFX_write(unsigned char c) { |
if (c == '\n' || c == '\r') { |
gfx_data.cursor_y += gfx_data.textsize * 8; |
gfx_data.cursor_x = 0; |
gfx_data_p->cursor_y += gfx_data_p->textsize * 8; |
gfx_data_p->cursor_x = 0; |
// } else if (c == '\r') { |
// // skip em |
} else { |
GFX_drawChar(gfx_data.cursor_x, gfx_data.cursor_y, c, gfx_data.textcolor, gfx_data.textbgcolor, gfx_data.textsize); |
gfx_data.cursor_x += gfx_data.textsize * 6; |
if (gfx_data.wrap && (gfx_data.cursor_x > (gfx_data._width - gfx_data.textsize * 6))) { |
gfx_data.cursor_y += gfx_data.textsize * 8; |
gfx_data.cursor_x = 0; |
GFX_drawChar(gfx_data_p->cursor_x, gfx_data_p->cursor_y, c, gfx_data_p->textcolor, gfx_data_p->textbgcolor, gfx_data_p->textsize); |
gfx_data_p->cursor_x += gfx_data_p->textsize * 6; |
if (gfx_data_p->wrap && (gfx_data_p->cursor_x > (gfx_data_p->_width - gfx_data_p->textsize * 6))) { |
gfx_data_p->cursor_y += gfx_data_p->textsize * 8; |
gfx_data_p->cursor_x = 0; |
} |
} |
} |
449,9 → 450,9 |
// Parse and create string |
va_list args; |
va_start(args, fmt); |
vsprintf((char *) gfx_data.buffer, fmt, args); |
vsprintf((char *) gfx_data_p->buffer, fmt, args); |
va_end(args); |
len = strlen((char *) gfx_data.buffer); |
len = strlen((char *) gfx_data_p->buffer); |
// Make sure string to insert fits in buffer, truncate if necessary |
if (len > GFX_STRING_BUFFER_SIZE) |
459,7 → 460,7 |
// Print buffer to string |
for (i = 0; i < len; i++) { |
GFX_write(gfx_data.buffer[i]); |
GFX_write(gfx_data_p->buffer[i]); |
} |
} |
469,11 → 470,11 |
// Parse and create string |
va_list args; |
va_start(args, fmt); |
vsprintf((char *) gfx_data.buffer, fmt, args); |
vsprintf((char *) gfx_data_p->buffer, fmt, args); |
va_end(args); |
// Make sure string to insert fits in buffer, truncate if necessary |
len = strlen((char *) gfx_data.buffer); |
len = strlen((char *) gfx_data_p->buffer); |
if (len == 1) { // This will only occur on "\n" |
// Do nothing? |
490,69 → 491,69 |
// Shift everything right and insert string at beginning |
for (i = 127; i > len - 1; i--) { |
gfx_data.lcd_buffer[i] = gfx_data.lcd_buffer[i - len]; |
gfx_data_p->lcd_buffer[i] = gfx_data_p->lcd_buffer[i - len]; |
} |
memcpy((char *)gfx_data.lcd_buffer, (const char *)gfx_data.buffer, len); |
memcpy((char *)gfx_data_p->lcd_buffer, (const char *)gfx_data_p->buffer, len); |
// Print full buffer to screen |
GFX_clearScreen(); |
GFX_setCursor(0,0); |
for (i = 0; i < GFX_LCD_BUFFER_SIZE-1; i++) { |
GFX_write(gfx_data.lcd_buffer[i]); |
GFX_write(gfx_data_p->lcd_buffer[i]); |
} |
} |
void GFX_setCursor(int x, int y) { |
gfx_data.cursor_x = x; |
gfx_data.cursor_y = y; |
gfx_data_p->cursor_x = x; |
gfx_data_p->cursor_y = y; |
} |
void GFX_setTextColor(unsigned int c) { |
// for 'transparent' background, we'll set the bg |
// to the same as fg instead of using a flag |
gfx_data.textcolor = c; |
gfx_data.textbgcolor = c; |
gfx_data_p->textcolor = c; |
gfx_data_p->textbgcolor = c; |
} |
void GFX_setTextColorBG(unsigned int c, unsigned int bg) { |
gfx_data.textcolor = c; |
gfx_data.textbgcolor = bg; |
gfx_data_p->textcolor = c; |
gfx_data_p->textbgcolor = bg; |
} |
void GFX_setTextSize(unsigned char s) { |
gfx_data.textsize = (s > 0) ? s : 1; |
gfx_data_p->textsize = (s > 0) ? s : 1; |
} |
void GFX_setTextWrap(unsigned char w) { |
gfx_data.wrap = w; |
gfx_data_p->wrap = w; |
} |
void GFX_setRotation(unsigned char x) { |
x %= 4; // cant be higher than 3 |
gfx_data.rotation = x; |
gfx_data_p->rotation = x; |
switch (x) { |
case 0: |
case 2: |
gfx_data._width = gfx_data.WIDTH; |
gfx_data._height = gfx_data.HEIGHT; |
gfx_data_p->_width = gfx_data_p->WIDTH; |
gfx_data_p->_height = gfx_data_p->HEIGHT; |
break; |
case 1: |
case 3: |
gfx_data._width = gfx_data.HEIGHT; |
gfx_data._height = gfx_data.WIDTH; |
gfx_data_p->_width = gfx_data_p->HEIGHT; |
gfx_data_p->_height = gfx_data_p->WIDTH; |
break; |
} |
} |
unsigned char GFX_getRotation() { |
gfx_data.rotation %= 4; |
return gfx_data.rotation; |
gfx_data_p->rotation %= 4; |
return gfx_data_p->rotation; |
} |
int GFX_height() { |
return gfx_data._height; |
return gfx_data_p->_height; |
} |
int GFX_width() { |
return gfx_data._width; |
return gfx_data_p->_width; |
} |
/PIC Stuff/PIC_27J13/adc.c |
---|
2,6 → 2,7 |
#include "adc.h" |
static ADC_DATA adc_data; |
static ADC_DATA *adc_data_p = &adc_data; |
void ADC_Init(unsigned char TAD, unsigned char FOSC) { |
TRISAbits.TRISA0 = 1; |
8,8 → 9,8 |
TRISAbits.TRISA1 = 1; |
TRISAbits.TRISA2 = 1; |
adc_data.last_channel = 0; |
adc_data.result = 0; |
adc_data_p->last_channel = 0; |
adc_data_p->result = 0; |
ADCON0bits.VCFG1 = 0; // VRef- = AVss |
ADCON0bits.VCFG0 = 1; // VRef+ != AVdd |
29,7 → 30,7 |
} |
void ADC_Start(unsigned char channel) { |
adc_data.last_channel = channel; |
adc_data_p->last_channel = channel; |
ADCON0bits.CHS = channel; // Set A/D channel |
ADCON0bits.GO_DONE = 1; // Start A/D conversion |
} |
39,7 → 40,7 |
} |
void ADC_Interrupt_Handler() { |
adc_data.result = ADRES; |
adc_data_p->result = ADRES; |
} |
char ADC_Get_Result(unsigned int* ret) { |
46,7 → 47,7 |
if (ADCON0bits.GO_DONE) { |
return 0; |
} else { |
*ret = adc_data.result; |
*ret = adc_data_p->result; |
return 1; |
} |
} |
/PIC Stuff/PIC_27J13/i2c.c |
---|
2,27 → 2,28 |
#include "i2c.h" |
static I2C_DATA i2c_data; |
static I2C_DATA *i2c_data_p = &i2c_data; |
// Set up the data structures for the i2c code |
// Should be called once before any i2c routines are called |
void I2C_Init() { |
i2c_data.buffer_in_len = 0; |
i2c_data.buffer_in_len_tmp = 0; |
i2c_data.buffer_in_read_ind = 0; |
i2c_data.buffer_in_write_ind = 0; |
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.buffer_out_ind = 0; |
i2c_data.buffer_out_len = 0; |
i2c_data_p->buffer_out_ind = 0; |
i2c_data_p->buffer_out_len = 0; |
i2c_data.operating_mode = 0; |
i2c_data.operating_state = I2C_IDLE; |
i2c_data.return_status = 0; |
i2c_data_p->operating_mode = 0; |
i2c_data_p->operating_state = I2C_IDLE; |
i2c_data_p->return_status = 0; |
i2c_data.slave_in_last_byte = 0; |
i2c_data.slave_sending_data = 0; |
i2c_data_p->slave_in_last_byte = 0; |
i2c_data_p->slave_sending_data = 0; |
i2c_data.master_dest_addr = 0; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data_p->master_dest_addr = 0; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
// Enable I2C interrupt |
PIE1bits.SSPIE = 1; |
30,7 → 31,7 |
// Setup the PIC to operate as a master. |
void I2C_Configure_Master(unsigned char speed) { |
i2c_data.operating_mode = I2C_MODE_MASTER; |
i2c_data_p->operating_mode = I2C_MODE_MASTER; |
TRISCbits.TRISC3 = 1; |
TRISCbits.TRISC4 = 1; |
56,16 → 57,16 |
// Copy message to send into buffer and save length/address |
for (i = 0; i < length; i++) { |
i2c_data.buffer_in[i] = msg[i]; |
i2c_data_p->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; |
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.operating_state = I2C_SEND_ADDR; |
i2c_data.master_status = I2C_MASTER_SEND; |
i2c_data_p->operating_state = I2C_SEND_ADDR; |
i2c_data_p->master_status = I2C_MASTER_SEND; |
// Generate start condition |
SSPCON2bits.SEN = 1; |
77,14 → 78,14 |
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; |
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.operating_state = I2C_SEND_ADDR; |
i2c_data.master_status = I2C_MASTER_RECV; |
i2c_data_p->operating_state = I2C_SEND_ADDR; |
i2c_data_p->master_status = I2C_MASTER_RECV; |
// Generate start condition |
SSPCON2bits.SEN = 1; |
100,15 → 101,15 |
} |
// 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; |
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.operating_state = I2C_SEND_ADDR; |
i2c_data.master_status = I2C_MASTER_RESTART; |
i2c_data_p->operating_state = I2C_SEND_ADDR; |
i2c_data_p->master_status = I2C_MASTER_RESTART; |
// Generate start condition |
SSPCON2bits.SEN = 1; |
116,7 → 117,7 |
// Setup the PIC to operate as a slave. The address must not include the R/W bit |
void I2C_Configure_Slave(unsigned char addr) { |
i2c_data.operating_mode = I2C_MODE_SLAVE; |
i2c_data_p->operating_mode = I2C_MODE_SLAVE; |
// Ensure the two lines are set for input (we are a slave) |
TRISCbits.TRISC3 = 1; |
135,9 → 136,9 |
void I2C_Interrupt_Handler() { |
// Call interrupt depending on which mode we are operating in |
if (i2c_data.operating_mode == I2C_MODE_MASTER) { |
if (i2c_data_p->operating_mode == I2C_MODE_MASTER) { |
I2C_Interrupt_Master(); |
} else if (i2c_data.operating_mode == I2C_MODE_SLAVE) { |
} else if (i2c_data_p->operating_mode == I2C_MODE_SLAVE) { |
I2C_Interrupt_Slave(); |
} |
} |
145,75 → 146,75 |
// An internal subroutine used in the master version of the i2c_interrupt_handler |
void I2C_Interrupt_Master() { |
// If we are in the middle of sending data |
if (i2c_data.master_status == I2C_MASTER_SEND) { |
switch (i2c_data.operating_state) { |
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.operating_state = I2C_CHECK_ACK_SEND; |
SSPBUF = (i2c_data.master_dest_addr << 1) | 0x0; |
i2c_data_p->operating_state = I2C_CHECK_ACK_SEND; |
SSPBUF = (i2c_data_p->master_dest_addr << 1) | 0x0; |
break; |
case I2C_CHECK_ACK_SEND: |
// Check if ACK is received or not |
if (!SSPCON2bits.ACKSTAT) { |
// If an ACK is received, send next byte of data |
if (i2c_data.buffer_in_read_ind < i2c_data.buffer_in_len) { |
SSPBUF = i2c_data.buffer_in[i2c_data.buffer_in_read_ind]; |
i2c_data.buffer_in_read_ind++; |
if (i2c_data_p->buffer_in_read_ind < i2c_data_p->buffer_in_len) { |
SSPBUF = 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.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_SEND_OK; |
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.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_SEND_FAIL; |
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.master_status == I2C_MASTER_RECV) { |
switch (i2c_data.operating_state) { |
} 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.operating_state = I2C_CHECK_ACK_RECV; |
SSPBUF = (i2c_data.master_dest_addr << 1) | 0x1; |
i2c_data_p->operating_state = I2C_CHECK_ACK_RECV; |
SSPBUF = (i2c_data_p->master_dest_addr << 1) | 0x1; |
break; |
case I2C_CHECK_ACK_RECV: |
// Check if ACK is received |
if (!SSPCON2bits.ACKSTAT) { |
// If an ACK is received, set module to receive 1 byte of data |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
SSPCON2bits.RCEN = 1; |
} else { |
// If a NACK is received, stop transmission and send error |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_RECV_FAIL; |
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.buffer_in[i2c_data.buffer_in_write_ind] = SSPBUF; |
i2c_data.buffer_in_write_ind++; |
if (i2c_data.buffer_in_write_ind < i2c_data.buffer_in_len) { |
i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = SSPBUF; |
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.operating_state = I2C_REQ_DATA; |
i2c_data_p->operating_state = I2C_REQ_DATA; |
SSPCON2bits.ACKDT = 0; // ACK |
SSPCON2bits.ACKEN = 1; |
} else { |
// If we are done reading, send an NACK to the slave |
i2c_data.operating_state = I2C_SEND_STOP; |
i2c_data_p->operating_state = I2C_SEND_STOP; |
SSPCON2bits.ACKDT = 1; // NACK |
SSPCON2bits.ACKEN = 1; |
} |
220,84 → 221,84 |
break; |
case I2C_REQ_DATA: |
// Set module to receive one byte of data |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
SSPCON2bits.RCEN = 1; |
break; |
case I2C_SEND_STOP: |
// Send the stop bit and copy message to send to Main() |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_RECV_OK; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_RECV_OK; |
break; |
} |
} else if (i2c_data.master_status == I2C_MASTER_RESTART) { |
switch (i2c_data.operating_state) { |
} 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.operating_state = I2C_CHECK_ACK_SEND; |
SSPBUF = (i2c_data.master_dest_addr << 1) | 0x0; |
i2c_data_p->operating_state = I2C_CHECK_ACK_SEND; |
SSPBUF = (i2c_data_p->master_dest_addr << 1) | 0x0; |
break; |
case I2C_CHECK_ACK_SEND: |
// Check if ACK is received or not |
if (!SSPCON2bits.ACKSTAT) { |
// If an ACK is received, send first byte of data |
SSPBUF = i2c_data.buffer_in[0]; |
i2c_data.operating_state = I2C_CHECK_ACK_RESTART; |
SSPBUF = 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.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_SEND_FAIL; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_SEND_FAIL; |
} |
break; |
case I2C_CHECK_ACK_RESTART: |
if (!SSPCON2bits.ACKSTAT) { |
SSPCON2bits.RSEN = 1; |
i2c_data.operating_state = I2C_SEND_ADDR_2; |
i2c_data_p->operating_state = I2C_SEND_ADDR_2; |
} else { |
// If a NACK is received, stop transmission and send error |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_SEND_FAIL; |
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.operating_state = I2C_CHECK_ACK_RECV; |
SSPBUF = (i2c_data.master_dest_addr << 1) | 0x1; |
i2c_data_p->operating_state = I2C_CHECK_ACK_RECV; |
SSPBUF = (i2c_data_p->master_dest_addr << 1) | 0x1; |
break; |
case I2C_CHECK_ACK_RECV: |
// Check if ACK is received |
if (!SSPCON2bits.ACKSTAT) { |
// If an ACK is received, set module to receive 1 byte of data |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
SSPCON2bits.RCEN = 1; |
} else { |
// If a NACK is received, stop transmission and send error |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_RECV_FAIL; |
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.buffer_in[i2c_data.buffer_in_write_ind] = SSPBUF; |
i2c_data.buffer_in_write_ind++; |
if (i2c_data.buffer_in_write_ind < i2c_data.buffer_in_len) { |
i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = SSPBUF; |
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.operating_state = I2C_REQ_DATA; |
i2c_data_p->operating_state = I2C_REQ_DATA; |
SSPCON2bits.ACKDT = 0; // ACK |
SSPCON2bits.ACKEN = 1; |
} else { |
// If we are done reading, send an NACK to the slave |
i2c_data.operating_state = I2C_SEND_STOP; |
i2c_data_p->operating_state = I2C_SEND_STOP; |
SSPCON2bits.ACKDT = 1; // NACK |
SSPCON2bits.ACKEN = 1; |
} |
304,15 → 305,15 |
break; |
case I2C_REQ_DATA: |
// Set module to receive one byte of data |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
SSPCON2bits.RCEN = 1; |
break; |
case I2C_SEND_STOP: |
// Send the stop bit and copy message to send to Main() |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_RECV_OK; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_RECV_OK; |
break; |
} |
} |
331,9 → 332,9 |
// 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.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
overrun_error = 1; |
i2c_data.return_status = I2C_ERR_OVERRUN; |
i2c_data_p->return_status = I2C_ERR_OVERRUN; |
} |
// Read SPPxBUF if it is full |
344,29 → 345,29 |
} |
if (!overrun_error) { |
switch (i2c_data.operating_state) { |
switch (i2c_data_p->operating_state) { |
case I2C_IDLE: |
{ |
// Ignore anything except a start |
if (SSPSTATbits.S == 1) { |
i2c_data.buffer_in_len_tmp = 0; |
i2c_data.operating_state = I2C_STARTED; |
i2c_data_p->buffer_in_len_tmp = 0; |
i2c_data_p->operating_state = I2C_STARTED; |
// if (data_read_from_buffer) { |
// if (SSPSTATbits.D_A == 1) { |
// DBG_PRINT_I2C("I2C Start: (ERROR) no address recieved\r\n"); |
// // This is bad because we got data and we wanted an address |
// i2c_data.operating_state = I2C_IDLE; |
// i2c_data.return_status = I2C_ERR_NOADDR; |
// i2c_data_p->operating_state = I2C_IDLE; |
// i2c_data_p->return_status = I2C_ERR_NOADDR; |
// } else { |
// // Determine if we are sending or receiving data |
// if (SSPSTATbits.R_W == 1) { |
// i2c_data.operating_state = I2C_SEND_DATA; |
// i2c_data_p->operating_state = I2C_SEND_DATA; |
// } else { |
// i2c_data.operating_state = I2C_RCV_DATA; |
// i2c_data_p->operating_state = I2C_RCV_DATA; |
// } |
// } |
// } else { |
// i2c_data.operating_state = I2C_STARTED; |
// i2c_data_p->operating_state = I2C_STARTED; |
// } |
} |
break; |
376,23 → 377,23 |
// In this case, we expect either an address or a stop bit |
if (SSPSTATbits.P == 1) { |
// Return to idle mode |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
} else if (data_read_from_buffer) { |
if (SSPSTATbits.D_A == 0) { |
// Address received |
if (SSPSTATbits.R_W == 0) { |
// Slave write mode |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
} else { |
// Slave read mode |
i2c_data.operating_state = I2C_SEND_DATA; |
i2c_data_p->operating_state = I2C_SEND_DATA; |
// Process the first byte immediatly if sending data |
goto send; |
} |
} else { |
DBG_PRINT_I2C("I2C: (ERROR) no data recieved\r\n"); |
i2c_data.operating_state = I2C_IDLE; |
i2c_data.return_status = I2C_ERR_NODATA; |
i2c_data_p->operating_state = I2C_IDLE; |
i2c_data_p->return_status = I2C_ERR_NODATA; |
} |
} |
break; |
400,29 → 401,29 |
send: |
case I2C_SEND_DATA: |
{ |
if (!i2c_data.slave_sending_data) { |
if (!i2c_data_p->slave_sending_data) { |
// If we are not currently sending data, figure out what to reply with |
if (I2C_Process_Send(i2c_data.slave_in_last_byte)) { |
if (I2C_Process_Send(i2c_data_p->slave_in_last_byte)) { |
// Data exists to be returned, send first byte |
SSPBUF = i2c_data.buffer_out[0]; |
i2c_data.buffer_out_ind = 1; |
i2c_data.slave_sending_data = 1; |
SSPBUF = 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.slave_sending_data = 0; |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->slave_sending_data = 0; |
i2c_data_p->operating_state = I2C_IDLE; |
} |
} else { |
// Sending remaining data back to master |
if (i2c_data.buffer_out_ind < i2c_data.buffer_out_len) { |
SSPBUF = i2c_data.buffer_out[i2c_data.buffer_out_ind]; |
i2c_data.buffer_out_ind++; |
if (i2c_data_p->buffer_out_ind < i2c_data_p->buffer_out_len) { |
SSPBUF = 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.slave_sending_data = 0; |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->slave_sending_data = 0; |
i2c_data_p->operating_state = I2C_IDLE; |
} |
} |
break; |
436,49 → 437,49 |
if (SSPSTATbits.D_A == 1) { |
// Data received with stop bit |
// TODO: handle i2c buffer overflow |
i2c_data.buffer_in[i2c_data.buffer_in_write_ind] = received_data; |
if (i2c_data.buffer_in_write_ind == MAXI2CBUF-1) { |
i2c_data.buffer_in_write_ind = 0; |
i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = received_data; |
if (i2c_data_p->buffer_in_write_ind == MAXI2CBUF-1) { |
i2c_data_p->buffer_in_write_ind = 0; |
} else { |
i2c_data.buffer_in_write_ind++; |
i2c_data_p->buffer_in_write_ind++; |
} |
i2c_data.buffer_in_len_tmp++; |
i2c_data_p->buffer_in_len_tmp++; |
// Save the last byte received |
i2c_data.slave_in_last_byte = received_data; |
i2c_data.return_status = I2C_DATA_AVAL; |
i2c_data_p->slave_in_last_byte = received_data; |
i2c_data_p->return_status = I2C_DATA_AVAL; |
} else { |
DBG_PRINT_I2C("I2C: (ERROR) no data recieved\r\n"); |
i2c_data.operating_state = I2C_IDLE; |
i2c_data.return_status = I2C_ERR_NODATA; |
i2c_data_p->operating_state = I2C_IDLE; |
i2c_data_p->return_status = I2C_ERR_NODATA; |
} |
} |
i2c_data.buffer_in_len += i2c_data.buffer_in_len_tmp; |
i2c_data.operating_state = I2C_IDLE; |
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 (SSPSTATbits.D_A == 1) { |
// Data received |
i2c_data.buffer_in[i2c_data.buffer_in_write_ind] = received_data; |
if (i2c_data.buffer_in_write_ind == MAXI2CBUF-1) { |
i2c_data.buffer_in_write_ind = 0; |
i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = received_data; |
if (i2c_data_p->buffer_in_write_ind == MAXI2CBUF-1) { |
i2c_data_p->buffer_in_write_ind = 0; |
} else { |
i2c_data.buffer_in_write_ind++; |
i2c_data_p->buffer_in_write_ind++; |
} |
i2c_data.buffer_in_len_tmp++; |
i2c_data_p->buffer_in_len_tmp++; |
// Save the last byte received |
i2c_data.slave_in_last_byte = received_data; |
i2c_data.return_status = I2C_DATA_AVAL; |
i2c_data_p->slave_in_last_byte = received_data; |
i2c_data_p->return_status = I2C_DATA_AVAL; |
} else { |
// Restart bit detected |
if (SSPSTATbits.R_W == 1) { |
i2c_data.buffer_in_len += i2c_data.buffer_in_len_tmp; |
i2c_data.operating_state = I2C_SEND_DATA; |
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 |
DBG_PRINT_I2C("I2C: (ERROR) no data recieved\r\n"); |
i2c_data.operating_state = I2C_IDLE; |
i2c_data.return_status = I2C_ERR_NODATA; |
i2c_data_p->operating_state = I2C_IDLE; |
i2c_data_p->return_status = I2C_ERR_NODATA; |
} |
} |
} |
498,37 → 499,37 |
/* Returns 0 if I2C module is currently busy, otherwise returns status code */ |
unsigned char I2C_Get_Status() { |
if (i2c_data.operating_mode == I2C_MODE_MASTER) { |
if (i2c_data.master_status != I2C_MASTER_IDLE || i2c_data.buffer_in_len == 0) { |
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.return_status; |
return i2c_data_p->return_status; |
} |
} else if (i2c_data.operating_mode = I2C_MODE_SLAVE) { |
if (i2c_data.operating_state != I2C_IDLE || i2c_data.buffer_in_len == 0) { |
} else if (i2c_data_p->operating_mode = I2C_MODE_SLAVE) { |
if (i2c_data_p->operating_state != I2C_IDLE || i2c_data_p->buffer_in_len == 0) { |
return 0; |
} else { |
return i2c_data.return_status; |
return i2c_data_p->return_status; |
} |
} |
} |
unsigned char I2C_Buffer_Len() { |
return i2c_data.buffer_in_len; |
return i2c_data_p->buffer_in_len; |
} |
/* Returns 0 if I2C module is currently busy, otherwise returns buffer length */ |
unsigned char I2C_Read_Buffer(char *buffer) { |
unsigned char i = 0; |
while (i2c_data.buffer_in_len != 0) { |
buffer[i] = i2c_data.buffer_in[i2c_data.buffer_in_read_ind]; |
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.buffer_in_read_ind == MAXI2CBUF-1) { |
i2c_data.buffer_in_read_ind = 0; |
if (i2c_data_p->buffer_in_read_ind == MAXI2CBUF-1) { |
i2c_data_p->buffer_in_read_ind = 0; |
} else { |
i2c_data.buffer_in_read_ind++; |
i2c_data_p->buffer_in_read_ind++; |
} |
i2c_data.buffer_in_len--; |
i2c_data_p->buffer_in_len--; |
} |
return i; |
} |
538,14 → 539,14 |
unsigned char ret = 0; |
switch (c) { |
case 0xAA: |
i2c_data.buffer_out[0] = 'A'; |
i2c_data.buffer_out_len = 1; |
i2c_data_p->buffer_out[0] = 'A'; |
i2c_data_p->buffer_out_len = 1; |
ret = 1; |
break; |
case 0xBB: |
i2c_data.buffer_out[0] = '1'; |
i2c_data.buffer_out[1] = '2'; |
i2c_data.buffer_out_len = 2; |
i2c_data_p->buffer_out[0] = '1'; |
i2c_data_p->buffer_out[1] = '2'; |
i2c_data_p->buffer_out_len = 2; |
ret = 1; |
break; |
} |
/PIC Stuff/PIC_27J13/led_backpack.c |
---|
24,9 → 24,10 |
}; |
static LED_DATA led_data; |
static LED_DATA *led_data_p = &led_data; |
void LED_Init() { |
led_data.i2c_address = 0x70; |
led_data_p->i2c_address = 0x70; |
} |
void LED_Start() { |
33,7 → 34,7 |
unsigned char result; |
unsigned char c = 0x21; // Cmd to turn on oscillator |
I2C_Master_Send(led_data.i2c_address, 1, &c); |
I2C_Master_Send(led_data_p->i2c_address, 1, &c); |
result = I2C_Get_Status(); |
while (!result) { |
result = I2C_Get_Status(); |
51,7 → 52,7 |
if (c > 15) c = 15; |
c |= 0xE0; |
I2C_Master_Send(led_data.i2c_address, 1, &c); |
I2C_Master_Send(led_data_p->i2c_address, 1, &c); |
result = I2C_Get_Status(); |
while (!result) { |
result = I2C_Get_Status(); |
65,7 → 66,7 |
buffer = HT16K33_BLINK_CMD | HT16K33_BLINK_DISPLAYON | (c << 1); |
I2C_Master_Send(led_data.i2c_address, 1, &buffer); |
I2C_Master_Send(led_data_p->i2c_address, 1, &buffer); |
buffer = I2C_Get_Status(); |
while (!buffer) { |
buffer = I2C_Get_Status(); |
75,8 → 76,8 |
void LED_writeDisplay() { |
unsigned char result; |
led_data.display_buffer[0] = 0x00; // Start at address 0x00 |
I2C_Master_Send(led_data.i2c_address, 17, led_data.display_buffer); |
led_data_p->display_buffer[0] = 0x00; // Start at address 0x00 |
I2C_Master_Send(led_data_p->i2c_address, 17, led_data_p->display_buffer); |
result = I2C_Get_Status(); |
while (!result) { |
87,21 → 88,21 |
void LED_clear() { |
unsigned char c; |
for (c = 0; c < 17; c++) { |
led_data.display_buffer[c] = 0; |
led_data_p->display_buffer[c] = 0; |
} |
} |
void LED_drawColon(unsigned char c) { |
if (c) { |
led_data.display_buffer[5] = 0xFF; |
led_data_p->display_buffer[5] = 0xFF; |
} else { |
led_data.display_buffer[5] = 0; |
led_data_p->display_buffer[5] = 0; |
} |
} |
void LED_writeDigitRaw(unsigned char loc, unsigned char bitmask) { |
if (loc > 4) return; |
led_data.display_buffer[(loc<<1)+1] = bitmask; |
led_data_p->display_buffer[(loc<<1)+1] = bitmask; |
} |
void LED_writeDigitNum(unsigned char loc, unsigned char num, unsigned char dot) { |
/PIC Stuff/PIC_27J13/maindefs.h |
---|
5,7 → 5,7 |
#include "uart.h" |
// Option to enable/disable internal oscillator |
//#define USE_EXT_OSC |
#define USE_EXT_OSC |
//#define UART1_RX_TO_BUFFER |
#define UART1_RX_TO_XBEE |
/PIC Stuff/PIC_27J13/nbproject/Makefile-genesis.properties |
---|
1,5 → 1,5 |
# |
#Sat Jul 21 14:17:00 EDT 2012 |
#Mon Jul 23 10:59:08 EDT 2012 |
default.com-microchip-mplab-nbide-toolchainC18-C18LanguageToolchain.md5=db1c0674398f590b65c1c1c4fb1e2b92 |
default.languagetoolchain.dir=C\:\\Program Files (x86)\\Microchip\\mplabc18\\v3.40\\bin |
com-microchip-mplab-nbide-embedded-makeproject-MakeProject.md5=485c926ba2cd86275d1848ca44c226c5 |
/PIC Stuff/PIC_27J13/nbproject/configurations.xml |
---|
94,7 → 94,7 |
<property key="enable-ob" value="true"/> |
<property key="enable-od" value="true"/> |
<property key="enable-om" value="true"/> |
<property key="enable-on" value="true"/> |
<property key="enable-on" value="false"/> |
<property key="enable-op" value="true"/> |
<property key="enable-opa" value="true"/> |
<property key="enable-or" value="true"/> |
105,7 → 105,7 |
<property key="extra-include-directories" value=""/> |
<property key="optimization-master" value="Enable all"/> |
<property key="preprocessor-macros" value=""/> |
<property key="procedural-abstraction-passes" value="0"/> |
<property key="procedural-abstraction-passes" value="9"/> |
<property key="storage-class" value="sca"/> |
<property key="verbose" value="false"/> |
<property key="warning-level" value="2"/> |
/PIC Stuff/PIC_27J13/nfc.c |
---|
5,6 → 5,7 |
#include <delays.h> |
static NFC_DATA nfc_data; |
static NFC_DATA *nfc_data_p = &nfc_data; |
// Const value arrays for comparison use |
static char pn532response_firmwarevers[] = {0x01, 0x00, 0x00, 0xFF, 0x06, 0xFA, 0xD5, 0x03}; |
23,17 → 24,17 |
// Configures the SAM (Secure Access Module) |
unsigned char NFC_SAMConfig() { |
nfc_data.packetbuffer[0] = PN532_COMMAND_SAMCONFIGURATION; |
nfc_data.packetbuffer[1] = 0x01; // Normal mode |
nfc_data.packetbuffer[2] = 0x14; // Timeout 50ms * 20 = 1s |
nfc_data.packetbuffer[3] = 0x01; // Use IRQ pin |
nfc_data_p->packetbuffer[0] = PN532_COMMAND_SAMCONFIGURATION; |
nfc_data_p->packetbuffer[1] = 0x01; // Normal mode |
nfc_data_p->packetbuffer[2] = 0x14; // Timeout 50ms * 20 = 1s |
nfc_data_p->packetbuffer[3] = 0x01; // Use IRQ pin |
if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 4)) |
if (!NFC_sendCommandCheckAck(nfc_data_p->packetbuffer, 4)) |
return 0; |
NFC_I2C_Read_Data(nfc_data.packetbuffer, 8); |
NFC_I2C_Read_Data(nfc_data_p->packetbuffer, 8); |
return (nfc_data.packetbuffer[7] == 0x15); |
return (nfc_data_p->packetbuffer[7] == 0x15); |
} |
// Checks the firmware version of the PN5xx chip |
41,23 → 42,23 |
NFC_FIRMWARE_VERSION response = {0, 0, 0, 0}; |
// Create and send command |
nfc_data.packetbuffer[0] = PN532_COMMAND_GETFIRMWAREVERSION; |
nfc_data_p->packetbuffer[0] = PN532_COMMAND_GETFIRMWAREVERSION; |
if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 1)) |
if (!NFC_sendCommandCheckAck(nfc_data_p->packetbuffer, 1)) |
return response; |
// Read back data from the PN532 |
NFC_I2C_Read_Data(nfc_data.packetbuffer, 12); |
NFC_I2C_Read_Data(nfc_data_p->packetbuffer, 12); |
// Compare and check returned values |
if (strncmp((char *) nfc_data.packetbuffer, (char *) pn532response_firmwarevers, 8) != 0) |
if (strncmp((char *) nfc_data_p->packetbuffer, (char *) pn532response_firmwarevers, 8) != 0) |
return response; |
// Save and return info |
response.IC = nfc_data.packetbuffer[8]; |
response.Ver = nfc_data.packetbuffer[9]; |
response.Rev = nfc_data.packetbuffer[10]; |
response.Support = nfc_data.packetbuffer[11]; |
response.IC = nfc_data_p->packetbuffer[8]; |
response.Ver = nfc_data_p->packetbuffer[9]; |
response.Rev = nfc_data_p->packetbuffer[10]; |
response.Support = nfc_data_p->packetbuffer[11]; |
return response; |
} |
90,17 → 91,17 |
// Passive polling, waits for an ISO14443A target to enter the field |
unsigned char NFC_readPassiveTargetID(NFC_TargetDataMiFare *cardData) { |
nfc_data.packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; |
nfc_data.packetbuffer[1] = 2; // Max 2 cards at once |
nfc_data.packetbuffer[2] = PN532_MIFARE_ISO14443A; // Mifare only |
nfc_data_p->packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; |
nfc_data_p->packetbuffer[1] = 2; // Max 2 cards at once |
nfc_data_p->packetbuffer[2] = PN532_MIFARE_ISO14443A; // Mifare only |
if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 3)) |
if (!NFC_sendCommandCheckAck(nfc_data_p->packetbuffer, 3)) |
return 0; |
// Wait for IRQ line |
while (NFC_I2C_Read_Status() != PN532_I2C_READY); |
NFC_I2C_Read_Data(nfc_data.packetbuffer, 35); |
NFC_I2C_Read_Data(nfc_data_p->packetbuffer, 35); |
/* InListPassiveTarget response should be in the following format: |
* Byte Description |
113,53 → 114,53 |
*/ |
// Check # of tags found |
if (!nfc_data.packetbuffer[8]) |
if (!nfc_data_p->packetbuffer[8]) |
return 0; |
// Save data from first card |
if (nfc_data.packetbuffer[13] == 4) { |
memcpy((char *)&cardData[0], (const char *)&nfc_data.packetbuffer[9], 9); |
if (nfc_data_p->packetbuffer[13] == 4) { |
memcpy((char *)&cardData[0], (const char *)&nfc_data_p->packetbuffer[9], 9); |
} else { |
memcpy((char *)&cardData[0], (const char *)&nfc_data.packetbuffer[9], 12); |
memcpy((char *)&cardData[0], (const char *)&nfc_data_p->packetbuffer[9], 12); |
} |
// Save data from second card |
if (nfc_data.packetbuffer[8] == 2) { |
if (nfc_data_p->packetbuffer[8] == 2) { |
// Offset will vary depending on length of first card |
if (nfc_data.packetbuffer[13] == 4) { |
if (nfc_data.packetbuffer[22] == 4) { |
memcpy((char *)&cardData[1], (const char *)&nfc_data.packetbuffer[18], 9); |
if (nfc_data_p->packetbuffer[13] == 4) { |
if (nfc_data_p->packetbuffer[22] == 4) { |
memcpy((char *)&cardData[1], (const char *)&nfc_data_p->packetbuffer[18], 9); |
} else { |
memcpy((char *)&cardData[1], (const char *)&nfc_data.packetbuffer[18], 12); |
memcpy((char *)&cardData[1], (const char *)&nfc_data_p->packetbuffer[18], 12); |
} |
} else { // Length of first UID is 7 |
if (nfc_data.packetbuffer[25] == 4) { |
memcpy((char *)&cardData[1], (const char *)&nfc_data.packetbuffer[21], 9); |
if (nfc_data_p->packetbuffer[25] == 4) { |
memcpy((char *)&cardData[1], (const char *)&nfc_data_p->packetbuffer[21], 9); |
} else { |
memcpy((char *)&cardData[1], (const char *)&nfc_data.packetbuffer[21], 12); |
memcpy((char *)&cardData[1], (const char *)&nfc_data_p->packetbuffer[21], 12); |
} |
} |
} |
// Return the number of cards detected |
return nfc_data.packetbuffer[8]; |
return nfc_data_p->packetbuffer[8]; |
} |
// Active polling, returns number of cards in the field |
unsigned char NFC_pollTargets(unsigned char number, unsigned char period, NFC_TargetDataMiFare *cardData) { |
nfc_data.packetbuffer[0] = PN532_COMMAND_INAUTOPOLL; |
nfc_data.packetbuffer[1] = number; // Number of polling |
nfc_data.packetbuffer[2] = period; // Polling period in units of 150ms |
nfc_data.packetbuffer[3] = 0x10; // Check for Mifare cards only |
nfc_data_p->packetbuffer[0] = PN532_COMMAND_INAUTOPOLL; |
nfc_data_p->packetbuffer[1] = number; // Number of polling |
nfc_data_p->packetbuffer[2] = period; // Polling period in units of 150ms |
nfc_data_p->packetbuffer[3] = 0x10; // Check for Mifare cards only |
if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 4)) |
if (!NFC_sendCommandCheckAck(nfc_data_p->packetbuffer, 4)) |
return 0; |
// Wait for IRQ line |
while (NFC_I2C_Read_Status() != PN532_I2C_READY); |
NFC_I2C_Read_Data(nfc_data.packetbuffer, 37); |
NFC_I2C_Read_Data(nfc_data_p->packetbuffer, 37); |
/* InAutoPoll response should be in the following format: |
* Byte Description |
174,36 → 175,36 |
*/ |
// Check # of tags found |
if (!nfc_data.packetbuffer[8]) |
if (!nfc_data_p->packetbuffer[8]) |
return 0; |
// Save data from first card |
if (nfc_data.packetbuffer[15] == 4) { |
memcpy((char *)&cardData[0], (const char *)&nfc_data.packetbuffer[11], 9); |
if (nfc_data_p->packetbuffer[15] == 4) { |
memcpy((char *)&cardData[0], (const char *)&nfc_data_p->packetbuffer[11], 9); |
} else { |
memcpy((char *)&cardData[0], (const char *)&nfc_data.packetbuffer[11], 12); |
memcpy((char *)&cardData[0], (const char *)&nfc_data_p->packetbuffer[11], 12); |
} |
// Save data from second card |
if (nfc_data.packetbuffer[8] == 2) { |
if (nfc_data_p->packetbuffer[8] == 2) { |
// Offset will vary depending on length of first card |
if (nfc_data.packetbuffer[15] == 4) { |
if (nfc_data.packetbuffer[26] == 4) { |
memcpy((char *)&cardData[1], (const char *)&nfc_data.packetbuffer[22], 9); |
if (nfc_data_p->packetbuffer[15] == 4) { |
if (nfc_data_p->packetbuffer[26] == 4) { |
memcpy((char *)&cardData[1], (const char *)&nfc_data_p->packetbuffer[22], 9); |
} else { |
memcpy((char *)&cardData[1], (const char *)&nfc_data.packetbuffer[22], 12); |
memcpy((char *)&cardData[1], (const char *)&nfc_data_p->packetbuffer[22], 12); |
} |
} else { |
if (nfc_data.packetbuffer[29] == 4) { |
memcpy((char *)&cardData[1], (const char *)&nfc_data.packetbuffer[25], 9); |
if (nfc_data_p->packetbuffer[29] == 4) { |
memcpy((char *)&cardData[1], (const char *)&nfc_data_p->packetbuffer[25], 9); |
} else { |
memcpy((char *)&cardData[1], (const char *)&nfc_data.packetbuffer[25], 12); |
memcpy((char *)&cardData[1], (const char *)&nfc_data_p->packetbuffer[25], 12); |
} |
} |
} |
// Return the number of cards detected |
return nfc_data.packetbuffer[8]; |
return nfc_data_p->packetbuffer[8]; |
} |
// Indicates whether the specified block number is the first block |
235,23 → 236,23 |
unsigned char i; |
// Assemble frame data |
nfc_data.packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; /* Data Exchange Header */ |
nfc_data.packetbuffer[1] = 1; /* Max card numbers */ |
nfc_data.packetbuffer[2] = (keyNumber) ? MIFARE_CMD_AUTH_A : MIFARE_CMD_AUTH_B; |
nfc_data.packetbuffer[3] = blockNumber; /* Block Number (1K = 0..63, 4K = 0..255 */ |
nfc_data_p->packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; /* Data Exchange Header */ |
nfc_data_p->packetbuffer[1] = 1; /* Max card numbers */ |
nfc_data_p->packetbuffer[2] = (keyNumber) ? MIFARE_CMD_AUTH_A : MIFARE_CMD_AUTH_B; |
nfc_data_p->packetbuffer[3] = blockNumber; /* Block Number (1K = 0..63, 4K = 0..255 */ |
for (i = 0; i < 6; i++) { |
nfc_data.packetbuffer[4 + i] = keyData[i]; |
nfc_data_p->packetbuffer[4 + i] = keyData[i]; |
} |
for (i = 0; i < uidLen; i++) { |
nfc_data.packetbuffer[10 + i] = uid[i]; |
nfc_data_p->packetbuffer[10 + i] = uid[i]; |
} |
// Send frame and check for ACK |
if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 10 + uidLen)) |
if (!NFC_sendCommandCheckAck(nfc_data_p->packetbuffer, 10 + uidLen)) |
return 0; |
// Read response from PN532 |
NFC_I2C_Read_Data(nfc_data.packetbuffer, 12); |
NFC_I2C_Read_Data(nfc_data_p->packetbuffer, 12); |
return 1; |
} |
261,20 → 262,20 |
unsigned char i; |
// Assemble frame data |
nfc_data.packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; |
nfc_data.packetbuffer[1] = 1; /* Card number */ |
nfc_data.packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */ |
nfc_data.packetbuffer[3] = blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ |
nfc_data_p->packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; |
nfc_data_p->packetbuffer[1] = 1; /* Card number */ |
nfc_data_p->packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */ |
nfc_data_p->packetbuffer[3] = blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ |
// Send frame and check for ACK |
if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 4)) |
if (!NFC_sendCommandCheckAck(nfc_data_p->packetbuffer, 4)) |
return 0; |
// Read reponse |
NFC_I2C_Read_Data(nfc_data.packetbuffer, 26); |
NFC_I2C_Read_Data(nfc_data_p->packetbuffer, 26); |
// If byte 9 isnt 0x00 we probably have and error |
if (nfc_data.packetbuffer[8] != 0x00) { |
if (nfc_data_p->packetbuffer[8] != 0x00) { |
return 0; |
} |
281,7 → 282,7 |
// Copy the 16 data bytes into the data buffer |
// Block contents starts at byte 10 of a valid response |
for (i = 0; i < 16; i++) { |
data[i] = nfc_data.packetbuffer[9 + i]; |
data[i] = nfc_data_p->packetbuffer[9 + i]; |
} |
return 1; |
292,20 → 293,20 |
unsigned char i; |
// Assemble frame data |
nfc_data.packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; |
nfc_data.packetbuffer[1] = 1; /* Card number */ |
nfc_data.packetbuffer[2] = MIFARE_CMD_WRITE; /* Mifare Write command = 0xA0 */ |
nfc_data.packetbuffer[3] = blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ |
nfc_data_p->packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; |
nfc_data_p->packetbuffer[1] = 1; /* Card number */ |
nfc_data_p->packetbuffer[2] = MIFARE_CMD_WRITE; /* Mifare Write command = 0xA0 */ |
nfc_data_p->packetbuffer[3] = blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ |
for (i = 0; i < 16; i++) { /* Data Payload */ |
nfc_data.packetbuffer[4 + i] = data[i]; |
nfc_data_p->packetbuffer[4 + i] = data[i]; |
} |
// Send frame and check for ACK |
if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 20)) |
if (!NFC_sendCommandCheckAck(nfc_data_p->packetbuffer, 20)) |
return 0; |
// Read response |
NFC_I2C_Read_Data(nfc_data.packetbuffer, 26); |
NFC_I2C_Read_Data(nfc_data_p->packetbuffer, 26); |
return 1; |
} |
/PIC Stuff/PIC_27J13/oled_ssd1306.c |
---|
77,7 → 77,7 |
#endif |
}; |
#else |
static unsigned char LCD_Buffer[1]; |
static unsigned char *LCD_Buffer; |
#endif |
void SSD1306_Init() { |
/PIC Stuff/PIC_27J13/spi.c |
---|
2,6 → 2,7 |
#include "spi.h" |
static SPI_DATA spi_data; |
static SPI_DATA *spi_data_p = &spi_data; |
void SPI2_Init(unsigned char speed) { |
// Set up SPI2 with specified pins |
49,11 → 50,11 |
PIE3bits.SSP2IE = 0; |
#endif |
spi_data.buffer_in_len = 0; |
spi_data.buffer_in_read_ind = 0; |
spi_data.buffer_in_write_ind = 0; |
spi_data.buffer_out_ind = 0; |
spi_data.buffer_out_len = 0; |
spi_data_p->buffer_in_len = 0; |
spi_data_p->buffer_in_read_ind = 0; |
spi_data_p->buffer_in_write_ind = 0; |
spi_data_p->buffer_out_ind = 0; |
spi_data_p->buffer_out_len = 0; |
} |
void SPI2_Recv_Interrupt_Handler() { |
60,27 → 61,27 |
unsigned char c; |
if (SSP2STATbits.BF) { // Check if data receive flag is set |
if (spi_data.buffer_in_len == MAXSPIBUF - 1) { |
if (spi_data_p->buffer_in_len == MAXSPIBUF - 1) { |
DBG_PRINT_SPI("SPI2: (ERROR) buffer overflow\r\n"); |
c = SSP2BUF; // Read SSP2BUF to clear it |
} else { |
// Save received data into buffer |
spi_data.buffer_in[spi_data.buffer_in_write_ind] = SSP2BUF; |
if (spi_data.buffer_in_write_ind == MAXSPIBUF - 1) { |
spi_data.buffer_in_write_ind = 0; |
spi_data_p->buffer_in[spi_data_p->buffer_in_write_ind] = SSP2BUF; |
if (spi_data_p->buffer_in_write_ind == MAXSPIBUF - 1) { |
spi_data_p->buffer_in_write_ind = 0; |
} else { |
spi_data.buffer_in_write_ind++; |
spi_data_p->buffer_in_write_ind++; |
} |
spi_data.buffer_in_len++; |
spi_data_p->buffer_in_len++; |
// Put next byte in SSP2BUF for transmit |
if (spi_data.buffer_out_ind != spi_data.buffer_out_len) { |
SSP2BUF = spi_data.buffer_out[spi_data.buffer_out_ind]; |
spi_data.buffer_out_ind++; |
if (spi_data_p->buffer_out_ind != spi_data_p->buffer_out_len) { |
SSP2BUF = spi_data_p->buffer_out[spi_data_p->buffer_out_ind]; |
spi_data_p->buffer_out_ind++; |
} else { |
LATBbits.LATB2 = 1; // Bring SS line high |
spi_data.buffer_out_ind = 0; |
spi_data.buffer_out_len = 0; |
spi_data_p->buffer_out_ind = 0; |
spi_data_p->buffer_out_len = 0; |
} |
} |
} |
89,13 → 90,13 |
void SPI2_Write(unsigned char *msg, unsigned int length) { |
#ifdef SPI2_USE_INTERRUPT |
unsigned char i; |
spi_data.buffer_out_len = length; |
spi_data.buffer_out_ind = 1; |
spi_data_p->buffer_out_len = length; |
spi_data_p->buffer_out_ind = 1; |
for (i = 0; i < length; i++) { |
spi_data.buffer_out[i] = msg[i]; |
spi_data_p->buffer_out[i] = msg[i]; |
} |
LATBbits.LATB7 = 0; // Bring SS line low |
SSP2BUF = spi_data.buffer_out[0]; // Transmit first byte |
SSP2BUF = spi_data_p->buffer_out[0]; // Transmit first byte |
#else |
unsigned int i = 0; |
unsigned char tmp = 0; |
106,13 → 107,13 |
while (!SSP2STATbits.BF); |
#ifndef SPI2_WRITE_ONLY |
spi_data.buffer_in[spi_data.buffer_in_write_ind] = SSP2BUF; |
if (spi_data.buffer_in_write_ind == MAXSPIBUF - 1) { |
spi_data.buffer_in_write_ind = 0; |
spi_data_p->buffer_in[spi_data_p->buffer_in_write_ind] = SSP2BUF; |
if (spi_data_p->buffer_in_write_ind == MAXSPIBUF - 1) { |
spi_data_p->buffer_in_write_ind = 0; |
} else { |
spi_data.buffer_in_write_ind++; |
spi_data_p->buffer_in_write_ind++; |
} |
spi_data.buffer_in_len++; |
spi_data_p->buffer_in_len++; |
#else |
// Read data in buffer to clear it |
tmp = SSP2BUF; |
135,13 → 136,13 |
while (!SSP2STATbits.BF); |
#ifndef SPI2_WRITE_ONLY |
spi_data.buffer_in[spi_data.buffer_in_write_ind] = SSP2BUF; |
if (spi_data.buffer_in_write_ind == MAXSPIBUF - 1) { |
spi_data.buffer_in_write_ind = 0; |
spi_data_p->buffer_in[spi_data_p->buffer_in_write_ind] = SSP2BUF; |
if (spi_data_p->buffer_in_write_ind == MAXSPIBUF - 1) { |
spi_data_p->buffer_in_write_ind = 0; |
} else { |
spi_data.buffer_in_write_ind++; |
spi_data_p->buffer_in_write_ind++; |
} |
spi_data.buffer_in_len++; |
spi_data_p->buffer_in_len++; |
#else |
// Read data in buffer to clear it |
tmp = SSP2BUF; |
154,13 → 155,13 |
void SPI2_Read(unsigned char length) { |
#ifdef SPI2_USE_INTERRUPT |
unsigned char i; |
spi_data.buffer_out_len = length; |
spi_data.buffer_out_ind = 1; |
spi_data_p->buffer_out_len = length; |
spi_data_p->buffer_out_ind = 1; |
for (i = 0; i < length; i++) { |
spi_data.buffer_out[i] = 0x0; |
spi_data_p->buffer_out[i] = 0x0; |
} |
LATBbits.LATB7 = 0; // Bring SS line low |
SSP2BUF = spi_data.buffer_out[0]; // Transmit first byte |
SSP2BUF = spi_data_p->buffer_out[0]; // Transmit first byte |
#else |
unsigned char i = 0; |
LATBbits.LATB7 = 0; |
169,13 → 170,13 |
SSP2BUF = 0x0; |
while (!SSP2STATbits.BF); |
spi_data.buffer_in[spi_data.buffer_in_write_ind] = SSP2BUF; |
if (spi_data.buffer_in_write_ind == MAXSPIBUF - 1) { |
spi_data.buffer_in_write_ind = 0; |
spi_data_p->buffer_in[spi_data_p->buffer_in_write_ind] = SSP2BUF; |
if (spi_data_p->buffer_in_write_ind == MAXSPIBUF - 1) { |
spi_data_p->buffer_in_write_ind = 0; |
} else { |
spi_data.buffer_in_write_ind++; |
spi_data_p->buffer_in_write_ind++; |
} |
spi_data.buffer_in_len++; |
spi_data_p->buffer_in_len++; |
} |
LATBbits.LATB7 = 1; |
#endif |
182,20 → 183,20 |
} |
unsigned char SPI2_Buffer_Len() { |
return spi_data.buffer_in_len; |
return spi_data_p->buffer_in_len; |
} |
unsigned char SPI2_Buffer_Read(unsigned char* buffer) { |
unsigned char i = 0; |
while (spi_data.buffer_in_len != 0) { |
buffer[i] = spi_data.buffer_in[spi_data.buffer_in_read_ind]; |
while (spi_data_p->buffer_in_len != 0) { |
buffer[i] = spi_data_p->buffer_in[spi_data_p->buffer_in_read_ind]; |
i++; |
if (spi_data.buffer_in_read_ind == MAXSPIBUF - 1) { |
spi_data.buffer_in_read_ind = 0; |
if (spi_data_p->buffer_in_read_ind == MAXSPIBUF - 1) { |
spi_data_p->buffer_in_read_ind = 0; |
} else { |
spi_data.buffer_in_read_ind++; |
spi_data_p->buffer_in_read_ind++; |
} |
spi_data.buffer_in_len--; |
spi_data_p->buffer_in_len--; |
} |
return i; |
} |
/PIC Stuff/PIC_27J13/uart.c |
---|
5,6 → 5,7 |
#include <stdio.h> |
static UART_DATA uart_1_data; |
static UART_DATA *uart_1_data_p = &uart_1_data; |
void UART1_Init() { |
// Configure the hardware USART device |
34,10 → 35,10 |
PIE1bits.RC1IE = 1; // Enable RX interrupt |
// Initialize the buffer that holds UART messages |
uart_1_data.buffer_in_read_ind = 0; |
uart_1_data.buffer_in_write_ind = 0; |
uart_1_data.buffer_in_len = 0; |
uart_1_data.buffer_in_len_tmp = 0; |
uart_1_data_p->buffer_in_read_ind = 0; |
uart_1_data_p->buffer_in_write_ind = 0; |
uart_1_data_p->buffer_in_len = 0; |
uart_1_data_p->buffer_in_len_tmp = 0; |
} |
//void uart_2_init() { |
62,28 → 63,28 |
c = RCREG1; |
#ifdef UART1_RX_TO_BUFFER |
// Save received data into buffer |
uart_1_data.buffer_in[uart_1_data.buffer_in_write_ind] = c; |
if (uart_1_data.buffer_in_write_ind == MAXUARTBUF - 1) { |
uart_1_data.buffer_in_write_ind = 0; |
uart_1_data_p->buffer_in[uart_1_data_p->buffer_in_write_ind] = c; |
if (uart_1_data_p->buffer_in_write_ind == MAXUARTBUF - 1) { |
uart_1_data_p->buffer_in_write_ind = 0; |
} else { |
uart_1_data.buffer_in_write_ind++; |
uart_1_data_p->buffer_in_write_ind++; |
} |
// Store the last MAXUARTBUF values entered |
if (uart_1_data.buffer_in_len_tmp < MAXUARTBUF) { |
uart_1_data.buffer_in_len_tmp++; |
if (uart_1_data_p->buffer_in_len_tmp < MAXUARTBUF) { |
uart_1_data_p->buffer_in_len_tmp++; |
} else { |
if (uart_1_data.buffer_in_read_ind == MAXUARTBUF - 1) { |
uart_1_data.buffer_in_read_ind = 0; |
if (uart_1_data_p->buffer_in_read_ind == MAXUARTBUF - 1) { |
uart_1_data_p->buffer_in_read_ind = 0; |
} else { |
uart_1_data.buffer_in_read_ind++; |
uart_1_data_p->buffer_in_read_ind++; |
} |
} |
// Update buffer size upon receiving newline (0x0D) |
if (c == UART1_BREAK_CHAR) { |
uart_1_data.buffer_in_len = uart_1_data.buffer_in_len_tmp; |
uart_1_data.buffer_in_len_tmp = 0; |
uart_1_data_p->buffer_in_len = uart_1_data_p->buffer_in_len_tmp; |
uart_1_data_p->buffer_in_len_tmp = 0; |
} |
#endif |
#ifdef UART1_RX_TO_XBEE |
114,14 → 115,14 |
void UART1_Send_Interrupt_Handler() { |
// Put remaining data in TSR for transmit |
if (uart_1_data.buffer_out_ind != uart_1_data.buffer_out_len) { |
TXREG1 = uart_1_data.buffer_out[uart_1_data.buffer_out_ind]; |
uart_1_data.buffer_out_ind++; |
if (uart_1_data_p->buffer_out_ind != uart_1_data_p->buffer_out_len) { |
TXREG1 = uart_1_data_p->buffer_out[uart_1_data_p->buffer_out_ind]; |
uart_1_data_p->buffer_out_ind++; |
} else { |
while (!TXSTA1bits.TRMT); // Wait for last byte to finish sending |
TXSTA1bits.TXEN = 0; // End transmission and disable TX interrupt |
uart_1_data.buffer_out_ind = 0; |
uart_1_data.buffer_out_len = 0; |
uart_1_data_p->buffer_out_ind = 0; |
uart_1_data_p->buffer_out_len = 0; |
} |
} |
130,12 → 131,12 |
unsigned char i; |
va_list args; |
va_start(args, fmt); |
vsprintf((char *) uart_1_data.buffer_out, fmt, args); |
vsprintf((char *) uart_1_data_p->buffer_out, fmt, args); |
va_end(args); |
uart_1_data.buffer_out_len = strlen((char *) uart_1_data.buffer_out); |
uart_1_data.buffer_out_ind = 1; |
for (i = 0; i < uart_1_data.buffer_out_len; i++) { |
TXREG1 = uart_1_data.buffer_out[i]; |
uart_1_data_p->buffer_out_len = strlen((char *) uart_1_data_p->buffer_out); |
uart_1_data_p->buffer_out_ind = 1; |
for (i = 0; i < uart_1_data_p->buffer_out_len; i++) { |
TXREG1 = uart_1_data_p->buffer_out[i]; |
Nop(); |
while (!PIR1bits.TX1IF); // Wait for byte to be transmitted |
} |
143,11 → 144,11 |
va_list args; |
while (TXSTA1bits.TXEN); // Wait for previous message to finish sending |
va_start(args, fmt); |
vsprintf((char *) uart_1_data.buffer_out, fmt, args); |
vsprintf((char *) uart_1_data_p->buffer_out, fmt, args); |
va_end(args); |
uart_1_data.buffer_out_len = strlen((char *) uart_1_data.buffer_out); |
uart_1_data.buffer_out_ind = 1; |
TXREG1 = uart_1_data.buffer_out[0]; // Put first byte in TSR |
uart_1_data_p->buffer_out_len = strlen((char *) uart_1_data_p->buffer_out); |
uart_1_data_p->buffer_out_ind = 1; |
TXREG1 = uart_1_data_p->buffer_out[0]; // Put first byte in TSR |
TXSTA1bits.TXEN = 1; // Begin transmission |
#endif |
} |
162,12 → 163,12 |
} |
#else |
while (TXSTA1bits.TXEN); // Wait for previous message to finish sending |
uart_1_data.buffer_out_len = length; |
uart_1_data.buffer_out_ind = 1; |
uart_1_data_p->buffer_out_len = length; |
uart_1_data_p->buffer_out_ind = 1; |
for (i = 0; i < length; i++) { |
uart_1_data.buffer_out[i] = msg[i]; |
uart_1_data_p->buffer_out[i] = msg[i]; |
} |
TXREG1 = uart_1_data.buffer_out[0]; // Put first byte in TSR |
TXREG1 = uart_1_data_p->buffer_out[0]; // Put first byte in TSR |
TXSTA1bits.TXEN = 1; // Begin transmission |
#endif |
} |
179,8 → 180,8 |
while (!PIR1bits.TX1IF); |
#else |
while (TXSTA1bits.TXEN); |
uart_1_data.buffer_out_len = 1; |
uart_1_data.buffer_out_ind = 1; |
uart_1_data_p->buffer_out_len = 1; |
uart_1_data_p->buffer_out_ind = 1; |
TXREG1 = c; |
TXSTA1bits.TXEN = 1; |
#endif |
188,21 → 189,21 |
} |
unsigned char UART1_Buffer_Len() { |
return uart_1_data.buffer_in_len; |
return uart_1_data_p->buffer_in_len; |
} |
/* Reader interface to the UART buffer, returns the number of bytes read */ |
unsigned char UART1_Read_Buffer(unsigned char *buffer) { |
unsigned char i = 0; |
while (uart_1_data.buffer_in_len != 0) { |
buffer[i] = uart_1_data.buffer_in[uart_1_data.buffer_in_read_ind]; |
while (uart_1_data_p->buffer_in_len != 0) { |
buffer[i] = uart_1_data_p->buffer_in[uart_1_data_p->buffer_in_read_ind]; |
i++; |
if (uart_1_data.buffer_in_read_ind == MAXUARTBUF - 1) { |
uart_1_data.buffer_in_read_ind = 0; |
if (uart_1_data_p->buffer_in_read_ind == MAXUARTBUF - 1) { |
uart_1_data_p->buffer_in_read_ind = 0; |
} else { |
uart_1_data.buffer_in_read_ind++; |
uart_1_data_p->buffer_in_read_ind++; |
} |
uart_1_data.buffer_in_len--; |
uart_1_data_p->buffer_in_len--; |
} |
return i; |
} |
/PIC Stuff/PIC_27J13/xbee.c |
---|
3,6 → 3,7 |
#include <string.h> |
static XBEE_DATA xbee_data; |
static XBEE_DATA *xbee_data_p = &xbee_data; |
static void *xbee_data_frame; |
static void *xbee_frame; |
14,17 → 15,17 |
XBEE_CTS_LAT = 0; // Pin set high to signal stop sending data to XBee |
XBEE_RTS_LAT = 0; // Pin set high to indicate stop sending data to PIC |
xbee_data.dataind = 0; |
xbee_data.checksum_sum = 0; |
xbee_data.frame_rdy = 0; |
xbee_data.escape_flag = 0; |
xbee_data.read_state = XBEE_STATE_READ_START; |
xbee_data_p->dataind = 0; |
xbee_data_p->checksum_sum = 0; |
xbee_data_p->frame_rdy = 0; |
xbee_data_p->escape_flag = 0; |
xbee_data_p->read_state = XBEE_STATE_READ_START; |
// memset(&xbee_data, 0, 32); |
// Grab a pointer to where the unique frame array starts |
xbee_data_frame = &(xbee_data.rcv_frame.FRAME); |
xbee_frame = &(xbee_data.rcv_frame); |
xbee_data_frame = &(xbee_data_p->rcv_frame.FRAME); |
xbee_frame = &(xbee_data_p->rcv_frame); |
} |
/* Here we handle the serial input from the UART interrupt */ |
32,31 → 33,30 |
// For some reason writing the length straight to xbee_data doesnt seem to work |
// so we work around it by pointing to the length bytes directly |
XBEE_ADDRESS_16 *length = xbee_frame + 1; |
#ifdef XBEE_USE_ESCAPE_CHAR |
if (c == XBEE_ESCAPE_CHAR) { |
// Next byte needs is an escaped char |
xbee_data.escape_flag = 1; |
xbee_data_p->escape_flag = 1; |
return; |
} |
if (xbee_data.escape_flag) { |
if (xbee_data_p->escape_flag) { |
// XOR byte with 0x20 to get escaped char |
c ^= XBEE_ESCAPE_VAL; |
xbee_data.escape_flag = 0; |
xbee_data_p->escape_flag = 0; |
} |
#endif |
// Reset on start bit and start saving data |
if (c == XBEE_START_DELIMITER) { |
// On detect start delimiter, clear out initial array |
xbee_data.dataind = 0; |
xbee_data.checksum_sum = 0; |
xbee_data.frame_rdy = 0; |
xbee_data.read_state = XBEE_STATE_READ_LENGTH_HIGH; |
xbee_data_p->dataind = 0; |
xbee_data_p->checksum_sum = 0; |
xbee_data_p->frame_rdy = 0; |
xbee_data_p->read_state = XBEE_STATE_READ_LENGTH_HIGH; |
*((unsigned char *)xbee_frame) = XBEE_START_DELIMITER; |
} else { |
switch (xbee_data.read_state) { |
switch (xbee_data_p->read_state) { |
case XBEE_STATE_READ_START: |
// Do nothing and wait till start bit is read |
break; |
63,36 → 63,36 |
case XBEE_STATE_READ_LENGTH_HIGH: |
// Read length (MSB) |
length->INT_16.char_value[1] = c; |
xbee_data.read_state = XBEE_STATE_READ_LENGTH_LOW; |
xbee_data_p->read_state = XBEE_STATE_READ_LENGTH_LOW; |
break; |
case XBEE_STATE_READ_LENGTH_LOW: |
// Read length (LSB) |
length->INT_16.char_value[0] = c; |
xbee_data.read_state = XBEE_STATE_READ_FRAME_DATA; |
xbee_data_p->read_state = XBEE_STATE_READ_FRAME_DATA; |
break; |
case XBEE_STATE_READ_FRAME_DATA: |
// Read unique frame data |
if (xbee_data.dataind < xbee_data.rcv_frame.length.INT_16.int_value) { |
*((char*) xbee_data_frame + xbee_data.dataind) = c; |
xbee_data.checksum_sum += c; |
xbee_data.dataind++; |
if (xbee_data_p->dataind < xbee_data_p->rcv_frame.length.INT_16.int_value) { |
*((char*) xbee_data_frame + xbee_data_p->dataind) = c; |
xbee_data_p->checksum_sum += c; |
xbee_data_p->dataind++; |
} |
// If total length is read, the next byte is the expected checksum |
if (xbee_data.dataind == xbee_data.rcv_frame.length.INT_16.int_value) { |
xbee_data.read_state = XBEE_STATE_READ_CHECKSUM; |
if (xbee_data_p->dataind == xbee_data_p->rcv_frame.length.INT_16.int_value) { |
xbee_data_p->read_state = XBEE_STATE_READ_CHECKSUM; |
} |
break; |
case XBEE_STATE_READ_CHECKSUM: |
// Calculate and compare checksum |
if (0xFF - xbee_data.checksum_sum == c) { |
if (0xFF - xbee_data_p->checksum_sum == c) { |
// Frame was recieved successfully |
xbee_data.frame_rdy = 1; |
xbee_data_p->frame_rdy = 1; |
// XBee_Process_Received_Frame(); |
} else { |
// If checksum does not match, drop frame |
DBG_PRINT_XBEE("XBEE: checksum mismatch\r\n"); |
} |
xbee_data.read_state = XBEE_STATE_READ_START; |
xbee_data_p->read_state = XBEE_STATE_READ_START; |
break; |
} |
} |
100,7 → 100,7 |
/* This processes the frame data within the interrupt. Dont use this. */ |
void XBee_Process_Received_Frame() { |
// DBG_PRINT_XBEE("Length: %d\r\n", xbee_data.rcv_frame.length.INT_16.int_value); |
// DBG_PRINT_XBEE("Length: %d\r\n", xbee_data_p->rcv_frame.length.INT_16.int_value); |
// Here we process the received frame depending on the frame type |
switch (*((unsigned char *) xbee_data_frame)) { |
case XBEE_RX_AT_COMMAND_RESPONSE: |
136,12 → 136,12 |
} |
unsigned int XBee_Get_Received_Frame(unsigned char *frame) { |
if (!xbee_data.frame_rdy) { |
if (!xbee_data_p->frame_rdy) { |
return 0; |
} else { |
memcpy(frame, xbee_data_frame, xbee_data.rcv_frame.length.INT_16.int_value); |
xbee_data.frame_rdy = 0; // Reset frame ready status |
return xbee_data.rcv_frame.length.INT_16.int_value; |
memcpy(frame, xbee_data_frame, xbee_data_p->rcv_frame.length.INT_16.int_value); |
xbee_data_p->frame_rdy = 0; // Reset frame ready status |
return xbee_data_p->rcv_frame.length.INT_16.int_value; |
} |
} |