From a8f2dc7c658efc1086d4e1f097e5eb2af2d20c83 Mon Sep 17 00:00:00 2001
From: Yaroslav Svitlytskyi <yariksvitlitskiy81@gmail.com>
Date: Tue, 26 Mar 2024 03:04:42 +0100
Subject: [PATCH] fix: fixed bugs

---
 .cproject                                     |  33 +-
 .github/workflows/build.yml                   |  14 +
 .project                                      |   2 +-
 CMakeLists.txt                                |   8 +-
 .../Proto/Buffer/Read/read_buffer.cpp         |  54 ++
 Core/External/Proto/Buffer/Read/read_buffer.h |  71 +++
 .../Proto/Buffer/Write/write_buffer.cpp       |  49 ++
 .../Proto/Buffer/Write/write_buffer.h         |  82 +++
 Core/External/Proto/Generated/data.h          | 521 +++++++++++++++++
 Core/External/Proto/Generated/info.h          | 519 +++++++++++++++++
 Core/External/Proto/Generated/settings.h      | 522 ++++++++++++++++++
 Core/External/Proto/proto.cpp                 |   0
 Core/External/Proto/proto.h                   |  16 +
 Core/External/Sensor/tsl2591x.cpp             | 269 +++++++++
 Core/External/Sensor/tsl2591x.h               | 245 ++++++++
 Core/External/State/state.cpp                 |   5 +
 Core/External/State/state.h                   |  15 +
 Core/External/Timer/timer.cpp                 |  12 +
 Core/External/Timer/timer.h                   |  18 +
 Core/External/Tools/Indicator/indicator.cpp   |  29 +
 Core/External/Tools/Indicator/indicator.h     |  32 ++
 Core/Inc/main.h                               |   3 +
 Core/Src/main.cpp                             |  39 +-
 Core/Src/syscalls.cpp                         | 176 ------
 Core/Src/sysmem.cpp                           |  79 ---
 Makefile                                      |   4 +-
 Resources/Proto/data.proto                    |  26 +
 Resources/Proto/info.proto                    |  24 +
 Resources/Proto/settings.proto                |  36 +-
 Resources/Proto/test.proto                    |  27 -
 Scripts/graph/proto/data_pb2.py               |  30 +
 Scripts/graph/proto/info_pb2.py               |  30 +
 Scripts/graph/proto/settings_pb2.py           |  30 +
 Scripts/graph/proto/test_pb2.py               |  30 -
 34 files changed, 2695 insertions(+), 355 deletions(-)
 create mode 100644 .github/workflows/build.yml
 create mode 100644 Core/External/Proto/Buffer/Read/read_buffer.cpp
 create mode 100644 Core/External/Proto/Buffer/Read/read_buffer.h
 create mode 100644 Core/External/Proto/Buffer/Write/write_buffer.cpp
 create mode 100644 Core/External/Proto/Buffer/Write/write_buffer.h
 create mode 100644 Core/External/Proto/Generated/data.h
 create mode 100644 Core/External/Proto/Generated/info.h
 create mode 100644 Core/External/Proto/Generated/settings.h
 create mode 100644 Core/External/Proto/proto.cpp
 create mode 100644 Core/External/Proto/proto.h
 create mode 100644 Core/External/Sensor/tsl2591x.cpp
 create mode 100644 Core/External/Sensor/tsl2591x.h
 create mode 100644 Core/External/State/state.cpp
 create mode 100644 Core/External/State/state.h
 create mode 100644 Core/External/Timer/timer.cpp
 create mode 100644 Core/External/Timer/timer.h
 create mode 100644 Core/External/Tools/Indicator/indicator.cpp
 create mode 100644 Core/External/Tools/Indicator/indicator.h
 delete mode 100644 Core/Src/syscalls.cpp
 delete mode 100644 Core/Src/sysmem.cpp
 create mode 100644 Resources/Proto/data.proto
 create mode 100644 Resources/Proto/info.proto
 delete mode 100644 Resources/Proto/test.proto
 create mode 100644 Scripts/graph/proto/data_pb2.py
 create mode 100644 Scripts/graph/proto/info_pb2.py
 create mode 100644 Scripts/graph/proto/settings_pb2.py
 delete mode 100644 Scripts/graph/proto/test_pb2.py

diff --git a/.cproject b/.cproject
index 9861dca..4efd6ec 100644
--- a/.cproject
+++ b/.cproject
@@ -14,7 +14,7 @@
 				</extensions>
 			</storageModule>
 			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
-				<configuration artifactExtension="elf" artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.exe" buildProperties="org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.exe,org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug" cleanCommand="rm -rf" description="" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.config.exe.debug.331241973" name="Debug" parent="com.st.stm32cube.ide.mcu.gnu.managedbuild.config.exe.debug">
+				<configuration artifactExtension="elf" artifactName="${ProjName}" buildArtefactType="org.eclipse.cdt.build.core.buildArtefactType.exe" buildProperties="org.eclipse.cdt.build.core.buildArtefactType=org.eclipse.cdt.build.core.buildArtefactType.exe,org.eclipse.cdt.build.core.buildType=org.eclipse.cdt.build.core.buildType.debug" cleanCommand="rm -rf" description="" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.config.exe.debug.331241973" name="Debug" parent="com.st.stm32cube.ide.mcu.gnu.managedbuild.config.exe.debug" prebuildStep="">
 					<folderInfo id="com.st.stm32cube.ide.mcu.gnu.managedbuild.config.exe.debug.331241973." name="/" resourcePath="">
 						<toolChain id="com.st.stm32cube.ide.mcu.gnu.managedbuild.toolchain.exe.debug.454728105" name="MCU ARM GCC" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.toolchain.exe.debug">
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.target_mcu.38962375" name="MCU" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.target_mcu" useByScannerDiscovery="true" value="STM32L476RGTx" valueType="string"/>
@@ -25,9 +25,11 @@
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.target_board.1044600179" name="Board" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.target_board" useByScannerDiscovery="false" value="genericBoard" valueType="string"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults.756928727" name="Defaults" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults" useByScannerDiscovery="false" value="com.st.stm32cube.ide.common.services.build.inputs.revA.1.0.6 || Debug || true || Executable || com.st.stm32cube.ide.mcu.gnu.managedbuild.option.toolchain.value.workspace || STM32L476RGTx || 0 || 0 || arm-none-eabi- || ${gnu_tools_for_stm32_compiler_path} || ../Core/Inc | ../Drivers/STM32L4xx_HAL_Driver/Inc | ../Drivers/STM32L4xx_HAL_Driver/Inc/Legacy | ../Drivers/CMSIS/Device/ST/STM32L4xx/Include | ../Drivers/CMSIS/Include ||  ||  || USE_HAL_DRIVER | STM32L476xx ||  || Drivers | Core/Startup | Core ||  ||  || ${workspace_loc:/${ProjName}/STM32L476RGTX_FLASH.ld} || true || NonSecure ||  || secure_nsclib.o ||  || None ||  ||  || " valueType="string"/>
 							<option id="com.st.stm32cube.ide.mcu.debug.option.cpuclock.720046019" name="Cpu clock frequence" superClass="com.st.stm32cube.ide.mcu.debug.option.cpuclock" useByScannerDiscovery="false" value="4" valueType="string"/>
+							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.toolchain.417945529" name="Toolchain" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.toolchain" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.toolchain.value.workspace" valueType="string"/>
+							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.runtimelibrary_cpp.1406644272" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.runtimelibrary_cpp" useByScannerDiscovery="true" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.runtimelibrary_cpp.value.standard_c_standard_cpp" valueType="enumerated"/>
 							<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.targetplatform.945127982" isAbstract="false" osList="all" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.targetplatform"/>
 							<builder buildPath="${workspace_loc:/task4}/Debug" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.builder.41523802" keepEnvironmentInBuildfile="false" managedBuildOn="true" name="Gnu Make Builder" parallelBuildOn="true" parallelizationNumber="optimal" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.builder"/>
-							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.402925686" name="MCU GCC Assembler" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler">
+							<tool command="g++" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.402925686" name="MCU GCC Assembler" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler">
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.debuglevel.51257419" name="Debug level" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.debuglevel" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.debuglevel.value.g3" valueType="enumerated"/>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.definedsymbols.579244450" name="Define symbols (-D)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.definedsymbols" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="DEBUG"/>
@@ -54,6 +56,7 @@
 									<listOptionValue builtIn="false" value="../Core/External/Proto/Generated"/>
 									<listOptionValue builtIn="false" value="../ThirdParty"/>
 									<listOptionValue builtIn="false" value="../Core/External/Proto/Buffer"/>
+									<listOptionValue builtIn="false" value="../Core/External/RingBuffer"/>
 								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.input.c.1702390565" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.input.c"/>
 							</tool>
@@ -71,13 +74,24 @@
 									<listOptionValue builtIn="false" value="../Drivers/STM32L4xx_HAL_Driver/Inc/Legacy"/>
 									<listOptionValue builtIn="false" value="../Drivers/CMSIS/Device/ST/STM32L4xx/Include"/>
 									<listOptionValue builtIn="false" value="../Drivers/CMSIS/Include"/>
+									<listOptionValue builtIn="false" value="../Core/External/RingBuffer"/>
+									<listOptionValue builtIn="false" value="../Core/External/Sensor"/>
+									<listOptionValue builtIn="false" value="../Core/External/Proto"/>
+									<listOptionValue builtIn="false" value="../Core/External/Tools/Indicator"/>
+									<listOptionValue builtIn="false" value="../Core/External/Proto/Generated"/>
 									<listOptionValue builtIn="false" value="../ThirdParty"/>
-									<listOptionValue builtIn="false" value="../Core/External/Proto/Buffer/Read"/>
-									<listOptionValue builtIn="false" value="../Core/External/Proto/Buffer/Write"/>
+									<listOptionValue builtIn="false" value="../Core/External/Proto/Buffer"/>
 								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.compiler.input.cpp.425825475" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.compiler.input.cpp"/>
 							</tool>
-							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.1926935555" name="MCU GCC Linker" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker"/>
+							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.1926935555" name="MCU GCC Linker" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker">
+								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.systemcalls.552443768" name="System calls" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.systemcalls" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.systemcalls.value.minimalimplementation" valueType="enumerated"/>
+								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.script.695225605" name="Linker Script (-T)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.script" value="${workspace_loc:/${ProjName}/STM32L476RGTX_FLASH.ld}" valueType="string"/>
+								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.input.592307479" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.input">
+									<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
+									<additionalInput kind="additionalinput" paths="$(LIBS)"/>
+								</inputType>
+							</tool>
 							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.582092523" name="MCU G++ Linker" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker">
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.script.30566923" name="Linker Script (-T)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.script" value="${workspace_loc:/${ProjName}/STM32L476RGTX_FLASH.ld}" valueType="string"/>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.input.1339005471" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.input">
@@ -166,7 +180,14 @@
 								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.compiler.input.cpp.1921150143" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.compiler.input.cpp"/>
 							</tool>
-							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.739188134" name="MCU GCC Linker" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker"/>
+							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.739188134" name="MCU GCC Linker" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker">
+								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.systemcalls.1174496947" name="System calls" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.systemcalls" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.systemcalls.value.minimalimplementation" valueType="enumerated"/>
+								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.script.1750919812" name="Linker Script (-T)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.script" value="${workspace_loc:/${ProjName}/STM32L476RGTX_FLASH.ld}" valueType="string"/>
+								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.input.985046144" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.input">
+									<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
+									<additionalInput kind="additionalinput" paths="$(LIBS)"/>
+								</inputType>
+							</tool>
 							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.2005041740" name="MCU G++ Linker" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker">
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.script.466307801" name="Linker Script (-T)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.script" value="${workspace_loc:/${ProjName}/STM32L476RGTX_FLASH.ld}" valueType="string"/>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.input.1828013521" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.input">
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 0000000..765ff2e
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,14 @@
+name: Build
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+        - uses: actions/checkout@v3
+
+        - uses: xanderhendriks/action-build-stm32cubeide@v10.0
+          with:
+            project-path: '.'
+            project-target: './Debug'
\ No newline at end of file
diff --git a/.project b/.project
index b0ddc02..0c72ee2 100644
--- a/.project
+++ b/.project
@@ -22,12 +22,12 @@
 		<nature>com.st.stm32cube.ide.mcu.MCUProjectNature</nature>
 		<nature>com.st.stm32cube.ide.mcu.MCUCubeProjectNature</nature>
 		<nature>org.eclipse.cdt.core.cnature</nature>
