static void display_x(uint8_t x, uint8_t y) {
display_draw(x, y, 1, 8, &pict_buff11[0]);
display_draw(x + 8, y, 1, 8, &pict_buff12[0]);
display_draw(x + 4, y + 1, 1, 8, &pict_buff13[0]);
display_draw(x, y + 2, 1, 8, &pict_buff12[0]);
display_draw(x + 8, y + 2, 1, 8, &pict_buff11[0]);
nxt_lcd_force_update();
}
int
main(int argv, char **argc)
{
int i;
sim_object_t * object;
/*Create a sim_data object*/
sim_data_t* test_sim = sim_new();
sim_init(test_sim,1, 10, 192, 120);
/*Create a display_state*/
display_state_t * state = calloc(1,sizeof(display_state_t));
/* memset(state, 0, sizeof(*state)); */
bcm_egl_openvg_init(state);
display_init(state, 0);
state->showfps = true;
/*
for(i = 0; i < 1000; i++)
*/
while(1)
{
sim_tick(test_sim);
/*Pass to display and alter*/
display_draw(state, test_sim);
/*
for(i = 0; i < test_sim->size; i++)
{
object = test_sim->objects[i];
object->x += 1;
object->y += 1;
}
*/
}
return EXIT_SUCCESS;
}
void display_text(char *message, int row_cur, int col_cur){
int i = 0, j, k;
while(message[i]){ //reads through characters in message
int ch_row = ascii_row(message[i]); //gets row of character in ascii table
//checking if pixel is out of bounds
if(col_cur > 125){
col_cur = 0;
row_cur = row_cur + 8;
}
if(row_cur > 56){
row_cur = 0;
col_cur = 0;
}
int row = row_cur;
int col = col_cur;
//loops through columns and rows of each charcter pixel values
for(j = 0; j < 5; j++){
for(k = 0; k < 8; k++){
int ch_hex = ASCII[ch_row][j]; //gets the pixel values from each column
int ch_bin = (ch_hex & (1 << k)) >> k; //bitmask the value
row = row_cur + k;
col = col_cur + j;
display_pixel_set(row, col, ch_bin); //set the pixel value
};
};
i++;
col_cur = col_cur + 5;
};
display_draw(); //draws the image
}
void accelerometer_test(void){
unsigned char who,message[5];
acc_read_register(WHO_AM_I,&who,1);
sprintf(message,"%d",who);
write_OLED_message(message,0,0);
display_draw();
}
void display_message(int row, int col, char *message){
int i = 0;
int k;
int j;
int new_row = row;
int column_ctr = 0;
while(message[i]){
char askey_index = message[i] - 0x20;
for (k=0; k<5; k++){
char askey_col = ASCII[askey_index][k];
for(j = 7; j>=0; j--){
display_pixel_set(new_row, (column_ctr + col), (askey_col&(1<<j)));
new_row = new_row - 1;
}
new_row = row;
column_ctr++;
}
i++;
}
display_draw();
}
int main ( void )
{
/* Initialize all MPLAB Harmony modules, including application(s). */
char message[100];
SYS_Initialize ( NULL );
//set up accelerometer
acc_setup();
//set up display
display_init();
display_clear();
sprintf(message,"System Initialised!");
write_string(message,0,0);
display_draw();
while ( true )
{
/* Maintain state machines of all polled MPLAB Harmony modules. */
SYS_Tasks ( );
}
/* Execution should not come here during normal operation */
return ( EXIT_FAILURE );
}
static void display_clean_sp(uint8_t x, uint8_t y) {
size_t t, k;
for (t = 0; t < 10; t++) {
for (k = 0; k < 3; k++) {
display_draw(x + t, y + k, 1, 8, &pict_buff0[0]);
}
}
nxt_lcd_force_update();
}
static void display_o(uint8_t x, uint8_t y) {
display_draw(x, y, 1, 8, &pict_buff1[0]);
display_draw(x + 8, y, 1, 8, &pict_buff2[0]);
display_draw(x, y + 1, 1, 8, &pict_buff8[0]);
display_draw(x + 8, y + 1, 1, 8, &pict_buff10[0]);
display_draw(x, y + 2, 1, 8, &pict_buff3[0]);
display_draw(x + 8, y + 2, 1, 8, &pict_buff4[0]);
nxt_lcd_force_update();
}
static void display_m(uint8_t x, uint8_t y) {
display_draw(x, y, 1, 8, &pict_buff3[0]);
display_draw(x + 8, y, 1, 8, &pict_buff5[0]);
display_draw(x, y + 1, 1, 8, &pict_buff6[0]);
display_draw(x + 8, y + 1, 1, 8, &pict_buff7[0]);
display_draw(x, y + 2, 1, 8, &pict_buff6[0]);
display_draw(x + 8, y + 2, 1, 8, &pict_buff7[0]);
nxt_lcd_force_update();
}
void display_arrow(int x_val, int y_val){
display_clear();
//starts at center of board
int row = 32;
int col = 64;
// scales the values to draw a line proportional to the values from accelerometer and still be able to fit on the screen
int x_draw, y_draw;
x_draw = x_val*SCALE;
y_draw = y_val*SCALE;
//determines direction to draw the line - up, down, left, or right
int x_direction = 1, y_direction = 1;
if (x_draw > 0){
x_direction = -1;
};
if (y_draw > 0){
y_direction = -1;
};
//take absolute value so that value will get smaller in while loop
x_draw = abs(x_draw);
y_draw = abs(y_draw);
//will draw a line of pixels at a time, to a length proportional to the value from accelerometer
int w;
while(x_draw > 0){
row = row + 1*x_direction; //multiply by x_direction for line to be in the right direction
for(w = 0; w < 5; w++){ // draws a thin line 5 pixels wide
display_pixel_set(row, col+w, 1); //set the pixel value
};
x_draw = x_draw - 1;
}
//set the row back to the center of screen
row = 32;
int h;
while(y_draw > 0){
col = col + 1*y_direction;
for(h = 0; h < 5; h++){
display_pixel_set(row + h, col, 1); //set the pixel value
};
y_draw = y_draw - 1;
}
display_draw(); //draws the image
}
void display_init() {
// u8g_InitSPI(
// &u8g,
// &u8g_dev_ssd1351_128x128_18bpp_sw_spi,
// // sck, mosi, cs, a0 (C/D), reset
// PN(1, 1), PN(1, 2), PN(1, 0), PN(0, 6), PN(0, 7)
// );
u8g_InitHWSPI(
&u8g,
&u8g_dev_ssd1351_128x128_18bpp_hw_spi,
// cs, a0 (C/D), reset
PN(1, 0), PN(0, 6), PN(0, 7)
);
display_draw( true );
}
void accelerometer_pixel_bars(void){
short accels[3];
int xpix,ypix;
char x_acc_dir,y_acc_dir;
unsigned char x_dir[20],y_dir[20];
acc_read_register(OUT_X_L_A,(unsigned char *) accels, 6);
xpix = accel_to_pixels(accels[0]);
ypix = accel_to_pixels(accels[1]);
x_acc_dir = accel_pixel_direction(xpix);
y_acc_dir = accel_pixel_direction(ypix);
sprintf(x_dir,"X-Acc = %c",x_acc_dir);
sprintf(y_dir,"Y-Acc = %c",y_acc_dir);
display_clear();
write_OLED_message(x_dir,0,0);
write_OLED_message(y_dir,10,0);
accel_pixels(xpix,'x');
accel_pixels(ypix,'y');
display_draw();
}
void display_bars(int len, int dir){
//0 for x dir, 1 for y dir
int i;
if (dir == 0){
if (len > 0){
if (len > 60){
len = 60;
}
for(i = 0; i < abs(len); i++){
display_pixel_set(32, (64+i), 1);
}
}
else if (len < 0){
if (len < -60){
len = -60;
}
for(i = 0; i < abs(len); i++){
display_pixel_set(32, (64-i), 1);
}
}
}
if(dir == 1){
if (len > 0){
if (len > 25){
len = 25;
}
for(i = 0; i < abs(len); i++){
display_pixel_set((32+i), 64, 1);
}
}
else if (len < 0){
if (len < -25){
len = -25;
}
for(i = 0; i < abs(len); i++){
display_pixel_set((32-i), 64, 1);
}
}
}
display_draw();
}
int main() {
BM_setup();
display_clear();
acc_write_register(0x00,0x04,(unsigned char *) buff,2);
sprintf(message,"%d%d",buff[1],buff[2]);
oledprint(1,10,message);
display_draw();
// while (1) {
//
// display_clear();
//
// acc_write_register(RDCVA, buff);
//
// sprintf(buff,"Message: ",data);
//
// oledprint(1,10,buff);
// display_draw();
// }
}
static void callback_display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
display_draw();
glutSwapBuffers();
}
void
graphics_redraw(struct container *co)
{
int scale=transform_get_scale(co->trans);
int i,slimit=255,tlimit=255,plimit=255;
int bw[4],w[4],t[4];
struct display_list **disp=co->disp;
struct graphics *gra=co->gra;
#if 0
printf("scale=%d center=0x%lx,0x%lx mercator scale=%f\n", scale, co->trans->center.x, co->trans->center.y, transform_scale(co->trans->center.y));
#endif
display_free(co->disp, display_end);
transform_setup_source_rect(co->trans);
gra->draw_mode(gra, draw_mode_begin);
for (i = 0 ; i < data_window_type_end; i++) {
data_window_begin(co->data_window[i]);
}
gra->gc_set_linewidth(gra->gc[GC_RAIL], 3);
bw[0]=0;
bw[1]=0;
bw[2]=0;
bw[3]=0;
w[0]=1;
w[1]=1;
w[2]=1;
w[3]=1;
t[0]=0xf;
t[1]=0xf;
t[2]=0xf;
t[3]=0xf;
if (scale < 2) {
tlimit=0xff;
slimit=0xff;
bw[0]=17;
w[0]=15;
bw[1]=19;
w[1]=17;
bw[2]=19;
w[2]=17;
bw[3]=21;
w[3]=17;
} else if (scale < 4) {
tlimit=0xff;
slimit=0xff;
bw[0]=11;
w[0]=9;
bw[1]=13;
w[1]=11;
bw[2]=13;
w[2]=11;
bw[3]=15;
w[3]=11;
} else if (scale < 8) {
tlimit=0xff;
slimit=0xff;
bw[0]=5;
w[0]=3;
bw[1]=11;
w[1]=9;
bw[2]=11;
w[2]=9;
bw[3]=13;
w[3]=9;
t[0]=0xa;
t[1]=0xf;
} else if (scale < 16) {
tlimit=0xff;
slimit=0xff;
bw[1]=9;
w[1]=7;
bw[2]=9;
w[2]=7;
bw[3]=11;
w[3]=7;
t[0]=0x9;
t[1]=0xe;
} else if (scale < 32) {
tlimit=0xff;
slimit=0xff;
bw[1]=5;
w[1]=3;
bw[2]=5;
w[2]=3;
bw[3]=5;
w[3]=3;
t[0]=0x8;
t[1]=0xb;
} else if (scale < 64) {
tlimit=0xf;
slimit=0x6;
bw[1]=5;
w[1]=3;
bw[2]=5;
w[2]=3;
bw[3]=5;
w[3]=3;
t[0]=0x8;
t[1]=0xa;
} else if (scale < 128) {
tlimit=0xc;
slimit=0x6;
plimit=0x1e;
w[1]=3;
w[2]=3;
bw[3]=5;
w[3]=3;
t[0]=0x7;
t[1]=0xa;
} else if (scale < 256) {
tlimit=0xb;
slimit=0x5;
plimit=0x1a;
w[2]=3;
bw[3]=5;
w[3]=3;
t[0]=0x7;
t[1]=0x8;
} else if (scale < 512) {
tlimit=0x9;
slimit=0x5;
plimit=0x14;
w[1]=0;
w[2]=1;
bw[3]=3;
w[3]=1;
t[0]=0x4;
t[1]=0x7;
} else if (scale < 1024) {
tlimit=0x8;
slimit=0x4;
slimit=0x4;
plimit=0x11;
w[1]=0;
w[2]=1;
bw[3]=3;
w[3]=1;
t[0]=0x3;
t[1]=0x5;
} else if (scale < 2048) {
tlimit=0x5;
slimit=0x3;
plimit=0x10;
bw[3]=3;
w[3]=1;
t[0]=0x2;
t[1]=0x4;
} else if (scale < 4096) {
bw[3]=3;
w[3]=1;
tlimit=0x4;
slimit=0x2;
plimit=0xf;
t[0]=0x2;
t[1]=0x3;
} else if (scale < 8192) {
bw[3]=3;
w[3]=1;
tlimit=0x3;
slimit=0x2;
plimit=0xf;
t[0]=0x1;
t[1]=0x2;
} else {
bw[3]=3;
w[3]=1;
tlimit=0x2;
slimit=0x2;
plimit=0xf;
t[0]=0x1;
t[1]=0x4;
}
gra->gc_set_linewidth(gra->gc[GC_STREET_SMALL], w[0]);
gra->gc_set_linewidth(gra->gc[GC_STREET_NO_PASS], w[0]);
gra->gc_set_linewidth(gra->gc[GC_STREET_SMALL_B], bw[0]);
gra->gc_set_linewidth(gra->gc[GC_STREET_MID], w[1]);
gra->gc_set_linewidth(gra->gc[GC_STREET_MID_B], bw[1]);
gra->gc_set_linewidth(gra->gc[GC_STREET_BIG], w[2]);
gra->gc_set_linewidth(gra->gc[GC_STREET_BIG_B], bw[2]);
gra->gc_set_linewidth(gra->gc[GC_STREET_BIG2], w[3]);
gra->gc_set_linewidth(gra->gc[GC_STREET_BIG2_B], bw[3]);
gra->gc_set_linewidth(gra->gc[GC_STREET_ROUTE], w[3]+7+w[3]/2);
profile_timer(NULL);
graphics_draw(co->map_data, file_border_ply, co, display_rail, plimit, 48, poly_draw_block);
graphics_draw(co->map_data, file_woodland_ply, co, display_wood, plimit, 48, poly_draw_block);
graphics_draw(co->map_data, file_other_ply, co, display_other, plimit, 48, poly_draw_block);
graphics_draw(co->map_data, file_town_twn, co, display_town, tlimit, 48, town_draw_block);
graphics_draw(co->map_data, file_water_ply, co, display_water, plimit, 48, poly_draw_block);
graphics_draw(co->map_data, file_sea_ply, co, display_sea, plimit, 48, poly_draw_block);
/* todo height, tunnel, bridge, street_bti ??? */
#if 0
graphics_draw(co->map_data, file_height_ply, co, display_other1, plimit, 48, poly_draw_block);
#endif
if (scale < 256) {
graphics_draw(co->map_data, file_rail_ply, co, display_rail, plimit, 48, poly_draw_block);
}
profile_timer("map_draw");
plugin_call_draw(co);
profile_timer("plugin");
#if 0
draw_poly(map, &co->d_tunnel_ply, "Tunnel", 0, 11, plimit);
#endif
graphics_draw(co->map_data, file_street_str, co, display_street, slimit, 7, street_draw_block);
display_draw(disp[display_sea], gra, gra->gc[GC_WATER_FILL], NULL);
display_draw(disp[display_wood], gra, gra->gc[GC_WOOD], NULL);
display_draw(disp[display_other], gra, gra->gc[GC_TOWN_FILL], gra->gc[GC_TOWN_LINE]);
display_draw(disp[display_other1], gra, gra->gc[GC_BUILDING], NULL);
display_draw(disp[display_other2], gra, gra->gc[GC_BUILDING_2], NULL);
display_draw(disp[display_other3], gra, gra->gc[GC_PARK], NULL);
display_draw(disp[display_water], gra, gra->gc[GC_WATER_FILL], gra->gc[GC_WATER_LINE]);
display_draw(disp[display_rail], gra, gra->gc[GC_RAIL], NULL);
street_route_draw(co);
display_draw(disp[display_street_route], gra, gra->gc[GC_STREET_ROUTE], NULL);
if (bw[0]) {
display_draw(disp[display_street_no_pass], gra, gra->gc[GC_STREET_SMALL_B], NULL);
display_draw(disp[display_street], gra, gra->gc[GC_STREET_SMALL_B], NULL);
}
if (bw[1])
display_draw(disp[display_street1], gra, gra->gc[GC_STREET_MID_B], NULL);
if (bw[2])
display_draw(disp[display_street2], gra, gra->gc[GC_STREET_BIG_B], NULL);
if (bw[3])
display_draw(disp[display_street3], gra, gra->gc[GC_STREET_BIG2_B], NULL);
if (w[0]) {
display_draw(disp[display_street_no_pass], gra, gra->gc[GC_STREET_NO_PASS], NULL);
display_draw(disp[display_street], gra, gra->gc[GC_STREET_SMALL], NULL);
}
if (w[1])
display_draw(disp[display_street1], gra, gra->gc[GC_STREET_MID], gra->gc[GC_BLACK]);
display_draw(disp[display_street2], gra, gra->gc[GC_STREET_BIG], gra->gc[GC_BLACK]);
display_draw(disp[display_street3], gra, gra->gc[GC_STREET_BIG2], gra->gc[GC_BLACK]);
if (w[3] > 1)
display_draw(disp[display_street3], gra, gra->gc[GC_STREET_BIG2_L], NULL);
display_draw(disp[display_poi], gra, gra->gc[GC_BLACK], NULL);
profile_timer("display_draw");
if (scale < 2) {
display_labels(disp[display_street], gra, gra->gc[GC_TEXT_FG], gra->gc[GC_TEXT_BG], gra->font[1]);
display_labels(disp[display_street1], gra, gra->gc[GC_TEXT_FG], gra->gc[GC_TEXT_BG], gra->font[1]);
}
else {
display_labels(disp[display_street], gra, gra->gc[GC_TEXT_FG], gra->gc[GC_TEXT_BG], gra->font[0]);
display_labels(disp[display_street1], gra, gra->gc[GC_TEXT_FG], gra->gc[GC_TEXT_BG], gra->font[0]);
}
display_labels(disp[display_street2], gra, gra->gc[GC_TEXT_FG], gra->gc[GC_TEXT_BG], gra->font[0]);
display_labels(disp[display_street3], gra, gra->gc[GC_TEXT_FG], gra->gc[GC_TEXT_BG], gra->font[0]);
for (i = display_town+t[1] ; i < display_town+0x10 ; i++)
display_labels(disp[i], gra, gra->gc[GC_TEXT_FG], gra->gc[GC_TEXT_BG], gra->font[0]);
for (i = display_town+t[0] ; i < display_town+t[1] ; i++)
display_labels(disp[i], gra, gra->gc[GC_TEXT_FG], gra->gc[GC_TEXT_BG], gra->font[1]);
for (i = display_town ; i < display_town+t[0] ; i++)
display_labels(disp[i], gra, gra->gc[GC_TEXT_FG], gra->gc[GC_TEXT_BG], gra->font[2]);
for (i = display_town ; i < display_town+0x10 ; i++)
display_draw(disp[i], gra, gra->gc[GC_BLACK], NULL);
display_draw(disp[display_bti], gra, gra->gc[GC_BLACK], NULL);
profile_timer("labels");
gra->draw_mode(gra, draw_mode_end);
for (i = 0 ; i < data_window_type_end; i++) {
data_window_end(co->data_window[i]);
}
#if 0
map_scrollbars_update(map);
#endif
}
int main() {
// startup
__builtin_disable_interrupts();
// set the CP0 CONFIG register to indicate that
// kseg0 is cacheable (0x3) or uncacheable (0x2)
// see Chapter 2 "CPU for Devices with M4K Core"
// of the PIC32 reference manual
__builtin_mtc0(_CP0_CONFIG, _CP0_CONFIG_SELECT, 0xa4210583);
// no cache on this chip!
// 0 data RAM access wait states
BMXCONbits.BMXWSDRM = 0x0;
// enable multi vector interrupts
INTCONbits.MVEC = 0x1;
// disable JTAG to be able to use TDI, TDO, TCK, TMS as digital
DDPCONbits.JTAGEN = 0;
__builtin_enable_interrupts();
// set up USER pin as input
ANSELBbits.ANSB13 = 0;
TRISBbits.TRISB13 = 1;
INT4Rbits.INT4R = 0b0100;
// set up LED1 pin as a digital output
ANSELBbits.ANSB15 = 0;
TRISBbits.TRISB15 = 0;
LATBbits.LATB15 = 1;
int d = 0;
while(d < 2000000){
d = d+1;
}
// initializing variables
// lookup table for all of the ascii characters
static const char ASCII[96][5] = {
{0x00, 0x00, 0x00, 0x00, 0x00} // 20 (space)
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ?
,{0x00, 0x06, 0x09, 0x09, 0x06} // 7f ?
}; // end char ASCII[96][5]
// Initializing Display
i2c_master_setup();
display_init();
char a;
char message[10];
int m = 0;
int i;
int j;
int row;
int col;
// main loop
while (1) {
row = 32;
col = 28;
sprintf(message,"Hello world 1337!");
while(message[m]){
for(j = 0; j<= 4; j = j+1,col = col + 1){
a = ASCII[message[m] - 0x20][j];
for(i = 0; i <= 7; i = i+1)
{
display_pixel_set(row -i,col,(a << i)&0x80);
}
}
m = m+1;
}
display_draw();
m = 0;
}
}
int main() {
int potValue;
int timerResets=0;
// startup
startup();
T2CONbits.TCKPS = 2; // Timer2 prescaler N=4 (1:4)
PR2 = 19999; // period = (PR2+1) * N * 12.5 ns = 100 us, 10 kHz
TMR2 = 0; // initial TMR2 count is 0
OC1CONbits.OCM = 0b110; // PWM mode without fault pin; other OC1CON bits are defaults
OC1RS = 5000; // duty cycle = OC1RS/(PR2+1) = 25%
OC1R = 5000; // initialize before turning OC1 on; afterward it is read-only
T2CONbits.ON = 1; // turn on Timer2
OC1CONbits.ON = 1; // turn on OC1
// set up USER pin as input
ANSELBbits.ANSB13 = 0; // 0 for digital, 1 for analog
// set up LED1 pin as a digital output
ANSELBbits.ANSB15 = 0; // 0 for digital, 1 for analog
TRISBbits.TRISB15 = 0;
// set up LED2 as OC1 using Timer2 at 1kHz
//RPB7Rbits.RPB7R = 0b0101; // set B15 to OC1
TRISBbits.TRISB7 = 0;
LATBbits.LATB7=0;
//LATBbits.LATB15=1;
// set up A0 as AN0
ANSELAbits.ANSA0 = 1;
AD1CON3bits.ADCS = 3;
AD1CHSbits.CH0SA = 0;
AD1CON1bits.ADON = 1;
int counter = 0;
int user = 1;
/* /////////Testing section, old code///////////
display_init();
drawChar(72-0x20,45,50);
drawChar(73-0x20,50,50);
display_draw();
*/
/* /////// Write to LCD
display_init();
int k=0;
int L=0;
int charCurrent;
int xIndex = 28;
int yIndex = 32;
char message[50];
sprintf(message,"Hello world 1337!");
while(L==0){
charCurrent = (int)message[k];
if(charCurrent==0){
L=1;
}
else{
drawChar(charCurrent - 0x20,xIndex, yIndex);
xIndex+=6;
k+=1;
}
}
display_draw();
*/
int a;
int b;
int aa;
int bb;
int c;
int d;
// set up power supply to LCD as digital output
_CP0_SET_COUNT(0);
while(_CP0_GET_COUNT()<4000000){
}
LATBbits.LATB15=1;
display_init();
int charCurrent;
acc_setup();
while (1) {
display_clear();
int xIndex = 10;
int yIndex = 32;
int k=0;
int L=0;
char message[500];
short accels[3]; // accelerations for the 3 axes
short mags[3]; // magnetometer readings for the 3 axes
short temp;
// read the accelerometer from all three axes
// the accelerometer and the pic32 are both little endian by default (the lowest address has the LSB)
// the accelerations are 16-bit twos compliment numbers, the same as a short
acc_read_register(OUT_X_L_A, (unsigned char *) accels, 6);
// need to read all 6 bytes in one transaction to get an update.
acc_read_register(OUT_X_L_M, (unsigned char *) mags, 6);
// read the temperature data. Its a right justified 12 bit two's compliment number
acc_read_register(TEMP_OUT_L, (unsigned char *) &temp, 2);
/*
/////// Write to LCD
sprintf(message,"%d %d %d ",accels[0], accels[1],accels[2]);
L=0;
while(message[k]){
drawChar(message[k] - 0x20,xIndex, yIndex);
xIndex+=6;
k+=1;
//}
} */
a=accels[0]/500;
b=accels[1]/1000;
display_pixel_set(31,64,1);
display_pixel_set(32,64,1);
display_pixel_set(33,64,1);
display_pixel_set(32,63,1);
display_pixel_set(32,65,1);
if(a<0){
c=-a;
for(aa=0;aa<c;aa++){
display_pixel_set(31,64-aa,1);
display_pixel_set(32,64-aa,1);
display_pixel_set(33,64-aa,1);
}
}
if(a>=0){
for(aa=0;aa<a;aa++){
display_pixel_set(31,aa+64,1);
display_pixel_set(32,aa+64,1);
display_pixel_set(33,aa+64,1);
}
}
if(b<0){
d=-b;
for(bb=0;bb<d;bb++){
display_pixel_set(32-bb,63,1);
display_pixel_set(32-bb,64,1);
display_pixel_set(32-bb,65,1);
}
}
if(b>=0){
for(bb=0;bb<b;bb++){
display_pixel_set(32+bb,63,1);
display_pixel_set(32+bb,64,1);
display_pixel_set(32+bb,65,1);
}
}
display_draw();
}
}
void APP_Tasks (void )
{
unsigned char print[26];
int jj = 0,row;
short accels[3];
/* Check if device is configured. See if it is configured with correct
* configuration value */
switch(appData.state)
{
case APP_STATE_INIT:
/* Open the device layer */
appData.usbDevHandle = USB_DEVICE_Open( USB_DEVICE_INDEX_0, DRV_IO_INTENT_READWRITE );
if(appData.usbDevHandle != USB_DEVICE_HANDLE_INVALID)
{
/* Register a callback with device layer to get event notification (for end point 0) */
USB_DEVICE_EventHandlerSet(appData.usbDevHandle, APP_USBDeviceEventHandler, 0);
appData.state = APP_STATE_WAIT_FOR_CONFIGURATION;
}
else
{
/* The Device Layer is not ready to be opened. We should try
* again later. */
}
break;
case APP_STATE_WAIT_FOR_CONFIGURATION:
if(appData.deviceConfigured == true)
{
/* Device is ready to run the main task */
appData.hidDataReceived = false;
appData.hidDataTransmitted = true;
appData.state = APP_STATE_MAIN_TASK;
/* Place a new read request. */
USB_DEVICE_HID_ReportReceive (USB_DEVICE_HID_INDEX_0,
&appData.rxTransferHandle, appData.receiveDataBuffer, 64);
}
break;
case APP_STATE_MAIN_TASK:
if(!appData.deviceConfigured)
{
/* Device is not configured */
appData.state = APP_STATE_WAIT_FOR_CONFIGURATION;
}
else if( appData.hidDataReceived )
{
/* Look at the data the host sent, to see what
* kind of application specific command it sent. */
switch(appData.receiveDataBuffer[0])
{
case 0x1:
/* Toggle on board LED1 to LED2. */
BSP_LEDToggle( APP_USB_LED_1 );
BSP_LEDToggle( APP_USB_LED_2 );
memcpy(print,&appData.receiveDataBuffer[2],25);
print[26] = '\0';
display_clear();
write_OLED_message(print,appData.receiveDataBuffer[1],0);
display_draw();
appData.hidDataReceived = false;
/* Place a new read request. */
USB_DEVICE_HID_ReportReceive (USB_DEVICE_HID_INDEX_0,
&appData.rxTransferHandle, appData.receiveDataBuffer, 64 );
_CP0_SET_COUNT(0);
break;
case 0x2:
if(appData.hidDataTransmitted)
{
/* Echo back to the host PC the command we are fulfilling in
* the first byte. In this case, the Get Push-button State
* command. */
BSP_LEDToggle( APP_USB_LED_1 );
BSP_LEDToggle( APP_USB_LED_2 );
if(_CP0_GET_COUNT() > 200000){
appData.transmitDataBuffer[0] = 1;
acc_read_register(OUT_X_L_A,(unsigned char *) accels, 6);
appData.transmitDataBuffer[1] = accels[0] >> 8;
appData.transmitDataBuffer[2] = accels[0];
appData.transmitDataBuffer[3] = accels[1] >> 8;
appData.transmitDataBuffer[4] = accels[1];
appData.transmitDataBuffer[5] = accels[2] >> 8;
appData.transmitDataBuffer[6] = accels[2];
_CP0_SET_COUNT(0);
}
else{
appData.transmitDataBuffer[0] = 0;
}
// appData.transmitDataBuffer[0] = 0x81;
//
// if( BSP_SwitchStateGet(APP_USB_SWITCH_1) == BSP_SWITCH_STATE_PRESSED )
// {
// appData.transmitDataBuffer[1] = 0x00;
// }
// else
// {
// appData.transmitDataBuffer[1] = 0x01;
// }
appData.hidDataTransmitted = false;
/* Prepare the USB module to send the data packet to the host */
USB_DEVICE_HID_ReportSend (USB_DEVICE_HID_INDEX_0,
&appData.txTransferHandle, appData.transmitDataBuffer, 64 );
appData.hidDataReceived = false;
/* Place a new read request. */
USB_DEVICE_HID_ReportReceive (USB_DEVICE_HID_INDEX_0,
&appData.rxTransferHandle, appData.receiveDataBuffer, 64 );
}
break;
default:
appData.hidDataReceived = false;
/* Place a new read request. */
USB_DEVICE_HID_ReportReceive (USB_DEVICE_HID_INDEX_0,
&appData.rxTransferHandle, appData.receiveDataBuffer, 64 );
break;
}
int main() {
// startup FROM HW1
__builtin_disable_interrupts();
__builtin_mtc0(_CP0_CONFIG, _CP0_CONFIG_SELECT, 0xa4210583);
BMXCONbits.BMXWSDRM = 0x0;
INTCONbits.MVEC = 0x1;
DDPCONbits.JTAGEN = 0;
__builtin_enable_interrupts();
ANSELBbits.ANSB13 = 0; //Make B13 Digital
TRISBbits.TRISB7 = 0;
RPB15Rbits.RPB15R = 0b0101; //Set B15 as OC1
T2CONbits.TCKPS = 0; //Prescalar = 1
PR2 = 39999; //Max counter value
TMR2 = 0; // Initialize timer 2
OC1CONbits.OCM = 0b110; //Without failsafe
OC1RS = 2000; //Duts cycle is 5%
OC1R = 2000; //Initial duty cycle is 5%
T2CONbits.ON = 1; //turns timer on
OC1CONbits.ON = 1; //Turns output control on
ANSELAbits.ANSA0 = 1;
AD1CON3bits.ADCS = 3;
AD1CHSbits.CH0SA = 0;
AD1CON1bits.ADON = 1;
display_init();
while (1) {
_CP0_SET_COUNT(0); // set core timer to 0, remember it counts at half the CPU clock
LATBINV = 0b10000000; // invert a pin B7 (LED1)
while (_CP0_GET_COUNT() < 10000000) {
int val;
val = readADC();
OC1RS = val * 39; //comes out to about 39
if (PORTBbits.RB13 == 1) {
} else {
LATBINV = 0b10000000; //Invert LED1
}
}
//END STARTUP FROM HW1
display_clear();
char MessageLetters[17]; //= 'Hello world 1337!';
sprintf(MessageLetters, "Hello world 1337!");
int ii = 0;
int currentVal;
int message[17];
while (MessageLetters[ii]) {
currentVal = MessageLetters[ii];
if (currentVal - 32 >= 0) {
message[ii] = currentVal - 32;
}
ii++;
}
int StringCount;
int colLCD; //Create column location on LCD
int rowLCD; //Create row location on LCD
for (StringCount = 0; StringCount < 20; StringCount++) {
for (colLCD = 1; colLCD < 6; colLCD++) { //Cycle through column of array
for (rowLCD = 1; rowLCD < 9; rowLCD++) { //Cycle through row of array
display_pixel_set(rowLCD + 32, colLCD + 6 * StringCount + 28, getBit(message[StringCount], rowLCD - 1, colLCD - 1)); //At this specific (row, col) of screen, turn LCD on (1) or off (0) based on array value
}
}
}
display_draw(); //Commit to LCD screen once all positions defined
}
}
int main ( void )
{
/* Initialize all MPLAB Harmony modules, including application(s). */
SYS_Initialize ( NULL );
// string used for OLED
char str[200];
ANSELBbits.ANSB13 = 0; // make analog input digital
U1RXRbits.U1RXR = 0b0000; // set U1RX to pin A2
RPB15Rbits.RPB15R = 0b0101; // set B15 to U1TX
TRISBbits.TRISB13 = 1; // set up USER pin as input
TRISBbits.TRISB7 = 0; // set up LED1 pin as a digital output
APP_USBDeviceEventHandler();
__builtin_disable_interrupts();
// set the CP0 CONFIG register to indicate that
// kseg0 is cacheable (0x3) or uncacheable (0x2)
// see Chapter 2 "CPU for Devices with M4K Core"
// of the PIC32 reference manual
__builtin_mtc0(_CP0_CONFIG, _CP0_CONFIG_SELECT, 0xa4210583);
// no cache on this chip!
// 0 data RAM access wait states
BMXCONbits.BMXWSDRM = 0x0;
// enable multi vector interrupts
INTCONbits.MVEC = 0x1;
// disable JTAG to be able to use TDI, TDO, TCK, TMS as digital
DDPCONbits.JTAGEN = 0;
// set up accelerometer
acc_setup();
__builtin_enable_interrupts();
short accels[3]; // accelerations for the 3 axes
short mags[3]; // magnetometer readings for the 3 axes
short temp; // temperature
display_init();
while ( true )
{
/* Maintain state machines of all polled MPLAB Harmony modules. */
// read the accelerometer from all three axes
// the accelerometer and the pic32 are both little endian by default (the lowest address has the LSB)
// the accelerations are 16-bit twos compliment numbers, the same as a short
acc_read_register(OUT_X_L_A, (unsigned char *) accels, 6);
// need to read all 6 bytes in one transaction to get an update.
acc_read_register(OUT_X_L_M, (unsigned char *) mags, 6);
// read the temperature data. Its a right justified 12 bit two's compliment number
acc_read_register(TEMP_OUT_L, (unsigned char *) &temp, 2);
display_clear();
// sprintf(str, "Hello world %d!", accels);
int x_acc = accels[0]*64/16000;
int y_acc = accels[1]*32/16000;
int xxx,yyy;
if (x_acc>=0){
if(x_acc>64) x_acc=64;
for (xxx=0;xxx<x_acc;xxx++){
display_pixel_set(31,64-xxx,1);
display_pixel_set(32,64-xxx,1);
display_pixel_set(33,64-xxx,1);
}
}
else{
if(x_acc<-64) x_acc=-64;
for (xxx=0;xxx>x_acc;xxx--){
display_pixel_set(31,64-xxx,1);
display_pixel_set(32,64-xxx,1);
display_pixel_set(33,64-xxx,1);
}
}
if (y_acc>=0){
if(y_acc>32) y_acc=32;
for (yyy=0;yyy<y_acc;yyy++){
display_pixel_set(32-yyy,63,1);
display_pixel_set(32-yyy,64,1);
display_pixel_set(32-yyy,65,1);
}
}
else{
if(y_acc<-32) y_acc=-32;
for (yyy=0;yyy>y_acc;yyy--){
display_pixel_set(32-yyy,63,1);
display_pixel_set(32-yyy,64,1);
display_pixel_set(32-yyy,65,1);
}
}
display_draw();
SYS_Tasks ( );
}
/* Execution should not come here during normal operation */
return ( EXIT_FAILURE );
}
int main(void) {
//Startup
__builtin_disable_interrupts();
// set the CP0 CONFIG register to indicate that
// kseg0 is cacheable (0x3) or uncacheable (0x2)
// see Chapter 2 "CPU for Devices with M4K Core"
// of the PIC32 reference manual
__builtin_mtc0(_CP0_CONFIG, _CP0_CONFIG_SELECT, 0xa4210583);
// no cache on this chip!
// 0 data RAM access wait states
BMXCONbits.BMXWSDRM = 0x0;
// enable multi vector interrupts
INTCONbits.MVEC = 0x1;
// disable JTAG to be able to use TDI, TDO, TCK, TMS as digital
DDPCONbits.JTAGEN = 0;
__builtin_enable_interrupts();
ANSELBbits.ANSB13 = 0; // 0 for digital, 1 for analog
ANSELBbits.ANSB15 = 0; // 0 for digital, 1 for analog
T2CONbits.TCKPS = 0; //Setting prescaler to 1 (0 corresponds to 1)
PR2 = 39999; //Setting PR for timer 2 to 39999
TMR2 = 0; //Setting Timer 2 to 0
OC1CONbits.OCTSEL = 0; //Telling OC1 to use timer 2
OC1CONbits.OCM = 0b110; //Telling OC1 to use PWM without the fault
OC1RS = 20000; //Setting initial duty cycle to 20000/(39999+1)*100% = 50%
OC1R = 20000; //Updating duty cycles to 20000/(39999+1)*100% = 50%
T2CONbits.ON = 1; //turn on timer
OC1CONbits.ON = 1; //turn on OC code
// set up USER pin as input
TRISBbits.TRISB13 = 1; // set pin B13 to be digital INPUT
// U1RXRbits.U1RXR = 0b0011; // set U1RX to pin B13 (Input pin from User button)
// set up LED1 pin as a digital output
TRISBbits.TRISB7 = 0; // set pin B7 to be digital OUTPUT
// LATBbits.LATB7 = 1;
// RPB7Rbits.RPB7R = 0b0001; //set B7 to U1TX (Output pin for LED1)
// set up LED2 as OC1 using Timer2 at 1kHz
// TRISBbits.TRISB15 = 0; // set B15 to digital OUTPUT
RPB15Rbits.RPB15R = 0b0101; // set B15 to U1TX (Output pin for OC1)
// set up A0 as AN0
ANSELAbits.ANSA0 = 1;
AD1CON3bits.ADCS = 3;
AD1CHSbits.CH0SA = 0;
AD1CON1bits.ADON = 1;
// Accelerometer
acc_setup();
short accels[3]; // accelerations for the 3 axes
short mags[3]; // magnetometer readings for the 3 axes
short temp;
// Display
display_init();
/*int number = 1337;
sprintf(buffer,"Hello World %d!", number);
display_write(28,32,buffer);
*/
/*
for (ii = 0; ii < 128; ii++){ // Draw a line from position (x,y) = (0,15) to (127,15)
display_pixel_set(15,ii,1);
display_draw();
}*/
while (1){
// invert pin every 0.5s, set PWM duty cycle % to the pot voltage output %
_CP0_SET_COUNT(0);
LATBINV = 0b10000000;
while(_CP0_GET_COUNT()<10000000){
OC1RS = readADC()*(PR2+1)/1023; // delay for 10M core ticks, 0.5s
if (PORTBbits.RB13 == 1){
;// nothing
}
else{
LATBINV = 0b10000000;
}
}
// read the accelerometer from all three axes
// the accelerometer and the pic32 are both little endian by default (the lowest address has the LSB)
// the accelerations are 16-bit twos compliment numbers, the same as a short
acc_read_register(OUT_X_L_A, (unsigned char *) accels, 6);
// need to read all 6 bytes in one transaction to get an update.
acc_read_register(OUT_X_L_M, (unsigned char *) mags, 6);
// read the temperature data. Its a right justified 12 bit two's compliment number
acc_read_register(TEMP_OUT_L, (unsigned char *) &temp, 2);
display_clear();
sprintf(buffer1, "(ax, ay, az)");
display_write(0, 0, buffer1);
sprintf(buffer2, "(%d, %d, %d)", accels[0], accels[1], accels[2]);
display_write(0, 48, buffer2);
sprintf(buffer, "Derek Oung");
display_write(0, 56, buffer);
if (accels[0]>0 && accels[1]>0){
x_line_point = (float)((float)accels[0]/16000*64) + 64;
y_line_point = (float)((float)accels[1]/16000*32) + 32;
/*
while (i<x_line_point){
display_pixel_set(32,i,1);
i++;
}
*/
for (i=64;i<x_line_point;i++){
display_pixel_set(31, i, 1);
display_pixel_set(32, i, 1);
display_pixel_set(33, i, 1);
}
for (j=32;j<y_line_point;j++){
display_pixel_set(j, 63, 1);
display_pixel_set(j, 64, 1);
display_pixel_set(j, 65, 1);
}
}
else if (accels[0]>0 && accels[1]<0){
x_line_point = (float)((float)accels[0]/16000*64) + 64;
y_line_point = (float)((float)accels[1]/16000*32) + 32;
for (i=64;i<x_line_point;i++){
display_pixel_set(31, i, 1);
display_pixel_set(32, i, 1);
display_pixel_set(33, i, 1);
}
for (j=32;j>y_line_point;j--){
display_pixel_set(j, 63, 1);
display_pixel_set(j, 64, 1);
display_pixel_set(j, 65, 1);
}
}
else if (accels[0]<0 && accels[1]>0){
x_line_point = (float)((float)accels[0]/16000*64) + 64;
y_line_point = (float)((float)accels[1]/16000*32) + 32;
for (i=64;i>x_line_point;i--){
display_pixel_set(31, i, 1);
display_pixel_set(32, i, 1);
display_pixel_set(33, i, 1);
}
for (j=32;j<y_line_point;j++){
display_pixel_set(j, 63, 1);
display_pixel_set(j, 64, 1);
display_pixel_set(j, 65, 1);
}
}
else if (accels[0]<0 && accels[1]<0){
x_line_point = (float)((float)accels[0]/16000*64) + 64;
y_line_point = (float)((float)accels[1]/16000*32) + 32;
for (i=64;i>x_line_point;i--){
display_pixel_set(31, i, 1);
display_pixel_set(32, i, 1);
display_pixel_set(33, i, 1);
}
for (j=32;j>y_line_point;j--){
display_pixel_set(j, 63, 1);
display_pixel_set(j, 64, 1);
display_pixel_set(j, 65, 1);
}
}
display_pixel_set(31,63,1);
display_pixel_set(31,64,1);
display_pixel_set(31,65,1);
display_pixel_set(32,63,1);
display_pixel_set(32,64,1);
display_pixel_set(32,65,1);
display_pixel_set(33,63,1);
display_pixel_set(33,64,1);
display_pixel_set(33,65,1);
display_draw();
}
}
int main ()
{
__builtin_disable_interrupts();
// set the CP0 CONFIG register to indicate that
// kseg0 is cacheable (0x3) or uncacheable (0x2)
// see Chapter 2 "CPU for Devices with M4K Core"
// of the PIC32 reference manual
__builtin_mtc0(_CP0_CONFIG, _CP0_CONFIG_SELECT, 0xa4210583);
// no cache on this chip!
// 0 data RAM access wait states
BMXCONbits.BMXWSDRM = 0x0;
// enable multi vector interrupts
INTCONbits.MVEC = 0x1;
// disable JTAG to be able to use TDI, TDO, TCK, TMS as digital
DDPCONbits.JTAGEN = 0;
__builtin_enable_interrupts();
TRISBbits.TRISB7 = 0; // set up LED1 pin as a digital output
// int i,a;
// display_init();
// for (i = 0; i<10; ++i)
// {
// a = 30+i;
// display_pixel_set(15,a,1);
// display_draw();
// }
char input[100];
int i=0;
short accels[3]; // accelerations for the 3 axes
short mags[3]; // magnetometer readings for the 3 axes
short temp;
acc_setup(); //initialize accelerometer
display_init(); //initialize LED screen
float xg, yg, zg;
while(1)
{
start_position[0] = 0;
start_position[1] = 0;
center_position[0] = 32;
center_position[1] = 64;
acc_read_register(OUT_X_L_A, (unsigned char *) accels, 6);
acc_read_register(OUT_X_L_M, (unsigned char *) mags, 6);
acc_read_register(TEMP_OUT_L, (unsigned char *) &temp, 2);
xg = (float) accels[0]/16000;
yg = (float) accels[1]/16000;
zg = (float) accels[2]/16000;
sprintf(input,"x: %.2f y: %.2f z: %.2f ", xg,yg,zg);
display_reset();
display_draw();
display_ggraph(xg,yg);
while(input[i])
{
display_message(input[i]);
i++;
start_position[1] = start_position[1]+5;
// if(start_position[1]+5>128)
// {start_position[0]+1;}
// else
// {start_position[1] = start_position[1]+5;}
}
i = 0;
display_draw();
_CP0_SET_COUNT(0);
while(_CP0_GET_COUNT()<5000000)
{;}
}
return (0);
}
void APP_Tasks (void )
{
char message[25];
char inputfrompc[25];
int i;
short accels[3]; // accelerations for the 3 axes
short accelsMAF;
short accelsFIR;
int buf1=0;
int buf2=0;
int buf3=0;
int buf4=0;
int buf5=0;
//bn*1000 for FIR
float b1=.0088;
float b2=.0479;
float b3=.1640;
float b4=.2793;
float b5=.2793;
float b6=.1640;
float b7=.0479;
float b8=.0088;
int FIRbuf1=0;
int FIRbuf2=0;
int FIRbuf3=0;
int FIRbuf4=0;
int FIRbuf5=0;
int FIRbuf6=0;
int FIRbuf7=0;
int FIRbuf8=0;
//sprintf(message,"Hello!");
//use_display(20,20,message);
//display_draw();
/* Check if device is configured. See if it is configured with correct
* configuration value */
switch(appData.state)
{
case APP_STATE_INIT:
/* Open the device layer */
appData.usbDevHandle = USB_DEVICE_Open( USB_DEVICE_INDEX_0, DRV_IO_INTENT_READWRITE );
if(appData.usbDevHandle != USB_DEVICE_HANDLE_INVALID)
{
/* Register a callback with device layer to get event notification (for end point 0) */
USB_DEVICE_EventHandlerSet(appData.usbDevHandle, APP_USBDeviceEventHandler, 0);
appData.state = APP_STATE_WAIT_FOR_CONFIGURATION;
}
else
{
/* The Device Layer is not ready to be opened. We should try
* again later. */
}
break;
case APP_STATE_WAIT_FOR_CONFIGURATION:
if(appData.deviceConfigured == true)
{
/* Device is ready to run the main task */
appData.hidDataReceived = false;
appData.hidDataTransmitted = true;
appData.state = APP_STATE_MAIN_TASK;
/* Place a new read request. */
USB_DEVICE_HID_ReportReceive (USB_DEVICE_HID_INDEX_0,
&appData.rxTransferHandle, appData.receiveDataBuffer, 64);
}
break;
case APP_STATE_MAIN_TASK:
if(!appData.deviceConfigured)
{
/* Device is not configured */
appData.state = APP_STATE_WAIT_FOR_CONFIGURATION;
}
else if( appData.hidDataReceived )
{
/* Look at the data the host sent, to see what
* kind of application specific command it sent. */
switch(appData.receiveDataBuffer[0])
{
case 0x80:
/* Toggle on board LED1 to LED2. */
BSP_LEDToggle( APP_USB_LED_1 );
BSP_LEDToggle( APP_USB_LED_2 );
for (i=0; i<8; i++){
inputfrompc[i] = appData.receiveDataBuffer[i+1];
}
use_display(20,20,inputfrompc);
display_draw();
appData.hidDataReceived = false;
/* Place a new read request. */
USB_DEVICE_HID_ReportReceive (USB_DEVICE_HID_INDEX_0,
&appData.rxTransferHandle, appData.receiveDataBuffer, 64 );
break;
case 0x81:
if(appData.hidDataTransmitted)
{
/* Echo back to the host PC the command we are fulfilling in
* the first byte. In this case, the Get Push-button State
* command. */
appData.transmitDataBuffer[0] = 0x81;
acc_read_register(OUT_X_L_A, (unsigned char *) accels, 6);
sprintf(message,"Z: %d",accels[0]);
use_display(10,10,message);
display_draw();
if(_CP0_GET_COUNT()>800000){
appData.transmitDataBuffer[1] = 1;
appData.transmitDataBuffer[2] = accels[0]>>8;
appData.transmitDataBuffer[3] = accels[0]&0xFF;
//use MAF buffer values to calculate accelsMAF
accelsMAF = ((buf1+buf2+buf3+buf4+buf5+accels[0])/6);
//change MAF buffer values
buf5=buf4;
buf4=buf3;
buf3=buf2;
buf2=buf1;
buf1=accels[0];
//change FIR buffer values
FIRbuf8=FIRbuf7;
FIRbuf7=FIRbuf6;
FIRbuf6=FIRbuf5;
FIRbuf5=FIRbuf4;
FIRbuf4=FIRbuf3;
FIRbuf3=FIRbuf2;
FIRbuf2=FIRbuf1;
FIRbuf1=accels[0];
//FIR Filtering calculations
accelsFIR = (b1*FIRbuf1)+(b2*FIRbuf2)+(b3*FIRbuf3)+(b4*FIRbuf4)+(b5*FIRbuf5)+(b6*FIRbuf6)+(b7*FIRbuf7)+(b8*FIRbuf8);
appData.transmitDataBuffer[4] = accelsMAF>>8;
appData.transmitDataBuffer[5] = accelsMAF&0xFF;
appData.transmitDataBuffer[6] = accelsFIR>>8;
appData.transmitDataBuffer[7] = accelsFIR&0xFF;
_CP0_SET_COUNT(0);
}
else{appData.transmitDataBuffer[1]=0;}
appData.hidDataTransmitted = false;
/* Prepare the USB module to send the data packet to the host */
USB_DEVICE_HID_ReportSend (USB_DEVICE_HID_INDEX_0,
&appData.txTransferHandle, appData.transmitDataBuffer, 64 );
appData.hidDataReceived = false;
/* Place a new read request. */
USB_DEVICE_HID_ReportReceive (USB_DEVICE_HID_INDEX_0,
&appData.rxTransferHandle, appData.receiveDataBuffer, 64 );
}
break;
default:
appData.hidDataReceived = false;
/* Place a new read request. */
USB_DEVICE_HID_ReportReceive (USB_DEVICE_HID_INDEX_0,
&appData.rxTransferHandle, appData.receiveDataBuffer, 64 );
break;
}
/* In pikrellcam, this callback receives resized I420 frames before
| sending them on to a jpeg encoder component which generates the
| mjpeg.jpg stream image. Here we send the frame data to the motion display
| routine for possible drawing of region outlines, motion vectors
| and/or various status text. Motion detection was done in the h264
| callback and a flag is set there so these two paths can be synchronized
| so motion vectors can be drawn on the right frame.
*/
void
I420_video_callback(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
{
CameraObject *obj = (CameraObject *) port->userdata;
MMAL_BUFFER_HEADER_T *buffer_in;
static struct timeval timer;
int utime;
static int encoder_busy_count;
if ( buffer->length > 0
&& motion_frame_event
)
{
motion_frame_event = FALSE;
/* Do not send buffer to encoder if it has not received the previous
| one we sent unless this is the frame we want for a preview save.
| In that case, we may be sending a buffer to preview save before
| the previous buffer is handled. This is accounted for below.
*/
if ( mjpeg_encoder_send_count == mjpeg_encoder_recv_count
|| motion_frame.do_preview_save
)
{
if (obj->callback_port_in && obj->callback_pool_in)
{
buffer_in = mmal_queue_get(obj->callback_pool_in->queue);
if ( buffer_in
&& obj->callback_port_in->buffer_size >= buffer->length
)
{
mmal_buffer_header_mem_lock(buffer);
memcpy(buffer_in->data, buffer->data, buffer->length);
buffer_in->length = buffer->length;
mmal_buffer_header_mem_unlock(buffer);
display_draw(buffer_in->data);
if (motion_frame.do_preview_save)
{
/* If mjpeg encoder has not received previous buffer,
| then the buffer to save will be the second buffer
| it gets from now. Otherwise it's the next buffer.
*/
pthread_mutex_lock(&mjpeg_encoder_count_lock);
if (mjpeg_encoder_send_count == mjpeg_encoder_recv_count)
mjpeg_do_preview_save = 1;
else
mjpeg_do_preview_save = 2;
pthread_mutex_unlock(&mjpeg_encoder_count_lock);
if (mjpeg_do_preview_save == 2 && pikrellcam.debug)
printf("%s: encoder not clear -> preview save delayed\n",
fname_base(pikrellcam.video_pathname));
}
motion_frame.do_preview_save = FALSE;
++mjpeg_encoder_send_count;
mmal_port_send_buffer(obj->callback_port_in, buffer_in);
}
}
}
else
{
++encoder_busy_count;
if (pikrellcam.debug)
printf("encoder not clear (%d) -> skipping mjpeg frame.\n",
encoder_busy_count);
if (encoder_busy_count > 2) /* Frame maybe dropped ??, move on */
{
if (pikrellcam.debug)
printf(" Syncing recv/send counts.\n");
encoder_busy_count = 0;
mjpeg_encoder_recv_count = mjpeg_encoder_send_count;
}
}
if (buffer->flags & MMAL_BUFFER_HEADER_FLAG_FRAME_END)
{
if (pikrellcam.debug_fps && (utime = micro_elapsed_time(&timer)) > 0)
printf("%s fps %d\n", obj->name, 1000000 / utime);
}
}
return_buffer_to_port(port, buffer);
}
