diff --git a/src/lib.rs b/src/lib.rs
index e168ac6..48260cf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,5 @@
 #![no_std]
+#![feature(generic_associated_types)]
 extern crate embedded_hal;
 use embedded_hal::{
 	digital::v2::OutputPin,
@@ -37,6 +38,8 @@ use crate::dds::DDS;
 
 pub mod scpi;
 
+pub mod nal_tcp_client;
+
 /*
  *	Enum for structuring error
  */
diff --git a/src/nal_tcp_client.rs b/src/nal_tcp_client.rs
new file mode 100644
index 0000000..e8b09af
--- /dev/null
+++ b/src/nal_tcp_client.rs
@@ -0,0 +1,109 @@
+use embedded_nal::{TcpStack, Mode, SocketAddr};
+use embedded_nal::SocketAddr::{V4, V6};
+
+use smoltcp::wire::{EthernetAddress, IpAddress, IpCidr};
+use smoltcp::iface::{NeighborCache, EthernetInterfaceBuilder};
+use smoltcp::socket::SocketSet;
+use smoltcp::socket::{SocketHandle, TcpSocket, TcpSocketBuffer};
+use smoltcp::time::{Duration, Instant};
+use smoltcp::Error;
+
+use nb::Error as nbError;
+use core::cell;
+
+const BUFFER_SIZE: usize = 2048;
+pub static mut TX_STORAGE: &'static mut [u8] = &mut [0; BUFFER_SIZE];
+pub static mut RX_STORAGE: &'static mut [u8] = &mut [0; BUFFER_SIZE];
+
+/*
+ *  Struct for a TCP socket
+ *  TODO: Consider handling all sockets in this struct
+ */
+pub struct NalTcpClient {}
+
+// impl NalTcpClient {
+//     pub fn new(socket: &'a mut TcpSocket<'a>) -> Self {
+
+//         NalTcpClient {
+//             socket,
+//         }
+//     }
+// }
+
+impl<'a> TcpStack for &'a NalTcpClient{
+    // The type returned when we create a new TCP socket
+    type TcpSocket = smoltcp::socket::TcpSocket<'a>;
+    // The type returned when we have an error
+    type Error = Error;
+
+    // Open a new TCP socket. The socket starts in the unconnected state.
+    fn open(&self, mode: Mode) -> Result<Self::TcpSocket, Self::Error> {
+        let tx_buffer = unsafe { TcpSocketBuffer::new(&mut TX_STORAGE[..]) };
+        let rx_buffer = unsafe { TcpSocketBuffer::new(&mut RX_STORAGE[..]) };
+        let mut socket = TcpSocket::new(rx_buffer, tx_buffer);
+        if let Mode::Timeout(dur) = mode {
+            socket.set_timeout(Some(Duration::from_millis(dur.into())));
+        }
+        Ok(socket)
+    }
+
+    // Connect to the given remote host and port.
+	fn connect(
+		&self,
+		mut socket: Self::TcpSocket,
+		remote: SocketAddr,
+	) -> Result<Self::TcpSocket, Self::Error> {
+        let result = match remote {
+            V4(v4_addr) => {
+                let ip_addr = v4_addr.ip().octets();
+                socket.connect((IpAddress::v4(ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]), v4_addr.port()), 49500)
+            },
+            V6(v6_addr) => {
+                let ip_addr = v6_addr.ip().segments();
+                socket.connect((IpAddress::v6(ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3],
+                    ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]), v6_addr.port()), 49500)
+            }
+        };
+        match result {
+            Ok(_) => Ok(socket),
+            Err(_e) => Err(_e),
+        }
+    }
+
+	/// Check if this socket is connected
+	fn is_connected(&self, socket: &Self::TcpSocket) -> Result<bool, Self::Error> {
+        Ok(socket.is_active())
+    }
+
+	/// Write to the stream. Returns the number of bytes written is returned
+	/// (which may be less than `buffer.len()`), or an error.
+	fn write(&self, socket: &mut Self::TcpSocket, buffer: &[u8]) -> nb::Result<usize, Self::Error> {
+        if socket.can_send() {
+            socket.send_slice(buffer).map_err(nbError::Other)
+        } else {
+            Err(nbError::Other(Error::Illegal))
+        }
+    }
+
+	/// Read from the stream. Returns `Ok(n)`, which means `n` bytes of
+	/// data have been received and they have been placed in
+	/// `&buffer[0..n]`, or an error.
+	fn read(
+		&self,
+		socket: &mut Self::TcpSocket,
+		buffer: &mut [u8],
+	) -> nb::Result<usize, Self::Error> {
+        if socket.can_recv() {
+            socket.recv_slice(buffer).map_err(nbError::Other)
+        } else {
+            Err(nbError::Other(Error::Illegal))
+        }
+    }
+
+	/// Close an existing TCP socket.
+	fn close(&self, mut socket: Self::TcpSocket) -> Result<(), Self::Error> {
+        socket.close();
+        Ok(())
+    }
+}
+