-		<nature>org.eclipse.cdt.core.ccnature</nature>
 		<nature>com.st.stm32cube.ide.mcu.MCUCubeIdeServicesRevAev2ProjectNature</nature>
 		<nature>com.st.stm32cube.ide.mcu.MCUAdvancedStructureProjectNature</nature>
 		<nature>com.st.stm32cube.ide.mcu.MCUSingleCpuProjectNature</nature>
 		<nature>com.st.stm32cube.ide.mcu.MCURootProjectNature</nature>
 		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
 		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
+		<nature>org.eclipse.cdt.core.ccnature</nature>
 	</natures>
 </projectDescription>
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 575d99f..191d346 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -49,13 +49,17 @@ else ()
     add_compile_options(-Og -g)
 endif ()
 
-include_directories(Core/Inc Drivers/STM32L4xx_HAL_Driver/Inc Drivers/STM32L4xx_HAL_Driver/Inc/Legacy Drivers/CMSIS/Device/ST/STM32L4xx/Include Drivers/CMSIS/Include Core/External/Sensor Core/External/Proto Core/External/Tools/Indicator Core/External/Proto/Generated ThirdParty Core/External/Proto/Buffer)
+include_directories(Core/Inc Drivers/STM32L4xx_HAL_Driver/Inc Drivers/STM32L4xx_HAL_Driver/Inc/Legacy Drivers/CMSIS/Device/ST/STM32L4xx/Include Drivers/CMSIS/Include Core/External/Sensor Core/External/Proto Core/External/Tools/Indicator Core/External/Proto/Generated ThirdParty Core/External/Proto/Buffer Core/External/RingBuffer)
 
 add_definitions(-DDEBUG -DUSE_HAL_DRIVER -DSTM32L476xx)
 
 file(GLOB_RECURSE SOURCES "ThirdParty/*.*" "Core/*.*" "Drivers/*.*")
 
-set(LINKER_SCRIPT ${CMAKE_SOURCE_DIR}/)
+set(LINKER_SCRIPT ${CMAKE_SOURCE_DIR}/STM32L476RGTX_FLASH.ld
+        Core/External/Timer/timer.cpp
+        Core/External/Timer/timer.h
+        Core/External/State/state.cpp
+        Core/External/State/state.h)
 
 add_link_options(-Wl,-gc-sections,--print-memory-usage,-Map=${PROJECT_BINARY_DIR}/${PROJECT_NAME}.map)
 add_link_options(-mcpu=cortex-m4 -mthumb -mthumb-interwork)
