diff --git a/Makefile b/Makefile
index 1f2c7aa..a91328e 100755
--- a/Makefile
+++ b/Makefile
@@ -2,23 +2,31 @@
 
 TESTER = testit
 
+TESTADDSEL = testaddsel
+
 DAEMON = ipmid
 DAEMON_OBJ  = $(DAEMON).o
+
+
 LIB_APP_OBJ = apphandler.o     \
               sensorhandler.o  \
               storagehandler.o \
               dcmihandler.o    \
               ipmisensor.o     \
+              storageaddsel.o  \
 
 
+TESTADDSEL_OBJ = $(TESTADDSEL).o \
+                 storageaddsel.o
+
 TESTER_OBJ = ipmisensor.o 	   \
-			 testit.o
+	     testit.o
 
 LIB_APP     = libapphandler.so
 INSTALLED_LIBS += $(LIB_APP)
 INSTALLED_HEADERS = ipmid-api.h
 
-INC_FLAG += $(shell pkg-config --cflags --libs libsystemd) -I. -O2 --std=gnu++11
+INC_FLAG += $(shell pkg-config --cflags --libs libsystemd) -I. -O2 
 LIB_FLAG += $(shell pkg-config  --libs libsystemd) -rdynamic
 IPMID_PATH ?= -DHOST_IPMI_LIB_PATH=\"/usr/lib/host-ipmid/\"
 
@@ -30,7 +38,7 @@
 all: $(DAEMON) $(LIB_APP) $(TESTER)
 
 %.o: %.C
-	$(CXX) -fpic -c $< $(CXXFLAGS) $(INC_FLAG) $(IPMID_PATH) -o $@
+	$(CXX) -std=c++14 -fpic -c $< $(CXXFLAGS) $(INC_FLAG) $(IPMID_PATH) -o $@
 
 $(LIB_APP): $(LIB_APP_OBJ)
 	$(CXX) $^ -shared $(LDFLAGS) $(LIB_FLAG) -o $@
@@ -44,6 +52,9 @@
 clean:
 	rm -f $(DAEMON) $(TESTER) *.o *.so
 
+$(TESTADDSEL): $(TESTADDSEL_OBJ)
+	$(CXX) $^ $(LDFLAGS) $(LIB_FLAG) -o $@ -ldl
+		
 install:
 		install -m 0755 -d $(DESTDIR)$(SBINDIR)
 		install -m 0755 ipmid $(DESTDIR)$(SBINDIR)
diff --git a/ipmid.C b/ipmid.C
index 6514849..9b19c7e 100644
--- a/ipmid.C
+++ b/ipmid.C
@@ -15,6 +15,17 @@
 
 
 sd_bus *bus = NULL;
+FILE *ipmiio, *ipmidbus, *ipmicmddetails;
+
+void print_usage(void) {
+  fprintf(stderr, "Options:  [-d mask]\n");
+  fprintf(stderr, "    mask : 0x01 - Print ipmi packets\n");
+  fprintf(stderr, "    mask : 0x02 - Print DBUS operations\n");
+  fprintf(stderr, "    mask : 0x04 - Print ipmi command details\n");
+  fprintf(stderr, "    mask : 0xFF - Print all trace\n");
+}
+
+
 
 // Channel that is used for OpenBMC Barreleye
 const char * DBUS_NAME = "org.openbmc.HostIpmi";
@@ -35,7 +46,7 @@
 #define HEXDUMP_COLS 16
 #endif
 
-void hexdump(void *mem, size_t len)
+void hexdump(FILE *s, void *mem, size_t len)
 {
         unsigned int i, j;
 
@@ -44,17 +55,17 @@
                 /* print offset */
                 if(i % HEXDUMP_COLS == 0)
                 {
-                        printf("0x%06x: ", i);
+                        fprintf(s,"0x%06x: ", i);
                 }
 
                 /* print hex data */
                 if(i < len)
                 {
-                        printf("%02x ", 0xFF & ((char*)mem)[i]);
+                        fprintf(s,"%02x ", 0xFF & ((char*)mem)[i]);
                 }
                 else /* end of block, just aligning for ASCII dump */
                 {
-                        printf("   ");
+                        fprintf(s,"   ");
                 }
 
                 /* print ASCII dump */
@@ -64,18 +75,18 @@
                         {
                                 if(j >= len) /* end of block, not really printing */
                                 {
-                                        putchar(' ');
+                                        fputc(' ', s);
                                 }
                                 else if(isprint(((char*)mem)[j])) /* printable char */
                                 {
-                                        putchar(0xFF & ((char*)mem)[j]);
+                                        fputc(0xFF & ((char*)mem)[j], s);
                                 }
                                 else /* other char */
                                 {
-                                        putchar('.');
+                                        fputc('.',s);
                                 }
                         }
-                        putchar('\n');
+                        fputc('\n',s);
                 }
         }
 }
