Subversion Repositories Code-Repo

Compare Revisions

Ignore whitespace Rev 127 → Rev 128

/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;
}
}