diff --git a/Core/External/Proto/Buffer/Read/read_buffer.cpp b/Core/External/Proto/Buffer/Read/read_buffer.cpp
new file mode 100644
index 0000000..91a19b3
--- /dev/null
+++ b/Core/External/Proto/Buffer/Read/read_buffer.cpp
@@ -0,0 +1,54 @@
+#include "read_buffer.h"
+
+ReadBuffer::ReadBuffer() : index(0), size(0), bytes{0U} {
+}
+
+void ReadBuffer::set_data(uint8_t *src1, const uint32_t src2) {
+    this->bytes = src1;
+    this->size = src2;
+}
+
+uint32_t ReadBuffer::get_size() const {
+    return index;
+}
+
+uint32_t ReadBuffer::get_max_size() const {
+    return size;
+}
+
+bool ReadBuffer::peek(uint8_t &byte) const {
+    bool result = this->index < this->size;
+    if (result) {
+        byte = this->bytes[this->index];
+    }
+
+    return result;
+}
+
+bool ReadBuffer::advance() {
+    const bool result = this->index < this->size;
+    if (result) {
+        ++this->index;
+    }
+    return result;
+}
+
+bool ReadBuffer::advance(const uint32_t src) {
+    this->index += src;
+    const bool result = this->index < this->size;
+    if (result) {
+        this->index = this->size;
+    }
+
+    return result;
+}
+
+bool ReadBuffer::pop(uint8_t &byte) {
+    bool result = this->index < this->size;
+    if (result) {
+        byte = this->bytes[this->index];
+        ++this->index;
+    }
+
+    return result;
+}
diff --git a/Core/External/Proto/Buffer/Read/read_buffer.h b/Core/External/Proto/Buffer/Read/read_buffer.h
new file mode 100644
index 0000000..91cd743
--- /dev/null
+++ b/Core/External/Proto/Buffer/Read/read_buffer.h
@@ -0,0 +1,71 @@
+#ifndef LIGHT_DETECTOR_READ_BUFFER_H
+#define LIGHT_DETECTOR_READ_BUFFER_H
+
+#include <stdio.h>
+#include "ReadBufferInterface.h"
+
+/**
+ * Represents read buffer implementation for protocol buffers serialization.
+ */
+class ReadBuffer : public EmbeddedProto::ReadBufferInterface {
+public:
+    ReadBuffer();
+
+    virtual ~ReadBuffer() = default;
+
+    /**
+     * Sets given buffer data.
+     *
+     * @param src1 - given buffer source.
+     * @param src2 - given buffer source size.
+     */
+    void set_data(uint8_t *src1, uint32_t src2);
+
+    /**
+     * @see EmbeddedProto::ReadBufferInterface
+     */
+    [[nodiscard]] uint32_t get_size() const override;
+
+    /**
+     * @see EmbeddedProto::ReadBufferInterface
+     */
+    [[nodiscard]] uint32_t get_max_size() const override;
+
+    /**
+     * @see EmbeddedProto::ReadBufferInterface
+     */
+    bool peek(uint8_t &byte) const override;
+
+    /**
+     * @see EmbeddedProto::ReadBufferInterface
+     */
+    bool advance() override;
+
+    /**
+     * @see EmbeddedProto::ReadBufferInterface
+     */
+    bool advance(const uint32_t N) override;
+
+    /**
+     * @see EmbeddedProto::ReadBufferInterface
+     */
+    bool pop(uint8_t &byte) override;
+
+private:
+    /**
+     * Represents current size of the buffer.
+     */
+    uint32_t index;
+
+    /**
+     * Represents max size of the buffer.
+     */
+    uint32_t size;
+
+    /**
+     * Represents current buffer data.
+     */
+    uint8_t *bytes;
+};
+
+#endif //LIGHT_DETECTOR_READ_BUFFER_H
diff --git a/Core/External/Proto/Buffer/Write/write_buffer.cpp b/Core/External/Proto/Buffer/Write/write_buffer.cpp
new file mode 100644
index 0000000..c5f31b6
--- /dev/null
+++ b/Core/External/Proto/Buffer/Write/write_buffer.cpp
@@ -0,0 +1,49 @@
+#ifndef _DEMO_WRITE_BUFFER_H_
+#define _DEMO_WRITE_BUFFER_H_
+
+#include "write_buffer.h"
+
+//WriteBuffer()
+//        : bytes_used_(0),
+//          bytes_{0U} {
+//
+//}
+//
+//virtual ~WriteBuffer() = default;
+//
+//void clear() override {
+//bytes_used_ = 0;
+//}
+//
+//uint32_t get_size() const override {
+//return bytes_used_;
+//}
+//
+//uint32_t get_max_size() const override {
+//return BUFFER_SIZE;
+//}
+//
+//uint32_t get_available_size() const override {
+//return -bytes_used_;
+//}
+//
+//bool push(const uint8_t byte) override {
+//bool result = BUFFER_SIZE > bytes_used_;
+//if (result) {
+//bytes_[bytes_used_] = byte;
+//++bytes_used_;
+//}
+//return result;
+//}
+//
+//bool push(const uint8_t *bytes, const uint32_t length) override {
+//bool result = BUFFER_SIZE >= (bytes_used_ + length);
+//if (result) {
+//memcpy(bytes_ + bytes_used_, bytes, length);
+//bytes_used_ += length;
+//}
+//return result;
+//}
+
+
+#endif // _DEMO_WRITE_BUFFER_H_
diff --git a/Core/External/Proto/Buffer/Write/write_buffer.h b/Core/External/Proto/Buffer/Write/write_buffer.h
new file mode 100644
index 0000000..6da2b7c
--- /dev/null
+++ b/Core/External/Proto/Buffer/Write/write_buffer.h
@@ -0,0 +1,82 @@
+#ifndef LIGHT_DETECTOR_WRITE_BUFFER_H
+#define LIGHT_DETECTOR_WRITE_BUFFER_H
+
+#include <WriteBufferInterface.h>
+#include <stdio.h>
+#include <cstring>
+
+/**
+ * Represents write buffer implementation for protocol buffers serialization.
+ *
+ * @tparam BUFFER_SIZE
+ */
+template<uint32_t BUFFER_SIZE>
+class WriteBuffer : public EmbeddedProto::WriteBufferInterface {
+public:
+    WriteBuffer();
+
+    virtual ~WriteBuffer() = default;
+
+    /**
+     * @see EmbeddedProto::WriteBufferInterface
+     */
+    void clear() override;
+
+    /**
+     * @see EmbeddedProto::WriteBufferInterface
+     */
+    [[nodiscard]] uint32_t get_size() const override {
+        return bytes_used;
+    }
+
+    /**
+     * @see EmbeddedProto::WriteBufferInterface
+     */
+    [[nodiscard]] uint32_t get_max_size() const override {
+        return BUFFER_SIZE;
+    }
+
+    /**
+     * @see EmbeddedProto::WriteBufferInterface
+     */
+    [[nodiscard]] uint32_t get_available_size() const override {
+        return -bytes_used;
+    }
+
+    /**
+     * @see EmbeddedProto::WriteBufferInterface
+     */
+    bool push(const uint8_t byte) override {
+        bool result = BUFFER_SIZE > bytes_used;
+        if (result) {
+            bytes[bytes_used] = byte;
+            ++bytes_used;
+        }
+        return result;
+    }
+
+    /**
+     * @see EmbeddedProto::WriteBufferInterface
+     */
+    bool push(const uint8_t *bytes, const uint32_t length) override {
+        bool result = BUFFER_SIZE >= (bytes_used + length);
+        if (result) {
+            memcpy(bytes, bytes + bytes_used, length);
+            bytes_used += length;
+        }
+        return result;
+    }
+
+private:
+    /**
+     * Represents amount of currently used bytes by buffer.
+     */
+    uint32_t bytes_used;
+
+    /**
+     * Represents current buffer data.
+     */
+    uint8_t bytes[BUFFER_SIZE];
+};
+
+#endif //LIGHT_DETECTOR_WRITE_BUFFER_H
diff --git a/Core/External/Proto/Generated/data.h b/Core/External/Proto/Generated/data.h
new file mode 100644
index 0000000..6fc0ff5
--- /dev/null
+++ b/Core/External/Proto/Generated/data.h
@@ -0,0 +1,521 @@
+/*
+ *  This file is generated with Embedded Proto, PLEASE DO NOT EDIT!
+ *  source: data.proto
+ */
+
+// This file is generated. Please do not edit!
+#ifndef DATA_H
+#define DATA_H
+
+#include <cstdint>
+#include <MessageInterface.h>
+#include <WireFormatter.h>
+#include <Fields.h>
+#include <MessageSizeCalculator.h>
+#include <ReadBufferSection.h>
+#include <RepeatedFieldFixedSize.h>
+#include <FieldStringBytes.h>
+#include <Errors.h>
+#include <Defines.h>
+#include <limits>
+
+// Include external proto definitions
+
+namespace light_detector {
+
+enum class DataType : uint32_t
+{
+  Raw = 0,
+  Full = 1,
+  Infrared = 2,
+  Visible = 3
+};
+
+class DataBusRequest final: public ::EmbeddedProto::MessageInterface
+{
+  public:
+    DataBusRequest() = default;
+    DataBusRequest(const DataBusRequest& rhs )
+    {
+      set_dataType(rhs.get_dataType());
+    }
+
+    DataBusRequest(const DataBusRequest&& rhs ) noexcept
+    {
+      set_dataType(rhs.get_dataType());
+    }
+
+    ~DataBusRequest() override = default;
+
+    enum class FieldNumber : uint32_t
+    {
+      NOT_SET = 0,
+      DATATYPE = 1
+    };
+
+    DataBusRequest& operator=(const DataBusRequest& rhs)
+    {
+      set_dataType(rhs.get_dataType());
+      return *this;
+    }
+
+    DataBusRequest& operator=(const DataBusRequest&& rhs) noexcept
+    {
+      set_dataType(rhs.get_dataType());
+      return *this;
+    }
+
+    static constexpr char const* DATATYPE_NAME = "dataType";
+    inline void clear_dataType() { dataType_.clear(); }
+    inline void set_dataType(const DataType& value) { dataType_ = value; }
+    inline void set_dataType(const DataType&& value) { dataType_ = value; }
+    inline const DataType& get_dataType() const { return dataType_.get(); }
+    inline DataType dataType() const { return dataType_.get(); }
+
+
+    ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+
+      if((static_cast<DataType>(0) != dataType_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = dataType_.serialize_with_id(static_cast<uint32_t>(FieldNumber::DATATYPE), buffer, false);
+      }
+
+      return return_value;
+    };
+
+    ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+      ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT;
+      uint32_t id_number = 0;
+      FieldNumber id_tag = FieldNumber::NOT_SET;
+
+      ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+      while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value))
+      {
+        id_tag = static_cast<FieldNumber>(id_number);
+        switch(id_tag)
+        {
+          case FieldNumber::DATATYPE:
+            return_value = dataType_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::NOT_SET:
+            return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID;
+            break;
+
+          default:
+            return_value = skip_unknown_field(buffer, wire_type);
+            break;
+        }
+
+        if(::EmbeddedProto::Error::NO_ERRORS == return_value)
+        {
+          // Read the next tag.
+          tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+        }
+      }
+
+      // When an error was detect while reading the tag but no other errors where found, set it in the return value.
+      if((::EmbeddedProto::Error::NO_ERRORS == return_value)
+         && (::EmbeddedProto::Error::NO_ERRORS != tag_value)
+         && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case.
+      {
+        return_value = tag_value;
+      }
+
+      return return_value;
+    };
+
+    void clear() override
+    {
+      clear_dataType();
+
+    }
+
+    static char const* field_number_to_name(const FieldNumber fieldNumber)
+    {
+      char const* name = nullptr;
+      switch(fieldNumber)
+      {
+        case FieldNumber::DATATYPE:
+          name = DATATYPE_NAME;
+          break;
+        default:
+          name = "Invalid FieldNumber";
+          break;
+      }
+      return name;
+    }
+
+#ifdef MSG_TO_STRING
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const
+    {
+      return this->to_string(str, 0, nullptr, true);
+    }
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override
+    {
+      ::EmbeddedProto::string_view left_chars = str;
+      int32_t n_chars_used = 0;
+
+      if(!first_field)
+      {
+        // Add a comma behind the previous field.
+        n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n");
+        if(0 < n_chars_used)
+        {
+          // Update the character pointer and characters left in the array.
+          left_chars.data += n_chars_used;
+          left_chars.size -= n_chars_used;
+        }
+      }
+
+      if(nullptr != name)
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name);
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name);
+        }
+      }
+      else
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n");
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " ");
+        }
+      }
+      
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      left_chars = dataType_.to_string(left_chars, indent_level + 2, DATATYPE_NAME, true);
+  
+      if( 0 == indent_level) 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}");
+      }
+      else 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " ");
+      }
+
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      return left_chars;
+    }
+
+#endif // End of MSG_TO_STRING
+
+  private:
+
+
+      EmbeddedProto::enumeration<DataType> dataType_ = static_cast<DataType>(0);
+
+};
+
+class DataBusResponse final: public ::EmbeddedProto::MessageInterface
+{
+  public:
+    DataBusResponse() = default;
+    DataBusResponse(const DataBusResponse& rhs )
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_dataType(rhs.get_dataType());
+      set_value(rhs.get_value());
+      set_nonce(rhs.get_nonce());
+    }
+
+    DataBusResponse(const DataBusResponse&& rhs ) noexcept
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_dataType(rhs.get_dataType());
+      set_value(rhs.get_value());
+      set_nonce(rhs.get_nonce());
+    }
+
+    ~DataBusResponse() override = default;
+
+    enum class FieldNumber : uint32_t
+    {
+      NOT_SET = 0,
+      DEVICEID = 1,
+      DATATYPE = 2,
+      VALUE = 3,
+      NONCE = 4
+    };
+
+    DataBusResponse& operator=(const DataBusResponse& rhs)
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_dataType(rhs.get_dataType());
+      set_value(rhs.get_value());
+      set_nonce(rhs.get_nonce());
+      return *this;
+    }
+
+    DataBusResponse& operator=(const DataBusResponse&& rhs) noexcept
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_dataType(rhs.get_dataType());
+      set_value(rhs.get_value());
+      set_nonce(rhs.get_nonce());
+      return *this;
+    }
+
+    static constexpr char const* DEVICEID_NAME = "deviceId";
+    inline void clear_deviceId() { deviceId_.clear(); }
+    inline void set_deviceId(const uint32_t& value) { deviceId_ = value; }
+    inline void set_deviceId(const uint32_t&& value) { deviceId_ = value; }
+    inline uint32_t& mutable_deviceId() { return deviceId_.get(); }
+    inline const uint32_t& get_deviceId() const { return deviceId_.get(); }
+    inline uint32_t deviceId() const { return deviceId_.get(); }
+
+    static constexpr char const* DATATYPE_NAME = "dataType";
+    inline void clear_dataType() { dataType_.clear(); }
+    inline void set_dataType(const DataType& value) { dataType_ = value; }
+    inline void set_dataType(const DataType&& value) { dataType_ = value; }
+    inline const DataType& get_dataType() const { return dataType_.get(); }
+    inline DataType dataType() const { return dataType_.get(); }
+
+    static constexpr char const* VALUE_NAME = "value";
+    inline void clear_value() { value_.clear(); }
+    inline void set_value(const uint32_t& value) { value_ = value; }
+    inline void set_value(const uint32_t&& value) { value_ = value; }
+    inline uint32_t& mutable_value() { return value_.get(); }
+    inline const uint32_t& get_value() const { return value_.get(); }
+    inline uint32_t value() const { return value_.get(); }
+
+    static constexpr char const* NONCE_NAME = "nonce";
+    inline void clear_nonce() { nonce_.clear(); }
+    inline void set_nonce(const uint32_t& value) { nonce_ = value; }
+    inline void set_nonce(const uint32_t&& value) { nonce_ = value; }
+    inline uint32_t& mutable_nonce() { return nonce_.get(); }
+    inline const uint32_t& get_nonce() const { return nonce_.get(); }
+    inline uint32_t nonce() const { return nonce_.get(); }
+
+
+    ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+
+      if((0U != deviceId_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = deviceId_.serialize_with_id(static_cast<uint32_t>(FieldNumber::DEVICEID), buffer, false);
+      }
+
+      if((static_cast<DataType>(0) != dataType_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = dataType_.serialize_with_id(static_cast<uint32_t>(FieldNumber::DATATYPE), buffer, false);
+      }
+
+      if((0U != value_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = value_.serialize_with_id(static_cast<uint32_t>(FieldNumber::VALUE), buffer, false);
+      }
+
+      if((0U != nonce_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = nonce_.serialize_with_id(static_cast<uint32_t>(FieldNumber::NONCE), buffer, false);
+      }
+
+      return return_value;
+    };
+
+    ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+      ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT;
+      uint32_t id_number = 0;
+      FieldNumber id_tag = FieldNumber::NOT_SET;
+
+      ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+      while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value))
+      {
+        id_tag = static_cast<FieldNumber>(id_number);
+        switch(id_tag)
+        {
+          case FieldNumber::DEVICEID:
+            return_value = deviceId_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::DATATYPE:
+            return_value = dataType_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::VALUE:
+            return_value = value_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::NONCE:
+            return_value = nonce_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::NOT_SET:
+            return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID;
+            break;
+
+          default:
+            return_value = skip_unknown_field(buffer, wire_type);
+            break;
+        }
+
+        if(::EmbeddedProto::Error::NO_ERRORS == return_value)
+        {
+          // Read the next tag.
+          tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+        }
+      }
+
+      // When an error was detect while reading the tag but no other errors where found, set it in the return value.
+      if((::EmbeddedProto::Error::NO_ERRORS == return_value)
+         && (::EmbeddedProto::Error::NO_ERRORS != tag_value)
+         && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case.
+      {
+        return_value = tag_value;
+      }
+
+      return return_value;
+    };
+
+    void clear() override
+    {
+      clear_deviceId();
+      clear_dataType();
+      clear_value();
+      clear_nonce();
+
+    }
+
+    static char const* field_number_to_name(const FieldNumber fieldNumber)
+    {
+      char const* name = nullptr;
+      switch(fieldNumber)
+      {
+        case FieldNumber::DEVICEID:
+          name = DEVICEID_NAME;
+          break;
+        case FieldNumber::DATATYPE:
+          name = DATATYPE_NAME;
+          break;
+        case FieldNumber::VALUE:
+          name = VALUE_NAME;
+          break;
+        case FieldNumber::NONCE:
+          name = NONCE_NAME;
+          break;
+        default:
+          name = "Invalid FieldNumber";
+          break;
+      }
+      return name;
+    }
+
+#ifdef MSG_TO_STRING
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const
+    {
+      return this->to_string(str, 0, nullptr, true);
+    }
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override
+    {
+      ::EmbeddedProto::string_view left_chars = str;
+      int32_t n_chars_used = 0;
+
+      if(!first_field)
+      {
+        // Add a comma behind the previous field.
+        n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n");
+        if(0 < n_chars_used)
+        {
+          // Update the character pointer and characters left in the array.
+          left_chars.data += n_chars_used;
+          left_chars.size -= n_chars_used;
+        }
+      }
+
+      if(nullptr != name)
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name);
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name);
+        }
+      }
+      else
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n");
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " ");
+        }
+      }
+      
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      left_chars = deviceId_.to_string(left_chars, indent_level + 2, DEVICEID_NAME, true);
+      left_chars = dataType_.to_string(left_chars, indent_level + 2, DATATYPE_NAME, false);
+      left_chars = value_.to_string(left_chars, indent_level + 2, VALUE_NAME, false);
+      left_chars = nonce_.to_string(left_chars, indent_level + 2, NONCE_NAME, false);
+  
+      if( 0 == indent_level) 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}");
+      }
+      else 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " ");
+      }
+
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      return left_chars;
+    }
+
+#endif // End of MSG_TO_STRING
+
+  private:
+
+
+      EmbeddedProto::uint32 deviceId_ = 0U;
+      EmbeddedProto::enumeration<DataType> dataType_ = static_cast<DataType>(0);
+      EmbeddedProto::uint32 value_ = 0U;
+      EmbeddedProto::uint32 nonce_ = 0U;
+
+};
+
+} // End of namespace light_detector
+#endif // DATA_H
\ No newline at end of file
diff --git a/Core/External/Proto/Generated/info.h b/Core/External/Proto/Generated/info.h
new file mode 100644
index 0000000..82ab1a1
--- /dev/null
+++ b/Core/External/Proto/Generated/info.h
@@ -0,0 +1,519 @@
+/*
+ *  This file is generated with Embedded Proto, PLEASE DO NOT EDIT!
+ *  source: info.proto
+ */
+
+// This file is generated. Please do not edit!
+#ifndef INFO_H
+#define INFO_H
+
+#include <cstdint>
+#include <MessageInterface.h>
+#include <WireFormatter.h>
+#include <Fields.h>
+#include <MessageSizeCalculator.h>
+#include <ReadBufferSection.h>
+#include <RepeatedFieldFixedSize.h>
+#include <FieldStringBytes.h>
+#include <Errors.h>
+#include <Defines.h>
+#include <limits>
+
+// Include external proto definitions
+
+namespace light_detector {
+
+enum class InfoType : uint32_t
+{
+  GetGain = 0,
+  GetIntegralTime = 1
+};
+
+class InfoBusRequest final: public ::EmbeddedProto::MessageInterface
+{
+  public:
+    InfoBusRequest() = default;
+    InfoBusRequest(const InfoBusRequest& rhs )
+    {
+      set_infoType(rhs.get_infoType());
+    }
+
+    InfoBusRequest(const InfoBusRequest&& rhs ) noexcept
+    {
+      set_infoType(rhs.get_infoType());
+    }
+
+    ~InfoBusRequest() override = default;
+
+    enum class FieldNumber : uint32_t
+    {
+      NOT_SET = 0,
+      INFOTYPE = 1
+    };
+
+    InfoBusRequest& operator=(const InfoBusRequest& rhs)
+    {
+      set_infoType(rhs.get_infoType());
+      return *this;
+    }
+
+    InfoBusRequest& operator=(const InfoBusRequest&& rhs) noexcept
+    {
+      set_infoType(rhs.get_infoType());
+      return *this;
+    }
+
+    static constexpr char const* INFOTYPE_NAME = "infoType";
+    inline void clear_infoType() { infoType_.clear(); }
+    inline void set_infoType(const InfoType& value) { infoType_ = value; }
+    inline void set_infoType(const InfoType&& value) { infoType_ = value; }
+    inline const InfoType& get_infoType() const { return infoType_.get(); }
+    inline InfoType infoType() const { return infoType_.get(); }
+
+
+    ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+
+      if((static_cast<InfoType>(0) != infoType_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = infoType_.serialize_with_id(static_cast<uint32_t>(FieldNumber::INFOTYPE), buffer, false);
+      }
+
+      return return_value;
+    };
+
+    ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+      ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT;
+      uint32_t id_number = 0;
+      FieldNumber id_tag = FieldNumber::NOT_SET;
+
+      ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+      while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value))
+      {
+        id_tag = static_cast<FieldNumber>(id_number);
+        switch(id_tag)
+        {
+          case FieldNumber::INFOTYPE:
+            return_value = infoType_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::NOT_SET:
+            return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID;
+            break;
+
+          default:
+            return_value = skip_unknown_field(buffer, wire_type);
+            break;
+        }
+
+        if(::EmbeddedProto::Error::NO_ERRORS == return_value)
+        {
+          // Read the next tag.
+          tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+        }
+      }
+
+      // When an error was detect while reading the tag but no other errors where found, set it in the return value.
+      if((::EmbeddedProto::Error::NO_ERRORS == return_value)
+         && (::EmbeddedProto::Error::NO_ERRORS != tag_value)
+         && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case.
+      {
+        return_value = tag_value;
+      }
+
+      return return_value;
+    };
+
+    void clear() override
+    {
+      clear_infoType();
+
+    }
+
+    static char const* field_number_to_name(const FieldNumber fieldNumber)
+    {
+      char const* name = nullptr;
+      switch(fieldNumber)
+      {
+        case FieldNumber::INFOTYPE:
+          name = INFOTYPE_NAME;
+          break;
+        default:
+          name = "Invalid FieldNumber";
+          break;
+      }
+      return name;
+    }
+
+#ifdef MSG_TO_STRING
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const
+    {
+      return this->to_string(str, 0, nullptr, true);
+    }
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override
+    {
+      ::EmbeddedProto::string_view left_chars = str;
+      int32_t n_chars_used = 0;
+
+      if(!first_field)
+      {
+        // Add a comma behind the previous field.
+        n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n");
+        if(0 < n_chars_used)
+        {
+          // Update the character pointer and characters left in the array.
+          left_chars.data += n_chars_used;
+          left_chars.size -= n_chars_used;
+        }
+      }
+
+      if(nullptr != name)
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name);
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name);
+        }
+      }
+      else
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n");
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " ");
+        }
+      }
+      
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      left_chars = infoType_.to_string(left_chars, indent_level + 2, INFOTYPE_NAME, true);
+  
+      if( 0 == indent_level) 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}");
+      }
+      else 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " ");
+      }
+
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      return left_chars;
+    }
+
+#endif // End of MSG_TO_STRING
+
+  private:
+
+
+      EmbeddedProto::enumeration<InfoType> infoType_ = static_cast<InfoType>(0);
+
+};
+
+class InfoBusResponse final: public ::EmbeddedProto::MessageInterface
+{
+  public:
+    InfoBusResponse() = default;
+    InfoBusResponse(const InfoBusResponse& rhs )
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_infoType(rhs.get_infoType());
+      set_value(rhs.get_value());
+      set_nonce(rhs.get_nonce());
+    }
+
+    InfoBusResponse(const InfoBusResponse&& rhs ) noexcept
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_infoType(rhs.get_infoType());
+      set_value(rhs.get_value());
+      set_nonce(rhs.get_nonce());
+    }
+
+    ~InfoBusResponse() override = default;
+
+    enum class FieldNumber : uint32_t
+    {
+      NOT_SET = 0,
+      DEVICEID = 1,
+      INFOTYPE = 2,
+      VALUE = 3,
+      NONCE = 4
+    };
+
+    InfoBusResponse& operator=(const InfoBusResponse& rhs)
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_infoType(rhs.get_infoType());
+      set_value(rhs.get_value());
+      set_nonce(rhs.get_nonce());
+      return *this;
+    }
+
+    InfoBusResponse& operator=(const InfoBusResponse&& rhs) noexcept
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_infoType(rhs.get_infoType());
+      set_value(rhs.get_value());
+      set_nonce(rhs.get_nonce());
+      return *this;
+    }
+
+    static constexpr char const* DEVICEID_NAME = "deviceId";
+    inline void clear_deviceId() { deviceId_.clear(); }
+    inline void set_deviceId(const uint32_t& value) { deviceId_ = value; }
+    inline void set_deviceId(const uint32_t&& value) { deviceId_ = value; }
+    inline uint32_t& mutable_deviceId() { return deviceId_.get(); }
+    inline const uint32_t& get_deviceId() const { return deviceId_.get(); }
+    inline uint32_t deviceId() const { return deviceId_.get(); }
+
+    static constexpr char const* INFOTYPE_NAME = "infoType";
+    inline void clear_infoType() { infoType_.clear(); }
+    inline void set_infoType(const InfoType& value) { infoType_ = value; }
+    inline void set_infoType(const InfoType&& value) { infoType_ = value; }
+    inline const InfoType& get_infoType() const { return infoType_.get(); }
+    inline InfoType infoType() const { return infoType_.get(); }
+
+    static constexpr char const* VALUE_NAME = "value";
+    inline void clear_value() { value_.clear(); }
+    inline void set_value(const uint32_t& value) { value_ = value; }
+    inline void set_value(const uint32_t&& value) { value_ = value; }
+    inline uint32_t& mutable_value() { return value_.get(); }
+    inline const uint32_t& get_value() const { return value_.get(); }
+    inline uint32_t value() const { return value_.get(); }
+
+    static constexpr char const* NONCE_NAME = "nonce";
+    inline void clear_nonce() { nonce_.clear(); }
+    inline void set_nonce(const uint32_t& value) { nonce_ = value; }
+    inline void set_nonce(const uint32_t&& value) { nonce_ = value; }
+    inline uint32_t& mutable_nonce() { return nonce_.get(); }
+    inline const uint32_t& get_nonce() const { return nonce_.get(); }
+    inline uint32_t nonce() const { return nonce_.get(); }
+
+
+    ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+
+      if((0U != deviceId_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = deviceId_.serialize_with_id(static_cast<uint32_t>(FieldNumber::DEVICEID), buffer, false);
+      }
+
+      if((static_cast<InfoType>(0) != infoType_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = infoType_.serialize_with_id(static_cast<uint32_t>(FieldNumber::INFOTYPE), buffer, false);
+      }
+
+      if((0U != value_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = value_.serialize_with_id(static_cast<uint32_t>(FieldNumber::VALUE), buffer, false);
+      }
+
+      if((0U != nonce_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = nonce_.serialize_with_id(static_cast<uint32_t>(FieldNumber::NONCE), buffer, false);
+      }
+
+      return return_value;
+    };
+
+    ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+      ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT;
+      uint32_t id_number = 0;
+      FieldNumber id_tag = FieldNumber::NOT_SET;
+
+      ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+      while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value))
+      {
+        id_tag = static_cast<FieldNumber>(id_number);
+        switch(id_tag)
+        {
+          case FieldNumber::DEVICEID:
+            return_value = deviceId_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::INFOTYPE:
+            return_value = infoType_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::VALUE:
+            return_value = value_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::NONCE:
+            return_value = nonce_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::NOT_SET:
+            return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID;
+            break;
+
+          default:
+            return_value = skip_unknown_field(buffer, wire_type);
+            break;
+        }
+
+        if(::EmbeddedProto::Error::NO_ERRORS == return_value)
+        {
+          // Read the next tag.
+          tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+        }
+      }
+
+      // When an error was detect while reading the tag but no other errors where found, set it in the return value.
+      if((::EmbeddedProto::Error::NO_ERRORS == return_value)
+         && (::EmbeddedProto::Error::NO_ERRORS != tag_value)
+         && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case.
+      {
+        return_value = tag_value;
+      }
+
+      return return_value;
+    };
+
+    void clear() override
+    {
+      clear_deviceId();
+      clear_infoType();
+      clear_value();
+      clear_nonce();
+
+    }
+
+    static char const* field_number_to_name(const FieldNumber fieldNumber)
+    {
+      char const* name = nullptr;
+      switch(fieldNumber)
+      {
+        case FieldNumber::DEVICEID:
+          name = DEVICEID_NAME;
+          break;
+        case FieldNumber::INFOTYPE:
+          name = INFOTYPE_NAME;
+          break;
+        case FieldNumber::VALUE:
+          name = VALUE_NAME;
+          break;
+        case FieldNumber::NONCE:
+          name = NONCE_NAME;
+          break;
+        default:
+          name = "Invalid FieldNumber";
+          break;
+      }
+      return name;
+    }
+
+#ifdef MSG_TO_STRING
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const
+    {
+      return this->to_string(str, 0, nullptr, true);
+    }
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override
+    {
+      ::EmbeddedProto::string_view left_chars = str;
+      int32_t n_chars_used = 0;
+
+      if(!first_field)
+      {
+        // Add a comma behind the previous field.
+        n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n");
+        if(0 < n_chars_used)
+        {
+          // Update the character pointer and characters left in the array.
+          left_chars.data += n_chars_used;
+          left_chars.size -= n_chars_used;
+        }
+      }
+
+      if(nullptr != name)
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name);
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name);
+        }
+      }
+      else
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n");
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " ");
+        }
+      }
+      
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      left_chars = deviceId_.to_string(left_chars, indent_level + 2, DEVICEID_NAME, true);
+      left_chars = infoType_.to_string(left_chars, indent_level + 2, INFOTYPE_NAME, false);
+      left_chars = value_.to_string(left_chars, indent_level + 2, VALUE_NAME, false);
+      left_chars = nonce_.to_string(left_chars, indent_level + 2, NONCE_NAME, false);
+  
+      if( 0 == indent_level) 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}");
+      }
+      else 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " ");
+      }
+
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      return left_chars;
+    }
+
+#endif // End of MSG_TO_STRING
+
+  private:
+
+
+      EmbeddedProto::uint32 deviceId_ = 0U;
+      EmbeddedProto::enumeration<InfoType> infoType_ = static_cast<InfoType>(0);
+      EmbeddedProto::uint32 value_ = 0U;
+      EmbeddedProto::uint32 nonce_ = 0U;
+
+};
+
+} // End of namespace light_detector
+#endif // INFO_H
\ No newline at end of file
diff --git a/Core/External/Proto/Generated/settings.h b/Core/External/Proto/Generated/settings.h
new file mode 100644
index 0000000..031b77c
--- /dev/null
+++ b/Core/External/Proto/Generated/settings.h
@@ -0,0 +1,522 @@
+/*
+ *  This file is generated with Embedded Proto, PLEASE DO NOT EDIT!
+ *  source: settings.proto
+ */
+
+// This file is generated. Please do not edit!
+#ifndef SETTINGS_H
+#define SETTINGS_H
+
+#include <cstdint>
+#include <MessageInterface.h>
+#include <WireFormatter.h>
+#include <Fields.h>
+#include <MessageSizeCalculator.h>
+#include <ReadBufferSection.h>
+#include <RepeatedFieldFixedSize.h>
+#include <FieldStringBytes.h>
+#include <Errors.h>
+#include <Defines.h>
+#include <limits>
+
+// Include external proto definitions
+
+namespace light_detector {
+
+enum class SettingsType : uint32_t
+{
+  Enable = 0,
+  Disable = 1,
+  Reset = 2,
+  SetGain = 3,
+  SetIntegralTime = 4
+};
+
+class SettingsBusRequest final: public ::EmbeddedProto::MessageInterface
+{
+  public:
+    SettingsBusRequest() = default;
+    SettingsBusRequest(const SettingsBusRequest& rhs )
+    {
+      set_settingsType(rhs.get_settingsType());
+    }
+
+    SettingsBusRequest(const SettingsBusRequest&& rhs ) noexcept
+    {
+      set_settingsType(rhs.get_settingsType());
+    }
+
+    ~SettingsBusRequest() override = default;
+
+    enum class FieldNumber : uint32_t
+    {
+      NOT_SET = 0,
+      SETTINGSTYPE = 1
+    };
+
+    SettingsBusRequest& operator=(const SettingsBusRequest& rhs)
+    {
+      set_settingsType(rhs.get_settingsType());
+      return *this;
+    }
+
+    SettingsBusRequest& operator=(const SettingsBusRequest&& rhs) noexcept
+    {
+      set_settingsType(rhs.get_settingsType());
+      return *this;
+    }
+
+    static constexpr char const* SETTINGSTYPE_NAME = "settingsType";
+    inline void clear_settingsType() { settingsType_.clear(); }
+    inline void set_settingsType(const SettingsType& value) { settingsType_ = value; }
+    inline void set_settingsType(const SettingsType&& value) { settingsType_ = value; }
+    inline const SettingsType& get_settingsType() const { return settingsType_.get(); }
+    inline SettingsType settingsType() const { return settingsType_.get(); }
+
+
+    ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+
+      if((static_cast<SettingsType>(0) != settingsType_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = settingsType_.serialize_with_id(static_cast<uint32_t>(FieldNumber::SETTINGSTYPE), buffer, false);
+      }
+
+      return return_value;
+    };
+
+    ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+      ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT;
+      uint32_t id_number = 0;
+      FieldNumber id_tag = FieldNumber::NOT_SET;
+
+      ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+      while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value))
+      {
+        id_tag = static_cast<FieldNumber>(id_number);
+        switch(id_tag)
+        {
+          case FieldNumber::SETTINGSTYPE:
+            return_value = settingsType_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::NOT_SET:
+            return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID;
+            break;
+
+          default:
+            return_value = skip_unknown_field(buffer, wire_type);
+            break;
+        }
+
+        if(::EmbeddedProto::Error::NO_ERRORS == return_value)
+        {
+          // Read the next tag.
+          tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+        }
+      }
+
+      // When an error was detect while reading the tag but no other errors where found, set it in the return value.
+      if((::EmbeddedProto::Error::NO_ERRORS == return_value)
+         && (::EmbeddedProto::Error::NO_ERRORS != tag_value)
+         && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case.
+      {
+        return_value = tag_value;
+      }
+
+      return return_value;
+    };
+
+    void clear() override
+    {
+      clear_settingsType();
+
+    }
+
+    static char const* field_number_to_name(const FieldNumber fieldNumber)
+    {
+      char const* name = nullptr;
+      switch(fieldNumber)
+      {
+        case FieldNumber::SETTINGSTYPE:
+          name = SETTINGSTYPE_NAME;
+          break;
+        default:
+          name = "Invalid FieldNumber";
+          break;
+      }
+      return name;
+    }
+
+#ifdef MSG_TO_STRING
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const
+    {
+      return this->to_string(str, 0, nullptr, true);
+    }
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override
+    {
+      ::EmbeddedProto::string_view left_chars = str;
+      int32_t n_chars_used = 0;
+
+      if(!first_field)
+      {
+        // Add a comma behind the previous field.
+        n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n");
+        if(0 < n_chars_used)
+        {
+          // Update the character pointer and characters left in the array.
+          left_chars.data += n_chars_used;
+          left_chars.size -= n_chars_used;
+        }
+      }
+
+      if(nullptr != name)
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name);
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name);
+        }
+      }
+      else
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n");
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " ");
+        }
+      }
+      
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      left_chars = settingsType_.to_string(left_chars, indent_level + 2, SETTINGSTYPE_NAME, true);
+  
+      if( 0 == indent_level) 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}");
+      }
+      else 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " ");
+      }
+
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      return left_chars;
+    }
+
+#endif // End of MSG_TO_STRING
+
+  private:
+
+
+      EmbeddedProto::enumeration<SettingsType> settingsType_ = static_cast<SettingsType>(0);
+
+};
+
+class SettingsBusResponse final: public ::EmbeddedProto::MessageInterface
+{
+  public:
+    SettingsBusResponse() = default;
+    SettingsBusResponse(const SettingsBusResponse& rhs )
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_settingsType(rhs.get_settingsType());
+      set_result(rhs.get_result());
+      set_nonce(rhs.get_nonce());
+    }
+
+    SettingsBusResponse(const SettingsBusResponse&& rhs ) noexcept
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_settingsType(rhs.get_settingsType());
+      set_result(rhs.get_result());
+      set_nonce(rhs.get_nonce());
+    }
+
+    ~SettingsBusResponse() override = default;
+
+    enum class FieldNumber : uint32_t
+    {
+      NOT_SET = 0,
+      DEVICEID = 1,
+      SETTINGSTYPE = 2,
+      RESULT = 3,
+      NONCE = 4
+    };
+
+    SettingsBusResponse& operator=(const SettingsBusResponse& rhs)
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_settingsType(rhs.get_settingsType());
+      set_result(rhs.get_result());
+      set_nonce(rhs.get_nonce());
+      return *this;
+    }
+
+    SettingsBusResponse& operator=(const SettingsBusResponse&& rhs) noexcept
+    {
+      set_deviceId(rhs.get_deviceId());
+      set_settingsType(rhs.get_settingsType());
+      set_result(rhs.get_result());
+      set_nonce(rhs.get_nonce());
+      return *this;
+    }
+
+    static constexpr char const* DEVICEID_NAME = "deviceId";
+    inline void clear_deviceId() { deviceId_.clear(); }
+    inline void set_deviceId(const uint32_t& value) { deviceId_ = value; }
+    inline void set_deviceId(const uint32_t&& value) { deviceId_ = value; }
+    inline uint32_t& mutable_deviceId() { return deviceId_.get(); }
+    inline const uint32_t& get_deviceId() const { return deviceId_.get(); }
+    inline uint32_t deviceId() const { return deviceId_.get(); }
+
+    static constexpr char const* SETTINGSTYPE_NAME = "settingsType";
+    inline void clear_settingsType() { settingsType_.clear(); }
+    inline void set_settingsType(const SettingsType& value) { settingsType_ = value; }
+    inline void set_settingsType(const SettingsType&& value) { settingsType_ = value; }
+    inline const SettingsType& get_settingsType() const { return settingsType_.get(); }
+    inline SettingsType settingsType() const { return settingsType_.get(); }
+
+    static constexpr char const* RESULT_NAME = "result";
+    inline void clear_result() { result_.clear(); }
+    inline void set_result(const bool& value) { result_ = value; }
+    inline void set_result(const bool&& value) { result_ = value; }
+    inline bool& mutable_result() { return result_.get(); }
+    inline const bool& get_result() const { return result_.get(); }
+    inline bool result() const { return result_.get(); }
+
+    static constexpr char const* NONCE_NAME = "nonce";
+    inline void clear_nonce() { nonce_.clear(); }
+    inline void set_nonce(const uint32_t& value) { nonce_ = value; }
+    inline void set_nonce(const uint32_t&& value) { nonce_ = value; }
+    inline uint32_t& mutable_nonce() { return nonce_.get(); }
+    inline const uint32_t& get_nonce() const { return nonce_.get(); }
+    inline uint32_t nonce() const { return nonce_.get(); }
+
+
+    ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+
+      if((0U != deviceId_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = deviceId_.serialize_with_id(static_cast<uint32_t>(FieldNumber::DEVICEID), buffer, false);
+      }
+
+      if((static_cast<SettingsType>(0) != settingsType_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = settingsType_.serialize_with_id(static_cast<uint32_t>(FieldNumber::SETTINGSTYPE), buffer, false);
+      }
+
+      if((false != result_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = result_.serialize_with_id(static_cast<uint32_t>(FieldNumber::RESULT), buffer, false);
+      }
+
+      if((0U != nonce_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value))
+      {
+        return_value = nonce_.serialize_with_id(static_cast<uint32_t>(FieldNumber::NONCE), buffer, false);
+      }
+
+      return return_value;
+    };
+
+    ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override
+    {
+      ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS;
+      ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT;
+      uint32_t id_number = 0;
+      FieldNumber id_tag = FieldNumber::NOT_SET;
+
+      ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+      while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value))
+      {
+        id_tag = static_cast<FieldNumber>(id_number);
+        switch(id_tag)
+        {
+          case FieldNumber::DEVICEID:
+            return_value = deviceId_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::SETTINGSTYPE:
+            return_value = settingsType_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::RESULT:
+            return_value = result_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::NONCE:
+            return_value = nonce_.deserialize_check_type(buffer, wire_type);
+            break;
+
+          case FieldNumber::NOT_SET:
+            return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID;
+            break;
+
+          default:
+            return_value = skip_unknown_field(buffer, wire_type);
+            break;
+        }
+
+        if(::EmbeddedProto::Error::NO_ERRORS == return_value)
+        {
+          // Read the next tag.
+          tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number);
+        }
+      }
+
+      // When an error was detect while reading the tag but no other errors where found, set it in the return value.
+      if((::EmbeddedProto::Error::NO_ERRORS == return_value)
+         && (::EmbeddedProto::Error::NO_ERRORS != tag_value)
+         && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case.
+      {
+        return_value = tag_value;
+      }
+
+      return return_value;
+    };
+
+    void clear() override
+    {
+      clear_deviceId();
+      clear_settingsType();
+      clear_result();
+      clear_nonce();
+
+    }
+
+    static char const* field_number_to_name(const FieldNumber fieldNumber)
+    {
+      char const* name = nullptr;
+      switch(fieldNumber)
+      {
+        case FieldNumber::DEVICEID:
+          name = DEVICEID_NAME;
+          break;
+        case FieldNumber::SETTINGSTYPE:
+          name = SETTINGSTYPE_NAME;
+          break;
+        case FieldNumber::RESULT:
+          name = RESULT_NAME;
+          break;
+        case FieldNumber::NONCE:
+          name = NONCE_NAME;
+          break;
+        default:
+          name = "Invalid FieldNumber";
+          break;
+      }
+      return name;
+    }
+
+#ifdef MSG_TO_STRING
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const
+    {
+      return this->to_string(str, 0, nullptr, true);
+    }
+
+    ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override
+    {
+      ::EmbeddedProto::string_view left_chars = str;
+      int32_t n_chars_used = 0;
+
+      if(!first_field)
+      {
+        // Add a comma behind the previous field.
+        n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n");
+        if(0 < n_chars_used)
+        {
+          // Update the character pointer and characters left in the array.
+          left_chars.data += n_chars_used;
+          left_chars.size -= n_chars_used;
+        }
+      }
+
+      if(nullptr != name)
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name);
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name);
+        }
+      }
+      else
+      {
+        if( 0 == indent_level)
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n");
+        }
+        else
+        {
+          n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " ");
+        }
+      }
+      
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      left_chars = deviceId_.to_string(left_chars, indent_level + 2, DEVICEID_NAME, true);
+      left_chars = settingsType_.to_string(left_chars, indent_level + 2, SETTINGSTYPE_NAME, false);
+      left_chars = result_.to_string(left_chars, indent_level + 2, RESULT_NAME, false);
+      left_chars = nonce_.to_string(left_chars, indent_level + 2, NONCE_NAME, false);
+  
+      if( 0 == indent_level) 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}");
+      }
+      else 
+      {
+        n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " ");
+      }
+
+      if(0 < n_chars_used)
+      {
+        left_chars.data += n_chars_used;
+        left_chars.size -= n_chars_used;
+      }
+
+      return left_chars;
+    }
+
+#endif // End of MSG_TO_STRING
+
+  private:
+
+
+      EmbeddedProto::uint32 deviceId_ = 0U;
+      EmbeddedProto::enumeration<SettingsType> settingsType_ = static_cast<SettingsType>(0);
+      EmbeddedProto::boolean result_ = false;
+      EmbeddedProto::uint32 nonce_ = 0U;
+
+};
+
+} // End of namespace light_detector
+#endif // SETTINGS_H
\ No newline at end of file
diff --git a/Core/External/Proto/proto.cpp b/Core/External/Proto/proto.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/Core/External/Proto/proto.h b/Core/External/Proto/proto.h
new file mode 100644
index 0000000..d007379
--- /dev/null
+++ b/Core/External/Proto/proto.h
@@ -0,0 +1,16 @@
+#ifndef LIGHT_DETECTOR_PROTO_H
+#define LIGHT_DETECTOR_PROTO_H
+
+#include "test.h"
+
+/**
+ * Represents parser used to
+ */
+class ProtoParser {
+public:
+
+private:
+    light_detector::A r;
+};
+
+#endif //LIGHT_DETECTOR_PROTO_H
diff --git a/Core/External/Sensor/tsl2591x.cpp b/Core/External/Sensor/tsl2591x.cpp
new file mode 100644
index 0000000..a95fc4c
--- /dev/null
+++ b/Core/External/Sensor/tsl2591x.cpp
@@ -0,0 +1,269 @@
+#include "tsl2591x.h"
+
+void TSL2591X::init() {
+    enable();
+
+    set_gain(MEDIUM_AGAIN);
+    set_integral_time(ATIME_200MS);
+    write_byte(PERSIST_REGISTER, 0x01);
+
+    disable();
+
+    initialized = true;
+}
+
+bool TSL2591X::is_available() {
+    return HAL_I2C_IsDeviceReady(&hi2c1, TSL2591X_ADDRESS, 1u, 10u) == HAL_OK;
+}
+
+bool TSL2591X::is_configured() {
+    return initialized;
+}
+
+bool TSL2591X::get_device_id() {
+    return read_byte(WHO_AM_I);
+};
+
+void TSL2591X::enable() {
+    write_byte(ENABLE_REGISTER, ENABLE_AIEN | ENABLE_POWERON | ENABLE_AEN | ENABLE_NPIEN);
+}
+
+void TSL2591X::disable() {
+    write_byte(ENABLE_REGISTER, ENABLE_POWEROFF);
+}
+
+void TSL2591X::reset() {
+    write_byte(CONTROL_REGISTER, SRESET);
+}
+
+uint16_t TSL2591X::read_lux() {
+    enable();
+
+    uint8_t externalIntegralTime = get_integral_time();
+
+    for (uint8_t i = 0; i < externalIntegralTime + 2; i++) {
+        HAL_Delay(100);
+    }
+
+    uint16_t channel0 = read_channel0();
+    uint16_t channel1 = read_channel1();
+    disable();
+
+    enable();
+    write_byte(0xE7, 0x13);
+    disable();
+
+    uint16_t maxCounts;
+
+    if (externalIntegralTime == ATIME_100MS) {
+        maxCounts = MAX_COUNT_100MS;
+    } else {
+        maxCounts = MAX_COUNT;
+    }
+
+    uint8_t externalGain;
+
+    if (channel0 >= maxCounts || channel1 >= maxCounts) {
+        externalGain = get_gain();
+
+        if (externalGain == LOW_AGAIN) {
+            return 0;
+        }
+
+        externalGain = ((externalGain >> 4) - 1) << 4;
+
+        set_gain(externalGain);
+
+        channel0 = 0;
+        channel1 = 0;
+        while (channel0 <= 0 || channel1 <= 0) {
+            channel0 = read_channel0();
+            channel1 = read_channel1();
+        }
+
+        HAL_Delay(100);
+    }
+
+    double gain = 1.0;
+
+    externalGain = get_gain();
+
+    if (externalGain == MEDIUM_AGAIN) {
+        gain = 25.0;
+    } else if (externalGain == HIGH_AGAIN) {
+        gain = 428.0;
+    } else if (externalGain == MAX_AGAIN) {
+        gain = 9876.0;
+    }
+
+    uint16_t lux1 = (int) ((channel0 - (2 * channel1)) / (((100 * externalIntegralTime + 100) * gain) / LUX_DF));
+
+    if (lux1 <= 0) {
+        return 0;
+    }
+
+    return lux1;
+}
+
+uint32_t TSL2591X::read_full() {
+    uint32_t result;
+
+    enable();
+
+    result = (read_channel1() << 16) | read_channel0();
+
+    disable();
+
+    return result;
+}
+
+uint16_t TSL2591X::read_infrared() {
+    uint16_t result;
+
+    enable();
+
+    result = read_channel0();
+
+    disable();
+
+    return result;
+}
+
+uint32_t TSL2591X::read_visible() {
+    enable();
+
+    uint16_t channel1 = read_channel1();
+    uint16_t channel0 = read_channel0();
+
+    disable();
+
+    return ((channel1 << 16) | channel0) - channel1;
+}
+
+void TSL2591X::set_raw_interrupt_threshold(uint16_t low, uint16_t high) {
+    enable();
+
+    write_byte(AILTL_REGISTER, low & 0xFF);
+    write_byte(AILTH_REGISTER, low >> 8);
+
+    write_byte(AIHTL_REGISTER, high & 0xFF);
+    write_byte(AIHTH_REGISTER, high >> 8);
+
+    write_byte(NPAILTL_REGISTER, 0);
+    write_byte(NPAILTH_REGISTER, 0);
+
+    write_byte(NPAIHTL_REGISTER, 0xff);
+    write_byte(NPAIHTH_REGISTER, 0xff);
+
+    disable();
+}
+
+void TSL2591X::set_lux_interrupt(uint16_t low, uint16_t high) {
+    double gain = 1.0;
+
+    uint8_t externalGain = get_gain();
+
+    if (externalGain == MEDIUM_AGAIN) {
+        gain = 25.0;
+    } else if (externalGain == HIGH_AGAIN) {
+        gain = 428.0;
+    } else if (externalGain == MAX_AGAIN) {
+        gain = 9876.0;
+    }
+
+    uint8_t externalIntegralTime = get_integral_time();
+
+    double cpl = ((100 * externalIntegralTime + 100) * gain) / LUX_DF;
+
+    uint16_t channel1 = read_channel1();
+
+    uint16_t highLux = (int) (cpl * high) + 2 * channel1 - 1;
+    uint16_t lowLux = (int) (cpl * low) + 2 * channel1 + 1;
+
+    enable();
+
+    write_byte(AILTL_REGISTER, lowLux & 0xFF);
+    write_byte(AILTH_REGISTER, lowLux >> 8);
+
+    write_byte(AIHTL_REGISTER, highLux & 0xFF);
+    write_byte(AIHTH_REGISTER, highLux >> 8);
+
+    write_byte(NPAILTL_REGISTER, 0);
+    write_byte(NPAILTH_REGISTER, 0);
+
+    write_byte(NPAIHTL_REGISTER, 0xff);
+    write_byte(NPAIHTH_REGISTER, 0xff);
+
+    disable();
+}
+
+uint16_t TSL2591X::read_channel0() {
+    return read_word(CHAN0_LOW);
+}
+
+uint16_t TSL2591X::read_channel1() {
+    return read_word(CHAN1_LOW);
+}
+
+uint8_t TSL2591X::get_integral_time() {
+    return read_byte(CONTROL_REGISTER) & 0x07;
+}
+
+void TSL2591X::set_integral_time(uint8_t src)  {
+    if (src < 0x06) {
+        uint8_t control = read_byte(CONTROL_REGISTER);
+        control &= 0xf8;
+        control |= src;
+        write_byte(CONTROL_REGISTER, control);
+    }
+}
+
+uint8_t TSL2591X::get_gain() {
+    return read_byte(CONTROL_REGISTER) & 0x30;
+}
+
+void TSL2591X::set_gain(uint8_t src) {
+    if (src == LOW_AGAIN || src == MEDIUM_AGAIN || src == HIGH_AGAIN || src == MAX_AGAIN) {
+        uint8_t control = read_byte(CONTROL_REGISTER);
+        control &= 0xCf;
+        control |= src;
+        write_byte(CONTROL_REGISTER, control);
+    }
+}
+
+uint8_t TSL2591X::read_byte(uint8_t src) {
+    return read_byte_i2c(src | COMMAND_BIT);
+}
+
+uint16_t TSL2591X::read_word(uint8_t src) {
+    return read_word_i2c(src | COMMAND_BIT);
+}
+
+void TSL2591X::write_byte(uint8_t src, uint8_t value) {
+    write_byte_i2c(src | COMMAND_BIT, value);
+}
+
+void TSL2591X::write_byte_i2c(uint8_t command, uint8_t value) {
+    uint8_t buffer[1] = {value};
+
+    HAL_I2C_Mem_Write(
+            &hi2c1, TSL2591X_ADDRESS, command, I2C_MEMADD_SIZE_8BIT, buffer, 1, I2C_TIMEOUT);
+}
+
+int TSL2591X::read_byte_i2c(uint8_t command) {
+    uint8_t buffer[1] = {0};
+
+    HAL_I2C_Mem_Read(
+            &hi2c1, TSL2591X_ADDRESS + 1, command, I2C_MEMADD_SIZE_8BIT, buffer, 1, I2C_TIMEOUT);
+
+    return buffer[0];
+}
+
+int TSL2591X::read_word_i2c(uint8_t command) {
+    uint8_t buffer[2] = {0, 0};
+
+    HAL_I2C_Mem_Read(&hi2c1, TSL2591X_ADDRESS + 1, command, I2C_MEMADD_SIZE_8BIT, buffer, 2, I2C_TIMEOUT);
+
+    return ((buffer[1] << 8) | (buffer[0] & 0xff));
+}
+
diff --git a/Core/External/Sensor/tsl2591x.h b/Core/External/Sensor/tsl2591x.h
new file mode 100644
index 0000000..df7f212
--- /dev/null
+++ b/Core/External/Sensor/tsl2591x.h
@@ -0,0 +1,245 @@
+#ifndef LIGHT_DETECTOR_SENSOR_H
+#define LIGHT_DETECTOR_SENSOR_H
+
+#include "i2c.h"
+#include <stdint.h>
+#include <stdio.h>
+
+#define TSL2591X_ADDRESS       (0x29<<1)
+
+#define WHO_AM_I (0x12)
+
+#define COMMAND_BIT           (0xA0)
+
+#define ENABLE_REGISTER       (0x00)
+#define ENABLE_POWERON        (0x01)
+#define ENABLE_POWEROFF       (0x00)
+#define ENABLE_AEN            (0x02)
+#define ENABLE_AIEN           (0x10)
+#define ENABLE_NPIEN          (0x80)
+
+#define CONTROL_REGISTER      (0x01)
+#define SRESET                (0x80)
+
+#define LOW_AGAIN             (0X00)
+#define MEDIUM_AGAIN          (0X10)
+#define HIGH_AGAIN            (0X20)
+#define MAX_AGAIN             (0x30)
+
+#define ATIME_100MS           (0x00)
+#define ATIME_200MS           (0x01)
+#define ATIME_300MS           (0x02)
+#define ATIME_400MS           (0x03)
+#define ATIME_500MS           (0x04)
+#define ATIME_600MS           (0x05)
+
+#define AILTL_REGISTER        (0x04)
+#define AILTH_REGISTER        (0x05)
+#define AIHTL_REGISTER        (0x06)
+#define AIHTH_REGISTER        (0x07)
+#define NPAILTL_REGISTER      (0x08)
+#define NPAILTH_REGISTER      (0x09)
+#define NPAIHTL_REGISTER      (0x0A)
+#define NPAIHTH_REGISTER      (0x0B)
+
+#define PERSIST_REGISTER      (0x0C)
+
+#define CHAN0_LOW             (0x14)
+#define CHAN0_HIGH            (0x15)
+#define CHAN1_LOW             (0x16)
+#define CHAN1_HIGH            (0x14)
+
+#define LUX_DF                (762.0)
+
+#define MAX_COUNT_100MS       (36863)
+#define MAX_COUNT             (65535)
+
+#define I2C_TIMEOUT (0x20)
+
+/**
+ * Represents driver implementation for "Waveshare" TSL2591X light sensor.
+ */
+class TSL2591X {
+public:
+    /**
+     * Initializes light sensor configuration.
+     */
+    static void init();
+
+    /**
+     * Checks if the device is available and thus can be configured.
+     *
+     * @return result of the check.
+     */
+    static bool is_available();
+
+    /**
+     * Checks if the device has already been configured.
+     *
+     * @return result of the check.
+     */
+    static bool is_configured();
+
+    /**
+     * Retrieves device id of the sensor.
+     *
+     * @return read device id.
+     */
+    static bool get_device_id();
+
+    /**
+     * Enables the sensor.
+     */
+    static void enable();
+
+    /**
+     * Disables the sensor.
+     */
+    static void disable();
+
+    /**
+     * Resets light sensor to the default state.
+     */
+    static void reset();
+
+    /**
+     * Reads raw data in LUX format.
+     *
+     * @return read raw data in LUX format.
+     */
+    static uint16_t read_lux();
+
+    /**
+     * Reads full data from the sensor.
+     *
+     * @return read full data.
+     */
+    static uint32_t read_full();
+
+    /**
+     * Reads infrared data from the sensor.
+     *
+     * @return read infrared data.
+     */
+    static uint16_t  read_infrared();
+
+    /**
+     * Reads visible data from the sensor.
+     *
+     * @return read visible data.
+     */
+    static uint32_t read_visible();
+
+    /**
+     * Sets raw interruption threshold.
+     *
+     * @param low - given low state.
+     * @param high - given high state.
+     */
+    static void set_raw_interrupt_threshold(uint16_t low, uint16_t high);
+
+    /**
+     * Sets LUX interruption configurations.
+     *
+     * @param low - given low state.
+     * @param high - given high state.
+     */
+    static void set_lux_interrupt(uint16_t low, uint16_t high);
+private:
+    /**
+     * Indicated that the device has already been initialized.
+     */
+    static bool initialized;
+
+    /**
+    * Reads value from the zero channel.
+    *
+    * @return read value.
+    */
+    static uint16_t read_channel0();
+
+    /**
+     * Reads value from the first channel.
+     *
+     * @return read value.
+     */
+    static uint16_t read_channel1();
+
+    /**
+     * Retrieves integral time option from the sensor.
+     *
+     * @return read value.
+     */
+    static uint8_t get_integral_time();
+
+    /**
+     * Sets integral time option to the sensor.
+     *
+     * @param src - given value to be set.
+     */
+    static void set_integral_time(uint8_t src);
+
+    /**
+     * Retrieves the value of gain option from the sensor.
+     *
+     * @return retrieved value.
+     */
+    static uint8_t get_gain();
+
+    /**
+     * Sets the value of gain option to the sensor.
+     *
+     * @param src - given value to be set.
+     */
+    static void set_gain(uint8_t src);
+
+    /**
+     * Reads combined command by bytes using I2C bone.
+     *
+     * @param src - given command to be read.
+     * @return read value.
+     */
+    static uint8_t read_byte(uint8_t src);
+
+    /**
+     * Reads combined command by word using I2C bone.
+     *
+     * @param src - given command to be read.
+     * @return read value.
+     */
+    static uint16_t read_word(uint8_t src);
+
+    /**
+     * Writes combined command by bytes via I2C bone.
+     *
+     * @param command - given command to be written.
+     * @param value - given value to be written to the given command.
+     */
+    static void write_byte(uint8_t src, uint8_t value);
+
+    /**
+     * Writes raw byte via I2C bone.
+     *
+     * @param command - given command to be written.
+     * @param value - given value to be written to the given command.
+     */
+    static void write_byte_i2c(uint8_t command, uint8_t value);
+
+    /**
+     * Reads raw byte via I2C bone.
+     *
+     * @param command - given command to be read.
+     * @return read byte.
+     */
+    static int read_byte_i2c(uint8_t command);
+
+    /**
+     * Reads raw word via I2C bone.
+     *
+     * @param command - given command to be read.
+     * @return read word.
+     */
+    static int read_word_i2c(uint8_t command);
+};
+
+#endif // LIGHT_DETECTOR_SENSOR_H
diff --git a/Core/External/State/state.cpp b/Core/External/State/state.cpp
new file mode 100644
index 0000000..5821ccb
--- /dev/null
+++ b/Core/External/State/state.cpp
@@ -0,0 +1,5 @@
+#include "state.h"
+
+void State::handle_check() {
+
+}
\ No newline at end of file
diff --git a/Core/External/State/state.h b/Core/External/State/state.h
new file mode 100644
index 0000000..5ff646e
--- /dev/null
+++ b/Core/External/State/state.h
@@ -0,0 +1,15 @@
+#ifndef LIGHT_DETECTOR_STATE_H
+#define LIGHT_DETECTOR_STATE_H
+
+/**
+ * Represents device state handler.
+ */
+class State {
+public:
+    /**
+    * Handles incoming action to
+    */
+    static void handle_check();
+};
+
+#endif //LIGHT_DETECTOR_STATE_H
diff --git a/Core/External/Timer/timer.cpp b/Core/External/Timer/timer.cpp
new file mode 100644
index 0000000..1c82583
--- /dev/null
+++ b/Core/External/Timer/timer.cpp
@@ -0,0 +1,12 @@
+#include "timer.h"
+
+void Timer::handle() {
+    TSL2591X::read_lux();
+
+//    	sprintf(buffer, "%d\r\n", TSL2591_ReadLux());
+//    	TSL2591X_SetLuxInterrupt(50,200);
+//    	printf("Infrared light: %d\r\n", TSL2591_ReadInfrared());
+//    	printf("Visible light: %d\r\n", TSL2591_ReadVisible());
+//    	printf("Full spectrum (IR + visible) light: %d\r\n\r\n", TSL2591X_ReadFull());
+
+}
\ No newline at end of file
diff --git a/Core/External/Timer/timer.h b/Core/External/Timer/timer.h
new file mode 100644
index 0000000..bbe7e76
--- /dev/null
+++ b/Core/External/Timer/timer.h
@@ -0,0 +1,18 @@
+#ifndef LIGHT_DETECTOR_TIMER_H
+#define LIGHT_DETECTOR_TIMER_H
+
+#include "tsl2591x.h"
+
+/**
+ * Represents timer handler implementation.
+ */
+class Timer {
+public:
+    /**
+     * Handles incoming timer tick action.
+     */
+    static void handle();
+private:
+};
+
+#endif //LIGHT_DETECTOR_TIMER_H
diff --git a/Core/External/Tools/Indicator/indicator.cpp b/Core/External/Tools/Indicator/indicator.cpp
new file mode 100644
index 0000000..73d52af
--- /dev/null
+++ b/Core/External/Tools/Indicator/indicator.cpp
@@ -0,0 +1,29 @@
+//
+// Created by Yaroslav Svitlytskyi on 18.03.2024.
+//
+
+#include "indicator.h"
+
+void Indicator::handle_check() {
+
+}
+
+/**
+     * Indicated initialization process success.
+     */
+static void toggle_initialization_success();
+
+/**
+ * Indicated initialization process failure.
+ */
+static void toggle_initialization_failure();
+
+/**
+ * Indicated operation action success.
+ */
+static void toggle_action_success();
+
+/**
+ * Indicated operation action failure.
+ */
+static void toggle_action_failure();
\ No newline at end of file
diff --git a/Core/External/Tools/Indicator/indicator.h b/Core/External/Tools/Indicator/indicator.h
new file mode 100644
index 0000000..0f7af29
--- /dev/null
+++ b/Core/External/Tools/Indicator/indicator.h
@@ -0,0 +1,32 @@
+#ifndef LIGHT_DETECTOR_INDICATOR_H
+#define LIGHT_DETECTOR_INDICATOR_H
+
+#include "gpio.h"
+
+/**
+ * Represents indicator state machine.
+ */
+class Indicator {
+public:
+    /**
+     * Indicated initialization process success.
+     */
+    static void toggle_initialization_success();
+
+    /**
+     * Indicated initialization process failure.
+     */
+    static void toggle_initialization_failure();
+
+    /**
+     * Indicated operation action success.
+     */
+    static void toggle_action_success();
+
+    /**
+     * Indicated operation action failure.
+     */
+    static void toggle_action_failure();
+};
+
+#endif //LIGHT_DETECTOR_INDICATOR_H
diff --git a/Core/Inc/main.h b/Core/Inc/main.h
index ea40398..ca29a2e 100644
--- a/Core/Inc/main.h
+++ b/Core/Inc/main.h
@@ -32,6 +32,9 @@ extern "C" {
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
 
+#include "timer.h"
+#include "state.h"
+#include "indicator.h"
 #include "tsl2591x.h"
 
 /* USER CODE END Includes */
diff --git a/Core/Src/main.cpp b/Core/Src/main.cpp
index 5e9b8be..a6a2841 100644
--- a/Core/Src/main.cpp
+++ b/Core/Src/main.cpp
@@ -44,17 +44,27 @@ void SystemClock_Config(void);
 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
 
-char buffer[50];
-
+/**
+ * Represents timer callback.
+ *
+ * @param htim - incoming timer tick data.
+ */
 void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
     if (htim == &htim16) {
-        HAL_UART_Transmit(&huart2, buffer, sizeof(buffer), 25);
+        Timer::handle();
+    } else {
+        __NOP();
     }
 }
 