@@ -118,7 +129,7 @@
     auto iter = g_ipmid_router_map.find(std::make_pair(netfn, cmd));
     if(iter == g_ipmid_router_map.end())
     {
-        printf("No registered handlers for NetFn:[0x%X], Cmd:[0x%X]"
+        fprintf(stderr, "No registered handlers for NetFn:[0x%X], Cmd:[0x%X]"
                " trying Wilcard implementation \n",netfn, cmd);
 
         // Now that we did not find any specific [NetFn,Cmd], tuple, check for
@@ -126,7 +137,7 @@
         iter = g_ipmid_router_map.find(std::make_pair(netfn, IPMI_CMD_WILDCARD));
         if(iter == g_ipmid_router_map.end())
         {
-            printf("No Registered handlers for NetFn:[0x%X],Cmd:[0x%X]\n",netfn, IPMI_CMD_WILDCARD);
+            fprintf(stderr, "No Registered handlers for NetFn:[0x%X],Cmd:[0x%X]\n",netfn, IPMI_CMD_WILDCARD);
 
             // Respond with a 0xC1
             memcpy(response, &rc, IPMI_CC_LEN);
@@ -209,24 +220,16 @@
     }
 
     r = sd_bus_message_read(reply, "x", &pty);
-#ifdef __IPMI_DEBUG__
-    printf("RC from the ipmi dbus method :%d \n", pty);
-#endif
     if (r < 0) {
        fprintf(stderr, "Failed to get a rc from the method: %s\n", strerror(-r));
 
     }
 
-
     sd_bus_error_free(&error);
     sd_bus_message_unref(m);
 
 
-#ifdef __IPMI_DEBUG__
-    printf("%d : %s\n", __LINE__, __PRETTY_FUNCTION__ );
-#endif
     return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
-
 }
 
 static int handle_ipmi_command(sd_bus_message *m, void *user_data, sd_bus_error
@@ -239,8 +242,6 @@
     size_t resplen =MAX_IPMI_BUFFER;
     unsigned char response[MAX_IPMI_BUFFER];
 
-    printf(" *** Received Signal: ");
-
     memset(response, 0, MAX_IPMI_BUFFER);
 
     r = sd_bus_message_read(m, "yyy",  &sequence, &netfn, &cmd);
@@ -255,9 +256,8 @@
         return -1;
     }
 
-
-    printf("Seq 0x%02x, NetFn 0x%02x, CMD: 0x%02x \n", sequence, netfn, cmd);
-    hexdump((void*)request, sz);
+    fprintf(ipmiio, "IPMI Incoming: Seq 0x%02x, NetFn 0x%02x, CMD: 0x%02x \n", sequence, netfn, cmd);
+    hexdump(ipmiio, (void*)request, sz);
 
     // Allow the length field to be used for both input and output of the
     // ipmi call
@@ -271,8 +271,8 @@
         fprintf(stderr,"ERROR:[0x%X] handling NetFn:[0x%X], Cmd:[0x%X]\n",r, netfn, cmd);
     }
 
-    printf("Response...\n");
-    hexdump((void*)response, resplen);
+    fprintf(ipmiio, "IPMI Response:\n");
+    hexdump(ipmiio,  (void*)response, resplen);
 
     // Send the response buffer from the ipmi command
     r = send_ipmi_message(sequence, netfn, cmd, response, resplen);
@@ -370,23 +370,39 @@
     sd_bus_slot *slot = NULL;
     int r;
     char *mode = NULL;
