445 lines
9.0 KiB
C++
445 lines
9.0 KiB
C++
|
|
#include "QDPRobotQDPPlayerMini.h"
|
|
|
|
void QDPRobotQDPPlayerMini::setTimeOut(unsigned long timeOutDuration){
|
|
_timeOutDuration = timeOutDuration;
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::uint16ToArray(uint16_t value, uint8_t *array){
|
|
*array = (uint8_t)(value>>8);
|
|
*(array+1) = (uint8_t)(value);
|
|
}
|
|
|
|
uint16_t QDPRobotQDPPlayerMini::calculateCheckSum(uint8_t *buffer){
|
|
uint16_t sum = 0;
|
|
for (int i=Stack_Version; i<Stack_CheckSum; i++) {
|
|
sum += buffer[i];
|
|
}
|
|
return -sum;
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::sendStack(){
|
|
if (_sending[Stack_ACK]) {
|
|
while (_isSending) {
|
|
available();
|
|
}
|
|
}
|
|
else{
|
|
delay(10);
|
|
}
|
|
|
|
|
|
_serial->write(_sending, QDPPLAYER_SEND_LENGTH);
|
|
_timeOutTimer = millis();
|
|
_isSending = _sending[Stack_ACK];
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::sendStack(uint8_t command){
|
|
sendStack(command, 0);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::sendStack(uint8_t command, uint16_t argument){
|
|
_sending[Stack_Command] = command;
|
|
uint16ToArray(argument, _sending+Stack_Parameter);
|
|
uint16ToArray(calculateCheckSum(_sending), _sending+Stack_CheckSum);
|
|
sendStack();
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::sendStack(uint8_t command, uint8_t argumentHigh, uint8_t argumentLow){
|
|
uint16_t buffer = argumentHigh;
|
|
buffer <<= 8;
|
|
sendStack(command, buffer | argumentLow);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::enableACK(){
|
|
_sending[Stack_ACK] = 0x01;
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::disableACK(){
|
|
_sending[Stack_ACK] = 0x00;
|
|
}
|
|
|
|
bool QDPRobotQDPPlayerMini::waitAvailable(){
|
|
_isSending = true;
|
|
while (!available());
|
|
return _handleType != TimeOut;
|
|
}
|
|
|
|
bool QDPRobotQDPPlayerMini::begin(Stream &stream, bool isACK){
|
|
if (isACK) {
|
|
enableACK();
|
|
}
|
|
else{
|
|
disableACK();
|
|
}
|
|
|
|
_serial = &stream;
|
|
_timeOutDuration += 3000;
|
|
reset();
|
|
waitAvailable();
|
|
_timeOutDuration -= 3000;
|
|
delay(200);
|
|
return (readType() == QDPPlayerCardOnline) || !isACK;
|
|
}
|
|
|
|
uint8_t QDPRobotQDPPlayerMini::readType(){
|
|
_isAvailable = false;
|
|
return _handleType;
|
|
}
|
|
|
|
uint16_t QDPRobotQDPPlayerMini::read(){
|
|
_isAvailable = false;
|
|
return _handleParameter;
|
|
}
|
|
|
|
bool QDPRobotQDPPlayerMini::handleMessage(uint8_t type, uint16_t parameter){
|
|
_receivedIndex = 0;
|
|
_handleType = type;
|
|
_handleParameter = parameter;
|
|
_isAvailable = true;
|
|
return _isAvailable;
|
|
}
|
|
|
|
bool QDPRobotQDPPlayerMini::handleError(uint8_t type, uint16_t parameter){
|
|
handleMessage(type, parameter);
|
|
_isSending = false;
|
|
}
|
|
|
|
uint8_t QDPRobotQDPPlayerMini::readCommand(){
|
|
_isAvailable = false;
|
|
return _handleCommand;
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::parseStack(){
|
|
_handleCommand = *(_received + Stack_Command);
|
|
_handleParameter = arrayToUint16(_received + Stack_Parameter);
|
|
|
|
switch (_handleCommand) {
|
|
case 0x3D:
|
|
handleMessage(QDPPlayerPlayFinished, _handleParameter);
|
|
break;
|
|
case 0x3F:
|
|
if (_handleParameter & 0x02) {
|
|
handleMessage(QDPPlayerCardOnline, _handleParameter);
|
|
}
|
|
break;
|
|
case 0x3A:
|
|
if (_handleParameter & 0x02) {
|
|
handleMessage(QDPPlayerCardInserted, _handleParameter);
|
|
}
|
|
break;
|
|
case 0x3B:
|
|
if (_handleParameter & 0x02) {
|
|
handleMessage(QDPPlayerCardRemoved, _handleParameter);
|
|
}
|
|
break;
|
|
case 0x40:
|
|
handleMessage(QDPPlayerError, _handleParameter);
|
|
break;
|
|
case 0x41:
|
|
_isSending = false;
|
|
break;
|
|
case 0x3C:
|
|
case 0x3E:
|
|
case 0x42:
|
|
case 0x43:
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46:
|
|
case 0x47:
|
|
case 0x48:
|
|
case 0x49:
|
|
case 0x4B:
|
|
case 0x4C:
|
|
case 0x4D:
|
|
case 0x4E:
|
|
case 0x4F:
|
|
_isAvailable = true;
|
|
break;
|
|
default:
|
|
handleError(WrongStack);
|
|
break;
|
|
}
|
|
}
|
|
|
|
uint16_t QDPRobotQDPPlayerMini::arrayToUint16(uint8_t *array){
|
|
uint16_t value = *array;
|
|
value <<=8;
|
|
value += *(array+1);
|
|
return value;
|
|
}
|
|
|
|
bool QDPRobotQDPPlayerMini::validateStack(){
|
|
return calculateCheckSum(_received) == arrayToUint16(_received+Stack_CheckSum);
|
|
}
|
|
|
|
bool QDPRobotQDPPlayerMini::available(){
|
|
while (_serial->available()) {
|
|
if (_receivedIndex == 0) {
|
|
_received[Stack_Header] = _serial->read();
|
|
|
|
if (_received[Stack_Header] == 0x7E) {
|
|
_isAvailable = false;
|
|
_receivedIndex ++;
|
|
}
|
|
}
|
|
else{
|
|
_received[_receivedIndex] = _serial->read();
|
|
|
|
switch (_receivedIndex) {
|
|
case Stack_Version:
|
|
if (_received[_receivedIndex] != 0xFF) {
|
|
return handleError(WrongStack);
|
|
}
|
|
break;
|
|
case Stack_Length:
|
|
if (_received[_receivedIndex] != 0x06) {
|
|
return handleError(WrongStack);
|
|
}
|
|
break;
|
|
case Stack_End:
|
|
|
|
if (_received[_receivedIndex] != 0xEF) {
|
|
return handleError(WrongStack);
|
|
}
|
|
else{
|
|
if (validateStack()) {
|
|
_receivedIndex = 0;
|
|
parseStack();
|
|
if (_isAvailable && !_sending[Stack_ACK]) {
|
|
_isSending = false;
|
|
}
|
|
return _isAvailable;
|
|
}
|
|
else{
|
|
return handleError(WrongStack);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
_receivedIndex++;
|
|
}
|
|
}
|
|
|
|
if (_isSending && (millis()-_timeOutTimer>=_timeOutDuration)) {
|
|
return handleError(TimeOut);
|
|
}
|
|
|
|
return _isAvailable;
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::next(){
|
|
sendStack(0x01);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::previous(){
|
|
sendStack(0x02);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::play(int fileNumber){
|
|
sendStack(0x03, fileNumber);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::volumeUp(){
|
|
sendStack(0x04);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::volumeDown(){
|
|
sendStack(0x05);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::volume(uint8_t volume){
|
|
sendStack(0x06, volume);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::EQ(uint8_t eq) {
|
|
sendStack(0x07, eq);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::loop(int fileNumber) {
|
|
sendStack(0x08, fileNumber);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::outputDevice(uint8_t device) {
|
|
sendStack(0x09, device);
|
|
delay(200);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::sleep(){
|
|
sendStack(0x0A);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::reset(){
|
|
sendStack(0x0C);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::start(){
|
|
sendStack(0x0D);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::pause(){
|
|
sendStack(0x0E);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::playFolder(uint8_t folderNumber, uint8_t fileNumber){
|
|
sendStack(0x0F, folderNumber, fileNumber);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::outputSetting(bool enable, uint8_t gain){
|
|
sendStack(0x10, enable, gain);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::enableLoopAll(){
|
|
sendStack(0x11, 0x01);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::disableLoopAll(){
|
|
sendStack(0x11, 0x00);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::playMp3Folder(int fileNumber){
|
|
sendStack(0x12, fileNumber);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::advertise(int fileNumber){
|
|
sendStack(0x13, fileNumber);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::playLargeFolder(uint8_t folderNumber, uint16_t fileNumber){
|
|
sendStack(0x14, (((uint16_t)folderNumber) << 12) | fileNumber);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::stopAdvertise(){
|
|
sendStack(0x15);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::stop(){
|
|
sendStack(0x16);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::loopFolder(int folderNumber){
|
|
sendStack(0x17, folderNumber);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::randomAll(){
|
|
sendStack(0x18);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::enableLoop(){
|
|
sendStack(0x19, 0x00);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::disableLoop(){
|
|
sendStack(0x19, 0x01);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::enableDAC(){
|
|
sendStack(0x1A, 0x00);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::disableDAC(){
|
|
sendStack(0x1A, 0x01);
|
|
}
|
|
|
|
int QDPRobotQDPPlayerMini::readState(){
|
|
sendStack(0x42);
|
|
if (waitAvailable()) {
|
|
return read();
|
|
}
|
|
else{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int QDPRobotQDPPlayerMini::readVolume(){
|
|
sendStack(0x43);
|
|
if (waitAvailable()) {
|
|
return read();
|
|
}
|
|
else{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
uint8_t QDPRobotQDPPlayerMini::readEQ(){
|
|
sendStack(0x44);
|
|
while (!available());
|
|
if (waitAvailable()) {
|
|
return read();
|
|
}
|
|
else{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int QDPRobotQDPPlayerMini::reaQDPileCounts(uint8_t device){
|
|
switch (device) {
|
|
case QDPPLAYER_DEVICE_U_DISK:
|
|
sendStack(0x47);
|
|
break;
|
|
case QDPPLAYER_DEVICE_SD:
|
|
sendStack(0x48);
|
|
break;
|
|
case QDPPLAYER_DEVICE_FLASH:
|
|
sendStack(0x49);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (waitAvailable()) {
|
|
return read();
|
|
}
|
|
else{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int QDPRobotQDPPlayerMini::readCurrentFileNumber(uint8_t device){
|
|
switch (device) {
|
|
case QDPPLAYER_DEVICE_U_DISK:
|
|
sendStack(0x4B);
|
|
break;
|
|
case QDPPLAYER_DEVICE_SD:
|
|
sendStack(0x4C);
|
|
break;
|
|
case QDPPLAYER_DEVICE_FLASH:
|
|
sendStack(0x4D);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (waitAvailable()) {
|
|
return read();
|
|
}
|
|
else{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int QDPRobotQDPPlayerMini::reaQDPileCountsInFolder(int folderNumber){
|
|
sendStack(0x4E, folderNumber);
|
|
if (waitAvailable()) {
|
|
return read();
|
|
}
|
|
else{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int QDPRobotQDPPlayerMini::reaQDPileCounts(){
|
|
reaQDPileCounts(QDPPLAYER_DEVICE_SD);
|
|
}
|
|
|
|
int QDPRobotQDPPlayerMini::readCurrentFileNumber(){
|
|
readCurrentFileNumber(QDPPLAYER_DEVICE_SD);
|
|
}
|
|
|
|
void QDPRobotQDPPlayerMini::order(uint8_t num){
|
|
if(num == 1)
|
|
start();
|
|
else if(num == 0)
|
|
pause();
|
|
} |