+/**
+ * Represents button click callback.
+ *
+ * @param GPIO_Pin - incoming button click event data.
+ */
 void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
     if (GPIO_Pin == GPIO_PIN_13) {
-        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
+        State::handle_check();
     } else {
         __NOP();
     }
@@ -95,25 +105,26 @@ int main(void) {
     MX_TIM16_Init();
     /* USER CODE BEGIN 2 */
 
-//    HAL_TIM_Base_Start_IT(&htim16);
-
-    TSL2591X_Init();
+    HAL_TIM_Base_Start_IT(&htim16);
 
     /* USER CODE END 2 */
 
     /* Infinite loop */
     /* USER CODE BEGIN WHILE */
     while (1) {
+        if (!TSL2591X::is_configured()) {
+            if (TSL2591X::is_available()) {
+                TSL2591X::init();
+
+                Indicator::toggle_initialization_success();
+            } else {
+                Indicator::toggle_initialization_failure();
+            }
+        }
+
         /* USER CODE END WHILE */
 
         /* USER CODE BEGIN 3 */
-
-//    	sprintf(buffer, "%d\r\n", TSL2591_ReadLux());
-//    	TSL2591X_SetLuxInterrupt(50,200);
-//
-//    	printf("Infrared light: %d\r\n", TSL2591_ReadInfrared());
-//    	printf("Visible light: %d\r\n", TSL2591_ReadVisible());
-//    	printf("Full spectrum (IR + visible) light: %d\r\n\r\n", TSL2591X_ReadFull());
     }
     /* USER CODE END 3 */
 }
