![](/media/cache/img/default_profile.jpg.50x50_q85.jpg)
2036 mbed lab4
Dependencies: 4DGL-uLCD-SE PinDetect
Revision 0:bbda88bee65a, committed 2022-03-28
- Comitter:
- lhanks02
- Date:
- Mon Mar 28 18:44:30 2022 +0000
- Commit message:
- lab4
Changed in this revision
diff -r 000000000000 -r bbda88bee65a .gitignore --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.gitignore Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,4 @@ +.build +.mbed +projectfiles +*.py*
diff -r 000000000000 -r bbda88bee65a 4DGL-uLCD-SE.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/4DGL-uLCD-SE.lib Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,1 @@ +https://mbed.org/users/4180_1/code/4DGL-uLCD-SE/#e39a44de229a
diff -r 000000000000 -r bbda88bee65a Die.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Die.cc Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,98 @@ +#include "Die.h" +#include <stdlib.h> + +#include "uLCD_4DGL.h" +extern uLCD_4DGL uLCD; + +DieState Die::getCurrDieState()//setter and getter for state +{ + return currDieState; +} + +void Die::setCurrDieState(DieState v) +{ + currDieState=v; +} + + + + +void Die::rollDie() +{//function to roll die, only roll if die is in roll state + if(currDieState==ROLL) { + int val=rand()%6+1; + value = val; + } +} +void Die::drawDie()//function to draw die +{ + uLCD.rectangle(x1,y1,x2,y2,Color); + if (value==1) {//if statements displaying certain numbers of dots for each number + uLCD.filled_circle(x1+((x2-x1)/2),(y1+(y2-y1)/2), 3, WHITE); + } + if (value==2) { + uLCD.filled_circle(x1+((x2-x1)/4),(y1+((y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+(3*(x2-x1)/4),(y1+(3*(y2-y1)/4)), 3, WHITE); + } + if (value==3) { + uLCD.filled_circle(x1+((x2-x1)/4),(y1+(3*(y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+(3*(x2-x1)/4),(y1+((y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+((x2-x1)/2),(y1+((y2-y1)/2)), 3, WHITE); + } + if (value==4) { + uLCD.filled_circle(x1+((x2-x1)/4),(y1+(3*(y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+(3*(x2-x1)/4),(y1+((y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+(3*(x2-x1)/4),(y1+(3*(y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+((x2-x1)/4),(y1+((y2-y1)/4)), 3, WHITE); + } + if (value==5) { + uLCD.filled_circle(x1+((x2-x1)/4),(y1+(3*(y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+(3*(x2-x1)/4),(y1+((y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+(3*(x2-x1)/4),(y1+(3*(y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+((x2-x1)/4),(y1+((y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+((x2-x1)/2),(y1+((y2-y1)/2)), 3, WHITE); + } + if (value==6) { + uLCD.filled_circle(x1+((x2-x1)/4),(y1+(3*(y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+(3*(x2-x1)/4),(y1+((y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+(3*(x2-x1)/4),(y1+(3*(y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+((x2-x1)/4),(y1+((y2-y1)/4)), 3, WHITE); + uLCD.filled_circle(x1+((x2-x1)/4),(y1+((y2-y1)/2)), 3, WHITE); + uLCD.filled_circle(x1+(3*(x2-x1)/4),(y1+((y2-y1)/2)), 3, WHITE); + + + + } + + + +} +int Die::getx1()//setters and getters for data members +{ + return x1; +} + +int Die::getx2() +{ + return x2; +} + +int Die::gety1() +{ + return y1; +} + +int Die::gety2() +{ + return y2; +} + +int Die::getColor() +{ + return Color; +} + +int Die::getValue() +{ + return value; +} \ No newline at end of file
diff -r 000000000000 -r bbda88bee65a Die.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Die.h Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,38 @@ +#define WHITE 0xFFFFFF +#include "mbed.h" + +enum DieState{ROLL,REMOVED};//dice class, members are positions, colors, value of dice, and a state +class Die{ + public: + Die(int x11=0, int y11=0, int x12=0, int y12=0, int col=WHITE, int val=0){ + x1=x11; + x2=x12; + y1=y11; + y2=y12; + Color=col; + value=val; + currDieState=ROLL; + }; + void rollDie(); + void drawDie();//functions for rolling, drawing, and setting and getting data members + void setCurrDieState(DieState v); + DieState getCurrDieState(); + int getx1(); + int getx2(); + int gety1(); + int gety2(); + int getColor(); + int getValue(); + + + private: + int x1; + int x2; + int y1; + int y2; + int Color; + int value; + DieState currDieState; + + +};
diff -r 000000000000 -r bbda88bee65a FarkleGame.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/FarkleGame.cc Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,279 @@ +#include "mbed.h" +#define WHITE 0xFFFFFF +#include <stdlib.h> +#include <time.h> +#include "PinDetect.h" +#define NUM_DICE 6 +#include "FarkleGame.h" + +#include "uLCD_4DGL.h" + +extern uLCD_4DGL uLCD; +void FarkleGame::changeDieArray() +{ + int rollable=0;//keep track of how many dice are in a rollable state + + for(int i=0; i<6; i++) { //determine which die are rollable and increment + if(arr[i].getCurrDieState()==ROLL) { + rollable+=1; + } + } + if(rollable==6) { //these next if statements change the number of rollable die based on how many are currently rollable + for(int i=0; i<6; i++) { + (arr[i].setCurrDieState(REMOVED)); + } + } else if(rollable==5) + for(int i=0; i<6; i++) { + if(arr[i].getCurrDieState()==REMOVED) { + arr[i].setCurrDieState(ROLL); + } + } else if(rollable==4) + for(int i=0; i<6; i++) { + if(arr[i].getCurrDieState()==REMOVED) { + arr[i].setCurrDieState(ROLL); + break; + } + } else if(rollable==3) + for(int i=0; i<6; i++) { + if(arr[i].getCurrDieState()==REMOVED) { + arr[i].setCurrDieState(ROLL); + break; + } + } else if(rollable==2) + for(int i=0; i<6; i++) { + if(arr[i].getCurrDieState()==REMOVED) { + arr[i].setCurrDieState(ROLL); + break; + } + } else if(rollable==1) + for(int i=0; i<6; i++) { + if(arr[i].getCurrDieState()==REMOVED) { + arr[i].setCurrDieState(ROLL); + break; + } + } else if(rollable==0) + for(int i=0; i<6; i++) { + if(arr[i].getCurrDieState()==REMOVED) { + arr[i].setCurrDieState(ROLL); + break; + } + } + + + +} + +void FarkleGame::printScore() //print score function +{ + uLCD.display_control(LANDSCAPE); + uLCD.text_width(2); + uLCD.text_height(2); + uLCD.locate(0,1); + uLCD.printf("Your\n"); + uLCD.printf("Turn\n"); + uLCD.printf("Score\n"); + uLCD.printf("------"); + uLCD.printf("\n%d", score); +} +Die* FarkleGame::getDieArray()//getter for die array +{ + return arr; +} + +int FarkleGame::calcScore(int *numarray) +{ + int rollScore=0;//initialize rollScore to zero + for(int i=1; i<7; i++) { + if (numarray[i] == 6) {//search for 6 of a kind, code is very similar for 5 and 4 of a kind except for point difference + rollScore += 3000; + numarray[i]=0; + for(int idx=0; i<6; i++) { + arr[idx].setCurrDieState(REMOVED);//if the dice in the array are part of the score, remove them + } + } + if (numarray[i] == 5) { + rollScore += 2000; + numarray[i]=0; + for(int idx=0; i<6; i++) { + if(arr[idx].getValue()==i) { + arr[idx].setCurrDieState(REMOVED); + } + } + } + if (numarray[i] == 4) { + rollScore += 1000; + numarray[i]=0; + for(int idx=0; idx<6; idx++) { + if(arr[idx].getValue()==i) { + arr[idx].setCurrDieState(REMOVED); + } + } + } + } + int pairCounter=0;//need to count how many pairs and triples + int tripCounter=0; + int flushCounter=0; + for(int i=1; i<7; i++) {//iterate to find pairs and triples + + if (numarray[i] == 3) { + tripCounter+=1; + } + if (tripCounter==2) { + rollScore+=2500; + tripCounter=0; + for(int i=0; i<7; i++) {//this function removes dice that score and resets so dice in triples don't score twice + if(numarray[i]==3) { + numarray[i]=0; + for(int idx=0; idx<6; idx++) { + if(arr[idx].getValue()==i) { + arr[idx].setCurrDieState(REMOVED); + } + } + } + } + } + if (numarray[i] == 2) { + pairCounter+=1; + } + if (pairCounter==3) { + rollScore+=1500; + pairCounter=0; + for(int i=0; i<7; i++) {//extremely similar to the triple counter + if(numarray[i]==2) { + numarray[i]=0; + for(int idx=0; idx<6; idx++) { + if(arr[idx].getValue()==i) { + arr[idx].setCurrDieState(REMOVED); + } + } + } + } + } + if (numarray[i]==1) { + flushCounter+=1; + } + if (flushCounter==6) {//flush counter to determine if all parts of an array keeping track of numbers only have one number each + rollScore+=1500; //indicating one of each number was rolled (flush) + for(int idx=0; idx<6; idx++) { + arr[idx].setCurrDieState(REMOVED);//remove scoring die + } + flushCounter=0; + + + } + } + if(tripCounter==1) { + for(int idx=0; idx<7; idx++) { + if(numarray[idx]==3) {//if there is only one triple, we add the corresponding number of points + if(idx==1) { + rollScore+=1000; + for(int index=0; index<6; index++) { + if(arr[index].getValue()==idx) { + arr[index].setCurrDieState(REMOVED);//remove scoring die + } + } + } else { + rollScore+=idx*100; + for(int index=0; index<6; index++) { + if(arr[index].getValue()==idx) { + arr[index].setCurrDieState(REMOVED); + } + } + } + numarray[idx]=0; + } + } + } + if(pairCounter!=3) { + for(int idx=0; idx<7; idx++) { + if(idx==1) { + if(numarray[idx]==2) { + rollScore+=200;//if there are not three pairs, only add points for 1's and 5's + numarray[idx]=0; + for(int index=0; index<6; index++) { + if(arr[index].getValue()==idx) { + arr[index].setCurrDieState(REMOVED); + } + } + } + if(numarray[idx]==1) { + rollScore+=100; + numarray[idx]=0; + for(int index=0; index<6; index++) { + if(arr[index].getValue()==idx) { + arr[index].setCurrDieState(REMOVED); + } + } + } + + } + if(idx==5) { + if(numarray[idx]==2) { + rollScore+=100; + numarray[idx]=0; + for(int index=0; index<6; index++) { + if(arr[index].getValue()==idx) { + arr[index].setCurrDieState(REMOVED); + } + } + } + if(numarray[idx]==1) { + rollScore+=50; + numarray[idx]=0; + for(int index=0; index<6; index++) { + if(arr[index].getValue()==idx) { + arr[index].setCurrDieState(REMOVED); + } + } + } + + } + } + pairCounter=0; + } + return rollScore; +} + + + + + + + + + + + + + +int FarkleGame::getScore()//setter and getter for score +{ + return score; +} + +void FarkleGame::setScore(int num) +{ + score=num; +} +void FarkleGame::startGame() +{ + uLCD.cls(); + uLCD.display_control(LANDSCAPE); + uLCD.text_width(2); + uLCD.text_height(2); + uLCD.locate(0,1); + uLCD.printf("Shake\n"); + uLCD.printf("Board\n"); + uLCD.printf("------\n"); + uLCD.printf("To\n"); + uLCD.printf("Roll\n"); + int rolling=0; + for(int i=0; i<6; i++) { + if(arr[i].getCurrDieState()==ROLL) {//count how many die are in a rollable state and use that to display how many dice the user will roll + rolling+=1; + } + } + uLCD.printf("%d", rolling); + uLCD.printf(" Dice"); +} +
diff -r 000000000000 -r bbda88bee65a FarkleGame.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/FarkleGame.h Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,36 @@ +#include "mbed.h" +#define WHITE 0xFFFFFF +#include <stdlib.h> +#include <time.h> +#include "PinDetect.h" +#define NUM_DICE 6 +#include "Die.h" + +//#include "uLCD_4DGL.h" +//farkle game class, includes data members for a score and an array of die objects +class FarkleGame{ + + public: + FarkleGame(int num=0){ + score = num; + arr[0]=Die(0,0,42,42,WHITE); + arr[1]=Die(43,0,85,42,WHITE); + arr[2]=Die(85,0,127,42,WHITE); + arr[3]=Die(0,43,42,85,WHITE); + arr[4]=Die(43,43,85,85,WHITE); + arr[5]=Die(85,43,127,85,WHITE); + } + void startGame(); //function to display initial "roll 6 dice" + int getScore(); //function returning score + void setScore(int num); //function setting score + Die* getDieArray(); //getter for die array + int calcScore(int *numarray);//function to calculate score + void printScore();//print score function + void changeDieArray();//function to change die array + + private: + int score; + Die arr[NUM_DICE]; + }; + + \ No newline at end of file
diff -r 000000000000 -r bbda88bee65a MMA8452.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MMA8452.cpp Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,538 @@ +// Authors: Ashley Mills, Nicholas Herriot +/* Copyright (c) 2013 Vodafone, MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software + * and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or + * substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "MMA8452.h" +#include "mbed.h" + +#ifdef MMA8452_DEBUG +// you need to define Serial pc(USBTX,USBRX) somewhere for the below line to make sense +extern Serial pc; +#define MMA8452_DBG(...) pc.printf(__VA_ARGS__); pc.printf("\r\n"); +#else +#define MMA8452_DBG(...) +#endif + +// Connect module at I2C address using I2C port pins sda and scl +MMA8452::MMA8452(PinName sda, PinName scl, int frequency) : _i2c(sda, scl) , _frequency(frequency) { + MMA8452_DBG("Creating MMA8452"); + + // set I2C frequency + _i2c.frequency(_frequency); + + // setup read and write addresses for convenience + _readAddress = MMA8452_ADDRESS | 0x01; + _writeAddress = MMA8452_ADDRESS & 0xFE; + + // set some defaults + _bitDepth = BIT_DEPTH_UNKNOWN; + setBitDepth(BIT_DEPTH_12); + _dynamicRange = DYNAMIC_RANGE_UNKNOWN; + setDynamicRange(DYNAMIC_RANGE_2G); + + MMA8452_DBG("Done"); +} + + +// Destroys instance +MMA8452::~MMA8452() {} + +// Setting the control register bit 1 to true to activate the MMA8452 +int MMA8452::activate() { + // perform write and return error code + return logicalORRegister(MMA8452_CTRL_REG_1,MMA8452_ACTIVE_MASK); +} + +// Setting the control register bit 1 to 0 to standby the MMA8452 +int MMA8452::standby() { + // perform write and return error code + return logicalANDRegister(MMA8452_CTRL_REG_1,MMA8452_STANDBY_MASK); +} + +// this reads a register, applies a bitmask with logical AND, sets a value with logical OR, +// and optionally goes into and out of standby at the beginning and end of the function respectively +int MMA8452::maskAndApplyRegister(char reg, char mask, char value, int toggleActivation) { + if(toggleActivation) { + if(standby()) { + return 1; + } + } + + // read from register + char oldValue = 0; + if(readRegister(reg,&oldValue)) { + return 1; + } + + // apply bitmask + oldValue &= mask; + + // set value + oldValue |= value; + + // write back to register + if(writeRegister(reg,oldValue)) { + return 1; + } + + if(toggleActivation) { + if(activate()) { + return 1; + } + } + return 0; +} + +int MMA8452::setDynamicRange(DynamicRange range, int toggleActivation) { + _dynamicRange = range; + return maskAndApplyRegister( + MMA8452_XYZ_DATA_CFG, + MMA8452_DYNAMIC_RANGE_MASK, + range, + toggleActivation + ); +} + +int MMA8452::setDataRate(DataRateHz dataRate, int toggleActivation) { + return maskAndApplyRegister( + MMA8452_CTRL_REG_1, + MMA8452_DATA_RATE_MASK, + dataRate<<MMA8452_DATA_RATE_MASK_SHIFT, + toggleActivation + ); +} + +int MMA8452::setBitDepth(BitDepth depth,int toggleActivation) { + _bitDepth = depth; + return maskAndApplyRegister( + MMA8452_CTRL_REG_1, + MMA8452_BIT_DEPTH_MASK, + depth<<MMA8452_BIT_DEPTH_MASK_SHIFT, + toggleActivation + ); +} + +char MMA8452::getMaskedRegister(int addr, char mask) { + char rval = 0; + if(readRegister(addr,&rval)) { + return 0; + } + return (rval&mask); +} + +int MMA8452::isXYZReady() { + return getMaskedRegister(MMA8452_STATUS,MMA8452_STATUS_ZYXDR_MASK)>0; +} + +int MMA8452::isXReady() { + return getMaskedRegister(MMA8452_STATUS,MMA8452_STATUS_XDR_MASK)>0; +} + +int MMA8452::isYReady() { + return getMaskedRegister(MMA8452_STATUS,MMA8452_STATUS_YDR_MASK)>0; +} + +int MMA8452::isZReady() { + return getMaskedRegister(MMA8452_STATUS,MMA8452_STATUS_ZDR_MASK)>0; +} + + +int MMA8452::getDeviceID(char *dst) { + return readRegister(MMA8452_WHO_AM_I,dst); +} + +int MMA8452::getStatus(char* dst) { + return readRegister(MMA8452_STATUS,dst); +} + +MMA8452::DynamicRange MMA8452::getDynamicRange() { + char rval = 0; + if(readRegister(MMA8452_XYZ_DATA_CFG,&rval)) { + return MMA8452::DYNAMIC_RANGE_UNKNOWN; + } + rval &= (MMA8452_DYNAMIC_RANGE_MASK^0xFF); + return (MMA8452::DynamicRange)rval; +} + +MMA8452::DataRateHz MMA8452::getDataRate() { + char rval = 0; + if(readRegister(MMA8452_CTRL_REG_1,&rval)) { + return MMA8452::RATE_UNKNOWN; + } + // logical AND with inverse of mask + rval = rval&(MMA8452_DATA_RATE_MASK^0xFF); + // shift back into position + rval >>= MMA8452_DATA_RATE_MASK_SHIFT; + return (MMA8452::DataRateHz)rval; +} + +// Reads xyz +int MMA8452::readXYZRaw(char *dst) { + if(_bitDepth==BIT_DEPTH_UNKNOWN) { + return 1; + } + int readLen = 3; + if(_bitDepth==BIT_DEPTH_12) { + readLen = 6; + } + return readRegister(MMA8452_OUT_X_MSB,dst,readLen); +} + +int MMA8452::readXRaw(char *dst) { + if(_bitDepth==BIT_DEPTH_UNKNOWN) { + return 1; + } + int readLen = 1; + if(_bitDepth==BIT_DEPTH_12) { + readLen = 2; + } + return readRegister(MMA8452_OUT_X_MSB,dst,readLen); +} + +int MMA8452::readYRaw(char *dst) { + if(_bitDepth==BIT_DEPTH_UNKNOWN) { + return 1; + } + int readLen = 1; + if(_bitDepth==BIT_DEPTH_12) { + readLen = 2; + } + return readRegister(MMA8452_OUT_Y_MSB,dst,readLen); +} + +int MMA8452::readZRaw(char *dst) { + if(_bitDepth==BIT_DEPTH_UNKNOWN) { + return 1; + } + int readLen = 1; + if(_bitDepth==BIT_DEPTH_12) { + readLen = 2; + } + return readRegister(MMA8452_OUT_Z_MSB,dst,readLen); +} + +int MMA8452::readXYZCounts(int *x, int *y, int *z) { + char buf[6]; + if(readXYZRaw((char*)&buf)) { + return 1; + } + if(_bitDepth==BIT_DEPTH_12) { + *x = twelveBitToSigned(&buf[0]); + *y = twelveBitToSigned(&buf[2]); + *z = twelveBitToSigned(&buf[4]); + } else { + *x = eightBitToSigned(&buf[0]); + *y = eightBitToSigned(&buf[1]); + *z = eightBitToSigned(&buf[2]); + } + + return 0; +} + +int MMA8452::readXCount(int *x) { + char buf[2]; + if(readXRaw((char*)&buf)) { + return 1; + } + if(_bitDepth==BIT_DEPTH_12) { + *x = twelveBitToSigned(&buf[0]); + } else { + *x = eightBitToSigned(&buf[0]); + } + return 0; +} + +int MMA8452::readYCount(int *y) { + char buf[2]; + if(readYRaw((char*)&buf)) { + return 1; + } + if(_bitDepth==BIT_DEPTH_12) { + *y = twelveBitToSigned(&buf[0]); + } else { + *y = eightBitToSigned(&buf[0]); + } + return 0; +} + +int MMA8452::readZCount(int *z) { + char buf[2]; + if(readZRaw((char*)&buf)) { + return 1; + } + if(_bitDepth==BIT_DEPTH_12) { + *z = twelveBitToSigned(&buf[0]); + } else { + *z = eightBitToSigned(&buf[0]); + } + return 0; +} + +double MMA8452::convertCountToGravity(int count, int countsPerG) { + return (double)count/(double)countsPerG; +} + +int MMA8452::getCountsPerG() { + // assume starting with DYNAMIC_RANGE_2G and BIT_DEPTH_12 + int countsPerG = 1024; + if(_bitDepth==BIT_DEPTH_8) { + countsPerG = 64; + } + switch(_dynamicRange) { + case DYNAMIC_RANGE_4G: + countsPerG /= 2; + break; + case DYNAMIC_RANGE_8G: + countsPerG /= 4; + break; + } + return countsPerG; +} + +int MMA8452::readXYZGravity(double *x, double *y, double *z) { + int xCount = 0, yCount = 0, zCount = 0; + if(readXYZCounts(&xCount,&yCount,&zCount)) { + return 1; + } + int countsPerG = getCountsPerG(); + + *x = convertCountToGravity(xCount,countsPerG); + *y = convertCountToGravity(yCount,countsPerG); + *z = convertCountToGravity(zCount,countsPerG); + return 0; +} + +int MMA8452::readXGravity(double *x) { + int xCount = 0; + if(readXCount(&xCount)) { + return 1; + } + int countsPerG = getCountsPerG(); + + *x = convertCountToGravity(xCount,countsPerG); + return 0; +} + +int MMA8452::readYGravity(double *y) { + int yCount = 0; + if(readYCount(&yCount)) { + return 1; + } + int countsPerG = getCountsPerG(); + + *y = convertCountToGravity(yCount,countsPerG); + return 0; +} + +int MMA8452::readZGravity(double *z) { + int zCount = 0; + if(readZCount(&zCount)) { + return 1; + } + int countsPerG = getCountsPerG(); + + *z = convertCountToGravity(zCount,countsPerG); + return 0; +} + +// apply an AND mask to a register. read register value, apply mask, write it back +int MMA8452::logicalANDRegister(char addr, char mask) { + char value = 0; + // read register value + if(readRegister(addr,&value)) { + return 0; + } + // apply mask + value &= mask; + return writeRegister(addr,value); +} + + +// apply an OR mask to a register. read register value, apply mask, write it back +int MMA8452::logicalORRegister(char addr, char mask) { + char value = 0; + // read register value + if(readRegister(addr,&value)) { + return 0; + } + // apply mask + value |= mask; + return writeRegister(addr,value); +} + +// apply an OR mask to a register. read register value, apply mask, write it back +int MMA8452::logicalXORRegister(char addr, char mask) { + char value = 0; + // read register value + if(readRegister(addr,&value)) { + return 0; + } + // apply mask + value ^= mask; + return writeRegister(addr,value); +} + +// Write register (The device must be placed in Standby Mode to change the value of the registers) +int MMA8452::writeRegister(char addr, char data) { + // what this actually does is the following + // 1. tell I2C bus to start transaction + // 2. tell slave we want to write (slave address & write flag) + // 3. send the write address + // 4. send the data to write + // 5. tell I2C bus to end transaction + + // we can wrap this up in the I2C library write function + char buf[2] = {0,0}; + buf[0] = addr; + buf[1] = data; + return _i2c.write(MMA8452_ADDRESS, buf,2); + // note, could also do return writeRegister(addr,&data,1); +} + +int MMA8452::eightBitToSigned(char *buf) { + return (int8_t)*buf; +} + +int MMA8452::twelveBitToSigned(char *buf) { + // cheat by using the int16_t internal type + // all we need to do is convert to little-endian format and shift right + int16_t x = 0; + ((char*)&x)[1] = buf[0]; + ((char*)&x)[0] = buf[1]; + // note this only works because the below is an arithmetic right shift + return x>>4; +} + +int MMA8452::writeRegister(char addr, char *data, int nbytes) { + // writing multiple bytes is a little bit annoying because + // the I2C library doesn't support sending the address separately + // so we just do it manually + + // 1. tell I2C bus to start transaction + _i2c.start(); + // 2. tell slave we want to write (slave address & write flag) + if(_i2c.write(_writeAddress)!=1) { + return 1; + } + // 3. send the write address + if(_i2c.write(addr)!=1) { + return 1; + } + // 4. send the data to write + for(int i=0; i<nbytes; i++) { + if(_i2c.write(data[i])!=1) { + return 1; + } + } + // 5. tell I2C bus to end transaction + _i2c.stop(); + return 0; +} + +int MMA8452::readRegister(char addr, char *dst, int nbytes) { + // this is a bit odd, but basically proceeds like this + // 1. Send a start command + // 2. Tell the slave we want to write (slave address & write flag) + // 3. Send the address of the register (addr) + // 4. Send another start command to delineate read portion + // 5. Tell the slave we want to read (slave address & read flag) + // 6. Read the register value bytes + // 7. Send a stop command + + // we can wrap this process in the I2C library read and write commands + if(_i2c.write(MMA8452_ADDRESS,&addr,1,true)) { + return 1; + } + return _i2c.read(MMA8452_ADDRESS,dst,nbytes); +} + +// most registers are 1 byte, so here is a convenience function +int MMA8452::readRegister(char addr, char *dst) { + return readRegister(addr,dst,1); +} + +MMA8452::BitDepth MMA8452::getBitDepth() { + return _bitDepth; +} + +#ifdef MMA8452_DEBUG +void MMA8452::debugRegister(char reg) { + // get register value + char v = 0; + if(readRegister(reg,&v)) { + MMA8452_DBG("Error reading specified register"); + return; + } + // print out details + switch(reg) { + case MMA8452_CTRL_REG_1: + MMA8452_DBG("CTRL_REG_1 has value: 0x%x",v); + MMA8452_DBG(" 7 ALSP_RATE_1: %d",(v&0x80)>>7); + MMA8452_DBG(" 6 ALSP_RATE_0: %d",(v&0x40)>>6); + MMA8452_DBG(" 5 DR2: %d", (v&0x20)>>5); + MMA8452_DBG(" 4 DR1: %d", (v&0x10)>>4); + MMA8452_DBG(" 3 DR0: %d", (v&0x08)>>3); + MMA8452_DBG(" 2 LNOISE: %d", (v&0x04)>>2); + MMA8452_DBG(" 1 FREAD: %d", (v&0x02)>>1); + MMA8452_DBG(" 0 ACTIVE: %d", (v&0x01)); + break; + + case MMA8452_XYZ_DATA_CFG: + MMA8452_DBG("XYZ_DATA_CFG has value: 0x%x",v); + MMA8452_DBG(" 7 Unused: %d", (v&0x80)>>7); + MMA8452_DBG(" 6 0: %d", (v&0x40)>>6); + MMA8452_DBG(" 5 0: %d", (v&0x20)>>5); + MMA8452_DBG(" 4 HPF_Out: %d",(v&0x10)>>4); + MMA8452_DBG(" 3 0: %d", (v&0x08)>>3); + MMA8452_DBG(" 2 0: %d", (v&0x04)>>2); + MMA8452_DBG(" 1 FS1: %d", (v&0x02)>>1); + MMA8452_DBG(" 0 FS0: %d", (v&0x01)); + switch(v&0x03) { + case 0: + MMA8452_DBG("Dynamic range: 2G"); + break; + case 1: + MMA8452_DBG("Dynamic range: 4G"); + break; + case 2: + MMA8452_DBG("Dynamic range: 8G"); + break; + default: + MMA8452_DBG("Unknown dynamic range"); + break; + } + break; + + case MMA8452_STATUS: + MMA8452_DBG("STATUS has value: 0x%x",v); + MMA8452_DBG(" 7 ZYXOW: %d",(v&0x80)>>7); + MMA8452_DBG(" 6 ZOW: %d", (v&0x40)>>6); + MMA8452_DBG(" 5 YOW: %d", (v&0x20)>>5); + MMA8452_DBG(" 4 XOW: %d", (v&0x10)>>4); + MMA8452_DBG(" 3 ZYXDR: %d",(v&0x08)>>3); + MMA8452_DBG(" 2 ZDR: %d", (v&0x04)>>2); + MMA8452_DBG(" 1 YDR: %d", (v&0x02)>>1); + MMA8452_DBG(" 0 XDR: %d", (v&0x01)); + break; + + default: + MMA8452_DBG("Unknown register address: 0x%x",reg); + break; + } +} +#endif \ No newline at end of file
diff -r 000000000000 -r bbda88bee65a MMA8452.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/MMA8452.h Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,344 @@ +#pragma once + +// Authors: Ashley Mills, Nicholas Herriot +/* Copyright (c) 2013 Vodafone, MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software + * and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or + * substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +// the SparkFun breakout board defaults to 1, set to 0 if SA0 jumper on the bottom of the board is set +// see the Table 10. I2C Device Address Sequence in Freescale MMA8452Q pdf + +#include "mbed.h" + +#define MMA8452_DEBUG 1 + +// More info on MCU Master address can be found on section 5.10.1 of http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=MMA8452Q +#define SA0 1 +#if SA0 + #define MMA8452_ADDRESS 0x3A // 0x1D<<1 // SA0 is high, 0x1C if low - +#else + #define MMA8452_ADDRESS 0x38 // 0x1C<<1 +#endif + +// Register descriptions found in section 6 of pdf +#define MMA8452_STATUS 0x00 // Type 'read' : Status of the data registers +#define MMA8452_OUT_X_MSB 0x01 // Type 'read' : x axis - MSB of 2 byte sample +#define MMA8452_OUT_X_LSB 0x02 // Type 'read' : x axis - LSB of 2 byte sample +#define MMA8452_OUT_Y_MSB 0x03 // Type 'read' : y axis - MSB of 2 byte sample +#define MMA8452_OUT_Y_LSB 0x04 // Type 'read' : y axis - LSB of 2 byte sample +#define MMA8452_OUT_Z_MSB 0x05 // Type 'read' : z axis - MSB of 2 byte sample +#define MMA8452_OUT_Z_LSB 0x06 // Type 'read' : z axis - LSB of 2 byte sample + +// register definitions +#define MMA8452_XYZ_DATA_CFG 0x0E + +#define MMA8452_SYSMOD 0x0B // Type 'read' : This tells you if device is active, sleep or standy 0x00=STANDBY 0x01=WAKE 0x02=SLEEP +#define MMA8452_WHO_AM_I 0x0D // Type 'read' : This should return the device id of 0x2A + +#define MMA8452_PL_STATUS 0x10 // Type 'read' : This shows portrait landscape mode orientation +#define MMA8452_PL_CFG 0x11 // Type 'read/write' : This allows portrait landscape configuration +#define MMA8452_PL_COUNT 0x12 // Type 'read' : This is the portraint landscape debounce counter +#define MMA8452_PL_BF_ZCOMP 0x13 // Type 'read' : +#define MMA8452_PL_THS_REG 0x14 // Type 'read' : + +#define MMA8452_FF_MT_CFG 0X15 // Type 'read/write' : Freefaul motion functional block configuration +#define MMA8452_FF_MT_SRC 0X16 // Type 'read' : Freefaul motion event source register +#define MMA8452_FF_MT_THS 0X17 // Type 'read' : Freefaul motion threshold register +#define MMA8452_FF_COUNT 0X18 // Type 'read' : Freefaul motion debouce counter + +#define MMA8452_ASLP_COUNT 0x29 // Type 'read/write' : Counter settings for auto sleep +#define MMA8452_CTRL_REG_1 0x2A // Type 'read/write' : +#define MMA8452_CTRL_REG_2 0x2B // Type 'read/write' : +#define MMA8452_CTRL_REG_3 0x2C // Type 'read/write' : +#define MMA8452_CTRL_REG_4 0x2D // Type 'read/write' : +#define MMA8452_CTRL_REG_5 0x2E // Type 'read/write' : + +// Defined in table 13 of the Freescale PDF +/// xxx these all need to have better names +#define STANDBY 0x00 // State value returned after a SYSMOD request, it can be in state STANDBY, WAKE or SLEEP +#define WAKE 0x01 // State value returned after a SYSMOD request, it can be in state STANDBY, WAKE or SLEEP +#define SLEEP 0x02 // State value returned after a SYSMOD request, it can be in state STANDBY, WAKE or SLEEP +#define ACTIVE 0x01 // Stage value returned and set in Control Register 1, it can be STANDBY=00, or ACTIVE=01 + +#define TILT_STATUS 0x03 // Tilt Status (Read only) +#define SRST_STATUS 0x04 // Sample Rate Status Register (Read only) +#define SPCNT_STATUS 0x05 // Sleep Count Register (Read/Write) +#define INTSU_STATUS 0x06 // Interrupt Setup Register +#define MODE_STATUS 0x07 // Mode Register (Read/Write) +#define SR_STATUS 0x08 // Auto-Wake and Active Mode Portrait/Landscape Samples per Seconds Register (Read/Write) +#define PDET_STATUS 0x09 // Tap/Pulse Detection Register (Read/Write) +#define PD_STATUS 0xA // Tap/Pulse Debounce Count Register (Read/Write) + +// masks for enabling/disabling standby +#define MMA8452_ACTIVE_MASK 0x01 +#define MMA8452_STANDBY_MASK 0xFE + +// mask for dynamic range reading and writing +#define MMA8452_DYNAMIC_RANGE_MASK 0xFC + +// mask and shift for data rate reading and writing +#define MMA8452_DATA_RATE_MASK 0xC7 +#define MMA8452_DATA_RATE_MASK_SHIFT 0x03 + +// mask and shift for general reading and writing +#define MMA8452_WRITE_MASK 0xFE +#define MMA8452_READ_MASK 0x01 + +// mask and shift for bit depth reading and writing +#define MMA8452_BIT_DEPTH_MASK 0xFD +#define MMA8452_BIT_DEPTH_MASK_SHIFT 0x01 + +// status masks and shifts +#define MMA8452_STATUS_ZYXDR_MASK 0x08 +#define MMA8452_STATUS_ZDR_MASK 0x04 +#define MMA8452_STATUS_YDR_MASK 0x02 +#define MMA8452_STATUS_XDR_MASK 0x01 + +/** + * Wrapper for the MMA8452 I2C driven accelerometer. + */ +class MMA8452 { + + public: + + enum DynamicRange { + DYNAMIC_RANGE_2G=0x00, + DYNAMIC_RANGE_4G, + DYNAMIC_RANGE_8G, + DYNAMIC_RANGE_UNKNOWN + }; + + enum BitDepth { + BIT_DEPTH_12=0x00, + BIT_DEPTH_8, // 1 sets fast read mode, hence the inversion + BIT_DEPTH_UNKNOWN + }; + + enum DataRateHz { + RATE_800=0x00, + RATE_400, + RATE_200, + RATE_100, + RATE_50, + RATE_12_5, + RATE_6_25, + RATE_1_563, + RATE_UNKNOWN + }; + + /** + * Create an accelerometer object connected to the specified I2C pins. + * + * @param sda I2C data port + * @param scl I2C clock port + * @param frequency + * + */ + MMA8452(PinName sda, PinName scl, int frequency); + + /// Destructor + ~MMA8452(); + + /** + * Puts the MMA8452 in active mode. + * @return 0 on success, 1 on failure. + */ + int activate(); + + /** + * Puts the MMA8452 in standby. + * @return 0 on success, 1 on failure. + */ + int standby(); + + /** + * Read the device ID from the accelerometer (should be 0x2a) + * + * @param dst pointer to store the ID + * @return 0 on success, 1 on failure. + */ + int getDeviceID(char* dst); + + /** + * Read the MMA8452 status register. + * + * @param dst pointer to store the register value. + * @ return 0 on success, 1 on failure. + */ + int getStatus(char* dst); + + /** + * Read the raw x, y, an z registers of the MMA8452 in one operation. + * All three registers are read sequentially and stored in the provided buffer. + * The stored values are signed 2's complement left-aligned 12 or 8 bit integers. + * + * @param dst The destination buffer. Note that this needs to be 3 bytes for + * BIT_DEPTH_8 and 6 bytes for BIT_DEPTH_12. It is upto the caller to ensure this. + * @return 0 for success, and 1 for failure + * @sa setBitDepth + */ + int readXYZRaw(char *dst); + + /// Read the raw x register into the provided buffer. @sa readXYZRaw + int readXRaw(char *dst); + /// Read the raw y register into the provided buffer. @sa readXYZRaw + int readYRaw(char *dst); + /// Read the raw z register into the provided buffer. @sa readXYZRaw + int readZRaw(char *dst); + + /** + * Read the x, y, and z signed counts of the MMA8452 axes. + * + * Count resolution is either 8 bits or 12 bits, and the range is either +-2G, +-4G, or +-8G + * depending on settings. The number of counts per G are 1024, 512, 256 for 2,4, and 8 G + * respectively at 12 bit resolution and 64, 32, 16 for 2, 4, and 8 G respectively at + * 8 bit resolution. + * + * This function queries the MMA8452 and returns the signed counts for each axes. + * + * @param x Pointer to integer to store x count + * @param y Pointer to integer to store y count + * @param z Pointer to integer to store z count + * @return 0 on success, 1 on failure. + */ + int readXYZCounts(int *x, int *y, int *z); + + /// Read the x axes signed count. @sa readXYZCounts + int readXCount(int *x); + /// Read the y axes signed count. @sa readXYZCounts + int readYCount(int *y); + /// Read the z axes signed count. @sa readXYZCounts + int readZCount(int *z); + + /** + * Read the x, y, and z accelerations measured in G. + * + * The measurement resolution is controlled via setBitDepth which can + * be 8 or 12, and by setDynamicRange, which can be +-2G, +-4G, or +-8G. + * + * @param x A pointer to the double to store the x acceleration in. + * @param y A pointer to the double to store the y acceleration in. + * @param z A pointer to the double to store the z acceleration in. + * + * @return 0 on success, 1 on failure. + */ + int readXYZGravity(double *x, double *y, double *z); + + /// Read the x gravity in G into the provided double pointer. @sa readXYZGravity + int readXGravity(double *x); + /// Read the y gravity in G into the provided double pointer. @sa readXYZGravity + int readYGravity(double *y); + /// Read the z gravity in G into the provided double pointer. @sa readXYZGravity + int readZGravity(double *z); + + /// Returns 1 if data has been internally sampled (is available) for all axes since last read, 0 otherwise. + int isXYZReady(); + /// Returns 1 if data has been internally sampled (is available) for the x-axis since last read, 0 otherwise. + int isXReady(); + /// Returns 1 if data has been internally sampled (is available) for the y-axis since last read, 0 otherwise. + int isYReady(); + /// Returns 1 if data has been internally sampled (is available) for the z-axis since last read, 0 otherwise. + int isZReady(); + + /** + * Reads a single byte from the specified MMA8452 register. + * + * @param addr The internal register address. + * @param dst The destination buffer address. + * @return 1 on success, 0 on failure. + */ + int readRegister(char addr, char *dst); + + /** + * Reads n bytes from the specified MMA8452 register. + * + * @param addr The internal register address. + * @param dst The destination buffer address. + * @param nbytes The number of bytes to read. + * @return 1 on success, 0 on failure. + */ + int readRegister(char addr, char *dst, int nbytes); + + /** + * Write to the specified MMA8452 register. + * + * @param addr The internal register address + * @param data Data byte to write + */ + int writeRegister(char addr, char data); + + /** + * Write a data buffer to the specified MMA8452 register. + * + * @param addr The internal register address + * @param data Pointer to data buffer to write + * @param nbytes The length of the data buffer to write + */ + int writeRegister(char addr, char *data, int nbytes); + + int setDynamicRange(DynamicRange range, int toggleActivation=1); + int setBitDepth(BitDepth depth, int toggleActivation=1); + int setDataRate(DataRateHz dataRate, int toggleActivation=1); + + DynamicRange getDynamicRange(); + DataRateHz getDataRate(); + BitDepth getBitDepth(); + + #ifdef MMA8452_DEBUG + void debugRegister(char reg); + #endif + + private: + /** + * Reads the specified register, applies the mask with logical AND, logical ORs the value + * and writes back the result to the register. If toggleActivation is set to true then the + * device is put in standby before the operation, and activated at the end. + * Setting it to false is useful for setting options on a device that you want to keep in + * standby. + */ + int maskAndApplyRegister(char reg, char mask, char value, int toggleActivation); + + /// Reads the specified register, applies the mask with logical AND, and writes the result back. + int logicalANDRegister(char addr, char mask); + /// Reads the specified register, applies the mask with logical OR, and writes the result back. + int logicalORRegister(char addr, char mask); + /// Reads the specified register, applies the mask with logical XOR, and writes the result back. + int logicalXORRegister(char addr, char mask); + + /// Converts the 12-bit two's complement number in buf to a signed integer. Returns the integer. + int twelveBitToSigned(char *buf); + /// Converts the 8-bit two's complement number in buf to a signed integer. Returns the integer. + int eightBitToSigned(char *buf); + + /// Converts a count to a gravity using the supplied countsPerG. Returns the gravity. + double convertCountToGravity(int count, int countsPerG); + + /// Reads the register at addr, applies the mask with logical AND, and returns the result. + char getMaskedRegister(int addr, char mask); + + /// Get the counts per G for the current settings of bit depth and dynamic range. + int getCountsPerG(); + + I2C _i2c; + int _frequency; + int _readAddress; + int _writeAddress; + + BitDepth _bitDepth; + DynamicRange _dynamicRange; +}; + \ No newline at end of file
diff -r 000000000000 -r bbda88bee65a PinDetect.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/PinDetect.lib Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/AjK/code/PinDetect/#cb3afc45028b
diff -r 000000000000 -r bbda88bee65a Speaker.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Speaker.h Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,19 @@ +#include "mbed.h" +// new class to play a note on Speaker based on PwmOut class +class Speaker +{ +public: + Speaker(PinName pin) : _pin(pin) { +// _pin(pin) means pass pin to the Speaker Constructor + } +// class method to play a note based on PwmOut class + void PlayNote(float frequency, float duration, float volume) { + _pin.period(1.0/frequency); + _pin = volume/2.0; + wait(duration); + _pin = 0.0; + } + +private: + PwmOut _pin; +}; \ No newline at end of file
diff -r 000000000000 -r bbda88bee65a TMP36.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TMP36.h Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,31 @@ +#include "mbed.h" + +//Setup a new class for TMP36 sensor +class TMP36 +{ +public: + TMP36(PinName pin); + TMP36(); + operator float (); + float read(); +private: +//class sets up the AnalogIn pin + AnalogIn _pin; +}; + +TMP36::TMP36(PinName pin) : _pin(pin) +{ +// _pin(pin) means pass pin to the AnalogIn constructor +} + +float TMP36::read() +{ +//convert sensor reading to temperature in degrees C + return ((_pin.read()*3.3)-0.500)*100.0; +} +//overload of float conversion (avoids needing to type .read() in equations) +TMP36::operator float () +{ +//convert sensor reading to temperature in degrees C + return ((_pin.read()*3.3)-0.500)*100.0; +} \ No newline at end of file
diff -r 000000000000 -r bbda88bee65a main.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/main.cpp Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,197 @@ +#include "mbed.h" +#define WHITE 0xFFFFFF +#include <stdlib.h> +#include <time.h> +#include "PinDetect.h" +#include "uLCD_4DGL.h" +#include "TMP36.h" +//#include "Die.h" +#include "FarkleGame.h" +#include "MMA8452.h" +#include <cmath> +#include "Speaker.h" +#include <sstream> +//------------------------Initial Declarations--------------------------------// +Speaker mySpeaker(p26); +PinDetect pb1(p25); +PinDetect pb2(p24); +PinDetect pb3(p23); +Serial pc(USBTX,USBRX); +MMA8452 acc(p28,p27,40000); +uLCD_4DGL uLCD(p9, p10, p11); +TMP36 myTMP36(p15); +enum Inputs{buttonA,buttonB,buttonC,shake,none}; +enum States{Initial,Display,Roll}; +volatile Inputs input=none; +volatile States currState=Initial; + +void pb1_pressed(void){ + input=buttonA; + } +void pb2_pressed(void){ + input=buttonB; + + } +void pb3_pressed(void){ + input=buttonC; + } + +void setupAccelerometer(){ + acc.setBitDepth(MMA8452::BIT_DEPTH_12); + acc.setDynamicRange(MMA8452::DYNAMIC_RANGE_4G); + acc.setDataRate(MMA8452::RATE_100); + } + + +//---------------------------------------------------------------------------// +int main() { + int seedAssist; + seedAssist = static_cast <int> (10000*myTMP36.read())%12344; + srand(time(0)+seedAssist); + //-------------------------// + FarkleGame Farkle; + + //-------------------------// + pb1.mode(PullUp); + wait(.01); + pb1.attach_deasserted(&pb1_pressed); + pb1.setSampleFrequency(); + + pb2.mode(PullUp); + wait(.01); + pb2.attach_deasserted(&pb2_pressed); + pb2.setSampleFrequency(); + + pb3.mode(PullUp); + wait(.01); + pb3.attach_deasserted(&pb3_pressed); + pb3.setSampleFrequency(); + + //--------------------------// + + int turnScore=0; + + for( ; ; ){ + switch(currState){ + //----------------------------------------------------------------// + case(Initial):{ + uLCD.color(WHITE); + Farkle.startGame(); + //---------------Reading from accelerometer-----------------------// + while(currState==Initial){ + double x=0.0l; + double y=0.0l; + double z=0.0l; + if (!acc.isXYZReady()) { + wait(0.01); + } else { + acc.readXYZGravity(&x,&y,&z); + } + if ((fabs(x)>1.5)||(fabs(y)>1.5)) { + input=shake; + + + } + //--------------Changing states based on input------------// + if (input==buttonA){ + currState=Initial; + input=none; + } + else if (input==buttonB){ + Farkle.changeDieArray(); + Farkle.startGame(); + currState=Initial; + input=none; + } + else if (input==buttonC){ + currState=Initial; + input=none; + } + else if (input==shake){ + currState=Roll; + input=none; + } + else if (input==none){ + currState=Initial; + input=none; + } + } + + continue; + } + //----------------------------------------------------------------// + case(Roll):{ + int numarray[7]={};//create an array keeping track of how many of each number there are for numbers on die faces + uLCD.cls();//clear screen + int tempScore; + mySpeaker.PlayNote(300.0,0.01,0.005); //make a sound + + for(int i=0;i<6;i++){ + int number=0; + if((Farkle.getDieArray())[i].getCurrDieState()==ROLL){//create the numarray based on die face numbers + (Farkle.getDieArray())[i].rollDie(); + (Farkle.getDieArray())[i].drawDie(); + number=(Farkle.getDieArray())[i].getValue(); + numarray[number]+=1; + } + } + tempScore=Farkle.calcScore(numarray);//use calculate score function to make a tempscore that will be added to turnscore + if (tempScore==0){ + turnScore=0; + uLCD.color(WHITE); + uLCD.text_width(2); + uLCD.text_height(2); + uLCD.locate(1,6); + uLCD.printf("FARKLE");//if score==0 we have a farkle + } + else{ + turnScore+=tempScore; + uLCD.color(WHITE); + uLCD.text_width(1); + uLCD.text_height(1); + uLCD.locate(0,11); + uLCD.printf("Roll Score: %d", tempScore); + uLCD.printf("\nTurn Score: %d", turnScore); + } + //------------change states based on input---------------------// + while(currState==Roll){ + if (input==buttonC){ + currState=Initial; + input=none; + } + if (input==buttonA){ + currState=Display; + input=none; + } + } + + continue; + } + case(Display):{ + uLCD.cls(); + Farkle.setScore(turnScore);//set farkle score data member to turnScore + Farkle.printScore();//print the score + for(int i=0;i<6;i++){//reset all die to be rollable if any are currently removed + (Farkle.getDieArray())[i].setCurrDieState(ROLL); + } + //----------change state based on inputs----------------------// + while(currState==Display){ + if(input==buttonA){ + turnScore=0; + currState=Initial; + input=none; + } + else{ + currState=Display; + + } + } + continue; + } + } + } + + + + +}
diff -r 000000000000 -r bbda88bee65a mbed-os.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed-os.lib Mon Mar 28 18:44:30 2022 +0000 @@ -0,0 +1,1 @@ +https://github.com/ARMmbed/mbed-os/#cf4f12a123c05fcae83fc56d76442015cb8a39e9
diff -r 000000000000 -r bbda88bee65a resources/official_armmbed_example_badge.png Binary file resources/official_armmbed_example_badge.png has changed