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 Software
      11             :  * @file backend/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 "backend/opcodes.hpp"
      20             : 
      21             : // ---------------------------------------------------------------------------
      22             : 
      23         108 : TCmdOpCode &TCmdOpCode::operator=(const TCmdOpCode &src) {
      24         108 :     this->code = src.code;
      25         108 :     this->descr = src.descr;
      26         108 :     this->params = src.params;
      27         108 :     this->result = src.result;
      28         108 :     return *this;
      29             : }
      30             : 
      31           6 : bool operator==(const TCmdOpCode &a, const TCmdOpCode &b) {
      32          12 :     return (a.code == b.code && a.descr == b.descr && a.params == b.params &&
      33          12 :             a.result == b.result);
      34             : }
      35             : 
      36             : // ---------------------------------------------------------------------------
      37             : 
      38          68 : bool OpCode::isOk(const void *buf, size_t size) {
      39          68 :     if (!buf || !size) {
      40           1 :         return false;
      41             :     }
      42          67 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
      43          67 :     return (pbuf[0] == kCmdResponseOk);
      44             : }
      45             : 
      46           5 : TCmdOpCode OpCode::getOpCode(const void *buf, size_t size) {
      47           5 :     if (!buf || !size) {
      48           2 :         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         112 : TCmdOpCode OpCode::getOpCode(uint8_t code) {
      55         112 :     auto it = kCmdOpCodes.find(static_cast<kCmdOpCodeEnum>(code));
      56         112 :     if (it == kCmdOpCodes.end()) {
      57           2 :         return kCmdOpCodes.at(kCmdNop);
      58             :     }
      59         111 :     return it->second;
      60             : }
      61             : 
      62          12 : float OpCode::getValueAsFloat(const void *buf, size_t size) {
      63          12 :     if (!buf || size < 3) {
      64           2 :         return 0.0f;
      65             :     }
      66          10 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
      67          10 :     return static_cast<float>(pbuf[1]) + static_cast<float>(pbuf[2]) * 0.01f;
      68             : }
      69             : 
      70          17 : uint8_t OpCode::getValueAsByte(const void *buf, size_t size) {
      71          17 :     if (!buf || size < 2) {
      72           8 :         return 0x00;
      73             :     }
      74           9 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
      75           9 :     return pbuf[1];
      76             : }
      77             : 
      78           6 : bool OpCode::getValueAsBool(const void *buf, size_t size) {
      79           6 :     return (getValueAsByte(buf, size) != kCmdParamOff);
      80             : }
      81             : 
      82          10 : uint16_t OpCode::getValueAsWord(const void *buf, size_t size) {
      83          10 :     if (size < 3) {
      84           4 :         return getValueAsByte(buf, size);
      85             :     }
      86           6 :     if (!buf) {
      87           1 :         return 0;
      88             :     }
      89           5 :     const uint8_t *pbuf = static_cast<const uint8_t *>(buf);
      90           5 :     return (static_cast<uint16_t>(pbuf[1]) << 8) |
      91           5 :            static_cast<uint16_t>(pbuf[2]);
      92             : }
      93             : 
      94          10 : uint32_t OpCode::getValueAsDWord(const void *buf, size_t size) {
      95          10 :     if (size < 4) {
      96           2 :         return getValueAsWord(buf, size);
      97             :     }
      98           8 :     if (!buf) {
      99           1 :         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          10 : bool OpCode::setFloat(void *buf, size_t size, float value) {
     115          10 :     if (!buf || size < 3) {
     116           1 :         return false;
     117             :     }
     118           9 :     uint8_t *pbuf = static_cast<uint8_t *>(buf);
     119           9 :     double i, f = std::modf(value, &i);
     120           9 :     pbuf[1] = i;
     121           9 :     pbuf[2] = f * 100;
     122           9 :     return true;
     123             : }
     124             : 
     125          57 : bool OpCode::setByte(void *buf, size_t size, uint8_t value) {
     126          57 :     if (!buf || size < 2) {
     127           3 :         return false;
     128             :     }
     129          54 :     uint8_t *pbuf = static_cast<uint8_t *>(buf);
     130          54 :     pbuf[1] = value & 0xFF;
     131          54 :     return true;
     132             : }
     133             : 
     134           6 : bool OpCode::setWord(void *buf, size_t size, uint16_t value) {
     135           6 :     if (!buf || size < 3) {
     136           1 :         return false;
     137             :     }
     138           5 :     uint8_t *pbuf = static_cast<uint8_t *>(buf);
     139           5 :     pbuf[1] = (value >> 8) & 0xFF;
     140           5 :     pbuf[2] = value & 0xFF;
     141           5 :     return true;
     142             : }
     143             : 
     144           7 : bool OpCode::setDWord(void *buf, size_t size, uint32_t value) {
     145           7 :     if (!buf || size < 4) {
     146           1 :         return false;
     147             :     }
     148           6 :     uint8_t *pbuf = static_cast<uint8_t *>(buf);
     149           6 :     if (size == 4) {
     150           5 :         pbuf[1] = (value >> 16) & 0xFF;
     151           5 :         pbuf[2] = (value >> 8) & 0xFF;
     152           5 :         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           6 :     return true;
     160             : }
     161             : 
     162          50 : bool OpCode::setBool(void *buf, size_t size, bool value) {
     163          50 :     return setByte(buf, size,
     164          50 :                    static_cast<uint8_t>(value ? kCmdParamOn : kCmdParamOff));
     165             : }