diff --git a/ponsim/v2/README.md b/ponsim/v2/README.md
new file mode 100644
index 0000000..fe50243
--- /dev/null
+++ b/ponsim/v2/README.md
@@ -0,0 +1,318 @@
+# 1. Overview
+
+The PON simulator was re-written for the purpose of easily integrating it in a cluster environment.
+
+Here are some differences with the legacy PONSIM implementation:
+* The OLT and ONU instances are deployed as independent entities.
+* Both OLT and ONU are scalable containers.
+* OLT-ONU and VOLTHA-OLT communication is done via GRPC
+
+# 2. Directory structure
+
+```
+./common - Contains utilities used within the project
+./core - Contains the main component for handling the OLT/ONU services
+./grpc - Contains the GRPC server implementation along with the necessary NBI and SBI handlers
+./misc - Contains scripts and required protobuf files
+```
+
+# 3. Requirements
+
+# Golang Installation
+
+If you plan on running the simulator locally, i.e. not in a container, you will need to first 
+install setup Golang on your system.  Install using existing packages for your operating system 
+or issue the following commands (Linux).
+
+```
+cd /tmp
+wget https://storage.googleapis.com/golang/go1.9.3.linux-amd64.tar.gz
+tar -C /usr/local -xzf /tmp/go1.9.3.linux-amd64.tar.gz
+rm -f /tmp/go1.9.3.linux-amd64.tar.gz
+mkdir ~/go
+```
+
+Edit your profile (e.g. .bashrc) and add the following configuration
+
+```
+export GOROOT=/usr/local/go
+export GOPATH=~/go
+export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
+```
+
+# 4. Build the PON simulator
+
+## Container
+
+The PON simulator container can be built by issuing the following command.
+
+```
+make ponsim
+```
+
+## Local
+
+In order to run the PON simulator as a standalone application, you need to do some manual setups
+
+### Protos
+
+The required protobuf files are built as part of the docker build process.  If you intend to run 
+the simulator in a non-containerized way, you will need to build the protobuf files manually.
+
+```
+mkdir -p ponsim/v2/protos
+cp voltha/protos/*.proto ponsim/v2/protos
+cp voltha/adapters/asfvolt16_olt/protos/*.proto ponsim/v2/protos
+cp ponsim/v2/misc/protos/*.proto ponsim/v2/protos
+
+sh ponsim/v2/misc/scripts/build_protos.sh ponsim/v2/protos
+
+```
+
+### PON simulator executable (optional)
+
+You can optionally build the PON simulator and make it available through your GOPATH.
+
+```
+go get -u github.com/opencord/voltha/ponsim/v2
+
+go build -o $GOPATH/bin/ponsim $GOPATH/src/github.com/opencord/voltha/ponsim/v2/ponsim.go
+``` 
+
+
+# 5. PON Simulator Usage
+
+```
+Usage of ./ponsim:
+  -alarm_freq int
+    	Frequency of simulated alarms (in seconds) (default 60)
+  -alarm_sim
+    	Enable generation of simulated alarms
+  -api_type string
+    	Type of API used to communicate with devices (PONSIM or BAL) (default "PONSIM")
+  -device_type string
+    	Type of device to simulate (OLT or ONU) (default "OLT")
+  -external_if string
+    	External Communication Interface for read/write network traffic (default "eth2")
+  -grpc_addr string
+    	Address used to establish GRPC server connection
+  -grpc_port int
+    	Port used to establish GRPC server connection (default 50060)
+  -internal_if string
+    	Internal Communication Interface for read/write network traffic (default "eth1")
+  -name string
+    	Name of the PON device (default "PON")
+  -no_banner
+    	Omit startup banner log lines
+  -onus int
+    	Number of ONUs to simulate (default 1)
+  -parent_addr string
+    	Address of OLT to connect to (default "olt")
+  -parent_port int
+    	Port of OLT to connect to (default 50060)
+  -promiscuous
+    	Enable promiscuous mode on network interfaces
+  -quiet
+    	Suppress debug and info logs
+  -vcore_endpoint string
+    	Voltha core endpoint address (default "vcore")
+  -verbose
+    	Enable verbose logging
+```
+
+# 6. Run in local mode (no container)
+
+## Create the necessary docker networks
+
+```
+docker network create -o "com.docker.network.bridge.name"="ponsim_wan" \
+    --subnet=172.31.31.0/24 ponsim_wan
+    
+docker network create -o "com.docker.network.bridge.name"="ponsim_internal" \
+    --subnet=172.32.32.0/24 ponsim_internal
+```
+
+Allow multicast traffic to flow through the ponsim_wan network
+
+```
+echo 8 > /sys/class/net/ponsim_wan/bridge/group_fwd_mask
+```
+
+## Start VOLTHA
+
+```
+docker-compose -f compose/docker-compose-system-test.yml up -d
+docker-compose -f compose/docker-compose-auth-test.yml -p auth up -d
+```
+
+## OLT
+
+```
+ponsim -device_type OLT \
+    -internal_if <network to voltha> \
+    -external_if <internal network> \
+    -vcore_endpoint <ip of vcore instance> \
+    -onus 10
+```
+
+Example:
+
+```
+# Run as root
+sudo su
+
+ponsim -device_type OLT \
+    -internal_if ponmgmt \
+    -external_if ponsim_internal \
+    -vcore_endpoint 172.30.30.3 \
+    -onus 10
+```
+
+
+## ONU
+
+```
+ponsim -device_type ONU \
+    -external_if <network to world> \
+    -internal_if <internal network> \
+    -grpc_port 50061 \
+    -parent_addr localhost
+```
+
+Example:
+
+```
+# Run as root
+sudo su
+
+ponsim -device_type ONU \
+    -external_if ponsim_wan \
+    -internal_if ponsim_internal \
+    -grpc_port 50061 \
+    -parent_addr localhost
+```
+
+## Create PONSIM adapter
+
+Log into the VOLTHA CLI and provision an OLT instance.
+
+```
+ssh -p 5022 voltha@localhost
+
+preprovision_olt -t ponsim_olt -H 172.17.0.1:50060
+enable
+```
+
+## RG
+
+Run the RG tester
+
+```
+docker run --net=ponsim_wan --rm --name RG -it cord/tester bash
+```
+
+Execute the EAPOL authentication
+
+```
+/sbin/wpa_supplicant -Dwired -ieth0 -c /etc/wpa_supplicant/wpa_supplicant.conf
+```
+
+
+# 7. Run in a Kubernetes cluster
+
+Note: The following instructions are just a reference and may be incomplete.
+
+
+## Install networking components
+
+Install the Weave network package
+
+```
+kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
+```
+
+Install the CNI Genie package (Required to support multiple network interfaces in a container)
+
+```
+kubectl apply -f https://raw.githubusercontent.com/Huawei-PaaS/CNI-Genie/master/conf/1.8/genie.yaml
+```
+
+Configure PON management network template (on each host).  
+
+```
+# Run as root
+sudo su
+
+cat <<EOF >> /etc/cni/net.d/10-pon0.conf
+{
+    "name": "pon0",
+    "type": "bridge",
+    "bridge": "pon0",
+    "isGateway": true,
+    "ipMask": true,
+    "ipam": {
+      "type": "host-local",
+      "subnet": "10.22.0.0/16",
+      "routes": [
+        { "dst": "0.0.0.0/0" }
+      ]
+    }
+}
+EOF
+```
+
+## Start Voltha Components
+
+```
+cd k8s
+
+kubectl create configmap freeradius-config --from-file data/clients.conf --from-file data/users
+
+kubectl apply -f consul.yml
+kubectl apply -f zookeeper.yml
+kubectl apply -f kafka.yml
+kubectl apply -f envoy_for_consul.yml
+kubectl apply -f vcore_for_consul.yml
+kubectl apply -f ofagent.yml
+kubectl apply -f vcli.yml
+kubectl apply -f onos.yml
+kubectl apply -f freeradius.yml
+```
+
+## Start PONSIM
+
+From the main directory, execute the following command:
+
+```
+cd k8s
+
+kubectl apply -f olt.yml
+
+# The ONU configuration will setup a bridge on the host to ensure communication with the RG
+kubectl apply -f onu.yml
+
+# Setup bridge to allow multicast traffic (must be done on each host running an ONU)
+echo 8 > /sys/class/net/pon0/bridge/group_fwd_mask
+```
+
+## Create PONSIM adapter
+
+```
+ssh -p 5022 voltha@<ip of cli>
+
+preprovision_olt -t ponsim_olt -H olt:50060
+enable
+```
+
+## Start RG
+
+```
+kubectl apply -f rg.yml
+
+# Enter the RG container
+kubectl exec <rg container id> -ti bash
+
+# Execute some test (e.g. EAPOL authentication)
+wpa_supplicant -i eth0 -Dwired -c /etc/wpa_supplicant/wpa_supplicant.conf
+
+```
diff --git a/ponsim/v2/common/flow_sort.go b/ponsim/v2/common/flow_sort.go
new file mode 100644
index 0000000..f62f7ca
--- /dev/null
+++ b/ponsim/v2/common/flow_sort.go
@@ -0,0 +1,17 @@
+package common
+
+import (
+	"github.com/opencord/voltha/protos/go/openflow_13"
+)
+
+type SortByPriority []*openflow_13.OfpFlowStats
+
+func (s SortByPriority) Len() int {
+	return len(s)
+}
+func (s SortByPriority) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+func (s SortByPriority) Less(i, j int) bool {
+	return s[i].Priority < s[j].Priority
+}
diff --git a/ponsim/v2/common/interval_handler.go b/ponsim/v2/common/interval_handler.go
new file mode 100644
index 0000000..973865e
--- /dev/null
+++ b/ponsim/v2/common/interval_handler.go
@@ -0,0 +1,164 @@
+package common
+
+import (
+	"github.com/sirupsen/logrus"
+	"sync"
+	"time"
+)
+
+/*
+ IntervalHandler is used to run a routine at regular intervals and provide all the necessary
+ utilities to manage the execution.
+*/
+
+type IntervalHandler struct {
+	// Interval period in between each execution (in seconds?)
+	Interval int
+	// function to execute after each interval
+	function func()
+	// Channel listening to execution events
+	execute chan _ExecutionState
+	// Channel listening for a termination event
+	terminate chan struct{}
+	// Current execution state of the handler
+	state _ExecutionState
+	wg    sync.WaitGroup
+}
+
+// Define execution state constants
+type _ExecutionState uint8
+
+const (
+	STARTED _ExecutionState = iota
+	STOPPED
+	PAUSED
+	RESUMED
+)
+
+// Execute state string equivalents
+var _ExecutionStateEnum = []string{
+	"STARTED",
+	"STOPPED",
+	"PAUSED",
+	"RESUMED",
+}
+
+func (s _ExecutionState) String() string {
+	return _ExecutionStateEnum[s]
+}
+
+/*
+NewIntervalHandler instantiates a new interval based function execution handler
+*/
+func NewIntervalHandler(interval int, function func()) *IntervalHandler {
+	handler := &IntervalHandler{
+		Interval: interval,
+		function: function,
+	}
+
+	handler.execute = make(chan _ExecutionState)
+	handler.terminate = make(chan struct{})
+	handler.state = STOPPED
+
+	return handler
+}
+
+/*
+_Execute is a routine running concurrently and listening to execution events
+*/
+func (h *IntervalHandler) _Execute() {
+	defer h.wg.Done()
+	for {
+		select {
+		case h.state = <-h.execute:
+			Logger().WithFields(logrus.Fields{
+				"handler": h,
+			}).Debug("Processing execution state")
+			switch h.state {
+			case STARTED:
+			case PAUSED:
+			case RESUMED:
+				h.state = STARTED
+			case STOPPED:
+				fallthrough
+			default:
+				h.terminate <- struct{}{}
+			}
+
+		case <-h.terminate:
+			return
+
+		default:
+			if h.state == STARTED {
+				h.function()
+				time.Sleep(time.Duration(h.Interval) * time.Second)
+			} else {
+				// TODO: replace hardcoded delay with a configurable parameter
+				time.Sleep(1 * time.Second)
+			}
+		}
+	}
+}
+
+/*
+Start initiates the interval based function execution
+*/
+func (h *IntervalHandler) Start() {
+	Logger().WithFields(logrus.Fields{
+		"handler": h,
+	}).Info("Starting interval handler")
+
+	if h.execute == nil {
+		return
+	}
+	if h.state == STOPPED {
+		go h._Execute()
+		h.execute <- STARTED
+	}
+}
+
+/*
+Pause interrupts the interval based function execution
+*/
+func (h *IntervalHandler) Pause() {
+	Logger().WithFields(logrus.Fields{
+		"handler": h,
+	}).Info("Pausing interval handler")
+
+	if h.execute == nil || h.state == STOPPED {
+		return
+	}
+	if h.state == STARTED {
+		h.execute <- PAUSED
+	}
+}
+
+/*
+Resume continues the interval based function execution
+*/
+func (h *IntervalHandler) Resume() {
+	Logger().WithFields(logrus.Fields{
+		"handler": h,
+	}).Info("Resuming interval handler")
+
+	if h.execute == nil || h.state == STOPPED {
+		return
+	}
+	if h.state == PAUSED {
+		h.execute <- RESUMED
+	}
+}
+
+/*
+Stop terminates the interval based function execution
+*/
+func (h *IntervalHandler) Stop() {
+	Logger().WithFields(logrus.Fields{
+		"handler": h,
+	}).Info("Stopping interval handler")
+
+	if h.execute == nil || h.state == STOPPED {
+		return
+	}
+	h.execute <- STOPPED
+}
diff --git a/ponsim/v2/common/interval_handler_test.go b/ponsim/v2/common/interval_handler_test.go
new file mode 100644
index 0000000..e1f060f
--- /dev/null
+++ b/ponsim/v2/common/interval_handler_test.go
@@ -0,0 +1,72 @@
+package common
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+var (
+	handler   *IntervalHandler
+	iteration int = 0
+	interval  int = 2
+)
+
+func RepeatMessage() {
+	fmt.Printf("Ran the function %d times\n", iteration)
+	iteration += 1
+}
+
+func TestNewIntervalHandler(t *testing.T) {
+	handler = NewIntervalHandler(interval, RepeatMessage)
+
+	if handler.state != STOPPED {
+		t.Error("The handler should be in STOPPED state", handler.state)
+	}
+	if handler.Interval != interval {
+		t.Error("The handler interval doesn't match the configured value", handler.Interval)
+	}
+	if handler.function == nil {
+		t.Error("The handler does not have function configured function", handler.function)
+	}
+}
+
+func TestIntervalHandler_Start(t *testing.T) {
+	handler.Start()
+
+	time.Sleep(5 * time.Second)
+
+	if handler.state != STARTED {
+		t.Error("The handler should be in STARTED state", handler.state)
+	}
+}
+
+func TestIntervalHandler_Pause(t *testing.T) {
+	handler.Pause()
+
+	if handler.state != PAUSED {
+		t.Error("The handler should be in PAUSED state", handler.state)
+	}
+
+	time.Sleep(5 * time.Second)
+}
+
+func TestIntervalHandler_Resume(t *testing.T) {
+	handler.Resume()
+
+	time.Sleep(5 * time.Second)
+
+	if handler.state != STARTED {
+		t.Error("The handler should be in STARTED state", handler.state)
+	}
+}
+
+func TestIntervalHandler_Stop(t *testing.T) {
+	handler.Stop()
+
+	if handler.state != STOPPED {
+		t.Error("The handler should be in STOPPED state", handler.state)
+	}
+
+	time.Sleep(5 * time.Second)
+}
diff --git a/ponsim/v2/common/logger.go b/ponsim/v2/common/logger.go
new file mode 100644
index 0000000..7749dd2
--- /dev/null
+++ b/ponsim/v2/common/logger.go
@@ -0,0 +1,81 @@
+package common
+
+import (
+	"github.com/evalphobia/logrus_fluent"
+	"github.com/sirupsen/logrus"
+	"net"
+	"strconv"
+	"sync"
+)
+
+type logManager struct {
+	*logrus.Logger
+}
+
+// Singleton instance
+var mgrInstance *logManager
+var once sync.Once
+
+func (mgr *logManager) SetFluentd(fluentdHost string) {
+	var hook *logrus_fluent.FluentHook
+	var err error
+	var host string
+	var portStr string
+	var port int
+
+	if host, portStr, err = net.SplitHostPort(fluentdHost); err != nil {
+		mgr.WithFields(logrus.Fields{
+			"error": err.Error(),
+		}).Error("Failed to retrieve host/port information")
+		return
+	}
+
+	if port, err = strconv.Atoi(portStr); err != nil {
+		mgr.WithFields(logrus.Fields{
+			"error": err.Error(),
+		}).Error("Failed to convert port to integer")
+		return
+	}
+
+	if hook, err = logrus_fluent.NewWithConfig(
+		logrus_fluent.Config{
+			Host: host,
+			Port: port,
+		}); err != nil {
+		mgr.WithFields(logrus.Fields{
+			"error": err.Error(),
+		}).Error("Failed to enable Fluentd hook")
+		return
+	}
+
+	hook.SetTag("ponsim")
+
+	hook.SetLevels([]logrus.Level{
+		logrus.DebugLevel,
+	})
+
+	mgr.AddHook(hook)
+
+	mgr.WithFields(logrus.Fields{
+		"hook": hook,
+	}).Info("Added fluentd hook")
+}
+
+/**
+ * Get instance
+ *
+ * It should get initialized only once
+ */
+func Logger() *logManager {
+	once.Do(func() {
+
+		_logger := logrus.New()
+		_logger.Formatter = new(logrus.JSONFormatter)
+		_logger.Level = logrus.DebugLevel
+		//_logger.Out =
+
+		mgrInstance = &logManager{_logger}
+	})
+
+	return mgrInstance
+}
diff --git a/ponsim/v2/common/net_utils.go b/ponsim/v2/common/net_utils.go
new file mode 100644
index 0000000..c37c4ef
--- /dev/null
+++ b/ponsim/v2/common/net_utils.go
@@ -0,0 +1,107 @@
+package common
+
+import (
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/sirupsen/logrus"
+	"net"
+)
+
+func GetInterfaceIP(ifName string) string {
+	var err error
+	var netIf *net.Interface
+	var netAddrs []net.Addr
+	var netIp net.IP
+	var ipAddr string
+
+	if netIf, err = net.InterfaceByName(ifName); err == nil {
+		if netAddrs, err = netIf.Addrs(); err == nil {
+			for _, addr := range netAddrs {
+				Logger().WithFields(logrus.Fields{
+					"type": addr.Network(),
+				}).Debug("Address network type")
+				switch v := addr.(type) {
+				case *net.IPNet:
+					netIp = v.IP
+				case *net.IPAddr:
+					netIp = v.IP
+				}
+				if netIp == nil || netIp.IsLoopback() {
+					continue
+				}
+				netIp = netIp.To4()
+				if netIp == nil {
+					continue // not an ipv4 address
+				}
+				ipAddr = netIp.String()
+				break
+			}
+		}
+	}
+
+	return ipAddr
+}
+func GetHostIP(hostName string) string {
+	var err error
+	var ipAddrs []string
+	var ipAddr string
+
+	if ipAddrs, err = net.LookupHost(hostName); err == nil {
+		for _, ip := range ipAddrs {
+			if addr := net.ParseIP(ip); err == nil {
+				Logger().WithFields(logrus.Fields{
+					"ip": addr,
+				}).Debug("Host address")
+				if addr == nil /*|| addr.IsLoopback()*/ {
+					continue
+				}
+				ipAddr = ip
+				break
+			}
+		}
+	}
+
+	return ipAddr
+}
+func GetMacAddress(ifName string) net.HardwareAddr {
+	var err error
+	var netIf *net.Interface
+	var hwAddr net.HardwareAddr
+
+	if netIf, err = net.InterfaceByName(ifName); err == nil {
+		hwAddr = netIf.HardwareAddr
+	}
+
+	return hwAddr
+}
+
+func GetEthernetLayer(frame gopacket.Packet) *layers.Ethernet {
+	eth := &layers.Ethernet{}
+	if ethLayer := frame.Layer(layers.LayerTypeEthernet); ethLayer != nil {
+		eth, _ = ethLayer.(*layers.Ethernet)
+	}
+	return eth
+}
+func GetDot1QLayer(frame gopacket.Packet) *layers.Dot1Q {
+	var dot1q *layers.Dot1Q
+	//dot1q := &layers.Dot1Q{}
+	if dot1qLayer := frame.Layer(layers.LayerTypeDot1Q); dot1qLayer != nil {
+		dot1q, _ = dot1qLayer.(*layers.Dot1Q)
+	}
+	return dot1q
+}
+
+func GetIpLayer(frame gopacket.Packet) *layers.IPv4 {
+	ip := &layers.IPv4{}
+	if ipLayer := frame.Layer(layers.LayerTypeIPv4); ipLayer != nil {
+		ip, _ = ipLayer.(*layers.IPv4)
+	}
+	return ip
+}
+func GetUdpLayer(frame gopacket.Packet) *layers.UDP {
+	udp := &layers.UDP{}
+	if udpLayer := frame.Layer(layers.LayerTypeUDP); udpLayer != nil {
+		udp, _ = udpLayer.(*layers.UDP)
+	}
+	return udp
+}
diff --git a/ponsim/v2/core/ponsim_alarm.go b/ponsim/v2/core/ponsim_alarm.go
new file mode 100644
index 0000000..e99b84d
--- /dev/null
+++ b/ponsim/v2/core/ponsim_alarm.go
@@ -0,0 +1,175 @@
+package core
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/protos/go/voltha"
+	"github.com/sirupsen/logrus"
+	"math/rand"
+	"net"
+	"time"
+)
+
+// TODO: user-defined values? min/max intervals, vlan?
+
+const (
+	minInterval = 20
+	maxInterval = 60
+	vlandId     = 4000
+	localhost   = "127.0.0.1"
+	ttl         = 64
+	ipVersion   = 4
+)
+
+type Alarm struct {
+	Severity    int    `json:"severity"`
+	Type        int    `json:"type"`
+	Category    int    `json:"category"`
+	State       int    `json:"state"`
+	TimeStamp   int    `json:"ts"`
+	Description string `json:"description"`
+}
+
+/*
+PonSimAlarm is the structure responsible for the handling of alarms
+*/
+type PonSimAlarm struct {
+	forwardFunction func(int, gopacket.Packet)
+	dstInterface    string
+	dstEndpoint     string
+}
+
+/*
+NewPonSimAlarm instantiates a new alarm handling structure
+*/
+func NewPonSimAlarm(dstInterface string, dstEndpoint string, function func(int, gopacket.Packet)) *PonSimAlarm {
+	psa := &PonSimAlarm{dstInterface: dstInterface, dstEndpoint: dstEndpoint, forwardFunction: function}
+	return psa
+}
+
+/*
+prepareAlarm constructs an alarm object with random field values.
+*/
+func (a *PonSimAlarm) prepareAlarm() *Alarm {
+	alarm_severity := rand.Intn(len(voltha.AlarmEventSeverity_AlarmEventSeverity_value))
+	alarm_type := rand.Intn(len(voltha.AlarmEventType_AlarmEventType_value))
+	alarm_category := rand.Intn(len(voltha.AlarmEventCategory_AlarmEventCategory_value))
+	alarm_state := int(voltha.AlarmEventState_RAISED)
+	alarm_ts := time.Now().UTC().Second()
+	alarm_description := fmt.Sprintf("%s.%s alarm",
+		voltha.AlarmEventType_AlarmEventType_name[int32(alarm_type)],
+		voltha.AlarmEventCategory_AlarmEventCategory_name[int32(alarm_category)],
+	)
+
+	alarm := &Alarm{
+		Severity:    alarm_severity,
+		Type:        alarm_type,
+		Category:    alarm_category,
+		State:       alarm_state,
+		TimeStamp:   alarm_ts,
+		Description: alarm_description,
+	}
+
+	return alarm
+}
+
+/*
+sendAlarm constructs and forwards the alarm to the network
+*/
+func (a *PonSimAlarm) sendAlarm(alarm *Alarm) {
+	// Ethernet layer is configured as a broadcast packet
+	ethLayer := &layers.Ethernet{
+		SrcMAC:       common.GetMacAddress(a.dstInterface),
+		DstMAC:       layers.EthernetBroadcast,
+		EthernetType: layers.EthernetTypeDot1Q,
+	}
+
+	// Need to encapsulate in VLAN so that voltha captures the packet
+	dot1qLayer := &layers.Dot1Q{
+		Type:           layers.EthernetTypeIPv4,
+		VLANIdentifier: vlandId,
+	}
+
+	common.Logger().WithFields(logrus.Fields{
+		"Alarm": a,
+		"srcIp": common.GetInterfaceIP(a.dstInterface),
+		"dstIp": common.GetHostIP(a.dstEndpoint),
+	}).Info("SRC/DST IP addresses")
+
+	// IP layer needs the following attributes at a minimum in order to have
+	// a properly formed packet
+	ipLayer := &layers.IPv4{
+		SrcIP: net.ParseIP(common.GetInterfaceIP(a.dstInterface)),
+		DstIP: net.ParseIP(common.GetHostIP(a.dstEndpoint)),
+		//SrcIP:    net.ParseIP(localhost),
+		//DstIP:    net.ParseIP(localhost),
+		Version:  ipVersion,
+		TTL:      ttl,
+		Protocol: layers.IPProtocolTCP,
+	}
+
+	// TCP layer does not require anything special
+	// except than providing the IP layer so that the checksum can be
+	// properly calculated
+	tcpLayer := &layers.TCP{}
+	tcpLayer.SetNetworkLayerForChecksum(ipLayer)
+
+	// Convert the alarm to bytes to include it as the packet payload
+	rawData, _ := json.Marshal(alarm)
+
+	// Construct the packet
+	buffer := gopacket.NewSerializeBuffer()
+	options := gopacket.SerializeOptions{
+		FixLengths:       true,
+		ComputeChecksums: true,
+	}
+	gopacket.SerializeLayers(buffer, options,
+		ethLayer,
+		dot1qLayer,
+		ipLayer,
+		tcpLayer,
+		gopacket.Payload(rawData),
+	)
+	frame := gopacket.NewPacket(
+		buffer.Bytes(),
+		layers.LayerTypeEthernet,
+		gopacket.Default,
+	)
+
+	// Forward the packetized alarm to the network
+	a.forwardFunction(0, frame)
+
+	common.Logger().WithFields(logrus.Fields{
+		"Alarm": alarm,
+		"Frame": frame.Dump(),
+	}).Debug("Sent alarm")
+}
+
+/*
+raiseAlarm submits an alarm object with a RAISED state
+*/
+func (a *PonSimAlarm) raiseAlarm(alarm *Alarm) {
+	alarm.State = int(voltha.AlarmEventState_RAISED)
+	a.sendAlarm(alarm)
+}
+
+/*
+clearAlarm submits an alarm object with a CLEARED state
+*/
+func (a *PonSimAlarm) clearAlarm(alarm *Alarm) {
+	alarm.State = int(voltha.AlarmEventState_CLEARED)
+	a.sendAlarm(alarm)
+}
+
+/*
+GenerateAlarm simulates RAISE and CLEAR alarm events with a random delay in between each state.
+*/
+func (a *PonSimAlarm) GenerateAlarm() {
+	alarm := a.prepareAlarm()
+	a.raiseAlarm(alarm)
+	time.Sleep(time.Duration(rand.Intn(maxInterval-minInterval)+minInterval) * time.Second)
+	a.clearAlarm(alarm)
+}
diff --git a/ponsim/v2/core/ponsim_api_type.go b/ponsim/v2/core/ponsim_api_type.go
new file mode 100644
index 0000000..f178c9b
--- /dev/null
+++ b/ponsim/v2/core/ponsim_api_type.go
@@ -0,0 +1,17 @@
+package core
+
+type PonSimApiType uint8
+
+const (
+	PONSIM PonSimApiType = iota
+	BAL
+)
+
+var enum_ponsim_api_types = []string{
+	"PONSIM",
+	"BAL",
+}
+
+func (t PonSimApiType) String() string {
+	return enum_ponsim_api_types[t]
+}
diff --git a/ponsim/v2/core/ponsim_device.go b/ponsim/v2/core/ponsim_device.go
new file mode 100644
index 0000000..c13d003
--- /dev/null
+++ b/ponsim/v2/core/ponsim_device.go
@@ -0,0 +1,796 @@
+package core
+
+import (
+	"context"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/google/gopacket/pcap"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/protos/go/openflow_13"
+	"github.com/sirupsen/logrus"
+	"net"
+	"sort"
+)
+
+// TODO: Pass-in the certificate information as a structure parameter
+// TODO: Add certification information
+
+type PonSimDevice struct {
+	Name        string               `json:name`
+	Port        int32                `json:port`
+	Address     string               `json:address`
+	ExternalIf  string               `json:external_if`
+	InternalIf  string               `json:internal_if`
+	Promiscuous bool                 `json:promiscuous`
+	SnapshotLen int32                `json:snapshot_len`
+	AlarmsOn    bool                 `json:alarm_on`
+	AlarmsFreq  int                  `json:alarm_freq`
+	Counter     *PonSimMetricCounter `json:counter`
+
+	//*grpc.GrpcSecurity
+
+	flows          []*openflow_13.OfpFlowStats `json:-`
+	ingressHandler *pcap.Handle                `json:-`
+	egressHandler  *pcap.Handle                `json:-`
+	links          map[int]map[int]interface{} `json:-`
+}
+
+const (
+	UDP_DST  = 1
+	UDP_SRC  = 2
+	IPV4_DST = 4
+	VLAN_PCP = 8
+	VLAN_VID = 16
+	IP_PROTO = 32
+	ETH_TYPE = 64
+	IN_PORT  = 128
+)
+
+/*
+Start performs common setup operations for a ponsim device
+*/
+func (o *PonSimDevice) Start(ctx context.Context) {
+}
+
+/*
+Stop performs common cleanup operations for a ponsim device
+*/
+func (o *PonSimDevice) Stop(ctx context.Context) {
+}
+
+/*
+GetAddress returns the IP/FQDN for the device
+*/
+func (o *PonSimDevice) GetAddress() string {
+	return o.Address
+}
+
+/*
+GetPort return the port assigned to the device
+*/
+func (o *PonSimDevice) GetPort() int32 {
+	return o.Port
+}
+
+/*
+Forward is responsible of processing incoming data, filtering it and redirecting to the
+intended destination
+*/
+func (o *PonSimDevice) Forward(
+	ctx context.Context,
+	port int,
+	frame gopacket.Packet,
+) error {
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+		"port":   port,
+		"frame":  frame,
+	}).Debug("Forwarding packet")
+
+	var err error
+
+	o.Counter.CountRxFrame(port, len(common.GetEthernetLayer(frame).Payload))
+
+	if egressPort, egressFrame := o.processFrame(ctx, port, frame); egressFrame != nil {
+		forwarded := 0
+		links := o.links[int(egressPort)]
+
+		o.Counter.CountTxFrame(int(egressPort), len(common.GetEthernetLayer(egressFrame).Payload))
+
+		for _, link := range links {
+			forwarded += 1
+
+			common.Logger().WithFields(logrus.Fields{
+				"device":      o,
+				"egressPort":  port,
+				"egressFrame": egressFrame,
+			}).Debug("Forwarding packet to link")
+
+			link.(func(int, gopacket.Packet))(int(egressPort), egressFrame)
+		}
+		if forwarded == 0 {
+			common.Logger().WithFields(logrus.Fields{
+				"device": o,
+				"port":   port,
+				"frame":  frame,
+			}).Warn("Nothing was forwarded")
+		}
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"port":   egressPort,
+			"frame":  egressFrame,
+		}).Error("Failed to properly process frame")
+	}
+
+	return err
+}
+
+/*
+connectNetworkInterfaces opens network interfaces for reading and/or writing packets
+*/
+func (o *PonSimDevice) connectNetworkInterfaces() {
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+	}).Debug("Opening network interfaces")
+
+	var err error
+	if o.ingressHandler, err = pcap.OpenLive(
+		o.ExternalIf, o.SnapshotLen, o.Promiscuous, pcap.BlockForever,
+	); err != nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device":    o,
+			"interface": o.ExternalIf,
+			"error":     err.Error(),
+		}).Fatal("Unable to open Ingress interface")
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"device":    o,
+			"interface": o.ExternalIf,
+		}).Info("Opened Ingress interface")
+	}
+
+	if o.egressHandler, err = pcap.OpenLive(
+		o.InternalIf, o.SnapshotLen, o.Promiscuous, pcap.BlockForever,
+	); err != nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device":    o,
+			"interface": o.InternalIf,
+			"error":     err.Error(),
+		}).Fatal("Unable to open egress interface")
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"device":    o,
+			"interface": o.InternalIf,
+		}).Info("Opened egress interface")
+	}
+}
+
+/*
+AddLink assigns a functional operation to a device endpoint
+
+The functional operation is called whenever a packet has been processed
+and the endpoint has been identified as the outgoing interface
+*/
+func (o *PonSimDevice) AddLink(
+	port int,
+	index int,
+	function interface{},
+) error {
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+		"port":   port,
+		"index":  index,
+	}).Debug("Linking port to functional operation")
+
+	if o.links == nil {
+		o.links = make(map[int]map[int]interface{})
+	}
+	if _, ok := o.links[port]; !ok {
+		o.links[port] = make(map[int]interface{})
+	}
+	o.links[port][index] = function
+
+	return nil
+}
+
+/*
+RemoveLink will remove reference a functional operation for a given port and index
+*/
+func (o *PonSimDevice) RemoveLink(
+	port int,
+	index int,
+) error {
+	if _, hasPort := o.links[port]; hasPort {
+		if _, hasIndex := o.links[port][index]; hasIndex {
+			common.Logger().WithFields(logrus.Fields{
+				"device": o,
+				"port":   port,
+				"index":  index,
+			}).Debug("Removing link functional operation")
+
+			delete(o.links[port], index)
+
+		} else {
+			common.Logger().WithFields(logrus.Fields{
+				"device": o,
+				"port":   port,
+				"index":  index,
+			}).Warn("No such index for link functional operation")
+
+		}
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"port":   port,
+			"index":  index,
+		}).Warn("No such port for functional operation")
+	}
+
+	return nil
+}
+
+/*
+InstallFlows assigns flows to the device in order of priority
+*/
+func (o *PonSimDevice) InstallFlows(
+	ctx context.Context,
+	flows []*openflow_13.OfpFlowStats,
+) error {
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+		"flows":  flows,
+	}).Debug("Installing flows")
+
+	o.flows = flows
+	sort.Sort(common.SortByPriority(o.flows))
+
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+	}).Debug("Installed sorted flows")
+
+	return nil
+}
+
+/*
+processFrame is responsible for matching or discarding a frame based on the configured flows
+*/
+func (o *PonSimDevice) processFrame(
+	ctx context.Context,
+	port int,
+	frame gopacket.Packet,
+) (uint32, gopacket.Packet) {
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+		"port":   port,
+		"frame":  frame,
+	}).Debug("Processing frame")
+
+	var err error
+	var matchedMask int = 0
+	var currentMask int
+	var highestPriority uint32 = 0
+	var matchedFlow *openflow_13.OfpFlowStats = nil
+
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+	}).Debug("Looping through flows")
+
+	for _, flow := range o.flows {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"flow":   flow,
+		}).Debug("Checking flow")
+
+		if matchedFlow != nil && flow.Priority < highestPriority {
+			common.Logger().WithFields(logrus.Fields{
+				"device":      o,
+				"matchedFlow": matchedFlow,
+				"priority":    highestPriority,
+			}).Debug("Flow has already been matched")
+			break
+		} else {
+			common.Logger().WithFields(logrus.Fields{
+				"device":          o,
+				"matchedFlow":     matchedFlow,
+				"priority":        flow.Priority,
+				"highestPriority": highestPriority,
+			}).Debug("Flow OR Priority requirements not met")
+		}
+
+		highestPriority = flow.Priority
+		if currentMask, err = o.isMatch(ctx, flow, port, frame); err != nil {
+			common.Logger().WithFields(logrus.Fields{
+				"device": o,
+				"flow":   flow,
+				"port":   port,
+				"frame":  frame,
+				"error":  err.Error(),
+			}).Error("Problem while matching flow")
+
+		} else if currentMask > matchedMask {
+			matchedMask = currentMask
+			matchedFlow = flow
+
+			common.Logger().WithFields(logrus.Fields{
+				"device":      o,
+				"matchedFlow": flow,
+				"port":        port,
+				"frame":       frame,
+				"matchedMask": matchedMask,
+			}).Debug("Flow matches")
+		}
+	}
+
+	if matchedFlow != nil {
+		egressPort, egressFrame := o.processActions(ctx, matchedFlow, frame)
+
+		common.Logger().WithFields(logrus.Fields{
+			"device":      o,
+			"port":        port,
+			"egressPort":  egressPort,
+			"egressFrame": egressFrame,
+		}).Debug("Processed actions to matched flow")
+
+		return egressPort, egressFrame
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"device":      o,
+			"port":        port,
+			"frame":       frame,
+			"matchedMask": matchedMask,
+		}).Warn("Flow was not successfully matched")
+	}
+
+	return 0, nil
+}
+
+/*
+isMatch traverses the criteria of a flow and identify all matching elements of a frame (if any)
+*/
+func (o *PonSimDevice) isMatch(
+	ctx context.Context,
+	flow *openflow_13.OfpFlowStats,
+	port int,
+	frame gopacket.Packet,
+) (int, error) {
+	matchedMask := 0
+
+	for _, ofbfield := range flow.Match.OxmFields {
+		if ofbfield.GetOxmClass() == openflow_13.OfpOxmClass_OFPXMC_OPENFLOW_BASIC {
+			switch ofbfield.GetOfbField().Type {
+			case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT:
+				if ofbfield.GetOfbField().GetPort() != uint32(port) {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetPort(),
+						"actual":   port,
+					}).Warn("Port does not match")
+					return 0, nil
+				} else {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetPort(),
+						"actual":   port,
+					}).Debug("Port matches")
+				}
+				matchedMask |= IN_PORT
+
+			case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE:
+				cmpType := uint32(common.GetEthernetLayer(frame).EthernetType)
+				if dot1q := common.GetDot1QLayer(frame); dot1q != nil {
+					cmpType = uint32(dot1q.Type)
+				}
+				if ofbfield.GetOfbField().GetEthType() != cmpType {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": layers.EthernetType(ofbfield.GetOfbField().GetEthType()),
+						"actual":   common.GetEthernetLayer(frame).EthernetType,
+					}).Warn("Frame type does not match")
+					return 0, nil
+				} else {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": layers.EthernetType(ofbfield.GetOfbField().GetEthType()),
+						"actual":   common.GetEthernetLayer(frame).EthernetType,
+					}).Debug("Frame type matches")
+				}
+				matchedMask |= ETH_TYPE
+
+			case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO:
+				if ofbfield.GetOfbField().GetIpProto() != uint32(common.GetIpLayer(frame).Protocol) {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetIpProto(),
+						"actual":   common.GetIpLayer(frame).Protocol,
+					}).Warn("IP protocol does not match")
+					return 0, nil
+				} else {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetIpProto(),
+						"actual":   common.GetIpLayer(frame).Protocol,
+					}).Debug("IP protocol matches")
+				}
+				matchedMask |= IP_PROTO
+
+			case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
+				expectedVlan := ofbfield.GetOfbField().GetVlanVid()
+				dot1q := common.GetDot1QLayer(frame)
+
+				if (expectedVlan&4096 == 0) != (dot1q == nil) {
+					common.Logger().WithFields(logrus.Fields{
+						"device":       o,
+						"flow":         flow,
+						"expectedVlan": expectedVlan,
+						"vlanBitwise":  expectedVlan & 4096,
+						"dot1q":        dot1q,
+					}).Warn("VLAN condition not met")
+					return 0, nil
+				}
+				if dot1q != nil {
+					if uint32(dot1q.VLANIdentifier) != (expectedVlan & 4095) {
+						common.Logger().WithFields(logrus.Fields{
+							"device":   o,
+							"flow":     flow,
+							"expected": expectedVlan,
+							"actual":   uint32(dot1q.VLANIdentifier),
+						}).Warn("VLAN VID does not match")
+						return 0, nil
+					} else {
+						common.Logger().WithFields(logrus.Fields{
+							"device":   o,
+							"flow":     flow,
+							"expected": expectedVlan,
+							"actual":   uint32(dot1q.VLANIdentifier),
+						}).Debug("VLAN VID matches")
+					}
+				} else {
+					common.Logger().WithFields(logrus.Fields{
+						"device": o,
+						"flow":   flow,
+					}).Warn("VLAN VID missing. Not dot1q encapsulation")
+				}
+				matchedMask |= VLAN_VID
+
+			case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP:
+				if ofbfield.GetOfbField().GetVlanPcp() != uint32(common.GetDot1QLayer(frame).Priority) {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetVlanPcp(),
+						"actual":   uint32(common.GetDot1QLayer(frame).Priority),
+					}).Warn("VLAN priority does not match")
+					return 0, nil
+				} else {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetVlanPcp(),
+						"actual":   uint32(common.GetDot1QLayer(frame).Priority),
+					}).Debug("VLAN priority matches")
+				}
+				matchedMask |= VLAN_PCP
+
+			case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST:
+				dstIpRaw := ofbfield.GetOfbField().GetIpv4Dst()
+				dstIp := net.IPv4(
+					byte((dstIpRaw>>24)&0xFF),
+					byte((dstIpRaw>>16)&0xFF),
+					byte((dstIpRaw>>8)&0xFF),
+					byte(dstIpRaw&0xFF))
+
+				if !dstIp.Equal(common.GetIpLayer(frame).DstIP) {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": dstIp,
+						"actual":   common.GetIpLayer(frame).DstIP,
+					}).Warn("IPv4 destination does not match")
+					return 0, nil
+				} else {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": dstIp,
+						"actual":   common.GetIpLayer(frame).DstIP,
+					}).Debug("IPv4 destination matches")
+
+				}
+				matchedMask |= IPV4_DST
+
+			case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC:
+				if ofbfield.GetOfbField().GetUdpSrc() != uint32(common.GetUdpLayer(frame).SrcPort) {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetUdpSrc(),
+						"actual":   common.GetUdpLayer(frame).SrcPort,
+					}).Warn("UDP source port does not match")
+					return 0, nil
+				} else {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetUdpSrc(),
+						"actual":   common.GetUdpLayer(frame).SrcPort,
+					}).Debug("UDP source port matches")
+				}
+				matchedMask |= UDP_SRC
+
+			case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST:
+				if ofbfield.GetOfbField().GetUdpDst() != uint32(common.GetUdpLayer(frame).DstPort) {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetUdpDst(),
+						"actual":   common.GetUdpLayer(frame).DstPort,
+					}).Warn("UDP destination port does not match")
+					return 0, nil
+				} else {
+					common.Logger().WithFields(logrus.Fields{
+						"device":   o,
+						"flow":     flow,
+						"expected": ofbfield.GetOfbField().GetUdpDst(),
+						"actual":   common.GetUdpLayer(frame).DstPort,
+					}).Debug("UDP destination port does matches")
+				}
+				matchedMask |= UDP_DST
+
+			case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_METADATA:
+				common.Logger().WithFields(logrus.Fields{
+					"device": o,
+					"flow":   flow,
+				}).Warn("Skipping metadata")
+				continue
+
+			default:
+				common.Logger().WithFields(logrus.Fields{
+					"device": o,
+					"flow":   flow,
+					"type":   ofbfield.GetOfbField().Type,
+				}).Warn("Field type not implemented")
+			}
+		}
+	}
+	return matchedMask, nil
+}
+
+/*
+processActions applies transformation instructions to a frame that met all the flow criteria
+*/
+func (o *PonSimDevice) processActions(
+	ctx context.Context,
+	flow *openflow_13.OfpFlowStats,
+	frame gopacket.Packet,
+) (uint32, gopacket.Packet) {
+	var egressPort uint32
+	var retFrame gopacket.Packet = frame
+
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+		"flow":   flow,
+		"frame":  retFrame,
+	}).Info("Processing actions")
+
+	for _, instruction := range flow.Instructions {
+		common.Logger().WithFields(logrus.Fields{
+			"device":      o,
+			"flow":        flow,
+			"frame":       retFrame,
+			"instruction": instruction,
+		}).Debug("Processing actions - Instruction entry")
+		if instruction.Type == uint32(openflow_13.OfpInstructionType_OFPIT_APPLY_ACTIONS) {
+			for _, action := range instruction.GetActions().GetActions() {
+				common.Logger().WithFields(logrus.Fields{
+					"device":     o,
+					"flow":       flow,
+					"frame":      retFrame,
+					"action":     action,
+					"actionType": action.Type,
+				}).Debug("Processing actions - Action entry")
+
+				switch action.Type {
+				case openflow_13.OfpActionType_OFPAT_OUTPUT:
+					common.Logger().WithFields(logrus.Fields{
+						"device": o,
+						"flow":   flow,
+						"frame":  retFrame,
+					}).Debug("Processing action OFPAT output")
+					egressPort = action.GetOutput().Port
+
+				case openflow_13.OfpActionType_OFPAT_POP_VLAN:
+					common.Logger().WithFields(logrus.Fields{
+						"device": o,
+						"flow":   flow,
+						"frame":  retFrame,
+					}).Debug("Processing action OFPAT POP VLAN")
+					if shim := common.GetDot1QLayer(retFrame); shim != nil {
+						if eth := common.GetEthernetLayer(retFrame); eth != nil {
+							ethernetLayer := &layers.Ethernet{
+								SrcMAC:       eth.SrcMAC,
+								DstMAC:       eth.DstMAC,
+								EthernetType: shim.Type,
+							}
+							buffer := gopacket.NewSerializeBuffer()
+							gopacket.SerializeLayers(buffer, gopacket.SerializeOptions{},
+								ethernetLayer,
+								gopacket.Payload(shim.Payload),
+							)
+							retFrame = gopacket.NewPacket(
+								buffer.Bytes(),
+								layers.LayerTypeEthernet,
+								gopacket.Default,
+							)
+						} else {
+							common.Logger().WithFields(logrus.Fields{
+								"device": o,
+								"flow":   flow,
+								"frame":  retFrame,
+							}).Warn("No ETH found while processing POP VLAN action")
+						}
+					} else {
+						common.Logger().WithFields(logrus.Fields{
+							"device": o,
+							"flow":   flow,
+							"frame":  retFrame,
+						}).Warn("No DOT1Q found while processing POP VLAN action")
+					}
+				case openflow_13.OfpActionType_OFPAT_PUSH_VLAN:
+					if eth := common.GetEthernetLayer(retFrame); eth != nil {
+						ethernetLayer := &layers.Ethernet{
+							SrcMAC:       eth.SrcMAC,
+							DstMAC:       eth.DstMAC,
+							EthernetType: layers.EthernetType(action.GetPush().GetEthertype()),
+						}
+						dot1qLayer := &layers.Dot1Q{
+							Type: eth.EthernetType,
+						}
+
+						buffer := gopacket.NewSerializeBuffer()
+						gopacket.SerializeLayers(
+							buffer,
+							gopacket.SerializeOptions{
+								FixLengths: false,
+							},
+							ethernetLayer,
+							dot1qLayer,
+							gopacket.Payload(eth.Payload),
+						)
+						retFrame = gopacket.NewPacket(
+							buffer.Bytes(),
+							layers.LayerTypeEthernet,
+							gopacket.Default,
+						)
+					} else {
+						common.Logger().WithFields(logrus.Fields{
+							"device": o,
+							"flow":   flow,
+							"frame":  retFrame,
+						}).Warn("No ETH found while processing PUSH VLAN action")
+					}
+				case openflow_13.OfpActionType_OFPAT_SET_FIELD:
+					common.Logger().WithFields(logrus.Fields{
+						"device": o,
+						"flow":   flow,
+						"frame":  retFrame,
+					}).Debug("Processing action OFPAT SET FIELD")
+					if action.GetSetField().GetField().GetOxmClass() ==
+						openflow_13.OfpOxmClass_OFPXMC_OPENFLOW_BASIC {
+						field := action.GetSetField().GetField().GetOfbField()
+
+						switch field.Type {
+						case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID:
+							common.Logger().WithFields(logrus.Fields{
+								"device": o,
+								"flow":   flow,
+								"frame":  retFrame,
+							}).Debug("Processing action OFPAT SET FIELD - VLAN VID")
+							if shim := common.GetDot1QLayer(retFrame); shim != nil {
+								eth := common.GetEthernetLayer(retFrame)
+								buffer := gopacket.NewSerializeBuffer()
+
+								var dot1qLayer *layers.Dot1Q
+								var ethernetLayer *layers.Ethernet
+								ethernetLayer = &layers.Ethernet{
+									SrcMAC:       eth.SrcMAC,
+									DstMAC:       eth.DstMAC,
+									EthernetType: eth.EthernetType,
+								}
+
+								dot1qLayer = &layers.Dot1Q{
+									Type:           shim.Type,
+									VLANIdentifier: uint16(field.GetVlanVid() & 4095),
+								}
+
+								gopacket.SerializeLayers(
+									buffer,
+									gopacket.SerializeOptions{},
+									ethernetLayer,
+									dot1qLayer,
+									gopacket.Payload(shim.LayerPayload()),
+								)
+								retFrame = gopacket.NewPacket(
+									buffer.Bytes(),
+									layers.LayerTypeEthernet,
+									gopacket.Default,
+								)
+
+								common.Logger().WithFields(logrus.Fields{
+									"device":    o,
+									"flow":      flow,
+									"frame":     retFrame,
+									"frameDump": retFrame.Dump(),
+									"vlanVid":   shim.VLANIdentifier,
+								}).Info("Setting DOT1Q VLAN VID")
+							} else {
+								common.Logger().WithFields(logrus.Fields{
+									"device": o,
+									"flow":   flow,
+									"frame":  retFrame,
+								}).Warn("No DOT1Q found while setting VLAN VID")
+							}
+
+						case openflow_13.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP:
+							common.Logger().WithFields(logrus.Fields{
+								"device": o,
+								"flow":   flow,
+								"frame":  retFrame,
+							}).Debug("Processing action OFPAT SET FIELD - VLAN PCP")
+							if shim := common.GetDot1QLayer(retFrame); shim != nil {
+								shim.Priority = uint8(field.GetVlanPcp())
+								common.Logger().WithFields(logrus.Fields{
+									"device":   o,
+									"flow":     flow,
+									"frame":    retFrame,
+									"priority": shim.Priority,
+								}).Info("Setting DOT1Q VLAN PCP")
+							} else {
+								common.Logger().WithFields(logrus.Fields{
+									"device": o,
+									"flow":   flow,
+									"frame":  retFrame,
+								}).Warn("No DOT1Q found while setting VLAN PCP")
+							}
+						default:
+							common.Logger().WithFields(logrus.Fields{
+								"device": o,
+								"flow":   flow,
+								"frame":  retFrame,
+								"type":   field.Type,
+							}).Warn("Set field not implemented for this type")
+						}
+					} else {
+						common.Logger().WithFields(logrus.Fields{
+							"device": o,
+							"flow":   flow,
+							"frame":  retFrame,
+						}).Warn("Field not of type OF-BASIC")
+					}
+				default:
+					common.Logger().WithFields(logrus.Fields{
+						"device": o,
+						"flow":   flow,
+						"frame":  retFrame,
+						"type":   action.Type,
+					}).Warn("Action type not implemented")
+				}
+			}
+		}
+	}
+
+	common.Logger().WithFields(logrus.Fields{
+		"device":     o,
+		"flow":       flow,
+		"egressPort": egressPort,
+		"retFrame":   retFrame,
+	}).Debug("Processed actions")
+
+	return egressPort, retFrame
+}
diff --git a/ponsim/v2/core/ponsim_device_state.go b/ponsim/v2/core/ponsim_device_state.go
new file mode 100644
index 0000000..a5805a2
--- /dev/null
+++ b/ponsim/v2/core/ponsim_device_state.go
@@ -0,0 +1,22 @@
+package core
+
+type PonSimDeviceState uint8
+
+const (
+	DISCONNECTED_FROM_PON PonSimDeviceState = iota
+	CONNECTED_TO_PON
+	REGISTERED_WITH_OLT
+	CONNECTED_IO_INTERFACE
+)
+
+// Execute state string equivalents
+var PonSimDeviceStateEnum = []string{
+	"DISCONNECTED_FROM_PON",
+	"CONNECTED_TO_PON",
+	"REGISTERED_WITH_OLT",
+	"CONNECTED_IO_INTERFACE",
+}
+
+func (s PonSimDeviceState) String() string {
+	return PonSimDeviceStateEnum[s]
+}
diff --git a/ponsim/v2/core/ponsim_device_type.go b/ponsim/v2/core/ponsim_device_type.go
new file mode 100644
index 0000000..306440c
--- /dev/null
+++ b/ponsim/v2/core/ponsim_device_type.go
@@ -0,0 +1,17 @@
+package core
+
+type PonSimDeviceType uint8
+
+const (
+	OLT PonSimDeviceType = iota
+	ONU
+)
+
+var enum_ponsim_device_types = []string{
+	"OLT",
+	"ONU",
+}
+
+func (t PonSimDeviceType) String() string {
+	return enum_ponsim_device_types[t]
+}
diff --git a/ponsim/v2/core/ponsim_interface.go b/ponsim/v2/core/ponsim_interface.go
new file mode 100644
index 0000000..d73d2ca
--- /dev/null
+++ b/ponsim/v2/core/ponsim_interface.go
@@ -0,0 +1,18 @@
+package core
+
+import (
+	"context"
+	"github.com/google/gopacket"
+)
+
+type PonSimInterface interface {
+	Start(context.Context)
+
+	Stop(context.Context)
+
+	GetAddress() string
+
+	GetPort() int32
+
+	Forward(context.Context, int, gopacket.Packet) error
+}
diff --git a/ponsim/v2/core/ponsim_metric.go b/ponsim/v2/core/ponsim_metric.go
new file mode 100644
index 0000000..d28c420
--- /dev/null
+++ b/ponsim/v2/core/ponsim_metric.go
@@ -0,0 +1,220 @@
+package core
+
+import (
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/protos/go/voltha"
+	"github.com/sirupsen/logrus"
+)
+
+/*
+metricCounter holds details for a specific metric
+*/
+type metricCounter struct {
+	Name  string
+	Value [2]int // [PON,NNI] values
+	Min   int
+	Max   int
+}
+
+/*
+Create a new MetricCounter instance for TX packets
+*/
+func newTxMetricCounter(name txMetricCounterType, min int, max int) *metricCounter {
+	return &metricCounter{Name: name.String(), Min: min, Max: max}
+}
+
+/*
+Create a new MetricCounter instance for RX packets
+*/
+func newRxMetricCounter(name rxMetricCounterType, min int, max int) *metricCounter {
+	return &metricCounter{Name: name.String(), Min: min, Max: max}
+}
+
+/*
+Define TX constants
+*/
+type txMetricCounterType uint8
+
+const (
+	tx_64_pkts txMetricCounterType = iota
+	tx_65_127_pkts
+	tx_128_255_pkts
+	tx_256_511_pkts
+	tx_512_1023_pkts
+	tx_1024_1518_pkts
+	tx_1519_9k_pkts
+)
+
+/*
+TX packet constants string equivalents
+*/
+var txMetricCounterEnum = []string{
+	"tx_64_pkts",
+	"tx_65_127_pkts",
+	"tx_128_255_pkts",
+	"tx_256_511_pkts",
+	"tx_512_1023_pkts",
+	"tx_1024_1518_pkts",
+	"tx_1519_9k_pkts",
+}
+
+func (t txMetricCounterType) String() string {
+	return txMetricCounterEnum[t]
+}
+
+/*
+Define RX constants
+*/
+type rxMetricCounterType uint8
+
+const (
+	rx_64_pkts rxMetricCounterType = iota
+	rx_65_127_pkts
+	rx_128_255_pkts
+	rx_256_511_pkts
+	rx_512_1023_pkts
+	rx_1024_1518_pkts
+	rx_1519_9k_pkts
+)
+
+/*
+RX packet constants string equivalents
+*/
+var rxMetricCounterEnum = []string{
+	"rx_64_pkts",
+	"rx_65_127_pkts",
+	"rx_128_255_pkts",
+	"rx_256_511_pkts",
+	"rx_512_1023_pkts",
+	"rx_1024_1518_pkts",
+	"rx_1519_9k_pkts",
+}
+
+func (t rxMetricCounterType) String() string {
+	return rxMetricCounterEnum[t]
+}
+
+/*
+
+ */
+type PonSimMetricCounter struct {
+	Name       string
+	TxCounters map[txMetricCounterType]*metricCounter
+	RxCounters map[rxMetricCounterType]*metricCounter
+}
+
+/*
+NewPonSimMetricCounter instantiates new metric counters for a PON device
+*/
+func NewPonSimMetricCounter(name string) *PonSimMetricCounter {
+	counter := &PonSimMetricCounter{Name: name}
+
+	counter.TxCounters = map[txMetricCounterType]*metricCounter{
+		tx_64_pkts:        newTxMetricCounter(tx_64_pkts, 1, 64),
+		tx_65_127_pkts:    newTxMetricCounter(tx_65_127_pkts, 65, 127),
+		tx_128_255_pkts:   newTxMetricCounter(tx_128_255_pkts, 128, 255),
+		tx_256_511_pkts:   newTxMetricCounter(tx_256_511_pkts, 256, 511),
+		tx_512_1023_pkts:  newTxMetricCounter(tx_512_1023_pkts, 512, 1023),
+		tx_1024_1518_pkts: newTxMetricCounter(tx_1024_1518_pkts, 1024, 1518),
+		tx_1519_9k_pkts:   newTxMetricCounter(tx_1519_9k_pkts, 1519, 9216),
+	}
+	counter.RxCounters = map[rxMetricCounterType]*metricCounter{
+		rx_64_pkts:        newRxMetricCounter(rx_64_pkts, 1, 64),
+		rx_65_127_pkts:    newRxMetricCounter(rx_65_127_pkts, 65, 127),
+		rx_128_255_pkts:   newRxMetricCounter(rx_128_255_pkts, 128, 255),
+		rx_256_511_pkts:   newRxMetricCounter(rx_256_511_pkts, 256, 511),
+		rx_512_1023_pkts:  newRxMetricCounter(rx_512_1023_pkts, 512, 1023),
+		rx_1024_1518_pkts: newRxMetricCounter(rx_1024_1518_pkts, 1024, 1518),
+		rx_1519_9k_pkts:   newRxMetricCounter(rx_1519_9k_pkts, 1519, 9216),
+	}
+
+	return counter
+}
+
+/*
+CountRxFrame increments the receive count for a specific packet size metric
+*/
+func (mc *PonSimMetricCounter) CountRxFrame(port int, size int) {
+	for k, v := range mc.RxCounters {
+		if size >= v.Min && size <= v.Max {
+			mc.RxCounters[k].Value[port-1] += 1
+		}
+	}
+}
+
+/*
+CountTxFrame increments the transmit count for a specific packet size metric
+*/
+func (mc *PonSimMetricCounter) CountTxFrame(port int, size int) {
+	for k, v := range mc.TxCounters {
+		if size >= v.Min && size <= v.Max {
+			mc.TxCounters[k].Value[port-1] += 1
+		}
+	}
+}
+
+/*
+LogCounts logs the current counts for all RX/TX packets
+*/
+func (mc *PonSimMetricCounter) LogCounts() {
+	common.Logger().WithFields(logrus.Fields{
+		"counters": mc.RxCounters,
+	}).Info("RX Metrics")
+	common.Logger().WithFields(logrus.Fields{
+		"counters": mc.TxCounters,
+	}).Info("TX Metrics")
+}
+
+/*
+MakeProto collects all RX/TX metrics with which it constructs a GRPC proto metrics structure
+*/
+func (mc *PonSimMetricCounter) MakeProto() *voltha.PonSimMetrics {
+	simMetrics := &voltha.PonSimMetrics{Device: mc.Name}
+	ponMetrics := &voltha.PonSimPortMetrics{PortName: "pon"}
+	nniMetrics := &voltha.PonSimPortMetrics{PortName: "nni"}
+
+	// Collect RX metrics
+	for _, c := range mc.RxCounters {
+		// PON values
+		ponMetrics.Packets = append(
+			ponMetrics.Packets,
+			&voltha.PonSimPacketCounter{
+				Name:  c.Name,
+				Value: int64(c.Value[0]),
+			},
+		)
+		// NNI values
+		nniMetrics.Packets = append(
+			nniMetrics.Packets,
+			&voltha.PonSimPacketCounter{
+				Name:  c.Name,
+				Value: int64(c.Value[1]),
+			},
+		)
+	}
+	// Collect TX metrics
+	for _, c := range mc.TxCounters {
+		// PON values
+		ponMetrics.Packets = append(
+			ponMetrics.Packets,
+			&voltha.PonSimPacketCounter{
+				Name:  c.Name,
+				Value: int64(c.Value[0]),
+			},
+		)
+		// NNI values
+		nniMetrics.Packets = append(
+			nniMetrics.Packets,
+			&voltha.PonSimPacketCounter{
+				Name:  c.Name,
+				Value: int64(c.Value[1]),
+			},
+		)
+	}
+
+	// Populate GRPC proto structure
+	simMetrics.Metrics = append(simMetrics.Metrics, ponMetrics)
+	simMetrics.Metrics = append(simMetrics.Metrics, nniMetrics)
+
+	return simMetrics
+}
diff --git a/ponsim/v2/core/ponsim_olt.go b/ponsim/v2/core/ponsim_olt.go
new file mode 100644
index 0000000..2485a67
--- /dev/null
+++ b/ponsim/v2/core/ponsim_olt.go
@@ -0,0 +1,403 @@
+package core
+
+import (
+	"context"
+	"crypto/tls"
+	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/google/gopacket"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/protos/go/ponsim"
+	"github.com/sirupsen/logrus"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/connectivity"
+	"google.golang.org/grpc/credentials"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// TODO: Pass-in the certificate information as a structure parameter
+
+/*
+PonSimOltDevice is the structure responsible for the handling of an OLT device
+*/
+type PonSimOltDevice struct {
+	PonSimDevice  `json:pon_device`
+	VCoreEndpoint string                  `json:vcore_ep`
+	MaxOnuCount   int                     `json:max_onu`
+	Onus          map[int32]*OnuRegistree `json:onu_registrees`
+	outgoing      chan []byte
+
+	counterLoop *common.IntervalHandler
+	alarmLoop   *common.IntervalHandler
+}
+
+/*
+
+ */
+type OnuRegistree struct {
+	Device *PonSimOnuDevice                      `json:onu_device`
+	Conn   *grpc.ClientConn                      `json:grpc_conn`
+	Client ponsim.PonSimCommonClient             `json:client`
+	Stream ponsim.PonSimCommon_ProcessDataClient `json:stream`
+}
+
+const (
+	BASE_PORT_NUMBER = 128
+)
+
+/*
+NewPonSimOltDevice instantiates a new OLT device structure
+*/
+func NewPonSimOltDevice(device PonSimDevice) *PonSimOltDevice {
+	olt := &PonSimOltDevice{PonSimDevice: device}
+	return olt
+}
+
+/*
+forwardToONU defines a EGRESS function to forward a packet to a specific ONU
+*/
+func (o *PonSimOltDevice) forwardToONU(onuPort int32) func(int, gopacket.Packet) {
+	return func(port int, frame gopacket.Packet) {
+		ipAddress := common.GetInterfaceIP(o.ExternalIf)
+		incoming := &ponsim.IncomingData{
+			Id:      "EGRESS.OLT." + ipAddress,
+			Address: ipAddress,
+			Port:    int32(port),
+			Payload: frame.Data(),
+		}
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"port":   port,
+			"frame":  frame,
+		}).Debug("Forwarding to ONU")
+
+		// Forward packet to ONU
+		if err := o.GetOnu(onuPort).Stream.Send(incoming); err != nil {
+			common.Logger().WithFields(logrus.Fields{
+				"device":    o,
+				"frameDump": frame.Dump(),
+				"incoming":  incoming,
+				"error":     err.Error(),
+			}).Error("A problem occurred while forwarding to ONU")
+		}
+
+	}
+}
+
+/*
+forwardToLAN defines an INGRESS function to forward a packet to VOLTHA
+*/
+func (o *PonSimOltDevice) forwardToLAN() func(int, gopacket.Packet) {
+	return func(port int, frame gopacket.Packet) {
+		common.Logger().WithFields(logrus.Fields{
+			"frame": frame.Dump(),
+		}).Info("Sending packet")
+
+		select {
+		case o.outgoing <- frame.Data():
+			common.Logger().WithFields(logrus.Fields{
+				"frame": frame.Dump(),
+			}).Info("Sent packet")
+		default:
+			common.Logger().WithFields(logrus.Fields{
+				"frame": frame.Dump(),
+			}).Warn("Unable to send packet")
+		}
+	}
+}
+
+/*
+Start performs setup operations for an OLT device
+*/
+func (o *PonSimOltDevice) Start(ctx context.Context) {
+	common.Logger().Info("Starting OLT device...")
+	o.PonSimDevice.Start(ctx)
+
+	// Open network interfaces for listening
+	o.connectNetworkInterfaces()
+
+	o.outgoing = make(chan []byte, 1)
+
+	// Add INGRESS operation
+	o.AddLink(2, 0, o.forwardToLAN())
+
+	// Start PM counter logging
+	o.counterLoop = common.NewIntervalHandler(90, o.Counter.LogCounts)
+	o.counterLoop.Start()
+
+	// Start alarm simulation
+	if o.AlarmsOn {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+		}).Debug("Starting alarm simulation")
+
+		alarms := NewPonSimAlarm(o.InternalIf, o.VCoreEndpoint, o.forwardToLAN())
+		o.alarmLoop = common.NewIntervalHandler(o.AlarmsFreq, alarms.GenerateAlarm)
+		o.alarmLoop.Start()
+	}
+}
+
+/*
+Stop performs cleanup operations for an OLT device
+*/
+func (o *PonSimOltDevice) Stop(ctx context.Context) {
+	common.Logger().Info("Stopping OLT device...")
+
+	// Stop PM counters loop
+	o.counterLoop.Stop()
+	o.counterLoop = nil
+
+	// Stop alarm simulation
+	if o.AlarmsOn {
+		o.alarmLoop.Stop()
+	}
+	o.alarmLoop = nil
+
+	o.ingressHandler.Close()
+	o.egressHandler.Close()
+
+	o.PonSimDevice.Stop(ctx)
+}
+
+/*
+ConnectToRemoteOnu establishes communication to a remote ONU device
+*/
+func (o *PonSimOltDevice) ConnectToRemoteOnu(onu *OnuRegistree) error {
+	var err error
+
+	host := strings.Join([]string{
+		onu.Device.Address,
+		strconv.Itoa(int(onu.Device.Port)),
+	}, ":")
+
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+		"host":   host,
+	}).Debug("Formatting host address")
+
+	// TODO: make it secure
+	ta := credentials.NewTLS(&tls.Config{
+		//Certificates:       []tls.Certificate{peerCert},
+		//RootCAs:            caCertPool,
+		InsecureSkipVerify: true,
+	})
+
+	// GRPC communication needs to be secured
+	if onu.Conn, err = grpc.DialContext(
+		context.Background(),
+		host,
+		grpc.WithTransportCredentials(ta),
+	); err != nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"error":  err.Error(),
+		}).Error("Problem with client connection")
+	}
+
+	return err
+}
+
+/*
+Listen waits for incoming EGRESS data on the internal interface
+*/
+func (o *PonSimOltDevice) Listen(ctx context.Context, port int32) {
+	var reply *empty.Empty
+	var err error
+
+	// Establish a GRPC connection with the ONU
+	onu := o.GetOnu(port)
+
+	common.Logger().WithFields(logrus.Fields{
+		"onu": onu,
+	}).Debug("Connecting to remote ONU")
+
+	if onu.Client = ponsim.NewPonSimCommonClient(onu.Conn); onu.Client == nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+		}).Error("Problem establishing client connection to ONU")
+		o.RemoveOnu(ctx, port)
+		return
+	}
+
+	// Prepare stream to ONU to forward incoming data as needed
+	if onu.Stream, err = onu.Client.ProcessData(ctx); err != nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+		}).Error("Problem establishing stream to ONU")
+		o.RemoveOnu(ctx, port)
+		return
+	}
+
+	defer o.egressHandler.Close()
+	packetSource := gopacket.NewPacketSource(o.egressHandler, o.egressHandler.LinkType())
+	common.Logger().WithFields(logrus.Fields{
+		"device":    o,
+		"interface": o.InternalIf,
+	}).Debug("Listening to incoming EGRESS data")
+
+	// Wait for incoming EGRESS data
+	for packet := range packetSource.Packets() {
+		if dot1q := common.GetDot1QLayer(packet); dot1q != nil {
+			common.Logger().WithFields(logrus.Fields{
+				"device": o,
+				"packet": packet,
+			}).Debug("Received EGRESS packet")
+
+			o.Forward(ctx, 2, packet)
+		}
+	}
+
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+	}).Debug("No more packets to process")
+
+	if reply, err = onu.Stream.CloseAndRecv(); err != nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"error":  err.Error(),
+		}).Error("A problem occurred while closing client stream")
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"reply":  reply,
+		}).Warn("Client stream closed")
+	}
+}
+
+/*
+GetOnus returns the list of registered ONU devices
+*/
+func (o *PonSimOltDevice) GetOnus() map[int32]*OnuRegistree {
+	if o.Onus == nil {
+		o.Onus = make(map[int32]*OnuRegistree)
+	}
+
+	return o.Onus
+}
+
+/*
+GetOnu return a specific registered ONU
+*/
+func (o *PonSimOltDevice) GetOnu(index int32) *OnuRegistree {
+	var onu *OnuRegistree
+	var ok bool
+
+	if onu, ok = (o.GetOnus())[index]; ok {
+		return onu
+	}
+
+	return nil
+}
+
+func (o *PonSimOltDevice) GetOutgoing() chan []byte {
+	return o.outgoing
+}
+
+/*
+nextAvailablePort returns a port that is not already used by a registered ONU
+*/
+func (o *PonSimOltDevice) nextAvailablePort() int32 {
+	var port int32 = BASE_PORT_NUMBER
+
+	if len(o.GetOnus()) < o.MaxOnuCount {
+		for {
+			if o.GetOnu(port) != nil {
+				// port is already used
+				port += 1
+			} else {
+				// port is available... use it
+				return port
+			}
+		}
+	} else {
+		// OLT has reached its max number of ONUs
+		return -1
+	}
+}
+
+/*
+AddOnu registers an ONU device and sets up all required monitoring and connections
+*/
+func (o *PonSimOltDevice) AddOnu(onu *PonSimOnuDevice) (int32, error) {
+	var portNum int32
+	ctx := context.Background()
+
+	if portNum = o.nextAvailablePort(); portNum != -1 {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"port":   portNum,
+			"onu":    onu,
+		}).Info("Adding ONU")
+
+		registree := &OnuRegistree{Device: onu}
+
+		// Setup GRPC communication and check if it succeeded
+		if err := o.ConnectToRemoteOnu(registree); err == nil {
+			o.GetOnus()[portNum] = registree
+
+			o.AddLink(1, int(portNum), o.forwardToONU(portNum))
+			go o.MonitorOnu(ctx, portNum)
+			go o.Listen(ctx, portNum)
+		}
+
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+		}).Warn("ONU Map is full")
+	}
+
+	return int32(portNum), nil
+}
+
+/*
+RemoveOnu removes the reference to a registered ONU
+*/
+func (o *PonSimOltDevice) RemoveOnu(ctx context.Context, onuIndex int32) error {
+	onu := o.GetOnu(onuIndex)
+	if err := onu.Conn.Close(); err != nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device":   o,
+			"onu":      onu.Device,
+			"onuIndex": onuIndex,
+		}).Error("Problem closing connection to ONU")
+	}
+
+	common.Logger().WithFields(logrus.Fields{
+		"device":   o,
+		"onu":      onu,
+		"onuIndex": onuIndex,
+	}).Info("Removing ONU")
+
+	delete(o.Onus, onuIndex)
+
+	// Remove link entries for this ONU
+	o.RemoveLink(1, int(onuIndex))
+
+	return nil
+}
+
+/*
+MonitorOnu verifies the connection status of a specific ONU and cleans up as necessary
+*/
+func (o *PonSimOltDevice) MonitorOnu(ctx context.Context, onuIndex int32) {
+	for {
+		if o.GetOnu(onuIndex) != nil {
+			if conn := o.GetOnu(onuIndex).Conn; conn.GetState() == connectivity.Ready {
+				// Wait for any change to occur
+				conn.WaitForStateChange(ctx, conn.GetState())
+				// We lost communication with the ONU ... remove it
+				o.RemoveOnu(ctx, onuIndex)
+				return
+			}
+			common.Logger().WithFields(logrus.Fields{
+				"device":   o,
+				"ctx":      ctx,
+				"onuIndex": onuIndex,
+			}).Debug("ONU is not ready")
+			time.Sleep(1 * time.Second)
+		} else {
+			return
+		}
+	}
+}
diff --git a/ponsim/v2/core/ponsim_onu.go b/ponsim/v2/core/ponsim_onu.go
new file mode 100644
index 0000000..f58d473
--- /dev/null
+++ b/ponsim/v2/core/ponsim_onu.go
@@ -0,0 +1,388 @@
+package core
+
+import (
+	"context"
+	"crypto/tls"
+	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/google/gopacket"
+	"github.com/google/uuid"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/protos/go/ponsim"
+	"github.com/sirupsen/logrus"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// TODO: Cleanup GRPC security config
+// TODO: Pass-in the certificate information as a structure parameter
+
+/*
+PonSimOnuDevice is the structure responsible for the handling of an ONU device
+*/
+type PonSimOnuDevice struct {
+	PonSimDevice
+
+	ParentAddress string
+	ParentPort    int32
+	AssignedPort  int32
+	Conn          *grpc.ClientConn
+
+	oltClient ponsim.PonSimCommonClient
+	stream    ponsim.PonSimCommon_ProcessDataClient
+	monitor   chan PonSimDeviceState
+	state     PonSimDeviceState
+}
+
+/*
+NewPonSimOnuDevice instantiates a new ONU device structure
+*/
+func NewPonSimOnuDevice(device PonSimDevice) *PonSimOnuDevice {
+	onu := &PonSimOnuDevice{PonSimDevice: device}
+
+	return onu
+}
+
+/*
+forwardToOLT defines a INGRESS function to forward a packet to the parent OLT
+*/
+func (o *PonSimOnuDevice) forwardToOLT() func(int, gopacket.Packet) {
+	return func(port int, frame gopacket.Packet) {
+		ipAddress := common.GetInterfaceIP(o.InternalIf)
+		incoming := &ponsim.IncomingData{
+			Id:      "INGRESS.ONU." + ipAddress,
+			Address: ipAddress,
+			Port:    int32(port),
+			Payload: frame.Data(),
+		}
+		common.Logger().WithFields(logrus.Fields{
+			"device":    o,
+			"port":      port,
+			"frame":     frame,
+			"frameDump": frame.Dump(),
+			"incoming":  incoming,
+		}).Debug("Forwarding to OLT")
+
+		// Forward packet to OLT
+		if err := o.stream.Send(incoming); err != nil {
+			common.Logger().WithFields(logrus.Fields{
+				"device":    o,
+				"port":      port,
+				"frameDump": frame.Dump(),
+				"incoming":  incoming,
+			}).Fatal("A problem occurred while forwarding to OLT")
+		}
+	}
+}
+
+/*
+forwardToWAN defines a EGRESS function to forward a packet to the world
+*/
+func (o *PonSimOnuDevice) forwardToWAN() func(int, gopacket.Packet) {
+	return func(port int, frame gopacket.Packet) {
+		var err error
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"port":   port,
+			"frame":  frame,
+		}).Debug("Forwarding packet to world")
+		if err = o.ingressHandler.WritePacketData(frame.Data()); err != nil {
+			common.Logger().WithFields(logrus.Fields{
+				"device": o,
+				"port":   port,
+				"frame":  frame,
+			}).Fatal("Problem while forwarding packet to world")
+		} else {
+			common.Logger().WithFields(logrus.Fields{
+				"device": o,
+				"port":   port,
+				"frame":  frame,
+			}).Debug("Forwarded packet to world")
+		}
+	}
+}
+
+/*
+Start performs setup operations for an ONU device
+*/
+func (o *PonSimOnuDevice) Start(ctx context.Context) {
+	// Initialize the parent
+	o.PonSimDevice.Start(ctx)
+
+	// Setup flow behaviours
+	// ONU -> OLT
+	o.AddLink(1, 0, o.forwardToOLT())
+	// ONU -> World
+	o.AddLink(2, 0, o.forwardToWAN())
+
+	go o.MonitorConnection(ctx)
+}
+
+/*
+Stop performs cleanup operations for an ONU device
+*/
+func (o *PonSimOnuDevice) Stop(ctx context.Context) {
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+	}).Debug("Stopping ONU")
+
+	o.RemoveLink(1, 0)
+	o.RemoveLink(2, 0)
+
+	o.PonSimDevice.Stop(ctx)
+}
+
+/*
+Listen waits for incoming INGRESS data on the external interface
+*/
+func (o *PonSimOnuDevice) Listen(ctx context.Context) {
+	var reply *empty.Empty
+	var err error
+
+	if o.oltClient = ponsim.NewPonSimCommonClient(o.Conn); o.oltClient == nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+		}).Fatal("Problem establishing client connection to OLT")
+		panic("Problem establishing client connection to OLT")
+	}
+
+	// Establish GRPC connection with OLT
+	if o.stream, err = o.oltClient.ProcessData(ctx); err != nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"error":  err.Error(),
+		}).Fatal("Problem establishing stream")
+		panic(err)
+	}
+
+	defer o.ingressHandler.Close()
+	packetSource := gopacket.NewPacketSource(o.ingressHandler, o.ingressHandler.LinkType())
+	common.Logger().WithFields(logrus.Fields{
+		"device":    o,
+		"interface": o.ExternalIf,
+	}).Debug("Listening to incoming ONU data")
+
+	for packet := range packetSource.Packets() {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"packet": packet,
+		}).Debug("Received INGRESS packet")
+
+		o.Forward(ctx, 2, packet)
+	}
+
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+	}).Debug("No more packets to process")
+
+	if reply, err = o.stream.CloseAndRecv(); err != nil {
+		common.Logger().Fatal("A problem occurred while closing Ingress stream", err.Error())
+	} else {
+		common.Logger().Info("Ingress stream closed", reply)
+	}
+}
+
+/*
+Register sends a registration request to the remote OLT
+*/
+func (o *PonSimOnuDevice) Register(ctx context.Context) error {
+	var err error
+	var rreq *ponsim.RegistrationRequest
+	var rrep *ponsim.RegistrationReply
+	var client ponsim.PonSimOltClient
+
+	if o.Conn != nil {
+		if client = ponsim.NewPonSimOltClient(o.Conn); client != nil {
+			rreq = &ponsim.RegistrationRequest{
+				Id:      uuid.New().String(),
+				Address: common.GetInterfaceIP(o.InternalIf),
+				Port:    o.Port,
+			}
+			common.Logger().Printf("Request details %+v\n", rreq)
+
+			// TODO: Loop registration until an OLT becomes available??
+
+			rrep, err = client.Register(ctx, rreq)
+			if err != nil {
+				common.Logger().Printf("Problem with registration", err.Error())
+			} else {
+				// Save OLT address details
+				o.ParentAddress = rrep.GetParentAddress()
+				o.ParentPort = rrep.GetParentPort()
+				o.AssignedPort = rrep.GetAssignedPort()
+
+				common.Logger().Printf("Registration details - %+v\n", rrep)
+
+				o.monitor <- REGISTERED_WITH_OLT
+			}
+
+		} else {
+			common.Logger().Info("Client is NIL")
+		}
+	}
+
+	return err
+}
+
+/*
+MonitorConnection verifies the communication with the OLT
+*/
+func (o *PonSimOnuDevice) MonitorConnection(ctx context.Context) {
+	for {
+		if o.state == DISCONNECTED_FROM_PON {
+			// Establish communication with OLT
+			o.Connect(ctx)
+		}
+
+		if o.state == CONNECTED_TO_PON {
+			// Just stay idle while the ONU-OLT connection is up
+			o.Conn.WaitForStateChange(ctx, o.Conn.GetState())
+
+			// The ONU-OLT connection was lost... need to cleanup
+			o.Disconnect(ctx)
+		}
+
+		time.Sleep(1 * time.Second)
+	}
+}
+
+/*
+Connect sets up communication and monitoring with remote OLT
+*/
+func (o *PonSimOnuDevice) Connect(ctx context.Context) {
+	o.monitor = make(chan PonSimDeviceState, 1)
+
+	// Define a waitgroup to block the current routine until
+	// a CONNECTED state is reached
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+
+	go o.MonitorState(ctx, &wg)
+
+	o.ConnectToRemoteOlt()
+
+	// Wait until we establish a connection to the remote PON
+	wg.Wait()
+}
+
+/*
+Disconnect tears down communication and monitoring with remote OLT
+*/
+func (o *PonSimOnuDevice) Disconnect(ctx context.Context) {
+	if o.egressHandler != nil {
+		o.egressHandler.Close()
+		o.egressHandler = nil
+	}
+
+	if o.Conn != nil {
+		o.Conn.Close()
+		o.Conn = nil
+	}
+
+	if o.monitor != nil {
+		close(o.monitor)
+		o.monitor = nil
+		o.state = DISCONNECTED_FROM_PON
+	}
+}
+
+/*
+MonitorState follows the progress of the OLT connection
+*/
+func (o *PonSimOnuDevice) MonitorState(ctx context.Context, wg *sync.WaitGroup) {
+	// Start a concurrent routine to handle ONU state changes
+	var ok bool
+	for {
+		select {
+		case o.state, ok = <-o.monitor:
+			if ok {
+				common.Logger().WithFields(logrus.Fields{
+					"device": o,
+					"state":  o.state,
+				}).Info("Received monitoring state")
+
+				switch o.state {
+				case CONNECTED_TO_PON:
+					// We have successfully connected to the OLT
+					// proceed with registration
+					wg.Done()
+
+					if err := o.Register(ctx); err != nil {
+						o.Disconnect(ctx)
+					}
+
+				case DISCONNECTED_FROM_PON:
+					// Connection to remote OLT was lost... exit
+					common.Logger().WithFields(logrus.Fields{
+						"device": o,
+					}).Warn("Exiting due to disconnection")
+					return
+
+				case REGISTERED_WITH_OLT:
+					// Start listening on network interfaces
+					o.connectNetworkInterfaces()
+					o.monitor <- CONNECTED_IO_INTERFACE
+
+				case CONNECTED_IO_INTERFACE:
+					// Start listening on local interfaces
+					go o.Listen(ctx)
+				}
+			} else {
+				common.Logger().WithFields(logrus.Fields{
+					"device": o,
+				}).Warn("Monitoring channel has closed")
+				return
+			}
+		case <-ctx.Done():
+			common.Logger().WithFields(logrus.Fields{
+				"device": o,
+			}).Warn("Received a cancellation notification")
+
+			return
+		}
+	}
+}
+
+/*
+ConnectToRemoteOlt establishes GRPC communication with the remote OLT
+*/
+func (o *PonSimOnuDevice) ConnectToRemoteOlt() {
+	common.Logger().WithFields(logrus.Fields{
+		"device": o,
+	}).Debug("Connecting to remote device")
+
+	var err error
+
+	host := strings.Join([]string{
+		o.ParentAddress,
+		strconv.Itoa(int(o.ParentPort)),
+	}, ":")
+
+	// TODO: make it secure
+	// GRPC communication needs to be secured
+	ta := credentials.NewTLS(&tls.Config{
+		//Certificates:       []tls.Certificate{peerCert},
+		//RootCAs:            caCertPool,
+		InsecureSkipVerify: true,
+	})
+
+	if o.Conn, err = grpc.DialContext(
+		context.Background(), host, grpc.WithTransportCredentials(ta), grpc.WithBlock(),
+	); err != nil {
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+			"error":  err.Error(),
+		}).Error("Problem establishing connection")
+	} else {
+		// We are now connected
+		// time to move on
+		common.Logger().WithFields(logrus.Fields{
+			"device": o,
+		}).Info("Connected to OLT")
+	}
+
+	o.monitor <- CONNECTED_TO_PON
+}
diff --git a/ponsim/v2/core/xponsim_device.go b/ponsim/v2/core/xponsim_device.go
new file mode 100644
index 0000000..aa7d64a
--- /dev/null
+++ b/ponsim/v2/core/xponsim_device.go
@@ -0,0 +1,215 @@
+package core
+
+import (
+	"context"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/protos/go/bbf_fiber"
+	"github.com/opencord/voltha/protos/go/voltha"
+	"github.com/sirupsen/logrus"
+)
+
+type XPonSimDevice struct {
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) Start(ctx context.Context) {
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) Stop(ctx context.Context) {
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) CreateInterface(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("create-interface-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) UpdateInterface(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("update-interface-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) RemoveInterface(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("remove-interface-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) CreateTcont(ctx context.Context,
+	config *bbf_fiber.TcontsConfigData,
+	profile *bbf_fiber.TrafficDescriptorProfileData,
+) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":                                ctx,
+		"device":                                 d,
+		"tcont_config_data":                      config,
+		"traffic_descriptor_profile_config_data": profile,
+	}).Info("create-tcont-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) UpdateTcont(
+	ctx context.Context,
+	config *bbf_fiber.TcontsConfigData,
+	profile *bbf_fiber.TrafficDescriptorProfileData,
+) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":                                ctx,
+		"device":                                 d,
+		"tcont_config_data":                      config,
+		"traffic_descriptor_profile_config_data": profile,
+	}).Info("update-tcont-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) RemoveTcont(
+	ctx context.Context,
+	config *bbf_fiber.TcontsConfigData,
+	profile *bbf_fiber.TrafficDescriptorProfileData,
+) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":                                ctx,
+		"device":                                 d,
+		"tcont_config_data":                      config,
+		"traffic_descriptor_profile_config_data": profile,
+	}).Info("remove-tcont-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) CreateGemport(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("create-gemport-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) UpdateGemport(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("update-gemport-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) RemoveGemport(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("remove-gemport-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) CreateMulticastGemport(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("create-multicast-gemport-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) UpdateMulticastGemport(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("update-multicast-gemport-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) RemoveMulticastGemport(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("remove-multicast-gemport-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) CreateMulticastDistributionSet(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("create-multicast-distribution-set-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) UpdateMulticastDistributionSet(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("update-multicast-distribution-set-request")
+}
+
+/*
+
+ */
+func (d *XPonSimDevice) RemoveMulticastDistributionSet(ctx context.Context, config *voltha.InterfaceConfig) {
+	common.Logger().WithFields(logrus.Fields{
+		"context":        ctx,
+		"device":         d,
+		"interface_type": config.GetInterfaceType(),
+		"data":           config,
+	}).Info("remove-multicast-distribution-set-request")
+}
diff --git a/ponsim/v2/grpc/grpc_security.go b/ponsim/v2/grpc/grpc_security.go
new file mode 100644
index 0000000..6dab468
--- /dev/null
+++ b/ponsim/v2/grpc/grpc_security.go
@@ -0,0 +1,7 @@
+package grpc
+
+type GrpcSecurity struct {
+	KeyFile  string
+	CertFile string
+	CaFile   string
+}
diff --git a/ponsim/v2/grpc/grpc_server.go b/ponsim/v2/grpc/grpc_server.go
new file mode 100644
index 0000000..aaa8a4d
--- /dev/null
+++ b/ponsim/v2/grpc/grpc_server.go
@@ -0,0 +1,162 @@
+package grpc
+
+import (
+	"net"
+
+	"context"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/ponsim/v2/core"
+	"github.com/opencord/voltha/ponsim/v2/grpc/nbi"
+	"github.com/opencord/voltha/ponsim/v2/grpc/sbi"
+	"github.com/opencord/voltha/protos/go/bal"
+	"github.com/opencord/voltha/protos/go/ponsim"
+	"github.com/opencord/voltha/protos/go/voltha"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"strconv"
+	"strings"
+)
+
+type GrpcServer struct {
+	gs       *grpc.Server
+	address  string
+	port     int32
+	secure   bool
+	services []func(*grpc.Server)
+
+	*GrpcSecurity
+}
+
+/*
+Instantiate a GRPC server data structure
+*/
+func NewGrpcServer(
+	address string,
+	port int32,
+	certs *GrpcSecurity,
+	secure bool,
+) *GrpcServer {
+	server := &GrpcServer{
+		address:      address,
+		port:         port,
+		secure:       secure,
+		GrpcSecurity: certs,
+	}
+	return server
+}
+
+/*
+Start prepares the GRPC server and starts servicing requests
+*/
+func (s *GrpcServer) Start(ctx context.Context) {
+	host := strings.Join([]string{
+		s.address,
+		strconv.Itoa(int(s.port)),
+	}, ":")
+
+	lis, err := net.Listen("tcp", host)
+	if err != nil {
+		common.Logger().Fatalf("failed to listen: %v", err)
+	}
+
+	if s.secure {
+		creds, err := credentials.NewServerTLSFromFile(s.CertFile, s.KeyFile)
+		if err != nil {
+			common.Logger().Fatalf("could not load TLS keys: %s", err)
+		}
+		s.gs = grpc.NewServer(grpc.Creds(creds))
+
+	} else {
+		common.Logger().Println("In DEFAULT\n")
+		s.gs = grpc.NewServer()
+	}
+
+	// Register all required services
+	for _, service := range s.services {
+		service(s.gs)
+	}
+
+	if err := s.gs.Serve(lis); err != nil {
+		common.Logger().Fatalf("failed to serve: %v\n", err)
+	}
+}
+
+/*
+Stop servicing GRPC requests
+*/
+func (s *GrpcServer) Stop() {
+	s.gs.Stop()
+}
+
+/*
+AddService appends a generic service request function
+*/
+func (s *GrpcServer) AddService(
+	registerFunction func(*grpc.Server, interface{}),
+	handler interface{},
+) {
+	s.services = append(s.services, func(gs *grpc.Server) { registerFunction(gs, handler) })
+}
+
+/*
+AddPonSimService appends service request functions for PonSim devices
+*/
+func (s *GrpcServer) AddPonSimService(device core.PonSimInterface) {
+	s.services = append(
+		s.services,
+		func(gs *grpc.Server) {
+			voltha.RegisterPonSimServer(gs, nbi.NewPonSimHandler(device))
+		},
+	)
+}
+
+/*
+AddCommonService appends service request functions common to all PonSim devices
+*/
+func (s *GrpcServer) AddCommonService(device core.PonSimInterface) {
+	s.services = append(
+		s.services,
+		func(gs *grpc.Server) {
+			ponsim.RegisterPonSimCommonServer(gs, sbi.NewPonSimCommonHandler(device))
+		},
+	)
+}
+
+/*
+AddOltService appends service request functions specific to OLT devices
+*/
+func (s *GrpcServer) AddOltService(device core.PonSimInterface) {
+	s.services = append(
+		s.services,
+		func(gs *grpc.Server) {
+			ponsim.RegisterPonSimOltServer(
+				gs,
+				sbi.NewPonSimOltHandler(device.(*core.PonSimOltDevice)),
+			)
+		},
+	)
+}
+
+/*
+AddXPonService appends service request functions specific to XPonSim
+*/
+func (s *GrpcServer) AddXPonService() {
+	s.services = append(
+		s.services,
+		func(gs *grpc.Server) {
+			voltha.RegisterXPonSimServer(gs, nbi.NewXPonSimHandler())
+		},
+	)
+}
+
+/*
+AddBalService appends service request functions specific to BAL
+*/
+func (s *GrpcServer) AddBalService() {
+	s.services = append(
+		s.services,
+		func(gs *grpc.Server) {
+			bal.RegisterBalServer(gs, nbi.NewBalHandler())
+		},
+	)
+}
diff --git a/ponsim/v2/grpc/nbi/bal_handler.go b/ponsim/v2/grpc/nbi/bal_handler.go
new file mode 100644
index 0000000..5cbafb3
--- /dev/null
+++ b/ponsim/v2/grpc/nbi/bal_handler.go
@@ -0,0 +1,82 @@
+package nbi
+
+import (
+	"context"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/protos/go/bal"
+)
+
+// TODO: fix BAL function parameters and returns
+
+type BalHandler struct {
+}
+
+func NewBalHandler() *BalHandler {
+	var handler *BalHandler
+	handler = &BalHandler{}
+	return handler
+}
+
+func (handler *BalHandler) BalApiInit(
+	ctx context.Context,
+	request *bal.BalInit,
+) (*bal.BalErr, error) {
+	common.Logger().Info("BalApiInit Called", ctx, request)
+	return &bal.BalErr{Err: bal.BalErrno_BAL_ERR_OK}, nil
+}
+
+func (handler *BalHandler) BalApiFinish(
+	ctx context.Context,
+	request *bal.BalCfg,
+) (*bal.BalErr, error) {
+	common.Logger().Info("BalApiFinish Called", ctx, request)
+	return &bal.BalErr{Err: bal.BalErrno_BAL_ERR_OK}, nil
+}
+
+func (handler *BalHandler) BalCfgSet(
+	ctx context.Context,
+	request *bal.BalCfg,
+) (*bal.BalErr, error) {
+	common.Logger().Info("BalCfgSet Called", ctx, request)
+	return &bal.BalErr{Err: bal.BalErrno_BAL_ERR_OK}, nil
+}
+
+func (handler *BalHandler) BalCfgClear(
+	ctx context.Context,
+	request *bal.BalKey,
+) (*bal.BalErr, error) {
+	common.Logger().Info("BalCfgClear Called", ctx, request)
+	return &bal.BalErr{Err: bal.BalErrno_BAL_ERR_OK}, nil
+}
+
+func (handler *BalHandler) BalCfgGet(
+	ctx context.Context,
+	request *bal.BalKey,
+) (*bal.BalCfg, error) {
+	common.Logger().Info("BalCfgGet Called", ctx, request)
+	return &bal.BalCfg{}, nil
+}
+
+func (handler *BalHandler) BalApiReboot(
+	ctx context.Context,
+	request *bal.BalReboot,
+) (*bal.BalErr, error) {
+	common.Logger().Info("BalApiReboot Called", ctx, request)
+	return &bal.BalErr{Err: bal.BalErrno_BAL_ERR_OK}, nil
+}
+
+func (handler *BalHandler) BalApiHeartbeat(
+	ctx context.Context,
+	request *bal.BalHeartbeat,
+) (*bal.BalRebootState, error) {
+	common.Logger().Info("BalApiHeartbeat Called", ctx, request)
+	return &bal.BalRebootState{}, nil
+}
+
+func (handler *BalHandler) BalCfgStatGet(
+	ctx context.Context,
+	request *bal.BalInterfaceKey,
+) (*bal.BalInterfaceStat, error) {
+	common.Logger().Info("BalCfgStatGet Called", ctx, request)
+	return &bal.BalInterfaceStat{}, nil
+}
diff --git a/ponsim/v2/grpc/nbi/ponsim_handler.go b/ponsim/v2/grpc/nbi/ponsim_handler.go
new file mode 100644
index 0000000..763f4bc
--- /dev/null
+++ b/ponsim/v2/grpc/nbi/ponsim_handler.go
@@ -0,0 +1,327 @@
+package nbi
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/ponsim/v2/core"
+	"github.com/opencord/voltha/protos/go/voltha"
+	"github.com/sirupsen/logrus"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"strconv"
+	"strings"
+)
+
+// TODO: Cleanup GRPC security config
+// TODO: Pass-in the certificate information as a structure parameter
+
+type PonSimHandler struct {
+	device core.PonSimInterface
+}
+
+/*
+NewPonSimHandler instantiates a handler for a PonSim device
+*/
+func NewPonSimHandler(device core.PonSimInterface) *PonSimHandler {
+	var handler *PonSimHandler
+	handler = &PonSimHandler{device: device}
+	return handler
+}
+
+/*
+SendFrame handles and forwards EGRESS packets (i.e. VOLTHA to OLT)
+*/
+func (handler *PonSimHandler) SendFrame(ctx context.Context, data *voltha.PonSimFrame) (*empty.Empty, error) {
+	frame := gopacket.NewPacket(data.Payload, layers.LayerTypeEthernet, gopacket.Default)
+
+	common.Logger().WithFields(logrus.Fields{
+		"handler": handler,
+		"frame":   frame.Dump(),
+	}).Info("Constructed frame")
+
+	handler.device.Forward(context.Background(), 2, frame)
+
+	out := new(empty.Empty)
+	return out, nil
+}
+
+/*
+ReceiveFrames handles a stream of INGRESS packets (i.e. OLT to VOLTHA)
+*/
+func (handler *PonSimHandler) ReceiveFrames(empty *empty.Empty, stream voltha.PonSim_ReceiveFramesServer) error {
+	common.Logger().WithFields(logrus.Fields{
+		"handler": handler,
+	}).Info("start-receiving-frames")
+
+	if _, ok := (handler.device).(*core.PonSimOltDevice); ok {
+		var data []byte
+		var ok bool
+
+		common.Logger().WithFields(logrus.Fields{
+			"handler": handler,
+			"device":  (handler.device).(*core.PonSimOltDevice),
+		}).Info("receiving-frames-from-olt-device")
+
+		for {
+			select {
+			case data, ok = <-(handler.device).(*core.PonSimOltDevice).GetOutgoing():
+				if ok {
+					frame := gopacket.NewPacket(data, layers.LayerTypeEthernet, gopacket.Default)
+					common.Logger().WithFields(logrus.Fields{
+						"handler": handler,
+						"frame":   frame,
+					}).Info("Received incoming data")
+
+					frameBytes := &voltha.PonSimFrame{Id: handler.device.GetAddress(), Payload: data}
+					if err := stream.Send(frameBytes); err != nil {
+						common.Logger().WithFields(logrus.Fields{
+							"handler": handler,
+							"frame":   frame,
+							"error":   err,
+						}).Error("Failed to send incoming data")
+						return err
+					}
+					common.Logger().WithFields(logrus.Fields{
+						"handler": handler,
+						"frame":   frame,
+					}).Info("Sent incoming data")
+
+				} else {
+					return errors.New("incoming data channel has closed")
+				}
+			}
+		}
+
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"handler": handler,
+		}).Error("Not handling an OLT device")
+	}
+
+	return nil
+}
+
+/*
+GetDeviceInfo returns information of a PonSim device (OLT or ONU)
+*/
+func (handler *PonSimHandler) GetDeviceInfo(
+	ctx context.Context,
+	empty *empty.Empty,
+) (*voltha.PonSimDeviceInfo, error) {
+	common.Logger().WithFields(logrus.Fields{
+		"handler": handler,
+	}).Info("Getting device information")
+
+	var out *voltha.PonSimDeviceInfo
+
+	// Check which device type we're currently handling
+	if _, ok := (handler.device).(*core.PonSimOltDevice); ok {
+		common.Logger().WithFields(logrus.Fields{
+			"handler": handler,
+		}).Debug("Handling OLT device")
+		keys := make([]int32, 0, len((handler.device).(*core.PonSimOltDevice).GetOnus()))
+		for k := range (handler.device).(*core.PonSimOltDevice).GetOnus() {
+			keys = append(keys, k)
+		}
+		out = &voltha.PonSimDeviceInfo{NniPort: 0, UniPorts: []int32(keys)}
+
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"handler": handler,
+		}).Debug("Handling ONU/OTHER device")
+
+		out = &voltha.PonSimDeviceInfo{}
+	}
+
+	common.Logger().WithFields(logrus.Fields{
+		"handler": handler,
+		"result":  out,
+	}).Info("Device information")
+
+	return out, nil
+}
+
+/*
+UpdateFlowTable populates and cleans up the flows for a PonSim device
+*/
+func (handler *PonSimHandler) UpdateFlowTable(
+	ctx context.Context,
+	table *voltha.FlowTable,
+) (*empty.Empty, error) {
+	common.Logger().WithFields(logrus.Fields{
+		"handler": handler,
+		"table":   table,
+	}).Info("Updating flows")
+
+	if _, ok := (handler.device).(*core.PonSimOltDevice); ok {
+		if table.Port == 0 {
+			common.Logger().WithFields(logrus.Fields{
+				"handler": handler,
+				"port":    table.Port,
+			}).Debug("Updating OLT flows")
+
+			if err := (handler.device).(*core.PonSimOltDevice).InstallFlows(ctx, table.Flows); err != nil {
+				common.Logger().WithFields(logrus.Fields{
+					"handler": handler,
+					"error":   err.Error(),
+					"flows":   table.Flows,
+				}).Error("Problem updating flows on OLT")
+			} else {
+				common.Logger().WithFields(logrus.Fields{
+					"handler": handler,
+				}).Debug("Updated OLT flows")
+			}
+
+		} else {
+			common.Logger().WithFields(logrus.Fields{
+				"handler": handler,
+				"port":    table.Port,
+			}).Debug("Updating ONU flows")
+
+			if child, ok := (handler.device).(*core.PonSimOltDevice).GetOnus()[table.Port]; ok {
+				// TODO: make it secure
+				ta := credentials.NewTLS(&tls.Config{
+					InsecureSkipVerify: true,
+				})
+
+				host := strings.Join([]string{
+					child.Device.Address,
+					strconv.Itoa(int(child.Device.Port)),
+				}, ":")
+
+				conn, err := grpc.Dial(
+					host,
+					grpc.WithTransportCredentials(ta),
+				)
+				if err != nil {
+					common.Logger().WithFields(logrus.Fields{
+						"handler": handler,
+						"error":   err.Error(),
+					}).Error("GRPC Connection problem")
+				}
+				defer conn.Close()
+				client := voltha.NewPonSimClient(conn)
+
+				if _, err = client.UpdateFlowTable(ctx, table); err != nil {
+					common.Logger().WithFields(logrus.Fields{
+						"handler": handler,
+						"host":    host,
+						"error":   err.Error(),
+					}).Error("Problem forwarding update request to ONU")
+				}
+			} else {
+				common.Logger().WithFields(logrus.Fields{
+					"handler": handler,
+					"port":    table.Port,
+				}).Warn("Unable to find ONU")
+			}
+
+		}
+	} else if _, ok := (handler.device).(*core.PonSimOnuDevice); ok {
+		if err := (handler.device).(*core.PonSimOnuDevice).InstallFlows(ctx, table.Flows); err != nil {
+			common.Logger().WithFields(logrus.Fields{
+				"handler": handler,
+				"error":   err.Error(),
+				"flows":   table.Flows,
+			}).Error("Problem updating flows on ONU")
+		} else {
+			common.Logger().WithFields(logrus.Fields{
+				"handler": handler,
+			}).Debug("Updated ONU flows")
+		}
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"handler": handler,
+			"port":    table.Port,
+		}).Warn("Unknown device")
+	}
+
+	common.Logger().WithFields(logrus.Fields{
+		"handler": handler,
+		"table":   table,
+	}).Info("Updated flows")
+
+	out := new(empty.Empty)
+	return out, nil
+}
+
+/*
+GetStats retrieves statistics for a PonSim device
+*/
+func (handler *PonSimHandler) GetStats(
+	ctx context.Context,
+	empty *empty.Empty,
+) (*voltha.PonSimMetrics, error) {
+	common.Logger().WithFields(logrus.Fields{
+		"handler": handler,
+	}).Info("Retrieving stats")
+
+	var metrics *voltha.PonSimMetrics = new(voltha.PonSimMetrics)
+
+	if olt, ok := (handler.device).(*core.PonSimOltDevice); ok {
+		common.Logger().WithFields(logrus.Fields{
+			"handler": handler,
+			"olt":     olt,
+		}).Debug("Retrieving stats for OLT")
+
+		// Get stats for current device
+
+		// Loop through each onus to get stats from those as well?
+		// send grpc request to each onu
+		for _, child := range (handler.device).(*core.PonSimOltDevice).GetOnus() {
+			// TODO: make it secure
+			ta := credentials.NewTLS(&tls.Config{
+				InsecureSkipVerify: true,
+			})
+
+			host := strings.Join([]string{child.Device.Address, strconv.Itoa(int(child.Device.Port))}, ":")
+			conn, err := grpc.Dial(
+				host,
+				grpc.WithTransportCredentials(ta),
+			)
+			if err != nil {
+				common.Logger().WithFields(logrus.Fields{
+					"handler": handler,
+					"error":   err.Error(),
+				}).Error("GRPC Connection problem")
+			}
+			defer conn.Close()
+			client := voltha.NewPonSimClient(conn)
+
+			if _, err = client.GetStats(ctx, empty); err != nil {
+				common.Logger().WithFields(logrus.Fields{
+					"handler": handler,
+					"host":    host,
+					"error":   err.Error(),
+				}).Error("Problem forwarding stats request to ONU")
+			}
+		}
+		metrics = (handler.device).(*core.PonSimOltDevice).Counter.MakeProto()
+
+		common.Logger().WithFields(logrus.Fields{
+			"handler": handler,
+			"metrics": metrics,
+		}).Debug("OLT Metrics")
+
+	} else if onu, ok := (handler.device).(*core.PonSimOnuDevice); ok {
+		common.Logger().WithFields(logrus.Fields{
+			"handler": handler,
+			"onu":     onu,
+		}).Debug("Retrieving stats for ONU")
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"handler": handler,
+		}).Warn("Unknown device")
+	}
+
+	common.Logger().WithFields(logrus.Fields{
+		"handler": handler,
+	}).Info("Retrieved stats")
+
+	return metrics, nil
+}
diff --git a/ponsim/v2/grpc/nbi/xponsim_handler.go b/ponsim/v2/grpc/nbi/xponsim_handler.go
new file mode 100644
index 0000000..fbc63eb
--- /dev/null
+++ b/ponsim/v2/grpc/nbi/xponsim_handler.go
@@ -0,0 +1,124 @@
+package nbi
+
+import (
+	"context"
+	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/opencord/voltha/ponsim/v2/core"
+	"github.com/opencord/voltha/protos/go/voltha"
+)
+
+type XPonSimHandler struct {
+	device *core.XPonSimDevice
+}
+
+func NewXPonSimHandler() *XPonSimHandler {
+	var handler *XPonSimHandler
+	handler = &XPonSimHandler{}
+	return handler
+}
+
+func (handler *XPonSimHandler) CreateInterface(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.CreateInterface(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) UpdateInterface(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.UpdateInterface(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) RemoveInterface(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.RemoveInterface(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) CreateTcont(
+	ctx context.Context,
+	config *voltha.TcontInterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.CreateTcont(ctx, config.TcontsConfigData, config.TrafficDescriptorProfileConfigData)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) UpdateTcont(
+	ctx context.Context,
+	config *voltha.TcontInterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.UpdateTcont(ctx, config.TcontsConfigData, config.TrafficDescriptorProfileConfigData)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) RemoveTcont(
+	ctx context.Context,
+	config *voltha.TcontInterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.RemoveTcont(ctx, config.TcontsConfigData, config.TrafficDescriptorProfileConfigData)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) CreateGemport(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.CreateGemport(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) UpdateGemport(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.UpdateGemport(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) RemoveGemport(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.RemoveGemport(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) CreateMulticastGemport(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.CreateMulticastGemport(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) UpdateMulticastGemport(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.UpdateMulticastGemport(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) RemoveMulticastGemport(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.RemoveMulticastGemport(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) CreateMulticastDistributionSet(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.CreateMulticastDistributionSet(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) UpdateMulticastDistributionSet(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.UpdateMulticastDistributionSet(ctx, config)
+	return &empty.Empty{}, nil
+}
+func (handler *XPonSimHandler) RemoveMulticastDistributionSet(
+	ctx context.Context,
+	config *voltha.InterfaceConfig,
+) (*empty.Empty, error) {
+	handler.device.RemoveMulticastDistributionSet(ctx, config)
+	return &empty.Empty{}, nil
+}
diff --git a/ponsim/v2/grpc/sbi/common_handler.go b/ponsim/v2/grpc/sbi/common_handler.go
new file mode 100644
index 0000000..4c59af6
--- /dev/null
+++ b/ponsim/v2/grpc/sbi/common_handler.go
@@ -0,0 +1,72 @@
+package sbi
+
+import (
+	"context"
+	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/ponsim/v2/core"
+	"github.com/opencord/voltha/protos/go/ponsim"
+	"github.com/sirupsen/logrus"
+	"io"
+)
+
+type PonSimCommonHandler struct {
+	device core.PonSimInterface
+}
+
+/*
+NewPonSimCommonHandler instantiates a handler for common GRPC servicing methods
+*/
+func NewPonSimCommonHandler(device core.PonSimInterface) *PonSimCommonHandler {
+	var handler *PonSimCommonHandler
+
+	handler = &PonSimCommonHandler{device: device}
+
+	return handler
+}
+
+/*
+ProcessData handles and forwards streaming INGRESS/EGRESS packets
+*/
+func (h *PonSimCommonHandler) ProcessData(stream ponsim.PonSimCommon_ProcessDataServer) error {
+	common.Logger().WithFields(logrus.Fields{
+		"handler": h,
+	}).Debug("Processing data")
+
+	var err error
+	var data *ponsim.IncomingData
+
+	for {
+
+		if data, err = stream.Recv(); err == io.EOF {
+			common.Logger().WithFields(logrus.Fields{
+				"handler": h,
+			}).Warn("Streaming channel was closed")
+			return stream.SendAndClose(&empty.Empty{})
+		} else if err != nil {
+			common.Logger().WithFields(logrus.Fields{
+				"handler": h,
+				"error":   err.Error(),
+			}).Warn("Error occurred with stream")
+			return err
+		}
+
+		frame := gopacket.NewPacket(data.Payload, layers.LayerTypeEthernet, gopacket.Default)
+
+		h.device.Forward(
+			context.Background(),
+			int(data.Port),
+			frame,
+		)
+		common.Logger().WithFields(logrus.Fields{
+			"handler": h,
+			"frame":   frame,
+			"port":    data.Port,
+		}).Debug("Retrieved and forwarded packet")
+
+	}
+
+	return nil
+}
diff --git a/ponsim/v2/grpc/sbi/olt_handler.go b/ponsim/v2/grpc/sbi/olt_handler.go
new file mode 100644
index 0000000..bb058ca
--- /dev/null
+++ b/ponsim/v2/grpc/sbi/olt_handler.go
@@ -0,0 +1,62 @@
+package sbi
+
+import (
+	"context"
+	"github.com/google/uuid"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/ponsim/v2/core"
+	"github.com/opencord/voltha/protos/go/ponsim"
+	"github.com/sirupsen/logrus"
+)
+
+type PonSimOltHandler struct {
+	olt *core.PonSimOltDevice
+}
+
+func NewPonSimOltHandler(olt *core.PonSimOltDevice) *PonSimOltHandler {
+	var handler *PonSimOltHandler
+
+	handler = &PonSimOltHandler{olt: olt}
+
+	return handler
+}
+
+func (h *PonSimOltHandler) Register(
+	ctx context.Context,
+	request *ponsim.RegistrationRequest,
+) (*ponsim.RegistrationReply, error) {
+	common.Logger().WithFields(logrus.Fields{
+		"handler": h,
+	}).Info("Registering device")
+
+	onu := &core.PonSimOnuDevice{
+		PonSimDevice: core.PonSimDevice{
+			Address: request.Address, Port: request.Port, //GrpcSecurity: h.olt.GrpcSecurity,
+		}}
+
+	if assignedPort, err := h.olt.AddOnu(onu); assignedPort == -1 || err != nil {
+		return &ponsim.RegistrationReply{
+			Id:            uuid.New().String(),
+			Status:        ponsim.RegistrationReply_FAILED,
+			StatusMessage: "Failed to register ONU",
+			ParentAddress: common.GetInterfaceIP(h.olt.ExternalIf),
+			ParentPort:    h.olt.Port,
+			AssignedPort:  assignedPort,
+		}, err
+	} else {
+		common.Logger().WithFields(logrus.Fields{
+			"handler": h,
+			"onus":    h.olt.GetOnus(),
+		}).Debug("ONU Added")
+
+		return &ponsim.RegistrationReply{
+			Id:            uuid.New().String(),
+			Status:        ponsim.RegistrationReply_REGISTERED,
+			StatusMessage: "Successfully registered ONU",
+			ParentAddress: common.GetInterfaceIP(h.olt.ExternalIf),
+			ParentPort:    h.olt.Port,
+			AssignedPort:  assignedPort,
+		}, nil
+
+	}
+}
diff --git a/ponsim/v2/ponsim.go b/ponsim/v2/ponsim.go
new file mode 100644
index 0000000..fad0972
--- /dev/null
+++ b/ponsim/v2/ponsim.go
@@ -0,0 +1,289 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/ponsim/v2/core"
+	"github.com/opencord/voltha/ponsim/v2/grpc"
+	"log"
+	"os"
+	"os/signal"
+	"path"
+)
+
+// TODO: Cleanup logs
+
+const (
+	default_name           = "PON"
+	default_grpc_port      = 50060
+	default_grpc_addr      = ""
+	default_device_type    = "OLT"
+	default_api_type       = "PONSIM"
+	default_internal_if    = "eth0"
+	default_external_if    = "eth1"
+	default_onus           = 1
+	default_alarm_sim      = false
+	default_alarm_freq     = 60
+	default_quiet          = false
+	default_verbose        = false
+	default_no_banner      = false
+	default_parent_addr    = "olt"
+	default_parent_port    = 50060
+	default_vcore_endpoint = "vcore"
+	default_fluentd_host   = ""
+
+	default_snapshot_len = 65535
+	default_promiscuous  = false
+
+	default_voltha_key  = "pki/voltha.key"
+	default_voltha_cert = "pki/voltha.crt"
+	default_voltha_ca   = "pki/voltha-CA.pem"
+)
+
+var (
+	voltha_base = os.Getenv("VOLTHA_BASE")
+	certs       *grpc.GrpcSecurity
+
+	name           string = default_name + "_" + device_type
+	grpc_port      int    = default_grpc_port
+	grpc_addr      string = default_grpc_addr
+	device_type    string = default_device_type
+	api_type       string = default_api_type
+	internal_if    string = default_internal_if
+	external_if    string = default_external_if
+	onus           int    = default_onus
+	alarm_sim      bool   = default_alarm_sim
+	alarm_freq     int    = default_alarm_freq
+	quiet          bool   = default_quiet
+	verbose        bool   = default_verbose
+	no_banner      bool   = default_no_banner
+	voltha_key     string = default_voltha_key
+	voltha_cert    string = default_voltha_cert
+	voltha_ca      string = default_voltha_ca
+	parent_addr    string = default_parent_addr
+	parent_port    int    = default_parent_port
+	vcore_endpoint string = default_vcore_endpoint
+	fluentd_host   string = default_fluentd_host
+
+	snapshot_len int32 = default_snapshot_len
+	promiscuous  bool  = default_promiscuous
+)
+
+func init() {
+	parseArgs()
+
+	// Enable fluentd support
+	if fluentd_host != "" {
+		common.Logger().SetFluentd(fluentd_host)
+	}
+
+	// Print banner unless no_banner is specified
+	if !no_banner {
+		printBanner()
+	}
+}
+
+func parseArgs() {
+	var help string
+
+	help = fmt.Sprintf("Name of the PON device")
+	flag.StringVar(&grpc_addr, "name", default_name, help)
+
+	help = fmt.Sprintf("Address used to establish GRPC server connection")
+	flag.StringVar(&grpc_addr, "grpc_addr", default_grpc_addr, help)
+
+	help = fmt.Sprintf("Port used to establish GRPC server connection")
+	flag.IntVar(&grpc_port, "grpc_port", default_grpc_port, help)
+
+	help = fmt.Sprintf("Type of device to simulate (OLT or ONU)")
+	flag.StringVar(&device_type, "device_type", default_device_type, help)
+
+	help = fmt.Sprintf("Type of API used to communicate with devices (PONSIM or BAL)")
+	flag.StringVar(&api_type, "api_type", default_api_type, help)
+
+	help = fmt.Sprintf("Internal Communication Interface for read/write network traffic")
+	flag.StringVar(&internal_if, "internal_if", default_internal_if, help)
+
+	help = fmt.Sprintf("External Communication Interface for read/write network traffic")
+	flag.StringVar(&external_if, "external_if", default_external_if, help)
+
+	help = fmt.Sprintf("Enable promiscuous mode on network interfaces")
+	flag.BoolVar(&promiscuous, "promiscuous", default_promiscuous, help)
+
+	help = fmt.Sprintf("Number of ONUs to simulate")
+	flag.IntVar(&onus, "onus", default_onus, help)
+
+	help = fmt.Sprintf("Suppress debug and info logs")
+	flag.BoolVar(&quiet, "quiet", default_quiet, help)
+
+	help = fmt.Sprintf("Enable verbose logging")
+	flag.BoolVar(&verbose, "verbose", default_verbose, help)
+
+	help = fmt.Sprintf("Omit startup banner log lines")
+	flag.BoolVar(&no_banner, "no_banner", default_no_banner, help)
+
+	help = fmt.Sprintf("Enable generation of simulated alarms")
+	flag.BoolVar(&alarm_sim, "alarm_sim", default_alarm_sim, help)
+
+	help = fmt.Sprintf("Frequency of simulated alarms (in seconds)")
+	flag.IntVar(&alarm_freq, "alarm_freq", default_alarm_freq, help)
+
+	help = fmt.Sprintf("Address of OLT to connect to")
+	flag.StringVar(&parent_addr, "parent_addr", default_parent_addr, help)
+
+	help = fmt.Sprintf("Port of OLT to connect to")
+	flag.IntVar(&parent_port, "parent_port", default_parent_port, help)
+
+	help = fmt.Sprintf("Voltha core endpoint address")
+	flag.StringVar(&vcore_endpoint, "vcore_endpoint", default_vcore_endpoint, help)
+
+	help = fmt.Sprintf("Fluentd host address")
+	flag.StringVar(&fluentd_host, "fluentd", default_fluentd_host, help)
+
+	flag.Parse()
+}
+
+func printBanner() {
+	log.Println("    ____  ____  _   _______ ______  ___")
+	log.Println("   / __ \\/ __ \\/ | / / ___//  _/  |/  /")
+	log.Println("  / /_/ / / / /  |/ /\\__ \\ / // /|_/ / ")
+	log.Println(" / ____/ /_/ / /|  /___/ // // /  / /  ")
+	log.Println("/_/    \\____/_/ |_//____/___/_/  /_/  ")
+
+	switch device_type {
+	case "OLT":
+		printOltBanner()
+	case "ONU":
+		printOnuBanner()
+	}
+
+	log.Println("(to stop: press Ctrl-C)")
+}
+func printOltBanner() {
+	log.Println("   ____  __  ______")
+	log.Println("  / __ \\/ / /_  __/")
+	log.Println(" / / / / /   / /   ")
+	log.Println("/ /_/ / /___/ /    ")
+	log.Println("\\____/_____/_/     ")
+}
+func printOnuBanner() {
+	log.Println("   ____  _   ____  __")
+	log.Println("  / __ \\/ | / / / / /")
+	log.Println(" / / / /  |/ / / / / ")
+	log.Println("/ /_/ / /|  / /_/ /  ")
+	log.Println("\\____/_/ |_/\\____/   ")
+}
+
+/*
+-----------------------------------------------------------------
+*/
+type PonSimService struct {
+	device core.PonSimInterface
+	server *grpc.GrpcServer
+}
+
+func (s *PonSimService) Start(ctx context.Context) {
+	// GRPC server needs to be secure.
+	// Otherwise communication between adapter and simulator does not occur
+	s.server = grpc.NewGrpcServer(s.device.GetAddress(), s.device.GetPort(), certs, true)
+
+	// Add GRPC services
+	s.server.AddCommonService(s.device)
+	s.server.AddPonSimService(s.device)
+
+	// Add OLT specific services
+	if device_type == core.OLT.String() {
+		s.server.AddOltService(s.device)
+	}
+
+	// Add XPON services unless using BAL
+	if api_type == core.PONSIM.String() {
+		s.server.AddXPonService()
+	} else {
+		s.server.AddBalService()
+	}
+
+	// Start the GRPC server
+	go s.server.Start(ctx)
+
+	// Start the PON device
+	go s.device.Start(ctx)
+}
+
+func (s *PonSimService) Stop(ctx context.Context) {
+	// Stop PON device
+	s.device.Stop(ctx)
+
+	// Stop GRPC server
+	s.server.Stop()
+}
+
+func main() {
+	var device core.PonSimInterface
+
+	// Init based on type of device
+	// Construct OLT/ONU object and pass it down
+	certs = &grpc.GrpcSecurity{
+		CertFile: path.Join(voltha_base, voltha_cert),
+		KeyFile:  path.Join(voltha_base, voltha_key),
+		CaFile:   path.Join(voltha_base, voltha_ca),
+	}
+
+	// Initialize device with common parameters
+	pon := core.PonSimDevice{
+		Name:        name,
+		ExternalIf:  external_if,
+		InternalIf:  internal_if,
+		Promiscuous: promiscuous,
+		SnapshotLen: snapshot_len,
+		Address:     grpc_addr,
+		Port:        int32(grpc_port),
+		AlarmsOn:    alarm_sim,
+		AlarmsFreq:  alarm_freq,
+		Counter:     core.NewPonSimMetricCounter(name),
+
+		// TODO: pass certificates
+		//GrpcSecurity: certs,
+	}
+
+	switch device_type {
+	case core.OLT.String():
+		device = core.NewPonSimOltDevice(pon)
+		device.(*core.PonSimOltDevice).MaxOnuCount = onus
+		device.(*core.PonSimOltDevice).VCoreEndpoint = vcore_endpoint
+
+	case core.ONU.String():
+		device = core.NewPonSimOnuDevice(pon)
+		device.(*core.PonSimOnuDevice).ParentAddress = parent_addr
+		device.(*core.PonSimOnuDevice).ParentPort = int32(parent_port)
+
+	default:
+		log.Println("Unknown device type")
+	}
+
+	ps := PonSimService{device: device}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	ps.Start(ctx)
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, os.Interrupt)
+
+	doneCh := make(chan struct{})
+
+	go func() {
+		for {
+			select {
+			case <-signals:
+				log.Println("Interrupt was detected")
+				doneCh <- struct{}{}
+			}
+		}
+	}()
+
+	<-doneCh
+}
diff --git a/ponsim/v2/protos/ponsim_common.proto b/ponsim/v2/protos/ponsim_common.proto
new file mode 100644
index 0000000..42f5994
--- /dev/null
+++ b/ponsim/v2/protos/ponsim_common.proto
@@ -0,0 +1,19 @@
+syntax = "proto3";
+
+option go_package = "github.com/opencord/voltha/protos/go/ponsim";
+
+package ponsim;
+
+import "google/protobuf/empty.proto";
+
+service PonSimCommon {
+    rpc ProcessData (stream IncomingData) returns (google.protobuf.Empty) {}
+}
+
+message IncomingData {
+    string id = 1;
+    string address = 2;
+    int32 port = 3;
+    bytes payload = 4;
+
+}
\ No newline at end of file
diff --git a/ponsim/v2/protos/ponsim_olt.proto b/ponsim/v2/protos/ponsim_olt.proto
new file mode 100644
index 0000000..82214a7
--- /dev/null
+++ b/ponsim/v2/protos/ponsim_olt.proto
@@ -0,0 +1,32 @@
+syntax = "proto3";
+
+option go_package = "github.com/opencord/voltha/protos/go/ponsim";
+
+package ponsim;
+
+service PonSimOlt {
+    rpc Register (RegistrationRequest) returns (RegistrationReply) {}
+}
+
+message RegistrationRequest {
+    string id = 1;
+    string address = 2;
+    int32 port = 3;
+}
+
+message RegistrationReply {
+    string id = 1;
+
+    enum Status {
+        REGISTERED = 0;
+        FAILED = 1;
+        UNAVAILABLE = 2;
+    }
+
+    Status status = 2;
+    string status_message = 3;
+
+    string parent_address = 4;
+    int32 parent_port = 5;
+    int32 assigned_port = 6;
+}
diff --git a/ponsim/v2/scripts/build_protos.sh b/ponsim/v2/scripts/build_protos.sh
new file mode 100644
index 0000000..daccdbe
--- /dev/null
+++ b/ponsim/v2/scripts/build_protos.sh
@@ -0,0 +1,48 @@
+#!/bin/sh
+
+export SRC_DIR="$1"
+
+echo $SRC_DIR
+
+export MAPS=Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor
+export INCS="\
+    -I $SRC_DIR \
+    -I $GOPATH/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis"
+
+export VOLTHA_PB="\
+    $SRC_DIR/adapter.proto \
+    $SRC_DIR/device.proto \
+    $SRC_DIR/events.proto \
+    $SRC_DIR/health.proto \
+    $SRC_DIR/logical_device.proto \
+    $SRC_DIR/ponsim.proto \
+    $SRC_DIR/voltha.proto"
+
+export COMMON_PB="\
+    $SRC_DIR/common.proto \
+    $SRC_DIR/meta.proto \
+    $SRC_DIR/yang_options.proto"
+
+export PONSIM_PB="$SRC_DIR/ponsim_common.proto $SRC_DIR/ponsim_olt.proto"
+export SCHEMA_PB="$SRC_DIR/schema.proto"
+export IETF_PB="$SRC_DIR/ietf_interfaces.proto"
+export OF_PB="$SRC_DIR/openflow_13.proto"
+export BAL_PB="$SRC_DIR/bal*.proto"
+export BBF_PB="$SRC_DIR/bbf*.proto"
+
+export PB_VARS="\
+    VOLTHA_PB \
+    COMMON_PB \
+    PONSIM_PB \
+    SCHEMA_PB \
+    IETF_PB \
+    OF_PB \
+    BAL_PB \
+    BBF_PB"
+
+for pb_var in $PB_VARS
+do
+    pbs="$(eval echo \$$pb_var)"
+    echo "Compiling $pbs"
+    protoc --go_out=$MAPS,plugins=grpc:$GOPATH/src $INCS $pbs
+done