Line data    Source code

       1             : // ---------------------------------------------------------------------------
       2             : // USB EPROM/Flash Programmer
       3             : //
       4             : // Copyright (2022) Robson Martins
       5             : //
       6             : // This work is licensed under a Creative Commons Attribution-NonCommercial-
       7             : // ShareAlike 4.0 International License.
       8             : // ---------------------------------------------------------------------------
       9             : /**
      10             :  * @ingroup Firmware
      11             :  * @file modules/opcodes.cpp
      12             :  * @brief Implementation of the Opcodes for communication.
      13             :  *
      14             :  * @author Robson Martins (https://www.robsonmartins.com)
      15             :  */
      16             : // ---------------------------------------------------------------------------
      17             : 
      18             : #include <cmath>
      19             : #include "modules/opcodes.hpp"
      20             : 
      21             : // ---------------------------------------------------------------------------
      22             : 
      23           4 : TCmdOpCode &TCmdOpCode::operator=(const TCmdOpCode &src) {
      24           4 :     this->code = src.code;
      25           4 :     this->descr = src.descr;
      26           4 :     this->params = src.params;
      27           4 :     this->result = src.result;
      28           4 :     return *this;
      29             : }
      30             : 
      31           4 : bool operator==(const TCmdOpCode &a, const TCmdOpCode &b) {
      32           8 :     return (a.code == b.code && a.descr == b.descr && a.params == b.params &&
      33           8 :             a.result == b.result);
      34             : }
      35             : 
      36             : // ---------------------------------------------------------------------------
      37             : 
      38           3 : bool OpCode::isOk(const void *buf, size_t size) {
      39           3 :     if (!buf || !size) {
      40           0 :         return false;
      41             :     }
      42           3 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
      43           3 :     return (pbuf[0] == kCmdResponseOk);
      44             : }
      45             : 
      46           4 : TCmdOpCode OpCode::getOpCode(const void *buf, size_t size) {
      47           4 :     if (!buf || !size) {
      48           0 :         return kCmdOpCodes.at(kCmdNop);
      49             :     }
      50           4 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
      51           4 :     return getOpCode(pbuf[0]);
      52             : }
      53             : 
      54           8 : TCmdOpCode OpCode::getOpCode(uint8_t code) {
      55           8 :     auto it = kCmdOpCodes.find(static_cast<kCmdOpCodeEnum>(code));
      56           8 :     if (it == kCmdOpCodes.end()) {
      57           2 :         return kCmdOpCodes.at(kCmdNop);
      58             :     }
      59           7 :     return it->second;
      60             : }
      61             : 
      62           4 : float OpCode::getValueAsFloat(const void *buf, size_t size) {
      63           4 :     if (!buf || size < 3) {
      64           0 :         return 0.0f;
      65             :     }
      66           4 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
      67           4 :     return static_cast<float>(pbuf[1]) + static_cast<float>(pbuf[2]) * 0.01f;
      68             : }
      69             : 
      70           8 : uint8_t OpCode::getValueAsByte(const void *buf, size_t size) {
      71           8 :     if (!buf || size < 2) {
      72           0 :         return 0x00;
      73             :     }
      74           8 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
      75           8 :     return pbuf[1];
      76             : }
      77             : 
      78           4 : bool OpCode::getValueAsBool(const void *buf, size_t size) {
      79           4 :     return (getValueAsByte(buf, size) != kCmdParamOff);
      80             : }
      81             : 
      82           4 : uint16_t OpCode::getValueAsWord(const void *buf, size_t size) {
      83           4 :     if (size < 3) {
      84           0 :         return getValueAsByte(buf, size);
      85             :     }
      86           4 :     if (!buf) {
      87           0 :         return 0;
      88             :     }
      89           4 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
      90           4 :     return (static_cast<uint16_t>(pbuf[1]) << 8) |
      91           4 :            static_cast<uint16_t>(pbuf[2]);
      92             : }
      93             : 
      94           7 : uint32_t OpCode::getValueAsDWord(const void *buf, size_t size) {
      95           7 :     if (size < 4) {
      96           0 :         return getValueAsWord(buf, size);
      97             :     }
      98           7 :     if (!buf) {
      99           0 :         return 0;
     100             :     }
     101           7 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
     102           7 :     if (size == 4) {
     103           3 :         return (static_cast<uint32_t>(pbuf[1]) << 16) |
     104           3 :                (static_cast<uint32_t>(pbuf[2]) << 8) |
     105           3 :                (static_cast<uint32_t>(pbuf[3]));
     106             :     } else {
     107           4 :         return (static_cast<uint32_t>(pbuf[1]) << 24) |
     108           4 :                (static_cast<uint32_t>(pbuf[2]) << 16) |
     109           4 :                (static_cast<uint32_t>(pbuf[3]) << 8) |
     110           4 :                (static_cast<uint32_t>(pbuf[4]));
     111             :     }
     112             : }
     113             : 
     114           1 : bool OpCode::setFloat(void *buf, size_t size, float value) {
     115           1 :     if (!buf || size < 3) {
     116           0 :         return false;
     117             :     }
     118           1 :     uint8_t *pbuf = static_cast<uint8_t *>(buf);
     119           1 :     double i, f = std::modf(value, &i);
     120           1 :     pbuf[1] = i;
     121           1 :     pbuf[2] = f * 100;
     122           1 :     return true;
     123             : }
     124             : 
     125           5 : bool OpCode::setByte(void *buf, size_t size, uint8_t value) {
     126           5 :     if (!buf || size < 2) {
     127           2 :         return false;
     128             :     }
     129           3 :     uint8_t *pbuf = static_cast<uint8_t *>(buf);
     130           3 :     pbuf[1] = value & 0xFF;
     131           3 :     return true;
     132             : }
     133             : 
     134           1 : bool OpCode::setWord(void *buf, size_t size, uint16_t value) {
     135           1 :     if (!buf || size < 3) {
     136           0 :         return false;
     137             :     }
     138           1 :     uint8_t *pbuf = static_cast<uint8_t *>(buf);
     139           1 :     pbuf[1] = (value >> 8) & 0xFF;
     140           1 :     pbuf[2] = value & 0xFF;
     141           1 :     return true;
     142             : }
     143             : 
     144           2 : bool OpCode::setDWord(void *buf, size_t size, uint32_t value) {
     145           2 :     if (!buf || size < 4) {
     146           0 :         return false;
     147             :     }
     148           2 :     uint8_t *pbuf = static_cast<uint8_t *>(buf);
     149           2 :     if (size == 4) {
     150           1 :         pbuf[1] = (value >> 16) & 0xFF;
     151           1 :         pbuf[2] = (value >> 8) & 0xFF;
     152           1 :         pbuf[3] = value & 0xFF;
     153             :     } else {
     154           1 :         pbuf[1] = (value >> 24) & 0xFF;
     155           1 :         pbuf[2] = (value >> 16) & 0xFF;
     156           1 :         pbuf[3] = (value >> 8) & 0xFF;
     157           1 :         pbuf[4] = value & 0xFF;
     158             :     }
     159           2 :     return true;
     160             : }
     161             : 
     162           2 : bool OpCode::setBool(void *buf, size_t size, bool value) {
     163           2 :     return setByte(buf, size,
     164           2 :                    static_cast<uint8_t>(value ? kCmdParamOn : kCmdParamOff));
     165             : }