+    unsigned long tvalue;
+    int c;
+
+
+
+    // This file and subsequient switch is for turning on levels
+    // of trace
+    ipmicmddetails = ipmiio = ipmidbus =  fopen("/dev/null", "w");
+
+    while ((c = getopt (argc, argv, "h:d:")) != -1)
+        switch (c) {
+            case 'd':
+                tvalue =  strtoul(optarg, NULL, 16);
+                if (1&tvalue) {
+                    ipmiio = stdout;
+                }
+                if (2&tvalue) {
+                    ipmidbus = stdout;
+                }
+                if (4&tvalue) {
+                    ipmicmddetails = stdout;
+                }
+                break;
+          case 'h':
+          case '?':
+                print_usage();
+                return 1;
+        }
 
 
     // Register all the handlers that provider implementation to IPMI commands.
     ipmi_register_callback_handlers(HOST_IPMI_LIB_PATH);
 
-#ifdef __IPMI_DEBUG__
-    printf("Registered Function handlers:\n");
-
-    // Print the registered handlers and their arguments.
-    for(auto& iter : g_ipmid_router_map)
-    {
-        ipmi_fn_cmd_t fn_and_cmd = iter.first;
-        printf("NETFN:[0x%X], cmd[0x%X]\n", fn_and_cmd.first, fn_and_cmd.second);
-    }
-#endif
-
-
     /* Connect to system bus */
     r = sd_bus_open_system(&bus);
     if (r < 0) {
@@ -440,7 +456,6 @@
 
     int r;
 
-
     r = sd_bus_message_new_method_call(bus,&m,interface->bus,interface->path,"org.freedesktop.DBus.Properties","Get");
     if (r < 0) {
         fprintf(stderr, "Failed to create a method call: %s", strerror(-r));
@@ -477,6 +492,7 @@
     return r;
 }
 
+
 // Use a lookup table to find the interface name of a specific sensor
 // This will be used until an alternative is found.  this is the first
 // step for mapping IPMI
@@ -522,9 +538,6 @@
 
     interface->sensornumber = num;
 
-    printf("%s\n", str2);
-
-
 final:
 
     sd_bus_error_free(&error);
@@ -550,7 +563,7 @@
     sd_bus_error error = SD_BUS_ERROR_NULL;
     sd_bus_message *reply = NULL, *m=NULL;
 
-    printf("Attempting to set a dbus Sensor 0x%02x via %s with a value of %s\n",
+    fprintf(ipmidbus, "Attempting to set a dbus Sensor 0x%02x via %s with a value of %s\n",
         number, method, value);
 
     r = find_openbmc_path("SENSOR", number, &a);
@@ -584,7 +597,7 @@
     sd_bus_error error = SD_BUS_ERROR_NULL;
     sd_bus_message *reply = NULL, *m=NULL;
 
-    printf("Attempting to set a dbus Variant Sensor 0x%02x via %s with a value of %s\n",
+    fprintf(ipmidbus, "Attempting to set a dbus Variant Sensor 0x%02x via %s with a value of %s\n",
         number, method, value);
 
     r = find_openbmc_path("SENSOR", number, &a);
diff --git a/ipmid.H b/ipmid.H
index 1cfe4c3..73b60e6 100755
--- a/ipmid.H
+++ b/ipmid.H
@@ -1,6 +1,7 @@
 #ifndef __HOST_IPMID_IPMI_H__
 #define __HOST_IPMID_IPMI_H__
 #include "ipmid-api.h"
+#include <stdio.h>
 
 // When the requester sends in a netfn and a command along with data, this
 // function will look for registered handlers that will handle that [netfn,cmd]
@@ -16,4 +17,6 @@
 // needs 1 byte for the length field. 
 #define MAX_IPMI_BUFFER 63
 
+extern FILE *ipmiio, *ipmidbus, *ipmicmddetails;
+
 #endif
diff --git a/storageaddsel.C b/storageaddsel.C
new file mode 100644
index 0000000..c36e1d3
--- /dev/null
+++ b/storageaddsel.C
@@ -0,0 +1,255 @@
+#include <stdint.h>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <memory>
+#include <systemd/sd-bus.h>
+
+#include "ipmid.H"
+#include "storagehandler.h"
+#include "sensorhandler.h"
+
+using namespace std;
+
+extern int find_openbmc_path(const char *, const uint8_t , dbus_interface_t *);
+
+
+//////////////////////////
+struct esel_section_headers_t {
+	uint8_t sectionid[2];
+	uint8_t sectionlength[2];
+	uint8_t version;
+	uint8_t subsectiontype;
+	uint8_t compid;
+};
+
+struct severity_values_t {
+	uint8_t type;
+	const char *description;
+};
+
+
+const std::vector<severity_values_t> g_sev_desc = {
+	{0x10, "recoverable error"},
+	{0x20, "predictive error"},
+	{0x40, "unrecoverable error"},
+	{0x50, "critical error"},
+	{0x60, "error from a diagnostic test"},
+	{0x70, "recovered symptom "},
+	{0xFF, "Unknown"},
+};
+
+const char* sev_lookup(uint8_t n) {
+	auto i = std::find_if(std::begin(g_sev_desc), std::end(g_sev_desc),
+	                      [n](auto p){ return p.type == n || p.type == 0xFF; });
+	return i->description;
+}
+
+
+
+
+int find_sensor_type_string(uint8_t sensor_number, char **s) {
+
+	dbus_interface_t a;
+	const char *p;
+	char r;
+
+	r = find_openbmc_path("SENSOR", sensor_number, &a);
+
+	if ((r < 0) || (a.bus[0] == 0)) {
+		// Just make a generic message for errors that
+		// occur on sensors that dont exist
+		asprintf(s, "Unknown Sensor (0x%02x)", sensor_number);
+	} else {
+
+		if ((p = strrchr (a.path, '/')) == NULL) {
+			p = "/Unknown Sensor";
+		}
+
+		asprintf(s, "%s", p+1);
+	}
+
+	return 0;
+}
+
+
+size_t getfilestream(const char *fn, uint8_t **buffer) {
+
+	FILE *fp;
+	size_t size = 0;
+
+	if ((fp = fopen(fn, "rb")) != NULL) {
+
+		fseek(fp, 0, SEEK_END);
+		size = ftell(fp);
+		fseek(fp, 0, SEEK_SET);
+
+		size = 0x100;
+
+		*buffer = new uint8_t [size];
+
+		fread(*buffer, 1, size, fp);
+		fclose(fp);
+	}
+
+	return size;
+}
+
+
+const char *create_esel_severity(const uint8_t *buffer) {
+
+	uint8_t severity;
+	// Dive in to the IBM log to find the severity
+	severity = (0xF0  & buffer[0x4A]);
+
+	return sev_lookup(severity);
+}
+
+int create_esel_association(const uint8_t *buffer, char **m) {
+
+	ipmi_add_sel_request_t *p;
+	dbus_interface_t dbusint;
+	uint8_t sensor;
+
+	p = ( ipmi_add_sel_request_t *) buffer;
+
+	sensor = p->sensornumber;
+
+	find_openbmc_path("SENSOR", sensor, &dbusint);
+
+	if (strlen(dbusint.path) < 1) {
+		printf("Sensor not found\n");
+		snprintf(dbusint.path, sizeof(dbusint.path), "0x%x", sensor);
+	}
+
+	asprintf(m, "%s", dbusint.path);
+
+	return 0;
+}
+
+
+
+int create_esel_description(const uint8_t *buffer, const char *sev, char **message) {
+
+
+	ipmi_add_sel_request_t *p;
+	int r;
+	char *m;
+
+	p =  ( ipmi_add_sel_request_t *) buffer;
+
+	find_sensor_type_string(p->sensornumber,&m);
+
+	asprintf(message, "A %s has experienced a %s", m, sev );
+
+	free(m);
+
+	return 0;
+}
+
+
+int send_esel_to_dbus(const char *desc, const char *sev, const char *details, uint8_t *debug, size_t debuglen) {
+
+	sd_bus *mbus = NULL;
+    sd_bus_error error = SD_BUS_ERROR_NULL;
+    sd_bus_message *reply = NULL, *m=NULL;
+    uint16_t *pty;
+    int r;
+
+
+
+    /* Connect to system bus */
+    r = sd_bus_open_system(&mbus);
+    if (r < 0) {
+        fprintf(stderr, "Failed to connect to system bus: %s\n",
+                strerror(-r));
+        goto finish;
+    }
+    r = sd_bus_message_new_method_call(mbus,&m,
+    									"org.openbmc.records.events",
+    									"/org/openbmc/records/events",
+    									"org.openbmc.recordlog",
+    									"acceptHostMessage");
+    if (r < 0) {
+        fprintf(stderr, "Failed to add the method object: %s\n", strerror(-r));
+        return -1;
+    }
+
+    r = sd_bus_message_append(m, "sss", desc, sev, details);
+    if (r < 0) {
+        fprintf(stderr, "Failed add the message strings : %s\n", strerror(-r));
+        return -1;
+    }
+
+    r = sd_bus_message_append_array(m, 'y', debug, debuglen);
+    if (r < 0) {
+        fprintf(stderr, "Failed to add the raw array of bytes: %s\n", strerror(-r));
+        return -1;
+    }
+
+    // Call the IPMI responder on the bus so the message can be sent to the CEC
+    r = sd_bus_call(mbus, m, 0, &error, &reply);
+    if (r < 0) {
+        fprintf(stderr, "Failed to call the method: %s", strerror(-r));
+        return -1;
+    }
+
+    r = sd_bus_message_read(reply, "q", &pty);
+    if (r < 0) {
+       fprintf(stderr, "Failed to get a rc from the method: %s\n", strerror(-r));
+    }
+
+finish:
+    sd_bus_error_free(&error);
+    sd_bus_message_unref(m);
+    sd_bus_message_unref(reply);
+    sd_bus_unref(mbus);
+
+    return r;
+
+}
+
+
+void send_esel(uint16_t recordid) {
+	char *desc, *assoc, *ascii;
+	const char *sev;
+	uint8_t *buffer = NULL;
+	char *path;
+	size_t sz;
+
+	uint8_t hack[] = {0x30, 0x32, 0x34};
+
+	asprintf(&path,"%s%04x", "/tmp/esel", recordid);
+
+	sz = getfilestream(path, &buffer);
+
+	if (sz == 0) {
+		printf("Error file does not exist %d\n",__LINE__);
+		free(path);
+		return;
+	}
+
+
+	sev = create_esel_severity(buffer);
+
+	create_esel_association(buffer, &assoc);
+
+	create_esel_description(buffer, sev, &desc);
+
+
+	// TODO until ISSUE https://github.com/openbmc/rest-dbus/issues/2
+	// I cant send extended ascii chars.  So 0,2,4 for now...
+	send_esel_to_dbus(desc, sev, assoc, hack, 3);
+
+
+	free(path);
+	free(assoc);
+	free(desc);
+
+	delete[] buffer;
+
+	return;
+}
diff --git a/storageaddsel.h b/storageaddsel.h
new file mode 100644
index 0000000..7535208
--- /dev/null
+++ b/storageaddsel.h
@@ -0,0 +1,3 @@
+#include <stdint.h>
+
+void send_esel(uint16_t recordid) ;
\ No newline at end of file
diff --git a/storagehandler.C b/storagehandler.C
index 023a82a..dc0217e 100644
--- a/storagehandler.C
+++ b/storagehandler.C
@@ -1,11 +1,13 @@
-#include "storagehandler.h"
-#include "ipmid-api.h"
 #include <stdio.h>
 #include <string.h>
 #include <stdint.h>
 #include <time.h>
 #include <arpa/inet.h>
 
+#include "storagehandler.h"
+#include "storageaddsel.h"
+#include "ipmid-api.h"
+
 void register_netfn_storage_functions() __attribute__((constructor));
 
 
@@ -162,6 +164,7 @@
 
     printf("IPMI Handling RESERVE-SEL 0x%04x\n", g_sel_reserve);
 
+
     *data_len = sizeof(g_sel_reserve);
 
     // Pack the actual response
@@ -170,30 +173,27 @@
     return rc;
 }
 
-
 ipmi_ret_t ipmi_storage_add_sel(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
                               ipmi_request_t request, ipmi_response_t response,
                               ipmi_data_len_t data_len, ipmi_context_t context)
 {
 
     ipmi_ret_t rc = IPMI_CC_OK;
+    ipmi_add_sel_request_t *p = (ipmi_add_sel_request_t*) request;
+    uint16_t recordid;
 
-    printf("IPMI Handling ADD-SEL \n");
+    recordid = ((uint16_t)p->eventdata[1] << 8) | p->eventdata[2];
+
+    printf("IPMI Handling ADD-SEL for record 0x%04x\n", recordid);
 
     *data_len = sizeof(g_sel_reserve);
 
     // Pack the actual response
-    memcpy(response, &g_sel_reserve, *data_len);
+    memcpy(response, &recordid, 2);
 
     // TODO This code should grab the completed partial esel located in
     // the /tmp/esel0100 file and commit it to the error log handler.
-
-
-    // TODO I advanced the sel reservation number so next time HB asks
-    // for a reservation they get a new number.  This tech may change
-    // based on how the HB team currently uses sel reservations but
-    // for now provide the ability to get new reservations
-    g_sel_reserve++;
+    send_esel(recordid);
 
     return rc;
 }
diff --git a/storagehandler.h b/storagehandler.h
index 1b7f552..7abefd5 100644
--- a/storagehandler.h
+++ b/storagehandler.h
@@ -14,4 +14,16 @@
 
 };
 
+struct ipmi_add_sel_request_t {
+
+	uint8_t recordid[2];
+	uint8_t recordtype;
+	uint8_t timestampe[4];
+	uint8_t generatorid[2];
+	uint8_t evmrev;
+	uint8_t sensortype;
+	uint8_t sensornumber;
+	uint8_t eventdir;
+	uint8_t eventdata[3];
+};
 #endif
diff --git a/testaddsel.C b/testaddsel.C
new file mode 100644
index 0000000..202200a
--- /dev/null
+++ b/testaddsel.C
@@ -0,0 +1,107 @@
+#include <stdlib.h>
+#include <limits.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdint.h>
+#include <systemd/sd-bus.h>
+#include "sensorhandler.h"
+
+
+extern void send_esel(uint16_t recordid);
+
+sd_bus *bus = NULL;
+
+// Use a lookup table to find the interface name of a specific sensor
+// This will be used until an alternative is found.  this is the first
+// step for mapping IPMI
+int find_openbmc_path(const char *type, const uint8_t num, dbus_interface_t *interface) {
+
+    const char  *busname = "org.openbmc.managers.System";
+    const char  *objname = "/org/openbmc/managers/System";
+
+    char  *str1, *str2, *str3;
+    sd_bus_error error = SD_BUS_ERROR_NULL;
+    sd_bus_message *reply = NULL, *m=NULL;
+
+
+    int r;
+
+    r = sd_bus_message_new_method_call(bus,&m,busname,objname,busname,"getObjectFromByteId");
+    if (r < 0) {
+        fprintf(stderr, "Failed to create a method call: %s", strerror(-r));
+    }
+
+    r = sd_bus_message_append(m, "sy", type, num);
+    if (r < 0) {
+        fprintf(stderr, "Failed to create a input parameter: %s", strerror(-r));
+    }
+
+    // Call the IPMI responder on the bus so the message can be sent to the CEC
+    r = sd_bus_call(bus, m, 0, &error, &reply);
+    if (r < 0) {
+        fprintf(stderr, "Failed to call the method: %s", strerror(-r));
+        goto final;
+    }
+
+
+    r = sd_bus_message_read(reply, "(sss)", &str1, &str2, &str3);
+    if (r < 0) {
+        fprintf(stderr, "Failed to get a response: %s", strerror(-r));
+        goto final;
+    }
+
+    strncpy(interface->bus, str1, MAX_DBUS_PATH);
+    strncpy(interface->path, str2, MAX_DBUS_PATH);
+    strncpy(interface->interface, str3, MAX_DBUS_PATH);
+
+    interface->sensornumber = num;
+
+final:
+
+    sd_bus_error_free(&error);
+    sd_bus_message_unref(m);
+
+    return r;
+}
+
+
+
+
+int main(int argc, char *argv[])
+{
+	int base;
+	char *endptr, *str;
+	long val;
+	uint16_t num;
+	int r;
+	
+	if (argc < 2) {
+		fprintf(stderr, "Usage: %s sensornumber\n", argv[0]);
+		return -1;
+	}
+	
+	str = argv[1];
+	base = (argc > 2) ? atoi(argv[2]) : 10;
+
+	val = strtol(str, &endptr, base);
+
+	num = (uint16_t) val;
+
+
+
+    /* Connect to system bus */
+    r = sd_bus_open_system(&bus);
+    if (r < 0) {
+        fprintf(stderr, "Failed to connect to system bus: %s\n",
+                strerror(-r));
+        goto finish;
+    } 
+
+    send_esel(num);	
+
+	
+finish:
+    sd_bus_unref(bus);
+
+	return 0;
+}
\ No newline at end of file