FrznChess/chessmcu
FrznChess/chessmcu
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

style: implement clang-format styling parameters

Browse source
This commit is contained in:
A.M. Rowsell 2026-09-22 02:06:49 -04:00
commit f2ce83335c
Signed by: amr
GPG key ID: E0879EDBDB0CA7B1
10 changed files with 462 additions and 547 deletions
Download patch file Download diff file Expand all files Collapse all files

11
.clang-format Normal file
View file

@ -0,0 +1,11 @@
BasedOnStyle: LLVM
IndentWidth: 4
TabWidth: 4
UseTab: Never
PointerAlignment: Right
ReferenceAlignment: Right
SpaceBeforeParens: Never
BreakBeforeBraces: Attach
AccessModifierOffset: -2
AllowShortFunctionsOnASingleLine: Inline
ColumnLimit: 120

31
Board.cpp
View file

@ -36,8 +36,7 @@ Board::Board() {
boardGrid[i].resize(8); boardGrid[i].resize(8);
} }
Board::~Board() { Board::~Board() {}
}
void Board::setupInitialPosition() { void Board::setupInitialPosition() {
// set up the board grid with smart pointers // set up the board grid with smart pointers
@ -99,7 +98,6 @@ void Board::clearBoard() {
} }
} }
int Board::setupFromFEN(std::string strFEN) { int Board::setupFromFEN(std::string strFEN) {
std::vector<std::string> splitFEN = split(strFEN, ' '); std::vector<std::string> splitFEN = split(strFEN, ' ');
if(splitFEN.size() != 6) // a valid FEN *must* contain 6 fields if(splitFEN.size() != 6) // a valid FEN *must* contain 6 fields
@ -201,7 +199,7 @@ int Board::setupFromFEN(std::string strFEN) {
case '8': { case '8': {
std::string skipStr(1, sym); std::string skipStr(1, sym);
skip = atoi(skipStr.c_str()); skip = atoi(skipStr.c_str());
//skip--; // fix off by 1 error // skip--; // fix off by 1 error
while(skip--) { while(skip--) {
boardGrid[rank][file++] = nullptr; // remove reference boardGrid[rank][file++] = nullptr; // remove reference
} }
@ -267,17 +265,17 @@ int Board::setupFromFEN(std::string strFEN) {
// ====== END OF FIELD 3 ====== // ====== END OF FIELD 3 ======
// ====== START OF FIELD 4 ====== // ====== START OF FIELD 4 ======
// if a pawn has just moved and can be attacked enPassant, it will be listed here // if a pawn has just moved and can be attacked enPassant, it will be listed here
//#ifdef DEBUG // #ifdef DEBUG
// for(auto &ranks : boardGrid) { // for(auto &ranks : boardGrid) {
// for(auto &files : ranks) { // for(auto &files : ranks) {
// if(files) // if(files)
// std::cout << files->getPieceName() << " "; // std::cout << files->getPieceName() << " ";
// else // else
// std::cout << "E "; // std::cout << "E ";
// } // }
// std::cout << "\n"; // std::cout << "\n";
// } // }
//#endif // #endif
return 0; return 0;
} }
@ -289,7 +287,8 @@ void Board::nextTurn() {
void Board::movePiece(Square from, Square to) { void Board::movePiece(Square from, Square to) {
Piece *movingPiece = getPieceAt(from); Piece *movingPiece = getPieceAt(from);
if(!movingPiece) return; if(!movingPiece)
return;
Square newEnPassantTarget = {INVALID_RANK, INVALID_FILE}; Square newEnPassantTarget = {INVALID_RANK, INVALID_FILE};

47
Piece.cpp
View file

@ -91,7 +91,8 @@ std::vector<Move> King::getLegalMoves(const Square &from, Board &board) const {
const Piece *target = board.getPieceAt(targetSquare); // examine the target square const Piece *target = board.getPieceAt(targetSquare); // examine the target square
if(!target) { // if square is empty (nullptr) if(!target) { // if square is empty (nullptr)
moveList.push_back({from, targetSquare}); // then it's potentially a legal move moveList.push_back({from, targetSquare}); // then it's potentially a legal move
} else if(target && target->getColour() != this->getColour()) { // if it's occupied with a piece of opposite colour } else if(target &&
target->getColour() != this->getColour()) { // if it's occupied with a piece of opposite colour
moveList.push_back({from, targetSquare}); // then again it's potentially legal moveList.push_back({from, targetSquare}); // then again it's potentially legal
break; break;
} else { } else {
@ -149,12 +150,14 @@ std::vector<Move> King::getLegalMoves(const Square &from, Board &board) const {
// we are being attacked by a knight, so remove it // we are being attacked by a knight, so remove it
moves.to.rank = INVALID_RANK; moves.to.rank = INVALID_RANK;
moves.to.file = INVALID_FILE; moves.to.file = INVALID_FILE;
} else if((target->getPieceType() == ROOK || target->getPieceType() == QUEEN) && (!diagonal && !knight)) { } else if((target->getPieceType() == ROOK || target->getPieceType() == QUEEN) &&
(!diagonal && !knight)) {
// again, being attacked, remove it // again, being attacked, remove it
moves.to.rank = INVALID_RANK; moves.to.rank = INVALID_RANK;
moves.to.file = INVALID_FILE; moves.to.file = INVALID_FILE;
} }
if(target->getPieceType() == PAWN && (abs(r - startSquare.rank) == 1 && abs(f - startSquare.file) == 1)) { if(target->getPieceType() == PAWN &&
(abs(r - startSquare.rank) == 1 && abs(f - startSquare.file) == 1)) {
moves.to.rank = INVALID_RANK; moves.to.rank = INVALID_RANK;
moves.to.file = INVALID_FILE; moves.to.file = INVALID_FILE;
} }
@ -173,11 +176,7 @@ std::vector<Move> King::getLegalMoves(const Square &from, Board &board) const {
} }
} }
// will this actually work? // will this actually work?
moveList.erase( moveList.erase(std::remove_if(moveList.begin(), moveList.end(), [&](const auto &x) { return !x.to.isValid(); }));
std::remove_if(moveList.begin(), moveList.end(),
[&](const auto & x) {
return !x.to.isValid();
}));
return moveList; return moveList;
} }
@ -249,10 +248,11 @@ std::vector<Move> Queen::getLegalMoves(const Square &from, Board &board) const {
int f = from.file + dir[1]; int f = from.file + dir[1];
while(r >= 0 && r < 8 && f >= 0 && f < 8) { while(r >= 0 && r < 8 && f >= 0 && f < 8) {
Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)}; Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)};
const Piece *target = board.getPieceAt(targetSquare);// examine the target square const Piece *target = board.getPieceAt(targetSquare); // examine the target square
if(!target) { // if square is empty (NULL) if(!target) { // if square is empty (NULL)
moveList.push_back({from, targetSquare}); // then it's potentially a legal move moveList.push_back({from, targetSquare}); // then it's potentially a legal move
} else if(target && target->getColour() != this->getColour()) { // if it's occupied with a piece of opposite colour } else if(target &&
target->getColour() != this->getColour()) { // if it's occupied with a piece of opposite colour
moveList.push_back({from, targetSquare}); // then again it's potentially legal moveList.push_back({from, targetSquare}); // then again it's potentially legal
break; break;
} else { } else {
@ -280,16 +280,7 @@ std::vector<Move> Queen::getLegalMoves(const Square &from, Board &board) const {
std::vector<Move> Knight::getLegalMoves(const Square &from, Board &board) const { std::vector<Move> Knight::getLegalMoves(const Square &from, Board &board) const {
std::vector<Move> moveList; std::vector<Move> moveList;
std::vector<std::vector<int>> directions = { std::vector<std::vector<int>> directions = {{-1, -2}, {-1, 2}, {-2, -1}, {-2, 1}, {1, -2}, {1, 2}, {2, -1}, {2, 1}};
{-1, -2},
{-1, 2},
{-2, -1},
{-2, 1},
{1, -2},
{1, 2},
{2, -1},
{2, 1}
};
for(auto &dir : directions) { for(auto &dir : directions) {
int r = from.rank + dir[0]; int r = from.rank + dir[0];
int f = from.file + dir[1]; int f = from.file + dir[1];
@ -358,8 +349,7 @@ std::vector<Move> Bishop::getLegalMoves(const Square &from, Board &board) const
std::vector<Move> Pawn::getLegalMoves(const Square &from, Board &board) const { std::vector<Move> Pawn::getLegalMoves(const Square &from, Board &board) const {
std::vector<Move> moveList; std::vector<Move> moveList;
const int directions[2][4][2] = { const int directions[2][4][2] = {{
{
// black // black
{-1, 0}, // Up {-1, 0}, // Up
{-2, 0}, // 2up first move {-2, 0}, // 2up first move
@ -372,19 +362,21 @@ std::vector<Move> Pawn::getLegalMoves(const Square &from, Board &board) const {
{2, 0}, // 2down first move {2, 0}, // 2down first move
{1, 1}, // attack to right {1, 1}, // attack to right
{1, -1} // attack to left {1, -1} // attack to left
} }};
};
if(this->getColour() == PIECE_BLACK) { if(this->getColour() == PIECE_BLACK) {
// go through black options // go through black options
for(auto &dir : directions[0]) { for(auto &dir : directions[0]) {
int r = from.rank + dir[0]; int r = from.rank + dir[0];
int f = from.file + dir[1]; int f = from.file + dir[1];
if(r >= 0 && r < 8 && f >= 0 && f < 8) { // no need for a while loop as we only have finite moves in limited directions if(r >= 0 && r < 8 && f >= 0 &&
f < 8) { // no need for a while loop as we only have finite moves in limited directions
Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)}; Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)};
const Piece *target = board.getPieceAt(targetSquare); const Piece *target = board.getPieceAt(targetSquare);
if(dir[0] == -2 && !this->checkIfMoved()) { if(dir[0] == -2 && !this->checkIfMoved()) {
// then 2 is potentially legal // then 2 is potentially legal
if(!target && board.isSquareEmpty(Square{static_cast<Rank>(r + 1), static_cast<File>(f)})) // check both squares for pieces of any colour if(!target &&
board.isSquareEmpty(Square{static_cast<Rank>(r + 1),
static_cast<File>(f)})) // check both squares for pieces of any colour
moveList.push_back({from, targetSquare}); moveList.push_back({from, targetSquare});
else else
continue; continue;
@ -410,7 +402,8 @@ std::vector<Move> Pawn::getLegalMoves(const Square &from, Board &board) const {
// go through white options // go through white options
int r = from.rank + dir[0]; int r = from.rank + dir[0];
int f = from.file + dir[1]; int f = from.file + dir[1];
if(r >= 0 && r < 8 && f >= 0 && f < 8) { // no need for a while loop as we only have finite moves in limited directions if(r >= 0 && r < 8 && f >= 0 &&
f < 8) { // no need for a while loop as we only have finite moves in limited directions
Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)}; Square targetSquare{static_cast<Rank>(r), static_cast<File>(f)};
const Piece *target = board.getPieceAt(targetSquare); const Piece *target = board.getPieceAt(targetSquare);
if(dir[0] == 2 && !this->checkIfMoved()) { if(dir[0] == 2 && !this->checkIfMoved()) {

119
graphics.cpp
View file

@ -1,90 +1,63 @@
#include <cstdint> #include <cstdint>
#include <vector>
#include <memory> #include <memory>
#include <vector>
/* Chess_Queen_White */ /* Chess_Queen_White */
#define Chess_Queen_White_width 45 #define Chess_Queen_White_width 45
#define Chess_Queen_White_height 45 #define Chess_Queen_White_height 45
const uint8_t Chess_Queen_White_bits[] = { const uint8_t Chess_Queen_White_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x60, 0xf0, 0xc1, 0x00, 0x00, 0x00, 0xf0, 0x90, 0xe1, 0x01, 0x00, 0x00, 0x98, 0x91, 0x31, 0x03, 0x00,
0x00, 0x60, 0xf0, 0xc1, 0x00, 0x00, 0x00, 0xf0, 0x90, 0xe1, 0x01, 0x00, 0x60, 0x98, 0xf1, 0x31, 0xc3, 0x00, 0xf0, 0xf0, 0xe0, 0xe0, 0xe1, 0x01, 0x98, 0x61, 0x60, 0xe0, 0x30, 0x03,
0x00, 0x98, 0x91, 0x31, 0x03, 0x00, 0x60, 0x98, 0xf1, 0x31, 0xc3, 0x00, 0x98, 0xe1, 0x60, 0x60, 0x30, 0x03, 0xf0, 0xe0, 0xe0, 0x60, 0xe0, 0x01, 0xe0, 0xe0, 0xe0, 0x70, 0xe0, 0x00,
0xf0, 0xf0, 0xe0, 0xe0, 0xe1, 0x01, 0x98, 0x61, 0x60, 0xe0, 0x30, 0x03, 0xc0, 0xe0, 0xb1, 0x70, 0x70, 0x00, 0xc0, 0xe1, 0xb1, 0x50, 0x38, 0x00, 0xc0, 0x63, 0xb1, 0x59, 0x38, 0x00,
0x98, 0xe1, 0x60, 0x60, 0x30, 0x03, 0xf0, 0xe0, 0xe0, 0x60, 0xe0, 0x01, 0x80, 0x62, 0x93, 0xc9, 0x3c, 0x00, 0x80, 0x66, 0x93, 0xcd, 0x36, 0x00, 0x80, 0x6c, 0x1e, 0xcd, 0x36, 0x00,
0xe0, 0xe0, 0xe0, 0x70, 0xe0, 0x00, 0xc0, 0xe0, 0xb1, 0x70, 0x70, 0x00, 0x80, 0x6d, 0x1e, 0xc7, 0x13, 0x00, 0x80, 0x79, 0x0c, 0xc7, 0x11, 0x00, 0x00, 0x71, 0x0c, 0xc7, 0x19, 0x00,
0xc0, 0xe1, 0xb1, 0x50, 0x38, 0x00, 0xc0, 0x63, 0xb1, 0x59, 0x38, 0x00, 0x00, 0xf1, 0xff, 0xff, 0x19, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x1f, 0x00,
0x80, 0x62, 0x93, 0xc9, 0x3c, 0x00, 0x80, 0x66, 0x93, 0xcd, 0x36, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x06, 0xff, 0x1f, 0x0e, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
0x80, 0x6c, 0x1e, 0xcd, 0x36, 0x00, 0x80, 0x6d, 0x1e, 0xc7, 0x13, 0x00, 0x00, 0x18, 0x00, 0x80, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x01, 0x00,
0x80, 0x79, 0x0c, 0xc7, 0x11, 0x00, 0x00, 0x71, 0x0c, 0xc7, 0x19, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x06, 0x00,
0x00, 0xf1, 0xff, 0xff, 0x19, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
0x00, 0x0f, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x06, 0xff, 0x1f, 0x0e, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
0x00, 0x18, 0x00, 0x80, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0x01, 0x00,
0x00, 0xf8, 0xff, 0xff, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x03, 0x00,
0x00, 0x0c, 0x00, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x06, 0x00,
0x00, 0x0c, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x00,
0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/* Chess King White */ /* Chess King White */
#define Chess_King_White_width 45 #define Chess_King_White_width 45
#define Chess_King_White_height 45 #define Chess_King_White_height 45
const uint8_t Chess_King_White_bits[] = { const uint8_t Chess_King_White_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00,
0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00,
0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00,
0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x78, 0x08, 0xc2, 0x03, 0x00, 0x00, 0xff, 0x0f, 0xfe, 0x1f, 0x00, 0x80, 0x03, 0x0f, 0x1e, 0x38, 0x00,
0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0xc0, 0x00, 0x1c, 0x07, 0x60, 0x00, 0xc0, 0x00, 0x18, 0x03, 0x60, 0x00, 0x60, 0x00, 0xb0, 0x01, 0xc0, 0x00,
0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x78, 0x08, 0xc2, 0x03, 0x00, 0x60, 0x00, 0xe0, 0x00, 0xc0, 0x00, 0x60, 0x00, 0xe0, 0x00, 0xc0, 0x00, 0x60, 0x00, 0x40, 0x00, 0xc0, 0x00,
0x00, 0xff, 0x0f, 0xfe, 0x1f, 0x00, 0x80, 0x03, 0x0f, 0x1e, 0x38, 0x00, 0xc0, 0x00, 0x40, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x40, 0x00, 0x60, 0x00, 0x80, 0x01, 0x40, 0x00, 0x30, 0x00,
0xc0, 0x00, 0x1c, 0x07, 0x60, 0x00, 0xc0, 0x00, 0x18, 0x03, 0x60, 0x00, 0x00, 0x03, 0xfe, 0x0f, 0x18, 0x00, 0x00, 0xce, 0xff, 0x7f, 0x0e, 0x00, 0x00, 0xfc, 0x00, 0xe0, 0x07, 0x00,
0x60, 0x00, 0xb0, 0x01, 0xc0, 0x00, 0x60, 0x00, 0xe0, 0x00, 0xc0, 0x00, 0x00, 0x30, 0xf0, 0x81, 0x01, 0x00, 0x00, 0x90, 0xff, 0x3f, 0x01, 0x00, 0x00, 0xf0, 0x03, 0xf8, 0x01, 0x00,
0x60, 0x00, 0xe0, 0x00, 0xc0, 0x00, 0x60, 0x00, 0x40, 0x00, 0xc0, 0x00, 0x00, 0x70, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x10, 0xfe, 0x0f, 0x01, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x00,
0xc0, 0x00, 0x40, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x40, 0x00, 0x60, 0x00, 0x00, 0xf0, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x70, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xc0, 0x07, 0x7c, 0x00, 0x00,
0x80, 0x01, 0x40, 0x00, 0x30, 0x00, 0x00, 0x03, 0xfe, 0x0f, 0x18, 0x00, 0x00, 0x00, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xce, 0xff, 0x7f, 0x0e, 0x00, 0x00, 0xfc, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
0x00, 0x30, 0xf0, 0x81, 0x01, 0x00, 0x00, 0x90, 0xff, 0x3f, 0x01, 0x00,
0x00, 0xf0, 0x03, 0xf8, 0x01, 0x00, 0x00, 0x70, 0x00, 0xc0, 0x01, 0x00,
0x00, 0x10, 0xfe, 0x0f, 0x01, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x00,
0x00, 0xf0, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x70, 0x00, 0xc0, 0x01, 0x00,
0x00, 0xc0, 0x07, 0x7c, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/* Chess Rook White */ /* Chess Rook White */
#define Chess_Rook_White_width 45 #define Chess_Rook_White_width 45
#define Chess_Rook_White_height 45 #define Chess_Rook_White_height 45
const uint8_t Chess_Rook_White_bits[] = { const uint8_t Chess_Rook_White_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xf8, 0xe3, 0x07, 0x00, 0x00, 0xcc, 0x18, 0x63, 0x06, 0x00, 0x00, 0xcc, 0x1f, 0x7f, 0x06, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xf8, 0xe3, 0x07, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x06, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
0x00, 0xcc, 0x18, 0x63, 0x06, 0x00, 0x00, 0xcc, 0x1f, 0x7f, 0x06, 0x00, 0x00, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00,
0x00, 0x0c, 0x00, 0x00, 0x06, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00,
0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00,
0x00, 0xf0, 0xff, 0xff, 0x01, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00,
0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00,
0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x03, 0x00,
0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x03, 0x00,
0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00,
0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
0x00, 0x60, 0x00, 0xc0, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x00,
0x00, 0xf8, 0xff, 0xff, 0x03, 0x00, 0x00, 0x18, 0x00, 0x00, 0x03, 0x00,
0x00, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x03, 0x00,
0x00, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x03, 0x00, 0x00, 0x18, 0x00,
0x00, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

66
inc/Board.hpp
View file

@ -17,11 +17,11 @@
#ifndef BOARD_HPP #ifndef BOARD_HPP
#define BOARD_HPP #define BOARD_HPP
#include "Piece.hpp"
#include <cstdint> #include <cstdint>
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include "Piece.hpp"
class Piece; class Piece;
/** @enum Players /** @enum Players
@ -44,7 +44,8 @@ struct Square;
*/ */
class Board { class Board {
private: private:
std::vector<std::vector<std::unique_ptr<Piece>>> boardGrid; /**< This holds the game state. std::vector<std::vector<std::unique_ptr<Piece>>>
boardGrid; /**< This holds the game state.
* It is a 2D vector of Piece types, or nullptr for empty squares * It is a 2D vector of Piece types, or nullptr for empty squares
* @image html boardGrid.svg "Logical diagram of boardGrid vector" */ * @image html boardGrid.svg "Logical diagram of boardGrid vector" */
Players playerTurn; Players playerTurn;
@ -53,13 +54,9 @@ class Board {
// let's get super object-oriented, baby // let's get super object-oriented, baby
// these help the getters and setters access the boardGrid // these help the getters and setters access the boardGrid
// and also make them shorter and less duplicative // and also make them shorter and less duplicative
std::unique_ptr<Piece> &at(int r, int f) { std::unique_ptr<Piece> &at(int r, int f) { return boardGrid[r][f]; }
return boardGrid[r][f];
}
const std::unique_ptr<Piece> &at(int r, int f) const { const std::unique_ptr<Piece> &at(int r, int f) const { return boardGrid[r][f]; }
return boardGrid[r][f];
}
std::unique_ptr<Piece> &at(const Square &sq) { std::unique_ptr<Piece> &at(const Square &sq) {
return boardGrid[static_cast<int>(sq.rank)][static_cast<int>(sq.file)]; return boardGrid[static_cast<int>(sq.rank)][static_cast<int>(sq.file)];
@ -68,6 +65,7 @@ class Board {
const std::unique_ptr<Piece> &at(const Square &sq) const { const std::unique_ptr<Piece> &at(const Square &sq) const {
return boardGrid[static_cast<int>(sq.rank)][static_cast<int>(sq.file)]; return boardGrid[static_cast<int>(sq.rank)][static_cast<int>(sq.file)];
} }
public: public:
Board(); Board();
virtual ~Board(); virtual ~Board();
@ -75,52 +73,26 @@ class Board {
// These are to allow Piece to access Board in a controlled way // These are to allow Piece to access Board in a controlled way
// instead of adding a friend declaration for every subclass // instead of adding a friend declaration for every subclass
// ----- Getters ----- // ----- Getters -----
Piece *getPieceAt(int r, int f) { Piece *getPieceAt(int r, int f) { return at(r, f).get(); }
return at(r, f).get(); const Piece *getPieceAt(int r, int f) const { return at(r, f).get(); }
}
const Piece *getPieceAt(int r, int f) const {
return at(r, f).get();
}
Piece *getPieceAt(const Square &sq) { Piece *getPieceAt(const Square &sq) { return at(sq).get(); }
return at(sq).get(); const Piece *getPieceAt(const Square &sq) const { return at(sq).get(); }
} Square getEnPassantTargetSquare() const { return enPassantTargetSquare; }
const Piece *getPieceAt(const Square &sq) const {
return at(sq).get();
}
Square getEnPassantTargetSquare() const {
return enPassantTargetSquare;
}
// ----- Setters ----- // ----- Setters -----
void setPieceAt(int r, int f, std::unique_ptr<Piece> piece) { void setPieceAt(int r, int f, std::unique_ptr<Piece> piece) { at(r, f) = std::move(piece); }
at(r, f) = std::move(piece); void setPieceAt(const Square &sq, std::unique_ptr<Piece> piece) { at(sq) = std::move(piece); }
}
void setPieceAt(const Square &sq, std::unique_ptr<Piece> piece) {
at(sq) = std::move(piece);
}
void clearSquare(int r, int f) { void clearSquare(int r, int f) { at(r, f).reset(); }
at(r, f).reset(); void clearSquare(const Square &sq) { at(sq).reset(); }
}
void clearSquare(const Square &sq) {
at(sq).reset();
}
void setEnPassantTargetSquare(Square sq) { void setEnPassantTargetSquare(Square sq) { enPassantTargetSquare = sq; }
enPassantTargetSquare = sq; void clearEnPassantTargetSquare() { enPassantTargetSquare = {INVALID_RANK, INVALID_FILE}; }
}
void clearEnPassantTargetSquare() {
enPassantTargetSquare = {INVALID_RANK, INVALID_FILE};
}
// ----- Utility ----- // ----- Utility -----
bool isSquareEmpty(int r, int f) const { bool isSquareEmpty(int r, int f) const { return at(r, f) == nullptr; }
return at(r, f) == nullptr; bool isSquareEmpty(const Square &sq) const { return at(sq) == nullptr; }
}
bool isSquareEmpty(const Square &sq) const {
return at(sq) == nullptr;
}
/** A function to setup the initial board /** A function to setup the initial board
* *

5
inc/NeoPixel.hpp
View file

@ -13,9 +13,7 @@
class NeoPixel { class NeoPixel {
public: public:
NeoPixel(uint8_t stringLength) : length(stringLength) { NeoPixel(uint8_t stringLength) : length(stringLength) { gpioPin = LATBbits.LATB9; };
gpioPin = LATBbits.LATB9;
};
uint8_t setNeoPixel(uint8_t index, uint8_t red, uint8_t green, uint8_t blue); uint8_t setNeoPixel(uint8_t index, uint8_t red, uint8_t green, uint8_t blue);
void allPixelsOff(void); void allPixelsOff(void);
@ -27,4 +25,3 @@ class NeoPixel {
}; };
#endif // NEOPIXEL_HPP #endif // NEOPIXEL_HPP

84
inc/Piece.hpp
View file

@ -22,34 +22,24 @@
* it helps make it obvious what certain bits of code are doing. * it helps make it obvious what certain bits of code are doing.
*/ */
#include <cstdint>
#include <algorithm> #include <algorithm>
#include <utility> #include <cstdint>
#include <string>
#include <memory> #include <memory>
#include <string>
#include <utility>
#include <vector> #include <vector>
class Board; class Board;
enum PieceType { enum PieceType { PAWN, BISHOP, KNIGHT, ROOK, QUEEN, KING, EMPTY };
PAWN, BISHOP, KNIGHT, ROOK, QUEEN, KING, EMPTY
};
enum PieceColour { enum PieceColour { PIECE_WHITE, PIECE_BLACK, PIECE_EMPTY };
PIECE_WHITE, PIECE_BLACK, PIECE_EMPTY
};
enum Rank { enum Rank { R1 = 0, R2 = 1, R3 = 2, R4 = 3, R5 = 4, R6 = 5, R7 = 6, R8 = 7, INVALID_RANK = 255 };
R1 = 0, R2 = 1, R3 = 2, R4 = 3, R5 = 4, R6 = 5, R7 = 6, R8 = 7, INVALID_RANK = 255
};
enum File { enum File { A = 0, B = 1, C = 2, D = 3, E = 4, F = 5, G = 6, H = 7, INVALID_FILE = 255 };
A = 0, B = 1, C = 2, D = 3, E = 4, F = 5, G = 6, H = 7, INVALID_FILE = 255
};
enum CastleSide { enum CastleSide { KINGSIDE = 1, QUEENSIDE = 2 };
KINGSIDE = 1, QUEENSIDE = 2
};
/** @struct Square /** @struct Square
* A struct that represents a square on the chess board. * A struct that represents a square on the chess board.
@ -62,9 +52,7 @@ struct Square {
* A function to test if the square is a valid square on the chessboard * A function to test if the square is a valid square on the chessboard
* @return True if the square is within the chessboard, False otherwise * @return True if the square is within the chessboard, False otherwise
*/ */
bool isValid() const { bool isValid() const { return rank >= 0 && rank < 8 && file >= 0 && file < 8; }
return rank >= 0 && rank < 8 && file >= 0 && file < 8;
}
}; };
/** @struct Move /** @struct Move
* A struct representing the start and end squares of a Move. * A struct representing the start and end squares of a Move.
@ -84,40 +72,28 @@ struct Move {
class Piece { class Piece {
private: private:
friend class Board; friend class Board;
protected: protected:
PieceColour colour; PieceColour colour;
PieceType pieceType; PieceType pieceType;
std::string pieceName; /**< std::string pieceName is a string showing the full name of the piece, i.e. "PAWN" */ std::string pieceName; /**< std::string pieceName is a string showing the full name of the piece, i.e. "PAWN" */
std::string std::string pieceSymbol; /**< std::string pieceSymbol is a single character, using the standard algebraic chess
pieceSymbol; /**< std::string pieceSymbol is a single character, using the standard algebraic chess notation, ie N for Knight */ notation, ie N for Knight */
bool hasMoved = false; bool hasMoved = false;
public: public:
Piece(PieceColour pColour) : colour(pColour) {}
Piece(PieceColour pColour) : colour(pColour) {
}
virtual ~Piece(); virtual ~Piece();
PieceColour getColour() const { return colour; }
PieceColour getColour() const { std::string getPieceName() const { return pieceName; }
return colour;
}
std::string getPieceName() const { std::string getPieceSymbol() const { return pieceSymbol; }
return pieceName;
}
std::string getPieceSymbol() const { PieceType getPieceType() const { return pieceType; }
return pieceSymbol;
}
PieceType getPieceType() const { bool checkIfMoved() const { return hasMoved; }
return pieceType;
}
bool checkIfMoved() const {
return hasMoved;
}
/** /**
* A virtual const function that should get all legal moves for a piece, but it may * A virtual const function that should get all legal moves for a piece, but it may
* include some moves that need to be pruned, like those exposing the king to check. * include some moves that need to be pruned, like those exposing the king to check.
@ -130,14 +106,13 @@ class Piece {
virtual std::vector<Move> getLegalMoves(const Square &from, Board &board) const; virtual std::vector<Move> getLegalMoves(const Square &from, Board &board) const;
bool finalMoveChecks(std::vector<Move> *moveList, Board &board); bool finalMoveChecks(std::vector<Move> *moveList, Board &board);
}; };
class King : public Piece { class King : public Piece {
private: private:
friend class Board; friend class Board;
public:
public:
King(PieceColour colour) : Piece(colour) { King(PieceColour colour) : Piece(colour) {
pieceName = "King"; pieceName = "King";
pieceSymbol = "K"; pieceSymbol = "K";
@ -156,12 +131,9 @@ class King : public Piece {
return false; return false;
} }
void setCastleQS(bool canCastle) { void setCastleQS(bool canCastle) { canCastleQS = canCastle; }
canCastleQS = canCastle; void setCastleKS(bool canCastle) { canCastleKS = canCastle; }
}
void setCastleKS(bool canCastle) {
canCastleKS = canCastle;
}
protected: protected:
bool canCastleQS = true; bool canCastleQS = true;
bool canCastleKS = true; bool canCastleKS = true;
@ -170,8 +142,8 @@ class King : public Piece {
class Rook : public Piece { class Rook : public Piece {
friend class Board; friend class Board;
public:
public:
Rook(PieceColour colour) : Piece(colour) { Rook(PieceColour colour) : Piece(colour) {
pieceName = "Rook"; pieceName = "Rook";
pieceSymbol = "R"; pieceSymbol = "R";
@ -182,8 +154,8 @@ class Rook : public Piece {
class Queen : public Piece { class Queen : public Piece {
friend class Board; friend class Board;
public:
public:
Queen(PieceColour colour) : Piece(colour) { Queen(PieceColour colour) : Piece(colour) {
pieceName = "Queen"; pieceName = "Queen";
pieceSymbol = "Q"; pieceSymbol = "Q";
@ -194,8 +166,8 @@ class Queen : public Piece {
class Knight : public Piece { class Knight : public Piece {
friend class Board; friend class Board;
public:
public:
Knight(PieceColour colour) : Piece(colour) { Knight(PieceColour colour) : Piece(colour) {
pieceName = "Knight"; pieceName = "Knight";
pieceSymbol = "N"; pieceSymbol = "N";
@ -206,8 +178,8 @@ class Knight : public Piece {
class Bishop : public Piece { class Bishop : public Piece {
friend class Board; friend class Board;
public:
public:
Bishop(PieceColour colour) : Piece(colour) { Bishop(PieceColour colour) : Piece(colour) {
pieceName = "Bishop"; pieceName = "Bishop";
pieceSymbol = "B"; pieceSymbol = "B";
@ -218,8 +190,8 @@ class Bishop : public Piece {
class Pawn : public Piece { class Pawn : public Piece {
friend class Board; friend class Board;
public:
public:
Pawn(PieceColour colour) : Piece(colour) { Pawn(PieceColour colour) : Piece(colour) {
pieceName = "Pawn"; pieceName = "Pawn";
pieceSymbol = "P"; pieceSymbol = "P";
@ -227,8 +199,8 @@ class Pawn : public Piece {
} }
virtual std::vector<Move> getLegalMoves(const Square &from, Board &board) const override; virtual std::vector<Move> getLegalMoves(const Square &from, Board &board) const override;
void promote(const Square &promotionSquare, Board &board, PieceType promoteTo); void promote(const Square &promotionSquare, Board &board, PieceType promoteTo);
protected: protected:
bool firstMove = true; bool firstMove = true;
}; };
#endif // PIECE_HPP #endif // PIECE_HPP

11
inc/strFuncs.hpp
View file

@ -8,16 +8,13 @@
#ifndef STRFUNCS_HPP #ifndef STRFUNCS_HPP
#define STRFUNCS_HPP #define STRFUNCS_HPP
#include <string>
#include <sstream>
#include <vector>
#include <iterator> #include <iterator>
#include <sstream>
#include <string>
#include <vector>
template <typename Out> template <typename Out> void split(const std::string &s, char delim, Out result);
void split(const std::string &s, char delim, Out result);
std::vector<std::string> split(const std::string &s, char delim); std::vector<std::string> split(const std::string &s, char delim);
#endif /* STRFUNCS_HPP */ #endif /* STRFUNCS_HPP */

22
main.cpp
View file

@ -45,13 +45,13 @@
// #pragma config statements should precede project file includes. // #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF. // Use project enums instead of #define for ON and OFF.
#include <xc.h>
#include <sys/attribs.h> // for ISR macros #include <sys/attribs.h> // for ISR macros
#include <sys/kmem.h> #include <sys/kmem.h>
#include <xc.h>
#include "inc/Board.hpp" #include "inc/Board.hpp"
#include "inc/Piece.hpp"
#include "inc/NeoPixel.hpp" #include "inc/NeoPixel.hpp"
#include "inc/Piece.hpp"
#define F_CPU 12000000UL // 12MHz #define F_CPU 12000000UL // 12MHz
#define F_PER 6000000UL // 6MHz #define F_PER 6000000UL // 6MHz
@ -69,7 +69,8 @@ extern "C" int open(const char *buf, int flags, int mode) {
void sendChar(uint8_t c) { void sendChar(uint8_t c) {
U1TXREG = c; U1TXREG = c;
while(!U1STAbits.TRMT); // wait for transmission while(!U1STAbits.TRMT)
; // wait for transmission
return; return;
} }
@ -134,7 +135,7 @@ uint8_t initSystem(void) {
// clear all 4 DMA channel flags & IE // clear all 4 DMA channel flags & IE
IEC1CLR = 0xF0000000; IEC1CLR = 0xF0000000;
IFS1CLR = 0xF0000000; IFS1CLR = 0xF0000000;
DMACONbits.ON = 1; //enable DMA controller DMACONbits.ON = 1; // enable DMA controller
// === DMA Channel 1 Init (RX from SPI1BUF to spi_rx_buffer[]) === // === DMA Channel 1 Init (RX from SPI1BUF to spi_rx_buffer[]) ===
DCH0CON = 0; // Reset channel config DCH0CON = 0; // Reset channel config
DCH0ECON = 0; DCH0ECON = 0;
@ -157,8 +158,8 @@ void initInterrupts(void) {
INTCONbits.MVEC = 1; // Enable multi-vector interrupts INTCONbits.MVEC = 1; // Enable multi-vector interrupts
__builtin_enable_interrupts(); __builtin_enable_interrupts();
IPC10bits.DMA0IP = 3; // Priority level 3 IPC10bits.DMA0IP = 3; // Priority level 3
// IFS1CLR = _IFS1_DMA0IF_MASK; // Clear interrupt flag // IFS1CLR = _IFS1_DMA0IF_MASK; // Clear interrupt flag
// IEC1SET = _IEC1_DMA0IE_MASK; // Enable DMA1 interrupt // IEC1SET = _IEC1_DMA0IE_MASK; // Enable DMA1 interrupt
} }
void startSPI_DMA_Transfer(void) { void startSPI_DMA_Transfer(void) {
@ -168,7 +169,8 @@ void startSPI_DMA_Transfer(void) {
SL_LAT = 1; SL_LAT = 1;
DCH0CONbits.CHEN = 1; DCH0CONbits.CHEN = 1;
for(int i = 0; i < 8; i++) { for(int i = 0; i < 8; i++) {
while(SPI1STATbits.SPITBF); // Wait if TX buffer full while(SPI1STATbits.SPITBF)
; // Wait if TX buffer full
SPI1BUF = 0x00; // Send dummy byte to clock in data SPI1BUF = 0x00; // Send dummy byte to clock in data
} }
return; return;
@ -192,10 +194,10 @@ extern "C" void __ISR(_DMA0_VECTOR, IPL3AUTO) DMA0Handler(void) {
DCH0INTCLR = _DCH0INT_CHBCIF_MASK; // Clear block complete flag DCH0INTCLR = _DCH0INT_CHBCIF_MASK; // Clear block complete flag
// DMA RX completed — spi_rx_buffer[] now contains the data // DMA RX completed — spi_rx_buffer[] now contains the data
} }
// IFS1CLR = _IFS1_DMA0IF_MASK; // Clear global DMA0 IRQ flag // IFS1CLR = _IFS1_DMA0IF_MASK; // Clear global DMA0 IRQ flag
} }
//extern "C" void __ISR(_USB1_VECTOR, IPL4AUTO) USBHandler(void) { // extern "C" void __ISR(_USB1_VECTOR, IPL4AUTO) USBHandler(void) {
// if (USBE2CSR1bits.RXPKTRDY) { // if (USBE2CSR1bits.RXPKTRDY) {
// int count = USB_receive_EP2(); // int count = USB_receive_EP2();
// // Echo back // // Echo back
@ -203,4 +205,4 @@ extern "C" void __ISR(_DMA0_VECTOR, IPL3AUTO) DMA0Handler(void) {
// USBCSR1bits.EP2RXIF = 0; // USBCSR1bits.EP2RXIF = 0;
// } // }
// IFS1bits.USBIF = 0; // clear USB interrupt flag // IFS1bits.USBIF = 0; // clear USB interrupt flag
//} // }

3
strFuncs.cpp
View file

@ -1,7 +1,6 @@
#include "inc/strFuncs.hpp" #include "inc/strFuncs.hpp"
template <typename Out> template <typename Out> void split(const std::string &s, char delim, Out result) {
void split(const std::string &s, char delim, Out result) {
std::istringstream iss(s); std::istringstream iss(s);
std::string item; std::string item;
while(std::getline(iss, item, delim)) while(std::getline(iss, item, delim))