diff --git a/Core/Src/syscalls.cpp b/Core/Src/syscalls.cpp
deleted file mode 100644
index d190edf..0000000
--- a/Core/Src/syscalls.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-/**
- ******************************************************************************
- * @file      syscalls.c
- * @author    Auto-generated by STM32CubeIDE
- * @brief     STM32CubeIDE Minimal System calls file
- *
- *            For more information about which c-functions
- *            need which of these lowlevel functions
- *            please consult the Newlib libc-manual
- ******************************************************************************
- * @attention
- *
- * Copyright (c) 2020-2023 STMicroelectronics.
- * All rights reserved.
- *
- * This software is licensed under terms that can be found in the LICENSE file
- * in the root directory of this software component.
- * If no LICENSE file comes with this software, it is provided AS-IS.
- *
- ******************************************************************************
- */
-
-/* Includes */
-#include <sys/stat.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <stdio.h>
-#include <signal.h>
-#include <time.h>
-#include <sys/time.h>
-#include <sys/times.h>
-
-
-/* Variables */
-extern int __io_putchar(int ch) __attribute__((weak));
-extern int __io_getchar(void) __attribute__((weak));
-
-
-char *__env[1] = { 0 };
-char **environ = __env;
-
-
-/* Functions */
-void initialise_monitor_handles()
-{
-}
-
-int _getpid(void)
-{
-  return 1;
-}
-
-int _kill(int pid, int sig)
-{
-  (void)pid;
-  (void)sig;
-  errno = EINVAL;
-  return -1;
-}
-
-void _exit (int status)
-{
-  _kill(status, -1);
-  while (1) {}    /* Make sure we hang here */
-}
-
-__attribute__((weak)) int _read(int file, char *ptr, int len)
-{
-  (void)file;
-  int DataIdx;
-
-  for (DataIdx = 0; DataIdx < len; DataIdx++)
-  {
-    *ptr++ = __io_getchar();
-  }
-
-  return len;
-}
-
-__attribute__((weak)) int _write(int file, char *ptr, int len)
-{
-  (void)file;
-  int DataIdx;
-
-  for (DataIdx = 0; DataIdx < len; DataIdx++)
-  {
-    __io_putchar(*ptr++);
-  }
-  return len;
-}
-
-int _close(int file)
-{
-  (void)file;
-  return -1;
-}
-
-
-int _fstat(int file, struct stat *st)
-{
-  (void)file;
-  st->st_mode = S_IFCHR;
-  return 0;
-}
-
-int _isatty(int file)
-{
-  (void)file;
-  return 1;
-}
-
-int _lseek(int file, int ptr, int dir)
-{
-  (void)file;
-  (void)ptr;
-  (void)dir;
-  return 0;
-}
-
-int _open(char *path, int flags, ...)
-{
-  (void)path;
-  (void)flags;
-  /* Pretend like we always fail */
-  return -1;
-}
-
-int _wait(int *status)
-{
-  (void)status;
-  errno = ECHILD;
-  return -1;
-}
-
-int _unlink(char *name)
-{
-  (void)name;
-  errno = ENOENT;
-  return -1;
-}
-
-int _times(struct tms *buf)
-{
-  (void)buf;
-  return -1;
-}
-
-int _stat(char *file, struct stat *st)
-{
-  (void)file;
-  st->st_mode = S_IFCHR;
-  return 0;
-}
-
-int _link(char *old, char *new)
-{
-  (void)old;
-  (void)new;
-  errno = EMLINK;
-  return -1;
-}
-
-int _fork(void)
-{
-  errno = EAGAIN;
-  return -1;
-}
-
-int _execve(char *name, char **argv, char **env)
-{
-  (void)name;
-  (void)argv;
-  (void)env;
-  errno = ENOMEM;
-  return -1;
-}
diff --git a/Core/Src/sysmem.cpp b/Core/Src/sysmem.cpp
deleted file mode 100644
index 921ecef..0000000
--- a/Core/Src/sysmem.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/**
- ******************************************************************************
- * @file      sysmem.c
- * @author    Generated by STM32CubeIDE
- * @brief     STM32CubeIDE System Memory calls file
- *
- *            For more information about which C functions
- *            need which of these lowlevel functions
- *            please consult the newlib libc manual
- ******************************************************************************
- * @attention
- *
- * Copyright (c) 2023 STMicroelectronics.
- * All rights reserved.
- *
- * This software is licensed under terms that can be found in the LICENSE file
- * in the root directory of this software component.
- * If no LICENSE file comes with this software, it is provided AS-IS.
- *
- ******************************************************************************
- */
-
-/* Includes */
-#include <errno.h>
-#include <stdint.h>
-
-/**
- * Pointer to the current high watermark of the heap usage
- */
-static uint8_t *__sbrk_heap_end = NULL;
-
-/**
- * @brief _sbrk() allocates memory to the newlib heap and is used by malloc
- *        and others from the C library
- *
- * @verbatim
- * ############################################################################
- * #  .data  #  .bss  #       newlib heap       #          MSP stack          #
- * #         #        #                         # Reserved by _Min_Stack_Size #
- * ############################################################################
- * ^-- RAM start      ^-- _end                             _estack, RAM end --^
- * @endverbatim
- *
- * This implementation starts allocating at the '_end' linker symbol
- * The '_Min_Stack_Size' linker symbol reserves a memory for the MSP stack
- * The implementation considers '_estack' linker symbol to be RAM end
- * NOTE: If the MSP stack, at any point during execution, grows larger than the
- * reserved size, please increase the '_Min_Stack_Size'.
- *
- * @param incr Memory size
- * @return Pointer to allocated memory
- */
-void *_sbrk(ptrdiff_t incr)
-{
-  extern uint8_t _end; /* Symbol defined in the linker script */
-  extern uint8_t _estack; /* Symbol defined in the linker script */
-  extern uint32_t _Min_Stack_Size; /* Symbol defined in the linker script */
-  const uint32_t stack_limit = (uint32_t)&_estack - (uint32_t)&_Min_Stack_Size;
-  const uint8_t *max_heap = (uint8_t *)stack_limit;
-  uint8_t *prev_heap_end;
-
-  /* Initialize heap end at first call */
-  if (NULL == __sbrk_heap_end)
-  {
-    __sbrk_heap_end = &_end;
-  }
-
-  /* Protect heap from growing into the reserved MSP stack */
-  if (__sbrk_heap_end + incr > max_heap)
-  {
-    errno = ENOMEM;
-    return (void *)-1;
-  }
-
-  prev_heap_end = __sbrk_heap_end;
-  __sbrk_heap_end += incr;
-
-  return (void *)prev_heap_end;
-}
diff --git a/Makefile b/Makefile
index 11246aa..caaf0fb 100644
--- a/Makefile
+++ b/Makefile
@@ -25,8 +25,8 @@ endif
 
 .PHONY: generate
 generate: ## Generate prerequisites
