diff --git a/goTool/main.go b/goTool/main.go
index c34c6fc..82958c1 100644
--- a/goTool/main.go
+++ b/goTool/main.go
@@ -3,8 +3,11 @@ package main
 import (
 	"context"
 	"encoding/binary"
+	"flag"
 	"fmt"
 	"log"
+	"os"
+	"time"
 
 	"github.com/pterm/pterm"
 	"go.bug.st/serial"
@@ -12,6 +15,19 @@ import (
 
 type ParserState int
 
+const (
+	// MISC
+	UART_ECHO        = 0x01
+	UART_VERSION     = 0x02
+	UART_CLIENT_INFO = 0x03
+
+	// OTA
+	UART_OTA_START   = 0x10
+	UART_OTA_PAYLOAD = 0x11
+	UART_OTA_END     = 0x12
+	UART_OTA_STATUS  = 0x13
+)
+
 const (
 	WAITING_FOR_START_BYTE ParserState = iota
 	ESCAPED_MESSAGE_ID
@@ -43,6 +59,23 @@ type MessageReceive struct {
 	raw_write_index int
 }
 
+type OTASyncManager struct {
+	OTA_MessageCounter         int
+	OTA_PayloadMessageSequence int
+	NewOTAMessage              chan MessageReceive
+	TimeoutMessage             time.Duration
+}
+
+func (ot *OTASyncManager) WaitForNextMessageTimeout() (*MessageReceive, error) {
+	select {
+	case msg := <-ot.NewOTAMessage:
+		log.Printf("OTASyncManager MessageReceive %v", msg)
+		return &msg, nil
+	case <-time.After(ot.TimeoutMessage):
+		return nil, fmt.Errorf("Message Timeout")
+	}
+}
+
 func initMessageReceive(mr *MessageReceive) {
 	mr.raw_message = make([]byte, 1024*4)
 	mr.parsed_message = make([]byte, 1024*4)
@@ -63,7 +96,17 @@ func addByteToParsedBuffer(mr *MessageReceive, pbyte byte) {
 	mr.checksum ^= pbyte
 }
 
-func parse_03_payload(payloadBuffer []byte, payload_len int) {
+func parse_uart_ota_payload_payload(payloadBuffer []byte, payload_len int) {
+	fmt.Printf("RAW BUFFER: % 02X", payloadBuffer[:payload_len])
+	if payload_len != 4 {
+		fmt.Printf("Payload should be 4 is %v", payload_len)
+		return
+	}
+
+	fmt.Printf("Sequence %v, WriteIndex %v", binary.LittleEndian.Uint16(payloadBuffer[0:1]), binary.LittleEndian.Uint16(payloadBuffer[2:3]))
+}
+
+func parse_uart_client_info_payload(payloadBuffer []byte, payload_len int) {
 
 	type payload_data struct {
 		ClientID           uint8
@@ -135,12 +178,25 @@ func parse_03_payload(payloadBuffer []byte, payload_len int) {
 func message_receive_callback(mr MessageReceive) {
 	log.Printf("Message Received: % 02X\n", mr.raw_message[:mr.raw_write_index])
 	switch mr.parsed_message[0] {
-	case 0x01:
+	case byte(UART_ECHO):
 		break
-	case 0x02:
+	case UART_VERSION:
 		break
-	case 0x03:
-		parse_03_payload(mr.parsed_message, mr.write_index)
+	case UART_CLIENT_INFO:
+		parse_uart_client_info_payload(mr.parsed_message, mr.write_index)
+		break
+	case UART_OTA_START:
+		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
+	case UART_OTA_PAYLOAD:
+		parse_uart_ota_payload_payload(mr.parsed_message, mr.write_index)
+		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
+	case UART_OTA_END:
+		OTA_UpdateHandler.NewOTAMessage <- mr
+		break
+	case UART_OTA_STATUS:
+		OTA_UpdateHandler.NewOTAMessage <- mr
 		break
 	}
 }
@@ -150,6 +206,7 @@ func message_receive_failed_callback(mr MessageReceive) {
 }
 
 func parseByte(mr *MessageReceive, pbyte byte) {
+	fmt.Printf("Parsing %v", pbyte)
 	addByteToRawBuffer(mr, pbyte)
 	switch mr.state {
 	case WAITING_FOR_START_BYTE:
@@ -179,18 +236,18 @@ func parseByte(mr *MessageReceive, pbyte byte) {
 		}
 		if pbyte == START_BYTE {
 			mr.error = UNEXPECETD_BYTE
-			message_receive_failed_callback(*mr)
+			go message_receive_failed_callback(*mr)
 			initMessageReceive(mr)
 			return
 		}
 		if pbyte == END_BYTE {
 			if mr.checksum != 0 { // checksum wrong
 				mr.error = WRONG_CHECKSUM
-				message_receive_failed_callback(*mr)
+				go message_receive_failed_callback(*mr)
 				initMessageReceive(mr)
 				return
 			}
-			message_receive_callback(*mr)
+			go message_receive_callback(*mr)
 			initMessageReceive(mr)
 			break
 		}
@@ -240,7 +297,22 @@ func sendMessage(port serial.Port, sendBuffer []byte) {
 	fmt.Printf("Send Message % 02X\n", sendBuffer[:n])
 }
 
+var (
+	updatePath        string
+	OTA_UpdateHandler OTASyncManager
+)
+
 func main() {
+	flag.StringVar(&updatePath, "update", "", "Path to Updatefile")
+	flag.Parse()
+
+	OTA_UpdateHandler = OTASyncManager{
+		OTA_MessageCounter:         0,
+		OTA_PayloadMessageSequence: 0,
+		NewOTAMessage:              make(chan MessageReceive),
+		TimeoutMessage:             time.Millisecond * 1000,
+	}
+
 	mode := &serial.Mode{
 		BaudRate: 115200,
 	}
@@ -279,6 +351,47 @@ func main() {
 		}
 	}()
 
+	if updatePath != "" {
+		// start update
+		update, err := os.ReadFile(updatePath)
+		if err != nil {
+			log.Printf("Could not read Update file %v", err)
+			return
+		}
+		log.Printf("Update Buffer read, update size %v", len(update))
+		log.Printf("Gonna break it down in 200 Bytes packages will send %v packages", len(update)/200)
+
+		// start
+		payload_buffer := make([]byte, 1024)
+		send_buffer := make([]byte, 1024)
+		payload_buffer[0] = UART_OTA_START
+		n := buildMessage(payload_buffer, 1, send_buffer)
+		sendMessage(port, send_buffer[:n])
+		_, err = OTA_UpdateHandler.WaitForNextMessageTimeout()
+		if err != nil {
+			log.Printf("Error Message not acked %v", err)
+		} else {
+			log.Printf("Message Waiting hat funktionioert")
+		}
+
+		// write update parts
+
+		// end
+		payload_buffer = make([]byte, 1024)
+		send_buffer = make([]byte, 1024)
+		payload_buffer[0] = UART_OTA_END
+		n = buildMessage(payload_buffer, 1, send_buffer)
+		sendMessage(port, send_buffer[:n])
+
+		_, err = OTA_UpdateHandler.WaitForNextMessageTimeout()
+		if err != nil {
+			log.Printf("Error Message not acked %v", err)
+		} else {
+			log.Printf("Message Waiting hat funktionioert")
+		}
+		return
+	}
+
 	for {
 		var input string
 		_, err := fmt.Scanln(&input)
@@ -293,24 +406,42 @@ func main() {
 		case "1":
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = 0x01
+			payload_buffer[0] = UART_ECHO
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
 			break
 		case "2":
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = 0x02
+			payload_buffer[0] = UART_VERSION
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
 			break
 		case "3":
 			payload_buffer := make([]byte, 1024)
 			send_buffer := make([]byte, 1024)
-			payload_buffer[0] = 0x03
+			payload_buffer[0] = UART_CLIENT_INFO
 			n := buildMessage(payload_buffer, 1, send_buffer)
 			sendMessage(port, send_buffer[:n])
 			break
+		case "4": // start update
+			payload_buffer := make([]byte, 1024)
+			send_buffer := make([]byte, 1024)
+			payload_buffer[0] = UART_OTA_START
+			n := buildMessage(payload_buffer, 1, send_buffer)
+			sendMessage(port, send_buffer[:n])
+			break
+		case "5": // send payload
+			payload_buffer := make([]byte, 1024)
+			send_buffer := make([]byte, 1024)
+			payload_buffer[0] = UART_OTA_PAYLOAD
+			for i := range 200 {
+				payload_buffer[i+1] = byte(i)
+			}
+			n := buildMessage(payload_buffer, 201, send_buffer)
+			sendMessage(port, send_buffer[:n])
+			break
+		case "6": // end update
 		default:
 			fmt.Printf("Not a valid input")
 		}