CybergunProtoClass.cpp

/*
* CybergunProtoClass.cpp
*
* Created: 03.06.2022 13:21:22
* Author: tabr
*/


#include "CybergunProtoClass.hpp"

void CybergunProtoClass::rx_ISR(uint8_t data){
    #ifdef USE_UART_DEBUG_COMMANDS
        if (this->rx_buffer_ptr < CG_PACKET_STUCTURE_CRC16H){
            if (data == UART_COMMAND_PRORO_RESET){
                this->reset();
                return;
            } else if (data == UART_COMMAND_DUMMY){
                UDR = UART_COMMAND_DUMMY;
                return;
            } else if (data == UART_COMMAND_SHOT){
                Cybergun.shot_detected();
                return;
            }
            if (this->rx_buffer_ptr >= CG_PACKET_STUCTURE_PACKET_SIZE){
                return;
            }
        }
    #endif //USE_UART_DEBUG_COMMANDS
    //ibi(PORTD,4);
    this->rx_buffer[this->rx_buffer_ptr] = data;
    this->rx_buffer_ptr++;//can't be more than CG_PACKET_STUCTURE_PACKET_SIZE-1
    //UDR = (this->buffer_ptr+48);
    if (this->is_packet_ready_to_proceed()){
        if (!(this->is_packet_valid())){//reset if packet invalid
            this->reset();
            return;
        }
    }
}
void CybergunProtoClass::ms_ISR(void){
    //if (this->rx_buffer_ptr >= CG_PACKET_STUCTURE_PACKET_SIZE){
        //sbi(PORTD,6);
    //}
    if (this->antistuck_counter < STUCK_THRESHOLD && this->rx_buffer_ptr != 0){
        this->antistuck_counter++;
    } else {
        this->antistuck_counter = 0;
    }
}
void CybergunProtoClass::clear_rx_bufer(void){
    memset(this->rx_buffer, 0, CG_PACKET_STUCTURE_PACKET_SIZE);
}
void CybergunProtoClass::clear_tx_bufer(void){
    memset(this->tx_buffer, 0, CG_PACKET_STUCTURE_PACKET_SIZE);
}
void CybergunProtoClass::reset(void){
    this->clear_rx_bufer();
    this->clear_tx_bufer();
    this->rx_buffer_ptr = 0;
    //this->tx_buffer_ptr = 0;
    this->current_status = STATUS_AWAINING_REQUEST;
    this->antistuck_counter = 0;
    //sbi(PORTD, 4);
    //sbi(PORTD, 6);
    //_delay_ms(100);
    //cbi(PORTD, 4);
    //cbi(PORTD, 6);
    //UDR = 90;

}
bool CybergunProtoClass::is_packet_valid(void){
    if (this->rx_buffer[CG_PACKET_STUCTURE_HEAD] >= CG_PACKET_STUCTURE_HEAD_TYPE_SIZE){
        //UDR = 'A';
        this->send_error(CG_PACKET_STUCTURE_ERROR_UNKNOWN_PACKET_HEAD);
        return false;
    }
    if (this->rx_buffer_ptr != CG_PACKET_STUCTURE_PACKET_SIZE){
        //UDR = 'B';
        this->send_error(CG_PACKET_STUCTURE_ERROR_INTERNAL_ERROR_BUFFER_PTR);
        return false;
    }
    switch (this->rx_buffer[CG_PACKET_STUCTURE_HEAD])
    {
        case CG_PACKET_STUCTURE_HEAD_TYPE_REQUEST:
        case CG_PACKET_STUCTURE_HEAD_TYPE_ANSWER:
        if (this->rx_buffer[CG_PACKET_STUCTURE_HEAD] >= CG_PACKET_STUCTURE_REQUEST_SIZE){
            //UDR = 'C';
            this->send_error(CG_PACKET_STUCTURE_ERROR_UNKNOWN_REQUEST);
            return false;
        }
        break;
    }
    #ifndef CRC_CALC_BYPASS
    uint16_t crc16 = crc16ccitt(this->rx_buffer, CG_PACKET_STUCTURE_PACKET_SIZE - 2 );
    if (crc16 != this->get_packet_crcr16()){
        //UDR = 'D';
        this->send_error(CG_PACKET_STUCTURE_ERROR_CRC_ERROR);
        return false;
    }
    #endif // CRC_CALC_BYPASS
    return true;
}
uint16_t CybergunProtoClass::get_packet_crcr16(void){
    return (this->rx_buffer[CG_PACKET_STUCTURE_CRC16H] << 8) | this->rx_buffer[CG_PACKET_STUCTURE_CRC16L];
}
bool CybergunProtoClass::is_packet_ready_to_proceed(void){
    return this->rx_buffer_ptr == CG_PACKET_STUCTURE_PACKET_SIZE;
}
void CybergunProtoClass::main(void){
    if (this->is_packet_ready_to_proceed()){
        if (this->is_packet_valid()){
            switch (this->rx_buffer[CG_PACKET_STUCTURE_HEAD]){
                case CG_PACKET_STUCTURE_HEAD_TYPE_REQUEST:
                if (this->rx_buffer[CG_PACKET_STUCTURE_SUBHEAD] == CG_PACKET_STUCTURE_REQUEST_SET_STORAGE){
                    Cybergun.Storage.set_raw_MSB(this->rx_buffer[CG_PACKET_STUCTURE_DATA0], this->rx_buffer[CG_PACKET_STUCTURE_DATA1]);
                    Cybergun.update_status();
                    this->send_answer_operation_successfull();
                    this->reset();
                    return;
                } else if (this->rx_buffer[CG_PACKET_STUCTURE_SUBHEAD] == CG_PACKET_STUCTURE_REQUEST_GET_STORAGE){
                    this->send_answer(Cybergun.Storage.get_raw_MSB());
                    this->reset();
                    return;
                } else if (this->rx_buffer[CG_PACKET_STUCTURE_SUBHEAD] == CG_PACKET_STUCTURE_REQUEST_UPTIME){
                    this->send_answer(uptime);
                    this->reset();
                    return;
                }
                break;
            }
        }
    }
    if (this->antistuck_counter >= this->STUCK_THRESHOLD){
        //this->send_error(this->CG_PACKET_STUCTURE_ERROR_CRC_ERROR);
        this->send_mcuirq_command(CybergunProtoClass::MCUIRQ_COMMANDS::MCUIRQ_COMMAND_ERROR_DETECTED,  CybergunProtoClass::CG_PACKET_STUCTURE_ERRORS::CG_PACKET_STUCTURE_ERROR_STUCK_DETECTED);
        this->reset();
        return;
    }

}
CybergunProtoClass::CybergunProtoClass(void){
    this->reset();
};
void CybergunProtoClass::send_answer(uint16_t dataMSB){
    this->send_answer((dataMSB >> 8), (dataMSB & 0xFF));
}
void CybergunProtoClass::send_answer(uint32_t dataMSB){
    this->send_answer((dataMSB >> 24), (dataMSB >> 16), (dataMSB >> 8), (dataMSB & 0xFF));
}
void CybergunProtoClass::send_answer_operation_successfull(void){
    this->send_answer(0,0);
}
void CybergunProtoClass::send_answer(uint8_t data0, uint8_t data1){
    this->clear_tx_bufer();
    this->tx_buffer[this->CG_PACKET_STUCTURE_HEAD]      = this->CG_PACKET_STUCTURE_HEAD_TYPE_ANSWER;
    this->tx_buffer[this->CG_PACKET_STUCTURE_SUBHEAD]   = 0;
    this->tx_buffer[this->CG_PACKET_STUCTURE_DATA0]     = data0;
    this->tx_buffer[this->CG_PACKET_STUCTURE_DATA1]     = data1;
    this->refresh_tx_packet_crc();
    this->send_buffer();
}
void CybergunProtoClass::send_answer(uint8_t data0, uint8_t data1, uint8_t data2, uint8_t data3){
    this->clear_tx_bufer();
    this->tx_buffer[this->CG_PACKET_STUCTURE_HEAD]      = this->CG_PACKET_STUCTURE_HEAD_TYPE_ANSWER;
    this->tx_buffer[this->CG_PACKET_STUCTURE_SUBHEAD]   = 0;
    this->tx_buffer[this->CG_PACKET_STUCTURE_DATA0]     = data0;
    this->tx_buffer[this->CG_PACKET_STUCTURE_DATA1]     = data1;
    this->tx_buffer[this->CG_PACKET_STUCTURE_DATA2]     = data2;
    this->tx_buffer[this->CG_PACKET_STUCTURE_DATA3]     = data3;
    this->refresh_tx_packet_crc();
    this->send_buffer();
}