-	@protoc --plugin=/Volumes/Files/embedded/university/techno/project/deps/EmbeddedProto -I./Resources/Proto --eams_out=./Core/External/Proto/Generated test.proto
-	@protoc -I./Resources/Proto --python_out=./Scripts/graph/proto test.proto
+	@protoc -I./Resources/Proto --python_out=./Scripts/graph/proto data.proto info.proto settings.proto
+	@protoc --plugin=/Volumes/Files/embedded/university/techno/project/deps/EmbeddedProto -I./Resources/Proto --eams_out=./Core/External/Proto/Generated data.proto info.proto settings.proto
 
 .PHONY: build
 build: ## Build the IOC project
diff --git a/Resources/Proto/data.proto b/Resources/Proto/data.proto
new file mode 100644
index 0000000..f63e8e8
--- /dev/null
+++ b/Resources/Proto/data.proto
@@ -0,0 +1,26 @@
+// Contains API declaration for board data bus.
+
+syntax = "proto3";
+
+package light_detector;
+
+// Represents all the available data types, which can be transferred via data bus.
+enum DataType {
+    Raw = 0;
+    Full = 1;
+    Infrared = 2;
+    Visible = 3;
+}
+
+// Represents data bus request send from the client to the board.
+message DataBusRequest {
+    DataType dataType = 1;
+}
+
+// Represents data bus response send to the client from the board.
+message DataBusResponse {
+    uint32 deviceId = 1;
+    DataType dataType = 2;
+    uint32 value = 3;
+    uint32 nonce = 4;
+}
\ No newline at end of file
diff --git a/Resources/Proto/info.proto b/Resources/Proto/info.proto
new file mode 100644
index 0000000..4249315
--- /dev/null
+++ b/Resources/Proto/info.proto
@@ -0,0 +1,24 @@
+// Contains API declaration for board information bus.
+
+syntax = "proto3";
+
+package light_detector;
+
+// Represents all the available info retrieval options, which can be modified via info bus.
+enum InfoType {
+    GetGain = 0;
+    GetIntegralTime = 1;
+}
+
+// Represents info bus request send from the client to the board.
+message InfoBusRequest {
+    InfoType infoType = 1;
+}
+
+// Represents info bus response send to the client from the board.
+message InfoBusResponse {
+    uint32 deviceId = 1;
+    InfoType infoType = 2;
+    uint32 value = 3;
+    uint32 nonce = 4;
+}
\ No newline at end of file
diff --git a/Resources/Proto/settings.proto b/Resources/Proto/settings.proto
index 6fb2575..70267d2 100644
--- a/Resources/Proto/settings.proto
+++ b/Resources/Proto/settings.proto
@@ -1,27 +1,27 @@
+// Contains API declaration for board settings bus.
+
 syntax = "proto3";
 
 package light_detector;
 
