int main(void) {
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
struct nunchuk_data data;
int screen = 0;
//initialization
delay(10);
f3d_lcd_init();
delay(10);
//reset & initializing physical screen
f3d_lcd_fillScreen2(WHITE);
f3d_i2c1_init();
delay(10);
f3d_mag_init();
delay(10);
f3d_accel_init();
delay(10);
f3d_nunchuk_init();
delay(10);
f3d_uart_init();
delay(10);
f3d_gyro_init();
delay(10);
f3d_led_init();
delay(10);
while (1){
f3d_nunchuk_read(&data);
//Selecting screen number
//reset screen
if(data.c == 1 || data.jx == 0){
while(data.c == 1 || data.jx == 0){
f3d_nunchuk_read(&data);
}
f3d_lcd_fillScreen2(WHITE);
screen--;
//Move to left info screen
if(screen == -1) {
screen = 3;
}
printf("%d", screen);
}
//Selecting screen number
//reset screen
if(data.z == 1 || data.jx == 255){
while(data.z == 1 || data.jx == 255){
f3d_nunchuk_read(&data);
}
f3d_lcd_fillScreen2(WHITE);
screen++;
//Move to left info screen
if(screen == 4) {
screen = 0;
}
}
//switch screen
switch (screen) {
case 0:
printf("Nunchuk\n");
nunchukScreen(data);
break;
case 1:
printf("Gyro\n");
gyroScreen();
break;
case 2:
printf("Accel\n");
accelScreen();
break;
case 3:
printf("Compass\n");
compassScreen();
break;
}
}
}
int main(void) {
// Set buffer to protect initializations
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
//Initialize peripherals
f3d_gyro_init();
f3d_uart_init();
f3d_lcd_init();
int chW = 6;
int chH = 10;
int width = ST7735_width;
char data[8];
int i, j;
int dataX;
int dataY;
int dataZ;
//Array to store gyro data
float axis[3];
//Fill background to RED
f3d_lcd_fillScreen2(BLUE);
//Set up data labels
f3d_lcd_drawString(chW,0,"X: ",BLACK,BLUE);
f3d_lcd_drawString(chW,chH,"Y: ",BLACK,BLUE);
f3d_lcd_drawString(chW,2*chH,"Z: ",BLACK,BLUE);
//Create bar graph labels
f3d_lcd_drawString(width/2-18, 45, "X-Axis", WHITE, BLUE);
f3d_lcd_drawString(width/2-18, 65, "Y-Axis", WHITE, BLUE);
f3d_lcd_drawString(width/2-18, 85, "Z-Axis", WHITE, BLUE);
//Labels to show which color is which value
f3d_lcd_drawString(chW, 110, "Positive", RED, BLUE);
f3d_lcd_drawString(width-9*chW, 110, "Negative", GREEN, BLUE);
//Create the bar graph box
int top;
int side;
f3d_lcd_drawString(3, 130, "Loading...",WHITE, BLUE);
for (top = 3; top < ST7735_width-3; top++) {
for (side = 40; side < 103; side++) {
f3d_lcd_drawPixel(top, 40, WHITE);
f3d_lcd_drawPixel(top, 41, WHITE);
f3d_lcd_drawPixel(top, 101, WHITE);
f3d_lcd_drawPixel(top, 102, WHITE);
f3d_lcd_drawPixel(2, side, WHITE);
f3d_lcd_drawPixel(3, side, WHITE);
f3d_lcd_drawPixel(ST7735_width-2, side, WHITE);
f3d_lcd_drawPixel(ST7735_width-3, side, WHITE);
}
}
f3d_lcd_drawString(64, 130, "Done!",WHITE, BLUE);
//Loop, collecting gyro data
while(1)
{
f3d_gyro_getdata(axis);
printf("X: %f\n", axis[0]);
sprintf(data, "%f", axis[0]);
f3d_lcd_drawString(4*chW,0,data,BLACK,BLUE);
sprintf(data, "%f", axis[1]);
f3d_lcd_drawString(4*chW,chH,data,BLACK,BLUE);
sprintf(data, "%f", axis[2]);
f3d_lcd_drawString(4*chW,2*chH,data,BLACK,BLUE);
//360/120 = 3 so we divided magnitude by 3
//X-axis point graph
dataX = (int)axis[0] / 3.0;
blockGen(dataX, 55);
// Y-axis point graph
dataY = (int)axis[1] / 3.0;
blockGen(dataY, 75);
// Z-axis point graph
dataZ = (int)axis[2] / 3.0;
blockGen(dataZ, 95);
}
}
int main(void) {
//various initializations
f3d_uart_init();
f3d_i2c1_init();
delay(10);
f3d_accel_init();
delay(10);
f3d_mag_init();
delay(10);
f3d_gyro_init();
delay(10);
f3d_nunchuk_init();
delay(10);
f3d_user_btn_init();
f3d_lcd_init();
//reset pixels by filling screen RED
f3d_lcd_fillScreen(RED);
//set buffers
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
// initialize gyro constants
START_X = (ST7735_width / 2) - (RECT_WIDTH / 2);
START_Y = (ST7735_height / 2) - (RECT_LENGTH / 2);
GYRO_UPPER_BOUND = 120;
X_MARGIN = (ST7735_width - RECT_WIDTH) / 2;
Y_MARGIN = (ST7735_height - RECT_LENGTH) / 2;
//set centerX and centerY by using global varaibles from library
centerX = ST7735_width / 2;
centerY = ST7735_height / 2;
// constants for the PITCHROLL_MODE
const int barGraphWidth = 40;
const int rollStartY = 30;
const int pitchStartY = 120;
//variables for keeping track of data from previous point
int prevRollX = 0, prevRollY = 0;
int prevPitchX = 0, prevPitchY = 0;
int prevGyroRow = START_X, prevGyroCol = START_Y;
//set float arrays for accel and mag data
float accel_buffer[3];
float mag_buffer[3];
float gyro_buffer[3];
nunchuk_t nunchuk_data;
nunchuk_t *nunchuk_ptr = &nunchuk_data;
//start board in compass mode
int app_mode = COMPASS_MODE;
char *app_mode_title;
while(1) {
//retrieve accel and mag data and insert into their buffers
f3d_accel_read(accel_buffer);
f3d_mag_read(mag_buffer);
f3d_gyro_getdata(gyro_buffer);
f3d_nunchuk_read(nunchuk_ptr);
delay(10);
float Ax1 = accel_buffer[0];
float Ay1 = accel_buffer[1];
float Az1 = accel_buffer[2];
//calcuation of sum of squares
float A_sum_squares = sqrt(Ax1 * Ax1 + Ay1 * Ay1 + Az1 * Az1);
//calculate pitch using accel data and atan2
float pitch = atan2(Ax1, sqrt(Ay1 * Ay1 + Az1 * Az1));
//calculate roll in a similar manner
float roll = atan2(Ay1, sqrt(Ax1 * Ax1 + Az1 * Az1));
//feed mag buffers mag x, y, and z
float Mx = mag_buffer[0];
float My = mag_buffer[1];
float Mz = mag_buffer[2];
//calculate heading in degrees
float Xh = Mx * cos(pitch) + Mz * sin(pitch);
float Yh = Mx * sin(roll) * sin(pitch) + My * cos(roll) - Mz * sin(roll) * cos(pitch);
float headingDegrees = rad_to_deg(atan2(Yh, Xh));
// convert heading degrees to a circular system
float newHeadingDegrees = 0.0;
if (headingDegrees > 90.0) {
// quad I
newHeadingDegrees = fabsf(headingDegrees - 180.0);
} else if (headingDegrees > 0.0) {
// quad II
newHeadingDegrees = 180.0 - headingDegrees;
} else {
// quads III and IV
newHeadingDegrees = 180.0 + fabsf(headingDegrees);
}
int prev_app_mode = app_mode;
// change mode based on nunchuk
const unsigned char joystick_epsilon = 50;
int c_pressed = nunchuk_ptr->z;
int z_pressed = nunchuk_ptr->c;
if (c_pressed != z_pressed) {
// decide based on buttons
if (c_pressed) {
// go right
app_mode = (app_mode + 1) % 4;
} else {
// go left
app_mode = (app_mode + 3) % 4;
}
} else {
// decide based on joystick
const int joystick_x_center = 141;
int joystick_delta = nunchuk_ptr->jx - joystick_x_center;
if (abs(joystick_delta) >= joystick_epsilon) {
// only switch app mode if joystick change is significant
if (joystick_delta < 0) {
// go right
app_mode = (app_mode + 1) % 4;
} else {
// go left
app_mode = (app_mode + 3) % 4;
}
}
}
if (app_mode != prev_app_mode) {
f3d_lcd_fillScreen(RED);
}
//define variables for row and columns of type int
int row, col;
switch(app_mode) {
case COMPASS_MODE: // compass mode
f3d_lcd_fillScreen(RED);
f3d_lcd_drawString(0, 0, "Compass", WHITE, RED);
//draw static white line point upwards on LCD
drawStraightupLine(WHITE);
const float radius = 30.0;
float theta = deg_to_rad(newHeadingDegrees) - (M_PI / 2.0);
//calculat x and y offset
float xOffset = radius * cos(theta);
float yOffset = radius * sin(theta);
//set second point
int x2 = centerX + ((int) xOffset);
int y2 = centerY + ((int) yOffset);
//draw point on the screen at location x2 and y2
f3d_lcd_drawPixel(x2, y2, CYAN);
break;
case PITCHROLL_MODE: // tilt mode
app_mode_title = "Board";
pitchroll_label:
// erase old bars
drawRect(0, rollStartY, prevRollX, prevRollY, RED);
drawRect(0, pitchStartY, prevPitchX, prevPitchY, RED);
//draw the word "Roll" on upper left of LCD
f3d_lcd_drawString(0, 0, "Roll", CYAN, RED);
// title the application
f3d_lcd_drawString((int) ST7735_width * 0.65, 0, app_mode_title, CYAN, RED);
//set color for redrawing of the bars
int rollColor = (roll < 0.0) ? MAGENTA : CYAN;
//calculate perceentage using fabsf (absolute value for float)
float rollPercentage = fabsf(roll) / M_PI;
//calculate rollX and rollY for drawing the roll bar
int rollX = rollPercentage * ST7735_width;
int rollY = rollStartY + barGraphWidth;
drawRect(0, rollStartY, rollX, rollY, rollColor);
//draw the word pitch 90 pixels below Roll
f3d_lcd_drawString(0, 90, "Pitch", CYAN, RED);
//set color for redrawing
int pitchColor = (pitch < 0.0) ? MAGENTA : CYAN;
//calculate pitchPercentage using fabsf(absolute for float)
float pitchPercentage = fabsf(pitch) / M_PI;
//calculate pitchX and pitch Y for drawing Pitch rectangle
int pitchX = pitchPercentage * ST7735_width;
int pitchY = pitchStartY + barGraphWidth;
drawRect(0, pitchStartY, pitchX, pitchY, pitchColor);
//keep track of RollX and PitchX for loop
prevRollX = rollX; prevRollY = rollY;
prevPitchX = pitchX; prevPitchY = pitchY;
break;
case GYRO_MODE: // gyro mode
f3d_lcd_fillScreen(RED);
float gyroDataAvg = (gyro_buffer[0] + gyro_buffer[1] + gyro_buffer[2]) / 3.0f;
float percentageOffset = gyroDataAvg / GYRO_UPPER_BOUND;
int xPixelsFromCenter = (percentageOffset * X_MARGIN) / 1;
int yPixelsFromCenter = (percentageOffset * Y_MARGIN) / 1;
row = START_X + xPixelsFromCenter;
col = START_Y + yPixelsFromCenter;
prevGyroRow = row;
prevGyroCol = col;
drawGyroRect(col, row, WHITE);
break;
case NUNCHUK_MODE:
app_mode_title = "Nunchuk";
const int nunchuk_tilt_upperbound = 1023;
const int nunchuk_tilt_midpoint = nunchuk_tilt_upperbound / 2;
int ax = nunchuk_ptr->ax - nunchuk_tilt_midpoint;
int ay = nunchuk_ptr->ay - nunchuk_tilt_midpoint;
int az = nunchuk_ptr->az;
// calculate pitch and roll of nunchuk
pitch = atan2(ay, sqrt(pow(ay, 2) + pow(az, 2)));
roll = atan2(ax, sqrt(pow(ax, 2) + pow(az, 2)));
// double pitch and roll values to exaggerate their size on bar graph
pitch *= 2;
roll *= 2;
// all the rest is the same as board accelerometer application, so...
goto pitchroll_label;
break;
default:
break;
}
}
}
int main(void) {
f3d_lcd_init();
f3d_gyro_init();
f3d_uart_init();
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
float ray[3];
int prev[3];
prev[0]=0; prev[1]=0; prev[2]=0;
char xaxis[] = "X-axis";
char yaxis[] = "Y-axis";
char zaxis[] = "Z-axis";
char *xptr,*yptr,*zptr;
xptr=xaxis; yptr=yaxis; zptr=zptr;
/// layout & labels \\\
f3d_lcd_fillScreen(WHITE);
//X-axis
f3d_lcd_fillSection(64,22,64,44,BLACK);
f3d_lcd_drawString(50,55,xaxis,BLACK,WHITE);
//Y-axis
f3d_lcd_fillSection(64,66,64,88,BLACK);
f3d_lcd_drawString(50,99,yaxis,BLACK,WHITE);
//Z-axis
f3d_lcd_fillSection(64,110,64,132,BLACK);
f3d_lcd_drawString(50,143,zaxis,BLACK,WHITE);
while(1){
f3d_gyro_getdata(ray);
/// xaaaaans \\\
//X-axis
double xval = (double) ray[0];
if(xval <=0){
//negative bar
double xp = xval/-400;
int xbp = (int) 63*xp; //number of pixels on x axis to show
int delta = 63-xbp; //x1 starting pixel
if(xbp > prev[0]){ /*check if its greater/smaller than prevRay*/
f3d_lcd_fillSection(delta,22,63,44,BLUE); /*increase bar size; fill with Blue*/
}else{
f3d_lcd_fillSection(0,22,delta,44,WHITE); /*decrease bar size; fill with White*/
}
prev[0] = xbp;
}else{
//positive bar
double xp = xval/400;
int xbp = (int) 65*xp;
int delta = 65+xbp;
if(xbp > prev[0]){ /*check if greater/smaller than prevRay*/
f3d_lcd_fillSection(65,22,delta,44,BLUE); /*increase bar size; fill with Blue*/
}else{
f3d_lcd_fillSection(delta,22,128,44,WHITE); /*decrease bar size; fill white*/
}
prev[0] = xbp;
}
//Y-axis
double yval = (double) ray[1];
if(yval <=0){
//negative bar
double yp = yval/-400;
int ybp = (int) 63*yp;
int delta = 63-ybp;
if(ybp > prev[0]){
f3d_lcd_fillSection(delta,66,63,88,GREEN);
}else{
f3d_lcd_fillSection(0,66,delta,88,WHITE);
}
prev[1] = ybp;
}else{
//positive bar
double yp = yval/400;
int ybp = (int) 65*yp;
int delta = 65+ybp;
if(ybp > prev[1]){
f3d_lcd_fillSection(65,66,delta,88,GREEN);
}else{
f3d_lcd_fillSection(delta,66,128,88,WHITE);
}
prev[1] = ybp;
}
//Z-axis
double zval = (double) ray[2];
if(zval <=0){
//negative bar
double zp = zval/-400;
int zbp = (int) 63*zp;
int delta = 63-zbp;
if(zbp > prev[0]){
f3d_lcd_fillSection(delta,110,63,132,YELLOW);
}else{
f3d_lcd_fillSection(0,110,delta,132,WHITE);
}
prev[2] = zbp;
}else{
//positive bar
double zp = zval/400;
int zbp = (int) 65*zp;
int delta = 65+zbp;
if(zbp > prev[1]){
f3d_lcd_fillSection(65,110,delta,132,YELLOW);
}else{
f3d_lcd_fillSection(delta,110,128,132,WHITE);
}
prev[2] = zbp;
}
}
}
int main(void) {
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
f3d_uart_init();
delay(10);
f3d_delay_init();
delay(10);
f3d_lcd_init();
delay(10);
f3d_i2c1_init();
delay(10);
f3d_accel_init();
delay(10);
f3d_nunchuk_init();
delay(10);
f3d_timer2_init();
delay(10);
f3d_dac_init();
delay(10);
f3d_rtc_init();
delay(10);
f3d_systick_init();
delay(10);
nunchuk_t nunc;
nunchuk_t *nun = &nunc;
int music = 0;
const int fileNum = 3;
char *musicFile[fileNum];
musicFile[0] = "thermo.wav";
musicFile[1] = "mario.wav";
musicFile[2] = "ting.wav";
printf("Reset\n");
//set up screen
f3d_lcd_fillScreen(WHITE);
f3d_lcd_drawString(37, 0, musicFile[0], RED, WHITE);
f3d_lcd_drawString(37, 20 * 1, musicFile[1], BLUE, WHITE);
f3d_lcd_drawString(37, 20 * 2, musicFile[2], BLUE, WHITE);
f3d_lcd_drawString(33, 80, "WAV Player", BLACK, WHITE);
f3d_lcd_drawString(43, 100, "sijlee", BLACK, WHITE);
f3d_lcd_drawString(48, 120, "sp21", BLACK, WHITE);
f_mount(0, &Fatfs);/* Register volume work area */
f3d_nunchuk_read(nun);
while(1) {
f3d_nunchuk_read(nun);
int lastSelect = music;
//nunchuk to right
if (nun->jx == 255) {
music = (music + 1) % 3;
f3d_lcd_drawString(37, lastSelect * 20, musicFile[lastSelect], BLUE, WHITE);
f3d_lcd_drawString(37, music * 20, musicFile[music], RED, WHITE);
//nunchuk to left
} else if (nun->jx == 0) {
music = (music + 2) % 3;
f3d_lcd_drawString(37, lastSelect * 20, musicFile[lastSelect], BLUE, WHITE);
f3d_lcd_drawString(37, music * 20, musicFile[music], RED, WHITE);
}
//when selected, play music!
if (nun->z) {
FRESULT rc; /* Result code */
DIR dir; /* Directory object */
FILINFO fno; /* File information object */
UINT bw, br;
unsigned int retval;
int bytesread;
printf("\nOpen %s\n", musicFile[music]);
rc = f_open(&fid, musicFile[music], FA_READ);
printf("opened file with rc: %d\n", rc);
if (!rc) {
printf("Success opening file\n");
struct ckhd hd;
uint32_t waveid;
struct fmtck fck;
readckhd(&fid, &hd, 'FFIR');
f_read(&fid, &waveid, sizeof(waveid), &ret);
if ((ret != sizeof(waveid)) || (waveid != 'EVAW'))
return -1;
readckhd(&fid, &hd, ' tmf');
f_read(&fid, &fck, sizeof(fck), &ret);
// skip over extra info
if (hd.cksize != 16) {
printf("extra header info %d\n", hd.cksize - 16);
f_lseek(&fid, hd.cksize - 16);
}
printf("audio format 0x%x\n", fck.wFormatTag);
printf("channels %d\n", fck.nChannels);
printf("sample rate %d\n", fck.nSamplesPerSec);
printf("data rate %d\n", fck.nAvgBytesPerSec);
printf("block alignment %d\n", fck.nBlockAlign);
printf("bits per sample %d\n", fck.wBitsPerSample);
// now skip all non-data chunks !
while(1){
printf("skipping all non-data chunks\n");
readckhd(&fid, &hd, 0);
if (hd.ckID == 'atad')
break;
f_lseek(&fid, hd.cksize);
}
printf("Samples %d\n", hd.cksize);
// Play it !
// audioplayerInit(fck.nSamplesPerSec);
f_read(&fid, Audiobuf, AUDIOBUFSIZE, &ret);
hd.cksize -= ret;
audioplayerStart();
while (hd.cksize) {
int next = hd.cksize > AUDIOBUFSIZE/2 ? AUDIOBUFSIZE/2 : hd.cksize;
if (audioplayerHalf) {
if (next < AUDIOBUFSIZE/2)
bzero(Audiobuf, AUDIOBUFSIZE/2);
f_read(&fid, Audiobuf, next, &ret);
hd.cksize -= ret;
audioplayerHalf = 0;
}
if (audioplayerWhole) {
if (next < AUDIOBUFSIZE/2)
bzero(&Audiobuf[AUDIOBUFSIZE/2], AUDIOBUFSIZE/2);
f_read(&fid, &Audiobuf[AUDIOBUFSIZE/2], next, &ret);
hd.cksize -= ret;
audioplayerWhole = 0;
}
}
audioplayerStop();
}
printf("\nClose the file.\n");
rc = f_close(&fid);
if (rc) die(rc);
delay(1000);
}
}
}
int main(void) {
int step = 0;
int stepMod;
nunchuk_t n;
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
f3d_i2c1_init();
delay(10);
f3d_nunchuk_init();
delay(10);
f3d_rtc_init();
//printf("check rtc\n");
delay(10);
f3d_uart_init();
f3d_timer2_init();
//printf("check timer2\n");
f3d_dac_init();
//printf("check dac\n");
f3d_delay_init();
//printf("check delay\n");
f3d_led_init();
//printf("check led\n");
f3d_lcd_init();
//printf("check lcd\n");
f3d_systick_init();
//printf("check systick\n");
f3d_user_btn_init();
//printf("check user btn\n");
f3d_lcd_fillScreen(WHITE);
while (1){
f3d_nunchuk_read(&n);
if(n.jy > 150){
step++;
}
if(n.jy < 15){
step--;
}
stepMod = abs(step)%3;
switch(stepMod) {
case 0:
strcpy(fileName, "thermo.wav");
f3d_lcd_drawString(20,10,"Thermo",RED,BLACK);
f3d_lcd_drawString(20,30,"Lion",RED,WHITE);
f3d_lcd_drawString(20,50,"Batman",RED,WHITE);
if(user_btn_read() == 1){
play();
}
break;
case 1:
strcpy(fileName, "lion.wav");
f3d_lcd_drawString(20,10,"Thermo",RED,WHITE);
f3d_lcd_drawString(20,30,"Lion",RED,BLACK);
f3d_lcd_drawString(20,50,"Batman",RED,WHITE);
if(user_btn_read() == 1){
play();
}
break;
case 2:
strcpy(fileName, "batman.wav");
f3d_lcd_drawString(20,10,"Thermo",RED,WHITE);
f3d_lcd_drawString(20,30,"Lion",RED,WHITE);
f3d_lcd_drawString(20,50,"Batman",RED,BLACK);
if(user_btn_read() == 1){
play();
}
break;
}
}
}