//void CybergunProtoClass::send_mcuirq_command(MCUIRQ_COMMANDS command){
//  this->send_mcuirq_command(command, 0);
//}
void CybergunProtoClass::send_mcuirq_command(MCUIRQ_COMMANDS command, uint8_t data){

    this->tx_buffer[this->CG_PACKET_STUCTURE_HEAD]      = this->CG_PACKET_STUCTURE_HEAD_TYPE_MCUIRQ;
    this->tx_buffer[this->CG_PACKET_STUCTURE_SUBHEAD]   = command;
    this->tx_buffer[this->CG_PACKET_STUCTURE_DATA0]     = data;
    this->refresh_tx_packet_crc();
    this->send_buffer();
}

void CybergunProtoClass::send_error(CG_PACKET_STUCTURE_ERRORS error){
    this->clear_tx_bufer();
    this->tx_buffer[this->CG_PACKET_STUCTURE_HEAD]      = this->CG_PACKET_STUCTURE_HEAD_TYPE_ERROR;
    this->tx_buffer[this->CG_PACKET_STUCTURE_SUBHEAD]   = this->PACKET_COMMAND_EMPTY;
    this->tx_buffer[this->CG_PACKET_STUCTURE_DATA0]     = error;
    this->tx_buffer[this->CG_PACKET_STUCTURE_DATA1]     = 0;
    this->refresh_tx_packet_crc();
    this->send_buffer();
}
void CybergunProtoClass::refresh_tx_packet_crc(void){
    uint16_t crc = this->calculate_tx_packet_crc();
    this->tx_buffer[this->CG_PACKET_STUCTURE_CRC16H] = crc >> 8;
    this->tx_buffer[this->CG_PACKET_STUCTURE_CRC16L] = crc & 0xFF;
}
uint16_t CybergunProtoClass::calculate_tx_packet_crc(void){
    return crc16ccitt(this->tx_buffer, this->CG_PACKET_STUCTURE_PACKET_SIZE - this->CRC_LENGTH_BYTES);
}
void CybergunProtoClass::send_buffer(void){
    TRX_environment::send_data(this->tx_buffer, CG_PACKET_STUCTURE_PACKET_SIZE);
    /*
    this->tx_buffer_ptr = 0;
    while (this->tx_buffer_ptr < this->CG_PACKET_STUCTURE_PACKET_SIZE){
        UDR=this->tx_buffer[this->tx_buffer_ptr];
        while ((UCSRA & DATA_REGISTER_EMPTY)==0);//wait for TX complete
        this->tx_buffer_ptr++;
    }
    */
}