-message
-{
-  uint32 x = 1;
-  uint32 y = 2;
-  uint32 z = 3;
+// Represents all the available settings options, which can be modified via settings bus.
+enum SettingsType {
+    Enable = 0;
+    Disable = 1;
+    Reset = 2;
+    SetGain = 3;
+    SetIntegralTime = 4;
 }
 
-message B
-{
-  double u = 1;
-  double v = 2;
-  double w = 3;
+// Represents settings bus request send from the client to the board.
+message SettingsBusRequest {
+    SettingsType settingsType = 1;
 }
 
-message reply
-{
-  uint32 msgId = 1;
-  oneof type
-  {
-    A a = 2;
-    B b = 3;
-  }
+// Represents settings bus response send to the client from the board.
+message SettingsBusResponse {
+    uint32 deviceId = 1;
+    SettingsType settingsType = 2;
+    bool result = 3;
+    uint32 nonce = 4;
 }
\ No newline at end of file
diff --git a/Resources/Proto/test.proto b/Resources/Proto/test.proto
deleted file mode 100644
index 6fb2575..0000000
--- a/Resources/Proto/test.proto
+++ /dev/null
@@ -1,27 +0,0 @@
-syntax = "proto3";
-
-package light_detector;
-
-message
-{
-  uint32 x = 1;
-  uint32 y = 2;
-  uint32 z = 3;
-}
-
-message B
-{
-  double u = 1;
-  double v = 2;
-  double w = 3;
-}
-
-message reply
-{
-  uint32 msgId = 1;
-  oneof type
-  {
-    A a = 2;
-    B b = 3;
-  }
-}
\ No newline at end of file
diff --git a/Scripts/graph/proto/data_pb2.py b/Scripts/graph/proto/data_pb2.py
new file mode 100644
index 0000000..197a7d1
--- /dev/null
+++ b/Scripts/graph/proto/data_pb2.py
@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: data.proto
+# Protobuf Python Version: 4.25.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ndata.proto\x12\x0elight_detector\"<\n\x0e\x44\x61taBusRequest\x12*\n\x08\x64\x61taType\x18\x01 \x01(\x0e\x32\x18.light_detector.DataType\"m\n\x0f\x44\x61taBusResponse\x12\x10\n\x08\x64\x65viceId\x18\x01 \x01(\r\x12*\n\x08\x64\x61taType\x18\x02 \x01(\x0e\x32\x18.light_detector.DataType\x12\r\n\x05value\x18\x03 \x01(\r\x12\r\n\x05nonce\x18\x04 \x01(\r*8\n\x08\x44\x61taType\x12\x07\n\x03Raw\x10\x00\x12\x08\n\x04\x46ull\x10\x01\x12\x0c\n\x08Infrared\x10\x02\x12\x0b\n\x07Visible\x10\x03\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'data_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_DATATYPE']._serialized_start=203
+  _globals['_DATATYPE']._serialized_end=259
+  _globals['_DATABUSREQUEST']._serialized_start=30
+  _globals['_DATABUSREQUEST']._serialized_end=90
+  _globals['_DATABUSRESPONSE']._serialized_start=92
+  _globals['_DATABUSRESPONSE']._serialized_end=201
+# @@protoc_insertion_point(module_scope)
diff --git a/Scripts/graph/proto/info_pb2.py b/Scripts/graph/proto/info_pb2.py
new file mode 100644
index 0000000..f0de34f
--- /dev/null
+++ b/Scripts/graph/proto/info_pb2.py
@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: info.proto
+# Protobuf Python Version: 4.25.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ninfo.proto\x12\x0elight_detector\"<\n\x0eInfoBusRequest\x12*\n\x08infoType\x18\x01 \x01(\x0e\x32\x18.light_detector.InfoType\"m\n\x0fInfoBusResponse\x12\x10\n\x08\x64\x65viceId\x18\x01 \x01(\r\x12*\n\x08infoType\x18\x02 \x01(\x0e\x32\x18.light_detector.InfoType\x12\r\n\x05value\x18\x03 \x01(\r\x12\r\n\x05nonce\x18\x04 \x01(\r*,\n\x08InfoType\x12\x0b\n\x07GetGain\x10\x00\x12\x13\n\x0fGetIntegralTime\x10\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'info_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_INFOTYPE']._serialized_start=203
+  _globals['_INFOTYPE']._serialized_end=247
+  _globals['_INFOBUSREQUEST']._serialized_start=30
+  _globals['_INFOBUSREQUEST']._serialized_end=90
+  _globals['_INFOBUSRESPONSE']._serialized_start=92
+  _globals['_INFOBUSRESPONSE']._serialized_end=201
+# @@protoc_insertion_point(module_scope)
diff --git a/Scripts/graph/proto/settings_pb2.py b/Scripts/graph/proto/settings_pb2.py
new file mode 100644
index 0000000..4d78c3a
--- /dev/null
+++ b/Scripts/graph/proto/settings_pb2.py
@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: settings.proto
+# Protobuf Python Version: 4.25.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0esettings.proto\x12\x0elight_detector\"H\n\x12SettingsBusRequest\x12\x32\n\x0csettingsType\x18\x01 \x01(\x0e\x32\x1c.light_detector.SettingsType\"z\n\x13SettingsBusResponse\x12\x10\n\x08\x64\x65viceId\x18\x01 \x01(\r\x12\x32\n\x0csettingsType\x18\x02 \x01(\x0e\x32\x1c.light_detector.SettingsType\x12\x0e\n\x06result\x18\x03 \x01(\x08\x12\r\n\x05nonce\x18\x04 \x01(\r*T\n\x0cSettingsType\x12\n\n\x06\x45nable\x10\x00\x12\x0b\n\x07\x44isable\x10\x01\x12\t\n\x05Reset\x10\x02\x12\x0b\n\x07SetGain\x10\x03\x12\x13\n\x0fSetIntegralTime\x10\x04\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'settings_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_SETTINGSTYPE']._serialized_start=232
+  _globals['_SETTINGSTYPE']._serialized_end=316
+  _globals['_SETTINGSBUSREQUEST']._serialized_start=34
+  _globals['_SETTINGSBUSREQUEST']._serialized_end=106
+  _globals['_SETTINGSBUSRESPONSE']._serialized_start=108
+  _globals['_SETTINGSBUSRESPONSE']._serialized_end=230
+# @@protoc_insertion_point(module_scope)
diff --git a/Scripts/graph/proto/test_pb2.py b/Scripts/graph/proto/test_pb2.py
deleted file mode 100644
index 0faa2fa..0000000
--- a/Scripts/graph/proto/test_pb2.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: test.proto
-# Protobuf Python Version: 4.25.3
-"""Generated protocol buffer code."""
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import descriptor_pool as _descriptor_pool
-from google.protobuf import symbol_database as _symbol_database
-from google.protobuf.internal import builder as _builder
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-
-
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ntest.proto\x12\x04\x64\x65mo\"$\n\x01\x41\x12\t\n\x01x\x18\x01 \x01(\r\x12\t\n\x01y\x18\x02 \x01(\r\x12\t\n\x01z\x18\x03 \x01(\r\"$\n\x01\x42\x12\t\n\x01u\x18\x01 \x01(\x01\x12\t\n\x01v\x18\x02 \x01(\x01\x12\t\n\x01w\x18\x03 \x01(\x01\"J\n\x05reply\x12\r\n\x05msgId\x18\x01 \x01(\r\x12\x14\n\x01\x61\x18\x02 \x01(\x0b\x32\x07.demo.AH\x00\x12\x14\n\x01\x62\x18\x03 \x01(\x0b\x32\x07.demo.BH\x00\x42\x06\n\x04typeb\x06proto3')
-
-_globals = globals()
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'test_pb2', _globals)
-if _descriptor._USE_C_DESCRIPTORS == False:
-  DESCRIPTOR._options = None
-  _globals['_A']._serialized_start=20
-  _globals['_A']._serialized_end=56
-  _globals['_B']._serialized_start=58
-  _globals['_B']._serialized_end=94
-  _globals['_REPLY']._serialized_start=96
-  _globals['_REPLY']._serialized_end=170
-# @@protoc_insertion_point(module_scope)