Can successfully send a reply packet

Author: FozzTexx

include/fuji_commands.h

@@ -131,6 +131,8 @@ enum FujiCommandID {
   FUJICMD_LOAD_RELOCATOR             = 0x21, // !
   FUJICMD_FORMAT                     = 0x21, // !
   FUJICMD_RENAME                     = 0x20,
+  FUJICMD_NAK                        = 0x15, // ASCII NAK
+  FUJICMD_ACK                        = 0x06, // ASCII ACK
   FUJICMD_SEND_ERROR                 = 0x02,
   FUJICMD_SEND_RESPONSE              = 0x01,
   FUJICMD_DEVICE_READY               = 0x00,

lib/bus/rs232/FujiBusPacket.cpp

@@ -1,5 +1,7 @@
 #include "FujiBusPacket.h"
 
+#include "../../include/debug.h"
+
 typedef struct {
     uint8_t device;   /* Destination Device */
     uint8_t command;  /* Command */
@@ -15,17 +17,14 @@ typedef struct {
 static uint8_t fieldSizeTable[] = {0, 1, 1, 1, 1, 2, 2, 4};
 static uint8_t numFieldsTable[] = {0, 1, 2, 3, 4, 1, 2, 1};
 
-FujiBusPacket::FujiBusPacket(const std::string &input)
+FujiBusPacket::FujiBusPacket(const std::string &slipEncoded)
 {
-    if (!parse(input))
+    if (!parse(slipEncoded))
         throw std::invalid_argument("Invalid FujiBusPacket data");
 
     return;
 }
 
-#include <string>
-#include <string_view>
-
 std::string FujiBusPacket::decodeSLIP(const std::string &input)
 {
     unsigned int idx;
@@ -128,68 +127,73 @@ bool FujiBusPacket::parse(const std::string &input)
     if (ck1 != ck2)
         return false;
 
-    device = static_cast<FujiDeviceID>(hdr->device);
-    command = static_cast<FujiCommandID>(hdr->command);
+    _device = static_cast<FujiDeviceID>(hdr->device);
+    _command = static_cast<FujiCommandID>(hdr->command);
 
     offset = sizeof(*hdr);
     fieldCount = numFieldsTable[hdr->fields & FUJI_FIELD_COUNT_MASK];
     if (fieldCount)
     {
-        fieldSize = fieldSizeTable[fieldCount];
+        _fieldSize = fieldSizeTable[fieldCount];
         for (idx = 0; idx < fieldCount; idx++)
         {
-            for (val = jdx = 0; jdx < fieldSize; jdx++)
+            for (val = jdx = 0; jdx < _fieldSize; jdx++)
             {
-                bt = decoded[offset + idx * fieldSize + jdx];
+                bt = decoded[offset + idx * _fieldSize + jdx];
                 val |= bt << (8 * jdx);
             }
-            fields.push_back(val);
+            _params.push_back(val);
         }
 
-        offset += idx * fieldSize;
+        offset += idx * _fieldSize;
     }
 
     if (offset < decoded.size())
-        data = decoded.substr(offset);
+        _data = decoded.substr(offset);
 
     return true;
 }
 
 std::string FujiBusPacket::serialize()
 {
-    fujibus_header *hdr;
-    std::string output;
+    fujibus_header hdr, *hptr;
     unsigned int idx, jdx;
     uint32_t val;
 
-    output.resize(sizeof(*hdr));
-    hdr = (fujibus_header *) output.data();
-    hdr->device = device;
-    hdr->command = command;
-    hdr->checksum = 0;
+    hdr.device = _device;
+    hdr.command = _command;
+    hdr.length = sizeof(hdr);
+    hdr.checksum = 0;
+
+    std::string output(sizeof(hdr), '\0');
 
-    if (fields.size())
+    if (_params.size())
     {
-        hdr->fields = fields.size() - 1;
-        if (fieldSize > 1)
+        hdr.fields = _params.size() - 1;
+        if (_fieldSize > 1)
         {
-            hdr->fields |= FUJI_FIELD_16_OR_32_MASK;
-            if (fieldSize == 4)
-                hdr->fields |= FUJI_FIELD_32_MASK;
-            hdr->fields++;
+            hdr.fields |= FUJI_FIELD_16_OR_32_MASK;
+            if (_fieldSize == 4)
+                hdr.fields |= FUJI_FIELD_32_MASK;
+            hdr.fields++;
         }
 
-        for (idx = 0; idx < fields.size(); idx++)
+        for (idx = 0; idx < _params.size(); idx++)
         {
-            for (jdx = 0, val = fields[idx]; jdx < fieldSize; jdx++, val >>= 8)
+            for (jdx = 0, val = _params[idx]; jdx < _fieldSize; jdx++, val >>= 8)
                 output.push_back(val & 0xFF);
         }
     }
 
-    if (data)
-        output += *data;
+    if (_data)
+        output += *_data;
 
-    hdr->checksum = calcChecksum(output);
+    hdr.length = output.size();
+    hptr = (fujibus_header *) output.data();
+    *hptr = hdr;
+    hptr->checksum = calcChecksum(output);
+    Debug_printv("Packet header: dev:%02x cmd:%02x len:%d chk:%02x fld:%02x",
+                 hptr->device, hptr->command, hptr->length, hptr->checksum, hptr->fields);
     return encodeSLIP(output);
 }
 

lib/bus/rs232/FujiBusPacket.h

@@ -19,21 +19,30 @@ enum {
 class FujiBusPacket
 {
 private:
+    FujiDeviceID _device;
+    FujiCommandID _command;
+    unsigned int _fieldSize;
+    std::vector<unsigned int> _params;
+    std::optional<std::string> _data = std::nullopt;
+
     std::string decodeSLIP(const std::string &input);
     std::string encodeSLIP(const std::string &input);
     bool parse(const std::string &input);
     uint8_t calcChecksum(const std::string &buf);
 
 public:
-    FujiDeviceID device;
-    FujiCommandID command;
-    unsigned int fieldSize;
-    std::vector<unsigned int> fields;
-    std::optional<std::string> data = std::nullopt;
+    FujiBusPacket(const std::string &slipEncoded);
+    FujiBusPacket(FujiDeviceID dev, FujiCommandID cmd, const std::string &dbuf) :
+        _device(dev), _command(cmd), _data(dbuf) {}
 
-    FujiBusPacket(const std::string &input);
-    std::string serialize();
     static std::unique_ptr<FujiBusPacket> fromSerialized(const std::string &input);
+
+    std::string serialize();
+
+    FujiDeviceID device() { return _device; }
+    FujiCommandID command() { return _command; }
+    unsigned int param(unsigned int index) { return _params[index]; }
+    std::optional<std::string> data() const { return _data; }
 };
 
 #endif /* FUJIBUSPACKET_H */

lib/bus/rs232/rs232.cpp

@@ -55,11 +55,12 @@ uint8_t rs232_checksum(uint8_t *buf, unsigned short len)
 }
 
 /*
-   RS232 WRITE to ATARI from DEVICE
+   RS232 WRITE to COMPUTER from DEVICE
    buf = buffer to send to Atari
    len = length of buffer
    err = along with data, send ERROR status to Atari rather than COMPLETE
 */
+#ifdef OBSOLETE
 void virtualDevice::bus_to_computer(uint8_t *buf, uint16_t len, bool err)
 {
     // Write data frame to computer
@@ -82,6 +83,13 @@ void virtualDevice::bus_to_computer(uint8_t *buf, uint16_t len, bool err)
 
     SYSTEM_BUS.flushOutput();
 }
+#else /* ! OBSOLETE */
+void virtualDevice::bus_to_computer(uint8_t *buf, uint16_t len, bool err)
+{
+    SYSTEM_BUS.sendReplyPacket(_devnum, !err, buf, len);
+    return;
+}
+#endif /* OBSOLETE */
 
 /*
    RS232 READ from ATARI by DEVICE
@@ -134,10 +142,12 @@ void virtualDevice::rs232_nak()
 // RS232 ACK
 void virtualDevice::rs232_ack()
 {
+#ifdef OBSOLETE
     SYSTEM_BUS.write('A');
     fnSystem.delay_microseconds(DELAY_T5); //?
     SYSTEM_BUS.flushOutput();
     Debug_println("ACK!");
+#endif /* OBSOLETE */
 }
 
 // RS232 COMPLETE
@@ -151,18 +161,21 @@ void virtualDevice::rs232_complete()
 // RS232 ERROR
 void virtualDevice::rs232_error()
 {
+    abort();
     fnSystem.delay_microseconds(DELAY_T5);
     SYSTEM_BUS.write('E');
     Debug_println("ERROR!");
 }
 
+#ifdef OBSOLETE
 // RS232 HIGH SPEED REQUEST
 void virtualDevice::rs232_high_speed()
 {
     Debug_print("rs232 HRS232 INDEX\n");
     uint8_t hsd = SYSTEM_BUS.getHighSpeedIndex();
     bus_to_computer((uint8_t *)&hsd, 1, false);
 }
+#endif /* OBSOLETE */
 
 // Read and process a command frame from RS232
 void systemBus::_rs232_process_cmd()
@@ -198,12 +211,11 @@ void systemBus::_rs232_process_cmd()
     // Turn on the RS232 indicator LED
     fnLedManager.set(eLed::LED_BUS, true);
 
-    Debug_printf("\nCF: dev:%02x cmd:%02x fsz:%d fld:%d dlen:%d\n",
-                 tempFrame->device, tempFrame->command,
-                 tempFrame->fieldSize, tempFrame->fields.size(),
-                 tempFrame->data ? tempFrame->data->size() : -1);
+    Debug_printf("\nCF: dev:%02x cmd:%02x dlen:%d\n",
+                 tempFrame->device(), tempFrame->command(),
+                 tempFrame->data() ? tempFrame->data()->size() : -1);
 
-    if (tempFrame->device == FUJI_DEVICEID_DISK && _fujiDev != nullptr
+    if (tempFrame->device() == FUJI_DEVICEID_DISK && _fujiDev != nullptr
         && _fujiDev->boot_config)
     {
         _activeDev = &_fujiDev->bootdisk;
@@ -218,7 +230,7 @@ void systemBus::_rs232_process_cmd()
         // or go back to WAIT
         for (auto devicep : _daisyChain)
         {
-            if (tempFrame->device == devicep->_devnum)
+            if (tempFrame->device() == devicep->_devnum)
             {
                 _activeDev = devicep;
                 // handle command
@@ -404,6 +416,7 @@ void systemBus::shutdown()
     Debug_printf("All devices shut down.\n");
 }
 
+#ifdef OBSOLETE
 void systemBus::toggleBaudrate()
 {
     int baudrate = _rs232Baud == RS232_BAUDRATE ? _rs232BaudHigh : RS232_BAUDRATE;
@@ -415,6 +428,7 @@ void systemBus::toggleBaudrate()
     _rs232Baud = baudrate;
     _port.setBaudrate(_rs232Baud);
 }
+#endif /* OBSOLETE */
 
 int systemBus::getBaudrate()
 {
@@ -434,6 +448,7 @@ void systemBus::setBaudrate(int baud)
     _port.setBaudrate(baud);
 }
 
+#ifdef OBSOLETE
 // Set HRS232 index. Sets high speed RS232 baud and also returns that value.
 int systemBus::setHighSpeedIndex(int hrs232_index)
 {
@@ -457,4 +472,70 @@ void systemBus::setUDPHost(const char *hostname, int port)
 void systemBus::setUltraHigh(bool _enable, int _ultraHighBaud)
 {
 }
+#endif /* OBSOLETE */
+
+void systemBus::sendReplyPacket(FujiDeviceID source, bool ack, void *data, size_t length)
+{
+    FujiBusPacket packet(source, ack ? FUJICMD_ACK : FUJICMD_NAK,
+                         ack ? std::string(static_cast<const char*>(data), length) : nullptr);
+    std::string encoded = packet.serialize();
+    _port.write(encoded.data(), encoded.size());
+    return;
+}
+
+/* Convert direct bus access into bus packets? */
+size_t systemBus::read(void *buffer, size_t length)
+{
+    abort();
+    return _port.read(buffer, length);
+}
+
+size_t systemBus::read()
+{
+    abort();
+    return _port.read();
+}
+
+size_t systemBus::write(const void *buffer, size_t length)
+{
+    abort();
+    return _port.write(buffer, length);
+}
+
+size_t systemBus::write(int n)
+{
+    abort();
+    return _port.write(n);
+}
+
+size_t systemBus::available()
+{
+    abort();
+    return _port.available();
+}
+
+void systemBus::flushOutput()
+{
+    abort();
+    _port.flushOutput();
+}
+
+size_t systemBus::print(int n, int base)
+{
+    abort();
+    return _port.print(n, base);
+}
+
+size_t systemBus::print(const char *str)
+{
+    abort();
+    return _port.print(str);
+}
+
+size_t systemBus::print(const std::string &str)
+{
+    abort();
+    return _port.print(str);
+}
+
 #endif /* BUILD_RS232 */