diff --git a/Cortex-M0/nanosoc/systems/mcu/fpga_imp/pynq_export/pz104/jupyter_notebooks/soclabs/nanosoc-iotest.ipynb b/Cortex-M0/nanosoc/systems/mcu/fpga_imp/pynq_export/pz104/jupyter_notebooks/soclabs/nanosoc-iotest.ipynb
index 15a9d8985625cada4d7dfb655cf4cd17ba07fc2b..7109345de811fa0a708cb4b9550c695166eccf14 100755
--- a/Cortex-M0/nanosoc/systems/mcu/fpga_imp/pynq_export/pz104/jupyter_notebooks/soclabs/nanosoc-iotest.ipynb
+++ b/Cortex-M0/nanosoc/systems/mcu/fpga_imp/pynq_export/pz104/jupyter_notebooks/soclabs/nanosoc-iotest.ipynb
@@ -27,7 +27,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
@@ -99,7 +99,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -115,16 +115,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'2023/2/20 17:44:40 +479858'"
+       "'2023/3/14 10:6:56 +300702'"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -139,6 +139,50 @@
    "metadata": {},
    "source": []
   },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/xilinx/pynq/overlays/soclabs/design_1.bit\n",
+      "2023/3/14 10:6:56 +300702\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(PL.bitfile_name)\n",
+    "print(PL.timestamp)\n",
+    "\n",
+    "#PL.ip_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0x80020000\n",
+      "0x80060000\n"
+     ]
+    }
+   ],
+   "source": [
+    "ADP_address = PL.ip_dict['cmsdk_socket/axi_stream_io_0']['phys_addr']\n",
+    "print(hex(ADP_address))\n",
+    "UART2_address = PL.ip_dict['cmsdk_socket/axi_uartlite_0']['phys_addr']\n",
+    "print(hex(UART2_address))"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 6,
@@ -153,8 +197,8 @@
     "#ADP_address = 0x80020000 # nanosoc FT1248 com channel\n",
     "#ADP_address = 0x80030000 # streamio TX/RX loopback (unbuffered)\n",
     "#ADP_address = 0x80040000 # streamio TX/RX loopback (FIFO buffered)\n",
-    "ADP_address  = 0x80050000 # local test ADP controller COM channel\n",
-    "UART2_address = 0x80060000 # nanosoc UART2 com serial (9600 baud?)\n",
+    "#ADP_address  = 0x80050000 # local test ADP controller COM channel\n",
+    "#UART2_address = 0x80060000 # nanosoc UART2 com serial (9600 baud?)\n",
     "#ADP_address = 0x80070000 # uart TX/RX loopback\n",
     "\n",
     "# HARDWARE CONSTANTS\n",
@@ -225,7 +269,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Inspect the ADP banner after reset (0x50CLAB02 expected)"
+    "Inspect the ADP banner after reset (0x50CLAB03 expected)"
    ]
   },
   {
@@ -234,21 +278,26 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "' 0x50c1ab02\\n\\r\\n\\r]'"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 0x50c1ab03\n",
+      "\r\n",
+      "\n",
+      "\n",
+      "SOCLABS: ARM Cortex-M0 nanosoc\n",
+      "** Remap->RAM2\n",
+      "\n",
+      "\r",
+      "]\n"
+     ]
     }
    ],
    "source": [
     "adp = ADPIO(ADP_address)\n",
     "# Setup AXI UART register\n",
     "adp.setupCtrlReg()\n",
-    "adp.read(20)"
+    "print(adp.read(100))"
    ]
   },
   {
@@ -294,26 +343,25 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'A 0x00000000\\n\\r]'"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x00000000\n",
+      "\r",
+      "]\n"
+     ]
     }
    ],
    "source": [
     "adp.write('A\\n')\n",
-    "adp.read(20)"
+    "print(adp.read(100))\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "And do a couple of 32-bit reads"
+    "Do a couple of auto-incrementing 32-bit reads from ROM1 space"
    ]
   },
   {
@@ -322,19 +370,22 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'R 0x00000000\\n\\r]'"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x10000000\n",
+      "\r",
+      "]R 0x30000368\n",
+      "\r",
+      "]R 0x10000335\n",
+      "\r",
+      "]\n"
+     ]
     }
    ],
    "source": [
-    "adp.write('R\\n')\n",
-    "adp.read(15)"
+    "adp.write('A 0x10000000\\nR\\nR\\n')\n",
+    "print(adp.read(100))"
    ]
   },
   {
@@ -343,26 +394,29 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'R 0x00000000\\n\\r]'"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x30000000\n",
+      "\r",
+      "]R 0x05f5e100\n",
+      "\r",
+      "]R 0x00000000\n",
+      "\r",
+      "]\n"
+     ]
     }
    ],
    "source": [
-    "adp.write('R\\n')\n",
-    "adp.read(15)"
+    "adp.write('A 0x30000000\\nR\\nR\\n')\n",
+    "print(adp.read(100))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Verify the address pointer has auto-incremented two words"
+    "Write patterns to RAM3 base"
    ]
   },
   {
@@ -371,47 +425,62 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'A 0x00000008\\n\\r]'"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x30000000\n",
+      "\r",
+      "]W 0x11111111\n",
+      "\r",
+      "]W 0x22222222\n",
+      "\r",
+      "]\n"
+     ]
     }
    ],
    "source": [
-    "adp.write('A\\n')\n",
-    "adp.read(15)"
+    "adp.write('A 0x30000000\\nW 0x11111111\\nW22222222\\n')\n",
+    "print(adp.read(100))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now set adp address to high memory and write a couple of patterns"
+    "Read back the patterns from RAM3"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 13,
-   "metadata": {},
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'A 0xc0000000\\n\\r]'"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x30000000\n",
+      "\r",
+      "]R 0x11111111\n",
+      "\r",
+      "]R 0x22222222\n",
+      "\r",
+      "]\n"
+     ]
     }
    ],
    "source": [
-    "adp.write('A c0000000\\n')\n",
-    "adp.read(20)"
+    "adp.write('A 0x30000000\\nR\\nR\\n')\n",
+    "print(adp.read(100))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next try writes to map with bus errors - get a \"!\" warning on faulting accesses"
    ]
   },
   {
@@ -420,19 +489,22 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'W 0x11111111\\n\\r]'"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x50000000\n",
+      "\r",
+      "]W!0x11111111\n",
+      "\r",
+      "]W!0x22222222\n",
+      "\r",
+      "]\n"
+     ]
     }
    ],
    "source": [
-    "adp.write('W 111111111\\n')\n",
-    "adp.read(15)"
+    "adp.write('A 0x50000000\\nW 0x11111111\\nW22222222\\n')\n",
+    "print(adp.read(100))"
    ]
   },
   {
@@ -441,26 +513,29 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'W 0x22222222\\n\\r]'"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x50000000\n",
+      "\r",
+      "]R!0x00000000\n",
+      "\r",
+      "]R!0x00000000\n",
+      "\r",
+      "]\n"
+     ]
     }
    ],
    "source": [
-    "adp.write('W 22222222\\n')\n",
-    "adp.read(15)"
+    "adp.write('A 0x50000000\\nR\\nR\\n')\n",
+    "print(adp.read(100))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Reset the address pointer and verify same patterns read back"
+    "Run a poll cammand (no match), followed by a poll with match"
    ]
   },
   {
@@ -469,19 +544,34 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'A 0xc0000000\\n\\r]'"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x10000000\n",
+      "]M 0xf0000000\n",
+      "]V 0x00000000\n",
+      "]P!0x00004000\n",
+      "]\n",
+      "A 0x10000000\n",
+      "]M 0xf0000000\n",
+      "]V 0x30000000\n",
+      "]P 0x00000001\n",
+      "]\n"
+     ]
     }
    ],
    "source": [
-    "adp.write('A c0000000\\n')\n",
-    "adp.read(20)"
+    "adp.write('A 10000000\\nM 0xF0000000\\nV 0\\nP 4000\\n')\n",
+    "print(adp.read(100))\n",
+    "adp.write('A 10000000\\nM\\nV 30000000\\nP 2000\\n')\n",
+    "print(adp.read(100))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Fill command - set a pattern value, base address and Fill number of words"
    ]
   },
   {
@@ -490,19 +580,26 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'R 0x11111111\\n\\r]'"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x90000000\n",
+      "\r",
+      "]V 0x87654321\n",
+      "\r",
+      "]F 0x00000400\n",
+      "\r",
+      "]A 0x90001000\n",
+      "\r",
+      "]W 0xffffffff\n",
+      "\r",
+      "]\n"
+     ]
     }
    ],
    "source": [
-    "adp.write('R\\n')\n",
-    "adp.read(15)"
+    "adp.write('A 90000000\\nV 0x87654321\\nF 400\\nA\\nW FFFFFFFF\\n')\n",
+    "print(adp.read(100))"
    ]
   },
   {
@@ -511,19 +608,27 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'R 0x22222222\\n\\r]'"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "A 0x90000000\n",
+      "]R 0x87654321\n",
+      "]R 0x87654321\n",
+      "]R 0x87654321\n",
+      "]\n",
+      "A 0x90000ffc\n",
+      "]R 0x87654321\n",
+      "]R 0xffffffff\n",
+      "]A 0x90001004\n",
+      "]\n"
+     ]
     }
    ],
    "source": [
-    "adp.write('R\\n')\n",
-    "adp.read(15)"
+    "adp.write('A 0x90000000\\nR\\nR\\nR\\n')\n",
+    "print(adp.read(100))\n",
+    "adp.write('A 0x90000FFC\\nR\\nR\\nA\\n')\n",
+    "print(adp.read(100))"
    ]
   },
   {
diff --git a/Cortex-M0/nanosoc/systems/mcu/rtl_sim/adp.cmd b/Cortex-M0/nanosoc/systems/mcu/rtl_sim/adp.cmd
index d0b75b39580ddb49af40fd737ded8ca4e2a32c1e..c7a8ea7f9a973f6058895275058fb4fc12ecf4c5 100644
--- a/Cortex-M0/nanosoc/systems/mcu/rtl_sim/adp.cmd
+++ b/Cortex-M0/nanosoc/systems/mcu/rtl_sim/adp.cmd
@@ -19,9 +19,28 @@ r
 r
 r
 r
-a 30000200
-z 400
 A
+
+v 0xe5e5e5e5
+a 80000000
+f 4000
+A
+A b0000000
+w 1
+r
+A
+A 0x10000000
+R 
+m 0xf0000000
+V 0x30000000
+P 1fff
+A
+A 0x10000000
+M
+V
+P 200
+A
+!
 C 201
 
   A
diff --git a/IPLIB/ADPcontrol_v1_0/ADPmanager.v b/IPLIB/ADPcontrol_v1_0/ADPmanager.v
index f4747ae3006625177bd065d731cdf0604d7334e9..96761df3a81a88f2de84365b8c685bde8eb0ff29 100755
--- a/IPLIB/ADPcontrol_v1_0/ADPmanager.v
+++ b/IPLIB/ADPcontrol_v1_0/ADPmanager.v
@@ -63,17 +63,17 @@ wire STD_RXE_i = !STDRX_TVALID_i;
 `ifdef ADPBASIC
   localparam BANNERHEX = 32'h50c1ab01;
 `else
-  localparam BANNERHEX = 32'h50c1ab02;
+  localparam BANNERHEX = 32'h50c1ab03;
 `endif
  
 localparam CMD_bad = 4'b0000;
 localparam CMD_A   = 4'b0001;  // set address
 `ifndef ADPBASIC
-localparam CMD_B   = 4'b1000;  // Binary upload (wordocunt) from addr++
+localparam CMD_U   = 4'b1000;  // Binary Upload (wordocunt) from addr++
 localparam CMD_M   = 4'b1010;  // set read mask
 localparam CMD_P   = 4'b1011;  // Poll hardware  (count)
 localparam CMD_V   = 4'b1100;  // match value
-localparam CMD_Z   = 4'b1101;  // Zero-fill (wordocunt) from addr++
+localparam CMD_F   = 4'b1101;  // (Zero)fill (wordocunt) from addr++
 `endif
 localparam CMD_C   = 4'b1001;  // Control
 localparam CMD_R   = 4'b0010;  // read word, addr++
@@ -103,16 +103,16 @@ case (char8[7:0])
 "X": FNvalid_cmd = CMD_X;
 "x": FNvalid_cmd = CMD_X;
 `ifndef ADPBASIC
-"B": FNvalid_cmd = CMD_B;
-"b": FNvalid_cmd = CMD_B;
+"U": FNvalid_cmd = CMD_U;
+"u": FNvalid_cmd = CMD_U;
 "M": FNvalid_cmd = CMD_M;
 "m": FNvalid_cmd = CMD_M;
 "P": FNvalid_cmd = CMD_P;
 "p": FNvalid_cmd = CMD_P;
 "V": FNvalid_cmd = CMD_V;
 "v": FNvalid_cmd = CMD_V;
-"Z": FNvalid_cmd = CMD_Z;
-"z": FNvalid_cmd = CMD_Z;
+"F": FNvalid_cmd = CMD_F;
+"f": FNvalid_cmd = CMD_F;
 `endif
 default:
       FNvalid_cmd = 0;
@@ -282,17 +282,17 @@ localparam  	  STD_RXD1 = 6'b011010 ;
 localparam  	  STD_RXD2 = 6'b011011 ; 
 localparam  	  STD_TXD1 = 6'b011101 ; 
 localparam  	  STD_TXD2 = 6'b011110 ; 
-localparam  	 ADP_BCTRL = 6'b011111 ; 
-localparam     ADP_BREADB0 = 6'b100000 ; 
-localparam     ADP_BREADB1 = 6'b100001 ; 
-localparam     ADP_BREADB2 = 6'b100010 ; 
-localparam     ADP_BREADB3 = 6'b100011 ; 
-localparam  	ADP_BWRITE = 6'b100100 ; 
+localparam  	 ADP_UCTRL = 6'b011111 ; 
+localparam     ADP_UREADB0 = 6'b100000 ; 
+localparam     ADP_UREADB1 = 6'b100001 ; 
+localparam     ADP_UREADB2 = 6'b100010 ; 
+localparam     ADP_UREADB3 = 6'b100011 ; 
+localparam  	ADP_UWRITE = 6'b100100 ; 
 localparam  	  ADP_POLL = 6'b100101 ; 
 localparam  	 ADP_POLL1 = 6'b100110 ; 
 localparam  	 ADP_POLL2 = 6'b100111 ; 
-localparam  	 ADP_ZCTRL = 6'b101110 ;
-localparam  	ADP_ZWRITE = 6'b101111 ; 
+localparam  	 ADP_FCTRL = 6'b101110 ;
+localparam  	ADP_FWRITE = 6'b101111 ; 
 localparam     ADP_ECHOCMD = 6'b110000 ; 
 localparam   ADP_ECHOCMDSP = 6'b110001 ;
 localparam     ADP_UNKNOWN = 6'b101000 ; 
@@ -333,17 +333,17 @@ localparam       STD_RXD1 = 48'b000000000000000000000100000000000000000000000000
 localparam       STD_RXD2 = 48'b000000000000000000001000000000000000000000000000 ; // = 6'b011011
 localparam       STD_TXD1 = 48'b000000000000000000010000000000000000000000000000 ; // = 6'b011101
 localparam       STD_TXD2 = 48'b000000000000000000100000000000000000000000000000 ; // = 6'b011110
-localparam      ADP_BCTRL = 48'b000000000000000001000000000000000000000000000000 ; // = 6'b011111
-localparam    ADP_BREADB0 = 48'b000000000000000010000000000000000000000000000000 ; // = 6'b100000
-localparam    ADP_BREADB1 = 48'b000000000000000100000000000000000000000000000000 ; // = 6'b100001
-localparam    ADP_BREADB2 = 48'b000000000000001000000000000000000000000000000000 ; // = 6'b100010
-localparam    ADP_BREADB3 = 48'b000000000000010000000000000000000000000000000000 ; // = 6'b100011
-localparam     ADP_BWRITE = 48'b000000000000100000000000000000000000000000000000 ; // = 6'b100100
+localparam      ADP_UCTRL = 48'b000000000000000001000000000000000000000000000000 ; // = 6'b011111
+localparam    ADP_UREADB0 = 48'b000000000000000010000000000000000000000000000000 ; // = 6'b100000
+localparam    ADP_UREADB1 = 48'b000000000000000100000000000000000000000000000000 ; // = 6'b100001
+localparam    ADP_UREADB2 = 48'b000000000000001000000000000000000000000000000000 ; // = 6'b100010
+localparam    ADP_UREADB3 = 48'b000000000000010000000000000000000000000000000000 ; // = 6'b100011
+localparam     ADP_UWRITE = 48'b000000000000100000000000000000000000000000000000 ; // = 6'b100100
 localparam       ADP_POLL = 48'b000000000001000000000000000000000000000000000000 ; // = 6'b100101
 localparam      ADP_POLL1 = 48'b000000000010000000000000000000000000000000000000 ; // = 6'b100110
 localparam      ADP_POLL2 = 48'b000000000100000000000000000000000000000000000000 ; // = 6'b100111
-localparam      ADP_ZCTRL = 48'b000000001000000000000000000000000000000000000000 ; // = 6'b101110
-localparam     ADP_ZWRITE = 48'b000000010000000000000000000000000000000000000000 ; // = 6'b101111
+localparam      ADP_FCTRL = 48'b000000001000000000000000000000000000000000000000 ; // = 6'b101110
+localparam     ADP_FWRITE = 48'b000000010000000000000000000000000000000000000000 ; // = 6'b101111
 localparam    ADP_ECHOCMD = 48'b000000100000000000000000000000000000000000000000 ; // = 6'b110000
 localparam  ADP_ECHOCMDSP = 48'b000001000000000000000000000000000000000000000000 ; // = 6'b110001
 localparam    ADP_UNKNOWN = 48'b000010000000000000000000000000000000000000000000 ; // = 6'b101000
@@ -364,8 +364,9 @@ reg [ 7:0] std_tx_byte;
 reg        std_rx_ack  ;
 reg        adp_bus_req ;
 reg        adp_bus_write ;
+reg        adp_bus_err ;
 reg  [7:0] adp_cmd     ;
-reg [31:0] adp_param   ;
+reg [32:0] adp_param   ;
 reg [31:0] adp_addr    ;
 reg        adp_addr_inc;
 reg [31:0] adp_sys     ;
@@ -411,16 +412,12 @@ assign HWRITE_o      =  adp_bus_write;
 
 
 `ifndef ADPBASIC
-//reg  [63:0] adp_bctrl64;
-reg  [31:0] adp_bctrl;
 reg  [31:0] adp_val;
 reg  [31:0] adp_mask;
 reg  [31:0] adp_poll;
 reg  [31:0] adp_count;
 reg         adp_count_dec ;
 wire        adp_delay_done;
-wire        adp_bctrl_done;
-wire        adp_bctrl_zero;
 wire        poll2_loop_next;
 `endif
 
@@ -476,6 +473,7 @@ always @(posedge HCLK or negedge HRESETn)
       std_tx_req   <= 0; // default no TX req
       std_rx_ack   <= 0; // default no RX ack
       adp_bus_req  <= 0; // default no bus transaction
+      adp_bus_err  <= 0; // default no bus error
       adp_cmd      <= 0;
       adp_param    <= 0;
       adp_addr     <= 0;
@@ -506,7 +504,7 @@ always @(posedge HCLK or negedge HRESETn)
        STD_IOCHK:  // check for commsrx or STDOUT and not busy service, else loop back
          if (com_rx_req) begin com_rx_ack <= 1; adp_state <= STD_RXD1; end // input char pending for STDIN
 //         else if (com_tx_ack & std_rx_req) begin std_rx_ack <= 1; adp_state <= STD_TXD1; end // STDOUT char pending and not busy
-         else if (std_rx_req) begin std_rx_ack <= 1; adp_state <= STD_TXD1; end // STDOUT char pending and not busy
+         else if (std_rx_req) begin std_rx_ack <= 1; adp_state <= STD_TXD1; end // STDOUT char pending
        STD_TXD1:  // get STD out char
          if (std_rx_done)
            begin com_tx_byte <= std_rx_byte; com_tx_req <= 1; adp_state <= STD_TXD2; end
@@ -532,9 +530,12 @@ always @(posedge HCLK or negedge HRESETn)
          else com_tx_req <= 1;  // extend
 
        ADP_IOCHK:  // check for commsrx or STDOUT and not busy service, else loop back
-         if (com_rx_req) begin com_rx_ack <= 1; adp_state <= ADP_RXCMD; end
-         else if (com_tx_ack & std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end
-//         else if (std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end
+         if (std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end
+         else if (com_rx_req) begin com_rx_ack <= 1; adp_state <= ADP_RXCMD; end
+
+//         if (com_rx_req) begin com_rx_ack <= 1; adp_state <= ADP_RXCMD; end
+//         else if (com_tx_ack & std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end
+////         else if (std_rx_req) begin com_tx_byte <= "<"; com_tx_req <= 1; adp_state <= ADP_STDOUT; end
 
 // >>>>>>>>>>>>>>>> ADP <STDOUT> >>>>>>>>>>>>>>>>>>>>>>
        ADP_STDOUT:  // output "<"
@@ -547,7 +548,7 @@ always @(posedge HCLK or negedge HRESETn)
          if (com_tx_done) begin com_tx_byte <= ">"; com_tx_req <= 1; adp_state <= ADP_STDOUT3; end
          else com_tx_req <= 1;  // else extend
        ADP_STDOUT3:  // output ">"
-         if (com_tx_done) begin adp_state <= ADP_IOCHK; end
+         if (com_tx_done) begin if (com_rx_req) begin com_rx_ack <= 1; adp_state <= ADP_RXCMD; end else adp_state <= ADP_IOCHK; end
          else com_tx_req <= 1; // else extend
 
 // >>>>>>>>>>>>>>>> ADP COMMAND PARSING >>>>>>>>>>>>>>>>>>>>>>
@@ -556,7 +557,7 @@ always @(posedge HCLK or negedge HRESETn)
            if (FNexit(com_rx_byte)) adp_state <= STD_IOCHK; // immediate exit
            else if (FNvalid_space(com_rx_byte)) com_rx_ack <= 1; // retry for a command
            else if (FNvalid_EOL(com_rx_byte)) begin adp_cmd <= "?"; adp_state <= ADP_ACTION; end // no command, skip param
-           else begin adp_cmd <= com_rx_byte; adp_param <= 32'hffffffff; com_rx_ack <= 1; adp_state <= ADP_RXPARAM; end // get optional parameter
+           else begin adp_cmd <= com_rx_byte; adp_param <= 33'h1_00000000; com_rx_ack <= 1; adp_state <= ADP_RXPARAM; end // get optional parameter
          end
          else com_rx_ack <= 1; // extend stream request if not ready
        ADP_RXPARAM:  // read and build hex parameter
@@ -564,12 +565,12 @@ always @(posedge HCLK or negedge HRESETn)
            if (FNexit(com_rx_byte)) adp_state <= STD_IOCHK; // exit
            else if (FNvalid_EOL(com_rx_byte))
 `ifndef ADPBASIC
-            begin adp_count <= adp_param; adp_state <= ADP_ACTION; end // parameter complete on EOL
+            begin adp_count <= adp_param[31:0]; adp_state <= ADP_ACTION; end // parameter complete on EOL
 `else
             begin adp_state <= ADP_ACTION; end // parameter complete on EOL
 `endif
            else
-             begin adp_param <= FNBuild_param32_hexdigit(adp_param, com_rx_byte); com_rx_ack <= 1; end // build parameter
+             begin adp_param <= {1'b0,FNBuild_param32_hexdigit(adp_param[31:0], com_rx_byte)}; com_rx_ack <= 1; end // build parameter
            end
          else com_rx_ack <= 1;
 
@@ -577,7 +578,7 @@ always @(posedge HCLK or negedge HRESETn)
          if (FNexit(com_rx_byte))
            adp_state <= STD_IOCHK;
          else if (FNvalid_cmd(adp_cmd) == CMD_A)
-           begin if (adp_param == 32'hffffffff) adp_param <= adp_addr; else adp_addr <= adp_param;
+           begin if (adp_param[32] == 1'b1) adp_param <= {1'b0, adp_addr}; else adp_addr <= adp_param[31:0];
              adp_state <= ADP_ECHOCMD; end
          else if (FNvalid_cmd(adp_cmd) == CMD_C) begin
            if (adp_param[31:8] == 0) // report GPO
@@ -596,22 +597,22 @@ always @(posedge HCLK or negedge HRESETn)
          else if (FNvalid_cmd(adp_cmd) == CMD_S)
            begin adp_state <= ADP_SYSCHK; end
          else if (FNvalid_cmd(adp_cmd) == CMD_W)
-           begin adp_bus_data <= adp_param; ADP_BUSWRITEINC_next(); adp_state <= ADP_WRITE; end
+           begin adp_bus_data <= adp_param[31:0]; ADP_BUSWRITEINC_next(); adp_state <= ADP_WRITE; end
          else if (FNvalid_cmd(adp_cmd) == CMD_X)
            begin com_tx_byte <= 8'h0a; com_tx_req <= 1; adp_state <= ADP_EXIT; end
 `ifndef ADPBASIC
-         else if (FNvalid_cmd(adp_cmd) == CMD_B)
-           if (FNcount_down_zero_next(adp_param)) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_BCTRL; // non-zero count
+         else if (FNvalid_cmd(adp_cmd) == CMD_U)
+           if (FNcount_down_zero_next(adp_param[31:0])) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_UCTRL; // non-zero count
          else if (FNvalid_cmd(adp_cmd) == CMD_M)
-           begin if (adp_param == 32'hffffffff) adp_param <= adp_mask; else adp_mask <= adp_param;
+           begin if (adp_param[32] == 1'b1) adp_param <= {1'b0,adp_mask}; else adp_mask <= adp_param[31:0];
              adp_state <= ADP_ECHOCMD; end
          else if (FNvalid_cmd(adp_cmd) == CMD_P)
-           if (FNcount_down_zero_next(adp_param)) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_POLL; // non-zero count
+           if (FNcount_down_zero_next(adp_param[31:0])) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_POLL; // non-zero count
          else if (FNvalid_cmd(adp_cmd) == CMD_V)
-           begin if (adp_param == 32'hffffffff) adp_param <= adp_val; else adp_val <= adp_param;
+           begin if (adp_param[32] == 1'b1) adp_param <= {1'b0,adp_val}; else adp_val <= adp_param[31:0];
              adp_state <= ADP_ECHOCMD; end
-         else if (FNvalid_cmd(adp_cmd) == CMD_Z)
-           if (FNcount_down_zero_next(adp_param)) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_ZCTRL; // non-zero count
+         else if (FNvalid_cmd(adp_cmd) == CMD_F)
+           if (FNcount_down_zero_next(adp_param[31:0])) adp_state <= ADP_ECHOCMD; else adp_state <= ADP_FCTRL; // non-zero count
 `endif
          else
            begin ADP_txchar_next("?"); adp_state <= ADP_UNKNOWN; end // unrecognised/invald
@@ -619,53 +620,53 @@ always @(posedge HCLK or negedge HRESETn)
 // >>>>>>>>>>>>>>>> ADP BUS WRITE and READ >>>>>>>>>>>>>>>>>>>>>>
 
        ADP_WRITE:  // perform bus write at current address pointer (and auto increment)
-         if (adp_bus_done) begin adp_state <= ADP_ECHOCMD; end
+         if (adp_bus_done) begin adp_state <= ADP_ECHOCMD; adp_bus_err <= HRESP_i; end
          else begin ADP_BUSWRITEINC_next(); end // extend request
               
        ADP_READ:  // perform bus read at current adp address (and auto increment)  - and report in hex
-         if (adp_bus_done) begin adp_bus_data <= HRDATA32_i; ADP_txchar_next("R"); com_tx_req <= 1; adp_state <= ADP_ECHOCMDSP; end
+         if (adp_bus_done) begin adp_bus_data <= HRDATA32_i; adp_bus_err <= HRESP_i; ADP_txchar_next("R"); com_tx_req <= 1; adp_state <= ADP_ECHOCMDSP; end
          else begin ADP_BUSREADINC_next(); end // extend request
 
 `ifndef ADPBASIC
 
 // >>>>>>>>>>>>>>>> ADP BINARY UPLOAD >>>>>>>>>>>>>>>>>>>>>>
-       ADP_BCTRL:  // set control value
-         begin com_rx_ack <= 1; adp_state <= ADP_BREADB0; end  // read next 4 bytes
-       ADP_BREADB0: // read raw binary byte
-         if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[31:24] <= com_rx_byte; adp_state <= ADP_BREADB1; end
+       ADP_UCTRL:  // set control value
+         begin com_rx_ack <= 1; adp_state <= ADP_UREADB0; end  // read next 4 bytes
+       ADP_UREADB0: // read raw binary byte
+         if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[31:24] <= com_rx_byte; adp_state <= ADP_UREADB1; end
          else com_rx_ack <= 1;  // extend stream request if not ready
-       ADP_BREADB1: // read raw binary byte
-         if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[23:16] <= com_rx_byte; adp_state <= ADP_BREADB2; end
+       ADP_UREADB1: // read raw binary byte
+         if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[23:16] <= com_rx_byte; adp_state <= ADP_UREADB2; end
          else com_rx_ack <= 1;  // extend stream request if not ready
-       ADP_BREADB2: // read raw binary byte 0
-         if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[15: 8] <= com_rx_byte; adp_state <= ADP_BREADB3; end
+       ADP_UREADB2: // read raw binary byte 0
+         if (com_rx_done) begin com_rx_ack <= 1; adp_bus_data[15: 8] <= com_rx_byte; adp_state <= ADP_UREADB3; end
          else com_rx_ack <= 1;  // extend stream request if not ready
-       ADP_BREADB3: // read raw binary byte 0
+       ADP_UREADB3: // read raw binary byte 0
          if (com_rx_done)
-           begin adp_bus_data[ 7: 0] <= com_rx_byte; ADP_BUSWRITEINC_next(); adp_count_dec <= 1; adp_state <= ADP_BWRITE; end
+           begin adp_bus_data[ 7: 0] <= com_rx_byte; ADP_BUSWRITEINC_next(); adp_count_dec <= 1; adp_state <= ADP_UWRITE; end
          else com_rx_ack <= 1;  // extend stream request if not ready
-       ADP_BWRITE:  // Write word to Addr++
+       ADP_UWRITE:  // Write word to Addr++
          if (adp_bus_done) begin // auto address++, count--
-           if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; else begin adp_state <= ADP_BREADB0; end
+           if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; else begin adp_state <= ADP_UREADB0; adp_bus_err <= adp_bus_err | HRESP_i; end
          end else begin  ADP_BUSWRITEINC_next(); adp_count_dec <= 1; end // extend request
 
 // >>>>>>>>>>>>>>>> ADP BUS READ LOOP >>>>>>>>>>>>>>>>>>>>>>
        ADP_POLL:  // set poll value
          begin adp_bus_req <= 1; adp_bus_write <= 0; adp_state <= ADP_POLL1; end
        ADP_POLL1:  // wait for read data, no addr++
-         if (adp_bus_done) begin adp_bus_data <= HRDATA32_i; adp_count_dec <=1; adp_state <= ADP_POLL2; end
+         if (adp_bus_done) begin adp_bus_data <= HRDATA32_i; adp_count_dec <=1; adp_state <= ADP_POLL2; adp_bus_err <= adp_bus_err | HRESP_i; end
          else begin adp_bus_req <= 1; adp_count_dec <=1; end
        ADP_POLL2:
-         if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; // timeout
-         else if (((adp_bus_data  & adp_mask) ^ adp_val) == 0) adp_state <= ADP_WRITEHEX; // exact match
+         if (FNcount_down_zero_next(adp_count)) begin adp_state <= ADP_ECHOCMD; adp_bus_err <= 1'b1; end // timeout
+         else if (((adp_bus_data  & adp_mask) ^ adp_val) == 0) begin adp_state <= ADP_ECHOCMD; adp_param <= {1'b0, (adp_param[31:0] - adp_count)}; end // exact match
          else adp_state <= ADP_POLL;
 
-// >>>>>>>>>>>>>>>> ADP ZERO MEMORY >>>>>>>>>>>>>>>>>>>>>>
-       ADP_ZCTRL:  // set control value
-           begin adp_bus_data <= adp_val; ADP_BUSWRITEINC_next(); adp_count_dec <= 1; adp_state <= ADP_ZWRITE; end
-       ADP_ZWRITE:  // Write word to Addr++
+// >>>>>>>>>>>>>>>> ADP (ZERO) FILL MEMORY >>>>>>>>>>>>>>>>>>>>>>
+       ADP_FCTRL:  // set control value
+           begin adp_bus_data <= adp_val; ADP_BUSWRITEINC_next(); adp_count_dec <= 1; adp_state <= ADP_FWRITE; end
+       ADP_FWRITE:  // Write word to Addr++
          if (adp_bus_done) begin // auto address++, count--
-           if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; else begin adp_state <= ADP_ZCTRL; end
+           if (FNcount_down_zero_next(adp_count)) adp_state <= ADP_ECHOCMD; else begin adp_state <= ADP_FCTRL;  adp_bus_err <= adp_bus_err | HRESP_i; end
          end else begin  ADP_BUSWRITEINC_next(); adp_count_dec <= 1; end // extend request
 `endif
         
@@ -692,13 +693,13 @@ always @(posedge HCLK or negedge HRESETn)
          begin adp_bus_data <= {GPI8_i[7:0],adp_sys[7:0],adp_param[15:0]}; ADP_txchar_next("C"); com_tx_req <= 1; adp_state <= ADP_ECHOCMDSP;  end
      
        ADP_ECHOCMD:  // output command and (param) data
-         begin adp_state <= ADP_ECHOCMDSP; ADP_txchar_next(adp_cmd & 8'h5f); adp_bus_data <= adp_param; end // output command char
+         begin adp_state <= ADP_ECHOCMDSP; ADP_txchar_next(adp_cmd & 8'h5f); adp_bus_data <= adp_param[31:0]; end // output command char
        ADP_ECHOCMDSP:  // output command space and (bus) data
-         if (com_tx_done) begin adp_state <= ADP_WRITEHEXS; ADP_txchar_next(" "); end // output space char      
+         if (com_tx_done) begin adp_state <= ADP_WRITEHEXS; ADP_txchar_next(adp_bus_err ? "!" : " "); end // output space char, or "!" on bus error      
          else com_tx_req <= 1;  // extend 
            
        ADP_WRITEHEX:  // output hex word with prefix
-         begin adp_state <= ADP_WRITEHEXS; ADP_txchar_next(" "); end // output "0" hex prefix
+         begin adp_state <= ADP_WRITEHEXS; ADP_txchar_next(adp_bus_err ? "!" : " "); end // output space char, or "!" on bus error
 
        ADP_WRITEHEXS:
          if (com_tx_done) begin adp_state <= ADP_WRITEHEX9; ADP_txchar_next("0"); end // output "0" hex prefix
@@ -732,6 +733,7 @@ always @(posedge HCLK or negedge HRESETn)
          else com_tx_req <= 1;  // extend
        ADP_WRITEHEX0:  // output hex nibble 0 (if not startup banner then scan to end of line before lineack
          if (com_tx_done) begin
+           adp_bus_err <= 1'b0; // clear sticky bus error flag
            if (banner) begin ADP_LINEACK_next(); end
            else begin ADP_txchar_next(8'h0A); com_tx_req <= 1; adp_state <= ADP_LINEACK; end // newline and prompt
          end else com_tx_req <= 1;  // extend
@@ -746,7 +748,7 @@ always @(posedge HCLK or negedge HRESETn)
            else begin ADP_txchar_next(PROMPT_CHAR); adp_state <= ADP_PROMPT; end
          end else com_tx_req <= 1;  // extend
       default: 
-        begin ADP_txchar_next("!"); adp_state <= ADP_UNKNOWN; end // default error
+        begin ADP_txchar_next("#"); adp_state <= ADP_UNKNOWN; end // default error
     endcase
   end
 
@@ -756,8 +758,8 @@ endmodule
 //ADPmaster
 //   #(.PROMPT_CHAR     ("]"))
 // ADPmaster(
-//  .HCLK          (ahb_hclk      ),
-//  .HRESETn       (ahb_hrestn    ),
+//  .HCLK        (ahb_hclk      ),
+//  .HRESETn     (ahb_hrestn    ),
 //  .HADDR32_o   (ahb_haddr     ),
 //  .HBURST3_o   (ahb_hburst    ),
 //  .HMASTLOCK_o (ahb_hmastlock ),