diff --git a/scripts/can_errgo/README.md b/scripts/can_errgo/README.md
new file mode 100644
index 000000000..8373077bd
--- /dev/null
+++ b/scripts/can_errgo/README.md
@@ -0,0 +1,55 @@
+# CAN Error TUI
+
+This is a Tangible User Interface program designed to track CAN Errors including their count, recency, description, and name.
+
+Users can:
+
+- Acknowledge the error (Hide and resets the error until it is sent again)
+- Ignore the error (Hides, resets, and stops reading all future occurrences of the error)
+- View ignored errors and choose to unignore those errors
+
+## Setup
+
+Install required dependencies:
+
+```bash
+sudo apt-get update
+sudo apt-get upgrade
+sudo apt install net-tools iproute2 can-utils linux-modules-extra-$(uname  -r)
+```
+
+Kill all existing instances of ip-links:
+
+```bash
+ip link show
+sudo ip link delete <ip-link>
+```
+
+Setup the can network:
+
+```bash
+./setup_vcan.sh <CAN_PORT>
+```
+
+## Usage
+
+Start the CLI viewer for single use:
+
+```bash
+go run error_tui.go -i <CAN_PORT> -w <WARN_TIMER>
+```
+
+OR
+
+Build the go file:
+
+```bash
+go build -o <BUILD_NAME>
+./<BUILD_NAME> -i <CAN_PORT> -w <WARN_TIMER>
+```
+
+You can now run:
+
+```bash
+cansend <CAN_PORT> <MSG>
+```
diff --git a/scripts/can_errgo/components/table.go b/scripts/can_errgo/components/table.go
new file mode 100644
index 000000000..ef5defb34
--- /dev/null
+++ b/scripts/can_errgo/components/table.go
@@ -0,0 +1,488 @@
+package components
+
+// Modified from "github.com/charmbracelet/bubbles/table"
+// Repurposed for use in CAN error handling application
+
+import (
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/mattn/go-runewidth"
+)
+
+// MetaRow is the implementation of a Error Row with its corresponding error index within the 64-bit CAN frame
+type MetaRow struct{
+	Row Row
+	Index int
+}
+
+// Model defines a state for the table widget.
+type Model struct {
+	KeyMap KeyMap
+	Help   help.Model
+
+	cols   []Column
+	metaRows []MetaRow
+	cursor int
+	focus  bool
+	styles Styles
+	ShowCursor bool
+
+
+	viewport viewport.Model
+	start    int
+	end      int
+}
+
+// Row represents one line in the table.
+type Row []string
+
+// Column defines the table structure.
+type Column struct {
+	Title string
+	Width int
+}
+
+// KeyMap defines keybindings. It satisfies to the help.KeyMap interface, which
+// is used to render the help menu.
+type KeyMap struct {
+	LineUp       key.Binding
+	LineDown     key.Binding
+	PageUp       key.Binding
+	PageDown     key.Binding
+	HalfPageUp   key.Binding
+	HalfPageDown key.Binding
+	GotoTop      key.Binding
+	GotoBottom   key.Binding
+}
+
+// ShortHelp implements the KeyMap interface.
+func (km KeyMap) ShortHelp() []key.Binding {
+	return []key.Binding{km.LineUp, km.LineDown}
+}
+
+// FullHelp implements the KeyMap interface.
+func (km KeyMap) FullHelp() [][]key.Binding {
+	return [][]key.Binding{
+		{km.LineUp, km.LineDown, km.GotoTop, km.GotoBottom},
+		{km.PageUp, km.PageDown, km.HalfPageUp, km.HalfPageDown},
+	}
+}
+
+// DefaultKeyMap returns a default set of keybindings.
+func DefaultKeyMap() KeyMap {
+	const spacebar = " "
+	return KeyMap{
+		LineUp: key.NewBinding(
+			key.WithKeys("up", "k"),
+			key.WithHelp("↑/k", "up"),
+		),
+		LineDown: key.NewBinding(
+			key.WithKeys("down", "j"),
+			key.WithHelp("↓/j", "down"),
+		),
+		PageUp: key.NewBinding(
+			key.WithKeys("b", "pgup"),
+			key.WithHelp("b/pgup", "page up"),
+		),
+		PageDown: key.NewBinding(
+			key.WithKeys("f", "pgdown", spacebar),
+			key.WithHelp("f/pgdn", "page down"),
+		),
+		HalfPageUp: key.NewBinding(
+			key.WithKeys("u", "ctrl+u"),
+			key.WithHelp("u", "½ page up"),
+		),
+		HalfPageDown: key.NewBinding(
+			key.WithKeys("d", "ctrl+d"),
+			key.WithHelp("d", "½ page down"),
+		),
+		GotoTop: key.NewBinding(
+			key.WithKeys("home", "g"),
+			key.WithHelp("g/home", "go to start"),
+		),
+		GotoBottom: key.NewBinding(
+			key.WithKeys("end", "G"),
+			key.WithHelp("G/end", "go to end"),
+		),
+	}
+}
+
+// Styles contains style definitions for this list component. By default, these
+// values are generated by DefaultStyles.
+type Styles struct {
+	Header   lipgloss.Style
+	Cell     lipgloss.Style
+	Selected lipgloss.Style
+}
+
+// DefaultStyles returns a set of default style definitions for this table.
+func DefaultStyles() Styles {
+	return Styles{
+		Selected: lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("212")),
+		Header:   lipgloss.NewStyle().Bold(true).Padding(0, 1),
+		Cell:     lipgloss.NewStyle().Padding(0, 1),
+	}
+}
+
+// SetStyles sets the table styles.
+func (m *Model) SetStyles(s Styles) {
+	m.styles = s
+	m.UpdateViewport()
+}
+
+// Option is used to set options in New. For example:
+//
+//	table := New(WithColumns([]Column{{Title: "ID", Width: 10}}))
+type Option func(*Model)
+
+// New creates a new model for the table widget.
+func New(opts ...Option) Model {
+	m := Model{
+		cursor:   0,
+		viewport: viewport.New(0, 20),
+		ShowCursor: true,
+
+		KeyMap: DefaultKeyMap(),
+		Help:   help.New(),
+		styles: DefaultStyles(),
+	}
+
+	for _, opt := range opts {
+		opt(&m)
+	}
+
+	m.UpdateViewport()
+
+	return m
+}
+
+// WithColumns sets the table columns (headers).
+func WithColumns(cols []Column) Option {
+	return func(m *Model) {
+		m.cols = cols
+	}
+}
+
+//WithRows sets the table rows (data).
+func WithRows(rows []MetaRow) Option {
+	return func(m *Model) {
+		m.metaRows = rows
+	}
+}
+
+// WithHeight sets the height of the table.
+func WithHeight(h int) Option {
+	return func(m *Model) {
+		m.viewport.Height = h - lipgloss.Height(m.headersView())
+	}
+}
+
+// WithWidth sets the width of the table.
+func WithWidth(w int) Option {
+	return func(m *Model) {
+		m.viewport.Width = w
+	}
+}
+
+// WithFocused sets the focus state of the table.
+func WithFocused(f bool) Option {
+	return func(m *Model) {
+		m.focus = f
+	}
+}
+
+// WithStyles sets the table styles.
+func WithStyles(s Styles) Option {
+	return func(m *Model) {
+		m.styles = s
+	}
+}
+
+// WithKeyMap sets the key map.
+func WithKeyMap(km KeyMap) Option {
+	return func(m *Model) {
+		m.KeyMap = km
+	}
+}
+
+// Update is the Bubble Tea update loop.
+func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
+	if !m.focus {
+		return m, nil
+	}
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch {
+		case key.Matches(msg, m.KeyMap.LineUp):
+			m.MoveUp(1)
+		case key.Matches(msg, m.KeyMap.LineDown):
+			m.MoveDown(1)
+		case key.Matches(msg, m.KeyMap.PageUp):
+			m.MoveUp(m.viewport.Height)
+		case key.Matches(msg, m.KeyMap.PageDown):
+			m.MoveDown(m.viewport.Height)
+		case key.Matches(msg, m.KeyMap.HalfPageUp):
+			m.MoveUp(m.viewport.Height / 2)
+		case key.Matches(msg, m.KeyMap.HalfPageDown):
+			m.MoveDown(m.viewport.Height / 2)
+		case key.Matches(msg, m.KeyMap.LineDown):
+			m.MoveDown(1)
+		case key.Matches(msg, m.KeyMap.GotoTop):
+			m.GotoTop()
+		case key.Matches(msg, m.KeyMap.GotoBottom):
+			m.GotoBottom()
+		}
+	}
+
+	return m, nil
+}
+
+// Focused returns the focus state of the table.
+func (m Model) Focused() bool {
+	return m.focus
+}
+
+// Focus focuses the table, allowing the user to move around the rows and
+// interact.
+func (m *Model) Focus() {
+	m.focus = true
+	m.UpdateViewport()
+}
+
+// Blur blurs the table, preventing selection or movement.
+func (m *Model) Blur() {
+	m.focus = false
+	m.UpdateViewport()
+}
+
+// View renders the component.
+func (m Model) View() string {
+	return m.headersView() + "\n" + m.viewport.View()
+}
+
+// HelpView is a helper method for rendering the help menu from the keymap.
+// Note that this view is not rendered by default and you must call it
+// manually in your application, where applicable.
+func (m Model) HelpView() string {
+	return m.Help.View(m.KeyMap)
+}
+
+// UpdateViewport updates the list content based on the previously defined
+// columns and rows.
+func (m *Model) UpdateViewport() {
+	renderedRows := make([]string, 0, len(m.metaRows))
+
+	// Render only rows from: m.cursor-m.viewport.Height to: m.cursor+m.viewport.Height
+	// Constant runtime, independent of number of rows in a table.
+	// Limits the number of renderedRows to a maximum of 2*m.viewport.Height
+	if m.cursor >= 0 {
+		m.start = clamp(m.cursor-m.viewport.Height, 0, m.cursor)
+	} else {
+		m.start = 0
+	}
+	m.end = clamp(m.cursor+m.viewport.Height, m.cursor, len(m.metaRows))
+	for i := m.start; i < m.end; i++ {
+		renderedRows = append(renderedRows, m.renderRow(i))
+	}
+
+	m.viewport.SetContent(
+		lipgloss.JoinVertical(lipgloss.Left, renderedRows...),
+	)
+}
+
+// SelectedRow returns the selected row.
+// You can cast it to your own implementation.
+func (m Model) SelectedRow() Row {
+	if m.cursor < 0 || m.cursor >= len(m.metaRows) {
+		return nil
+	}
+
+	return m.metaRows[m.cursor].Row
+}
+
+// SelectedIndex returns the Error Index of the selected row.
+func (m Model) SelectedIndex() int {
+	if m.cursor < 0 || m.cursor >= len(m.metaRows) {
+		return -1
+	}
+	return m.metaRows[m.cursor].Index
+}
+
+// Rows returns the current metaRows.
+func (m Model) Rows() []MetaRow {
+	return m.metaRows
+}
+
+// Columns returns the current columns.
+func (m Model) Columns() []Column {
+	return m.cols
+}
+
+// SetRows sets a new metaRows state.
+func (m *Model) SetRows(r []MetaRow) {
+	m.metaRows = r
+	m.UpdateViewport()
+}
+
+// SetColumns sets a new columns state.
+func (m *Model) SetColumns(c []Column) {
+	m.cols = c
+	m.UpdateViewport()
+}
+
+// SetWidth sets the width of the viewport of the table.
+func (m *Model) SetWidth(w int) {
+	m.viewport.Width = w
+	m.UpdateViewport()
+}
+
+// SetHeight sets the height of the viewport of the table.
+func (m *Model) SetHeight(h int) {
+	m.viewport.Height = h - lipgloss.Height(m.headersView())
+	m.UpdateViewport()
+}
+
+// Height returns the viewport height of the table.
+func (m Model) Height() int {
+	return m.viewport.Height
+}
+
+// Width returns the viewport width of the table.
+func (m Model) Width() int {
+	return m.viewport.Width
+}
+
+// Cursor returns the index of the selected row.
+func (m Model) Cursor() int {
+	return m.cursor
+}
+
+// ForceCursor forces the cursor to a specific row, regardless if the row is out of bounds.
+func (m *Model) ForceCursor(n int) {
+    // Clamp the cursor position within bounds
+    m.cursor = clamp(n, 0, len(m.metaRows)-1)
+    m.UpdateViewport()
+}
+
+// SetCursor sets the cursor position in the table.
+func (m *Model) SetCursor(n int) {
+	m.cursor = clamp(n, 0, len(m.metaRows)-1)
+	m.UpdateViewport()
+}
+// SetCursor sets the cursor position in the table.
+func (m *Model) SetCursorAndViewport(n int) {
+	m.cursor = clamp(n, 0, len(m.metaRows)-1)
+
+	switch {
+	case m.start == 0:
+		m.viewport.SetYOffset(clamp(m.viewport.YOffset, 0, m.cursor))
+	case m.end == len(m.metaRows) && m.cursor > m.viewport.Height:
+		m.viewport.SetYOffset(clamp(m.viewport.YOffset-n, 1, m.viewport.Height))
+	}
+
+	m.UpdateViewport()
+}
+
+func (m *Model) SetShowCursor(show bool) {
+	m.ShowCursor = show
+	m.UpdateViewport()
+}
+
+// MoveUp moves the selection up by any number of metaRows.
+// It can not go above the first row.
+func (m *Model) MoveUp(n int) {
+	m.cursor = clamp(m.cursor-n, 0, len(m.metaRows)-1)
+	switch {
+	case m.start == 0:
+		m.viewport.SetYOffset(clamp(m.viewport.YOffset, 0, m.cursor))
+	case m.start < m.viewport.Height:
+		m.viewport.YOffset = (clamp(clamp(m.viewport.YOffset+n, 0, m.cursor), 0, m.viewport.Height))
+	case m.viewport.YOffset >= 1:
+		m.viewport.YOffset = clamp(m.viewport.YOffset+n, 1, m.viewport.Height)
+	}
+	m.UpdateViewport()
+}
+
+// MoveDown moves the selection down by any number of metaRows.
+// It can not go below the last row.
+func (m *Model) MoveDown(n int) {
+	m.cursor = clamp(m.cursor+n, 0, len(m.metaRows)-1)
+	m.UpdateViewport()
+
+	switch {
+	case m.end == len(m.metaRows) && m.viewport.YOffset > 0:
+		m.viewport.SetYOffset(clamp(m.viewport.YOffset-n, 1, m.viewport.Height))
+	case m.cursor > (m.end-m.start)/2 && m.viewport.YOffset > 0:
+		m.viewport.SetYOffset(clamp(m.viewport.YOffset-n, 1, m.cursor))
+	case m.viewport.YOffset > 1:
+	case m.cursor > m.viewport.YOffset+m.viewport.Height-1:
+		m.viewport.SetYOffset(clamp(m.viewport.YOffset+1, 0, 1))
+	}
+}
+
+// GotoTop moves the selection to the first row.
+func (m *Model) GotoTop() {
+	m.MoveUp(m.cursor)
+}
+
+// GotoBottom moves the selection to the last row.
+func (m *Model) GotoBottom() {
+	m.MoveDown(len(m.metaRows))
+}
+
+func (m Model) headersView() string {
+	s := make([]string, 0, len(m.cols))
+	for _, col := range m.cols {
+		if col.Width <= 0 {
+			continue
+		}
+		style := lipgloss.NewStyle().Width(col.Width).MaxWidth(col.Width).Inline(true)
+		renderedCell := style.Render(runewidth.Truncate(col.Title, col.Width, "…"))
+		s = append(s, m.styles.Header.Render(renderedCell))
+	}
+	return lipgloss.JoinHorizontal(lipgloss.Top, s...)
+}
+
+func (m *Model) renderRow(r int) string {
+	s := make([]string, 0, len(m.cols))
+	for i, value := range m.metaRows[r].Row {
+		if m.cols[i].Width <= 0 {
+			continue
+		}
+		style := lipgloss.NewStyle().Width(m.cols[i].Width).MaxWidth(m.cols[i].Width).Inline(true)
+		renderedCell := m.styles.Cell.Render(style.Render(runewidth.Truncate(value, m.cols[i].Width, "…")))
+		s = append(s, renderedCell)
+	}
+
+	row := lipgloss.JoinHorizontal(lipgloss.Top, s...)
+
+	if r == m.cursor && m.ShowCursor {
+		return m.styles.Selected.Render(row)
+	}
+
+	return row
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+
+	return b
+}
+
+func clamp(v, low, high int) int {
+	return min(max(v, low), high)
+}
diff --git a/scripts/can_errgo/components/text-box.go b/scripts/can_errgo/components/text-box.go
new file mode 100644
index 000000000..316c3145b
--- /dev/null
+++ b/scripts/can_errgo/components/text-box.go
@@ -0,0 +1,60 @@
+// Custom text-box component for rendering a box with a title and description, will dynamically wrap text to fit within the box width.
+package components
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+type Box struct {
+	Width       int
+	Title       string
+	Description string
+}
+
+func (b *Box) SetWidth(width int){
+	b.Width = width
+}
+ 
+// SetText updates the Title and Description of the Box
+func (b *Box) SetText(title, description string) {
+	b.Title = title
+	b.Description = description
+}
+
+// View renders the Box component
+func (b Box) View() string {
+	borderStyle := lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).Padding(1, 2).BorderForeground(lipgloss.Color("57"))
+	titleStyle := lipgloss.NewStyle().Bold(true).Underline(true).Align(lipgloss.Center).Width(b.Width).MaxWidth(b.Width)
+	descriptionStyle := lipgloss.NewStyle().Align(lipgloss.Left).Width(b.Width).MaxWidth(b.Width)
+
+	titleContent := titleStyle.Render(b.Title) + "\n"
+	descriptionContent := descriptionStyle.Render(b.wrapText(b.Description))
+
+	content := lipgloss.JoinVertical(lipgloss.Left, titleContent, descriptionContent)
+
+	boxHeight := 3 + strings.Count(content, "\n \n \n")
+	return borderStyle.Width(b.Width).Height(boxHeight).Render(content)
+}
+
+// Function to wrap text to fit within the box width
+func (b Box) wrapText(text string) string {
+	var wrapped string
+	maxLineLength := b.Width - 4
+
+	for len(text) > 0 {
+		if len(text) < maxLineLength {
+			wrapped += text
+			break
+		}
+
+		lineEnd := maxLineLength
+		if idx := strings.LastIndex(text[:maxLineLength], " "); idx != -1 {
+			lineEnd = idx
+		}
+		wrapped += text[:lineEnd] + "\n"
+		text = text[lineEnd+1:]
+	}
+	return wrapped
+}
diff --git a/scripts/can_errgo/error_tui.go b/scripts/can_errgo/error_tui.go
new file mode 100644
index 000000000..caa8a8bad
--- /dev/null
+++ b/scripts/can_errgo/error_tui.go
@@ -0,0 +1,576 @@
+package main
+
+import (
+	"context"
+	"encoding/binary"
+	"flag"
+	"fmt"
+	"log"
+	"math"
+	"net"
+	"os"
+	"sort"
+	"strconv"
+	"time"
+
+	box "main/components"
+	table "main/components"
+
+	"github.com/charmbracelet/bubbles/key"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"golang.org/x/sys/unix"
+)
+
+
+const canFrameSize = 16   // CAN frame size (for a standard CAN frame)
+
+// Converts a 8-byte slice to a uint64, this is for masking purposes.
+func bytesToUint64(b []byte) uint64 {
+    var result uint64
+    for i := 0; i < len(b) && i < 8; i++ {
+        // Reverse the order: least significant byte (rightmost) gets the lowest bits
+        result |= uint64(b[len(b)-1-i]) << (8 * i)
+    }
+    return result
+}
+
+// Default style for the table
+var baseStyle = lipgloss.NewStyle().
+	BorderStyle(lipgloss.NormalBorder()).
+	BorderForeground(lipgloss.Color("240"))
+
+// RowValuesToRow converts a ErrorData struct to a table.Row
+func RowValuesToRow(r ErrorData) table.MetaRow{
+	return table.MetaRow{Row : table.Row{r.Error, strconv.Itoa(r.Count), strconv.Itoa(r.Recency)}, Index: r.ErrorIndex}
+}
+
+func toTableRows(r []ErrorData) []table.MetaRow {
+	var rows []table.MetaRow
+	for _, v := range r {
+		// Check if the ErrorData is active
+		if v.Count != 0 && !v.Ignored{
+			rows = append(rows, RowValuesToRow(v))
+		}
+	}
+	return rows
+}
+
+// This creates a deep copy of the input slice.
+func SortRowValuesByRecency(r []ErrorData) []ErrorData {
+	copied := make([]ErrorData, len(r))
+	copy(copied, r)
+
+	sort.SliceStable(copied, func(i, j int) bool {
+		return copied[i].Recency < copied[j].Recency
+	})
+
+	return copied
+}
+
+
+// findError returns the relative index (Row index) of the error in the slice of ErrorData, if the error is not found it returns -1.
+func findError(errorIndex int, rowValues []ErrorData) int {
+	cnt := 0
+	for i ,row := range rowValues{
+		if row.Count == 0 || row.Ignored{
+			cnt += 1
+		} 
+		if row.ErrorIndex == errorIndex{
+			return i - cnt  
+		}
+	}
+	return -1
+}
+
+func (m model) getIgnoredRows() []table.MetaRow {
+	var rows []table.MetaRow
+	for _,row := range m.errorData{
+		if row.Ignored{
+		rows = append(rows, table.MetaRow{Row: table.Row{row.Error}, Index: row.ErrorIndex})
+		}
+	}
+	return rows
+}
+
+type ErrorData struct{
+	Error string
+	Count int
+	Recency int
+	Description string
+	Ignored bool
+	//  This is used for keeping track of the error bit after sorting
+	ErrorIndex int
+}
+
+func (m model) isTimeout() bool {
+    return time.Now().Sub(m.lastCANTime) > m.timeout
+}
+
+type CANMsg struct {
+	ID    uint32
+	Value uint64
+}
+
+// Empty type for the tick message
+type TickMsg struct{}
+
+type model struct {
+	// Main table
+    table        table.Model
+	tableKeys	 KeyMap	
+
+	// Submenu table
+	submenuTable  table.Model
+	submenuActive bool
+	submenuKeys   KeyMap
+
+	// Slice of row information and ignore mask for incoming errors/bits
+	errorData  []ErrorData
+    ignoreMask   uint64
+
+	// Timeout flag and last CAN message time
+	lastCANTime time.Time
+	timeout           time.Duration
+
+	// Box for displaying error descriptions
+	box box.Box
+	showBox bool
+}
+
+func toggleBit(n uint64, bitPosition int) uint64 {
+    mask := uint64(1) << bitPosition
+    return n ^ mask
+}
+
+func tickEvery(timeout time.Duration) tea.Cmd {
+	return func() tea.Msg {
+		time.Sleep(timeout)
+		return TickMsg{}
+	}
+}
+
+func (m model) Init() tea.Cmd { return tickEvery(m.timeout) }
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmd tea.Cmd
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		if m.submenuActive{
+			// If submenu is active, only let the submenu handle KeyMsg
+			switch {
+			case key.Matches(msg, table.DefaultKeyMap().LineUp):
+				m.submenuTable.MoveUp(1)			
+				return m,nil	
+			case key.Matches(msg, table.DefaultKeyMap().LineDown):
+				m.submenuTable.MoveDown(1)		
+				return m,nil			
+			case key.Matches(msg, m.submenuKeys.i):
+				if m.submenuTable.SelectedRow() == nil{
+					return m, nil
+				}
+				
+				// Toggle the mask for the selected error and delete the row. 
+				errorIndex := m.submenuTable.SelectedIndex()
+				m.ignoreMask = toggleBit(m.ignoreMask, errorIndex)
+				m.errorData[errorIndex].Ignored = false
+				newRows := m.getIgnoredRows()
+				m.submenuTable.SetRows(newRows)
+
+			case key.Matches(msg, m.submenuKeys.s):
+				m.submenuActive = false  
+				m.table.Focus()  
+				m.submenuTable.Blur() 
+				m.table.SetShowCursor(true) 
+
+				return m, nil
+	
+			case key.Matches(msg, m.tableKeys.q):
+				return m, tea.Quit
+			}
+
+			m.submenuTable, cmd = m.submenuTable.Update(msg)
+			return m, cmd
+		}
+
+
+		switch {
+		case key.Matches(msg, m.tableKeys.q):
+			return m, tea.Quit
+		case key.Matches(msg, m.tableKeys.a):	
+			
+			// Prevent panic if no row is selected
+			if m.table.SelectedRow() == nil{
+				m.table.SetCursorAndViewport(0)
+				return m, nil
+			}
+
+			// Remove the row and reset its count.
+			errorIndex := m.table.SelectedIndex()
+			m.errorData[errorIndex].Count = 0
+			newRows := toTableRows(m.errorData)
+			m.table.SetRows(newRows)
+			return m, nil
+		case key.Matches(msg, m.tableKeys.i):
+
+			// Prevent panic if no row is selected
+			if m.table.SelectedRow() == nil{
+				m.table.SetCursorAndViewport(0)
+				return m, nil
+			}
+
+			// Toggle the mask for the selected error and move it to the ignore menu.
+			errorIndex := m.table.SelectedIndex()
+			m.ignoreMask = toggleBit(m.ignoreMask, errorIndex)
+			m.errorData[errorIndex].Ignored = true
+
+			// Remove the row from the main table and reset its count.
+			m.errorData[errorIndex].Count = 0
+			newRows := toTableRows(m.errorData)
+			m.table.SetRows(newRows)
+
+			//Set add the ignored rows to submenu
+			ignoredRows := m.getIgnoredRows()
+			m.submenuTable.SetRows(ignoredRows)
+
+			return m, nil
+        case key.Matches(msg, m.tableKeys.s):
+            if m.submenuActive {
+                // Hide submenu and return to main menu
+                m.submenuActive = false
+                m.table.Focus()
+            } else {
+                // Show submenu and focus it
+                m.submenuActive = true
+                m.table.Blur()
+                m.submenuTable.Focus()
+				m.table.SetShowCursor(false)
+            }
+		case key.Matches(msg, table.DefaultKeyMap().LineUp):
+			m.table.MoveUp(1)
+			return m,nil	
+		case key.Matches(msg, table.DefaultKeyMap().LineDown):
+			m.table.MoveDown(1)
+			return m,nil			
+	}
+	case CANMsg:
+		m.lastCANTime = time.Now()
+		msg.Value = msg.Value & m.ignoreMask
+
+		for i,errorVal := range m.errorData{
+			m.errorData[i].Recency += 1
+			if msg.Value&(1<<errorVal.ErrorIndex) != 0{
+				m.errorData[i].Count += 1
+				m.errorData[i].Recency = 0
+			}
+		}
+		// Sort the table by the recency.
+		currentError := m.table.SelectedIndex()
+		newRowValues :=  SortRowValuesByRecency(m.errorData)
+		newRows := toTableRows(newRowValues)
+		m.table.SetRows(newRows)
+
+		// Fix the cursor back onto the row it was on before the sort.
+		if currentError != -1{
+			newIndex := findError(currentError, newRowValues)
+			m.table.SetCursorAndViewport(newIndex)
+		}
+		return m, nil
+	case TickMsg:
+		return m, tickEvery(m.timeout)
+	}
+	return m, cmd
+}
+
+// KeyMap is a set of keybindings for the application.
+type KeyMap struct {
+	a       key.Binding
+	i       key.Binding
+	s	    key.Binding
+	q       key.Binding
+
+}
+
+// ShortHelp implements the KeyMap interface.
+func (km KeyMap) ShortHelp() []key.Binding {
+	return []key.Binding{km.a, km.i, km.s, km.q}
+}
+
+
+// key bindings for the main table
+func tableKeyMap() KeyMap {
+	return KeyMap{
+		a: key.NewBinding(
+			key.WithKeys("a"),
+			key.WithHelp("a", "Acknowledge"),
+		),
+		i: key.NewBinding(
+			key.WithKeys("i"),
+			key.WithHelp("i", "Ignore"),
+		),	
+		s: key.NewBinding(
+			key.WithKeys("s"),
+			key.WithHelp("s", "Ignored Menu"),
+		),
+		q: key.NewBinding(
+			key.WithKeys("q", "ctrl+c"),
+			key.WithHelp("q/ctrl+c", "quit"),
+		),
+	}
+}
+
+// key bindings for the submenu
+func subMenuKeyMap() KeyMap {
+	return KeyMap{
+		i: key.NewBinding(
+			key.WithKeys("i"),
+			key.WithHelp("i", "Unignore"),
+		),
+		s: key.NewBinding(
+			key.WithKeys("s"),
+			key.WithHelp("s", "Close Ignored Menu"),
+		),
+		q: key.NewBinding(
+			key.WithKeys("q"),
+			key.WithHelp("q/ctrl+c", "quit"),
+		),
+	}
+}
+
+// View returns the string representation of the model. We could combine and condense, but its clearer to keep it separate.
+func (m model) View() string {
+
+	out := "\n \n \n"
+	// Help menu changes based on the state of the submenu
+	if m.submenuActive{
+		out = 	m.table.HelpView() + "\n" + 
+				m.submenuTable.Help.ShortHelpView(m.submenuKeys.ShortHelp()) + "\n"
+	}else{
+		out = 	m.table.HelpView() + "\n" +
+				m.table.Help.ShortHelpView(m.tableKeys.ShortHelp()) + "\n"	
+	}
+
+	// Timeout warning
+	if m.lastCANTime.Add(m.timeout).Before(time.Now()){
+		out = fmt.Sprint("\n\x1b[41m\x1b[37mWarning! Last recorded message was over ",math.Round(time.Since(m.lastCANTime).Seconds()), " seconds ago!\x1b[0m") + "\n" +  out
+	}
+
+	// Render the table 
+	out = out + baseStyle.Render(m.table.View()) + "\n"
+
+	// Render the submenu if it is active
+	if m.submenuActive{
+		out = out + baseStyle.Render(m.submenuTable.View()) + "\n"
+	}
+
+	// Render the box 
+	if m.submenuActive && m.submenuTable.SelectedRow() != nil{
+		m.box.SetText(m.submenuTable.SelectedRow()[0], m.errorData[m.submenuTable.SelectedIndex()].Description)
+		out = out + m.box.View()
+	} else if m.table.SelectedRow() != nil && !m.submenuActive{
+		m.box.SetText(m.table.SelectedRow()[0],  m.errorData[m.table.SelectedIndex()].Description)
+		out = out + m.box.View()
+	}
+
+	return out
+}
+
+func initViewer(warning int) model{
+
+	mainTable := createTable()
+	table2 := createSubMenu()
+
+	// This can be determined at runtime later (DBC file parsing), for now it is hardcoded.
+	customErrors := []ErrorData{
+	}
+	for i := 0; i < 64; i++ { 
+		customErrors = append(customErrors, ErrorData{
+			Error:       fmt.Sprintf("error%d", i),
+			Count:       0,
+			Recency:     0,
+			Description: fmt.Sprintf("Description for error %d", i),
+			Ignored:     false,
+			ErrorIndex:  i,
+		})
+	}
+	
+	box := box.Box{};
+	// Each column has padding of 2, so the width is 60 + 2*3(error columns) = 66
+	box.SetWidth(66)
+
+	m := model{
+		mainTable,
+		tableKeyMap(),
+		
+		table2,
+		false,
+		subMenuKeyMap(),
+
+		customErrors,
+		^uint64(0),
+		
+		time.Now(),
+		time.Duration(warning) * time.Second,
+		
+		box,
+		false,
+	}
+	return m
+}
+
+// Default setup for the main table
+func createTable() table.Model{
+
+	// True Width = 60 + 2(padding) * (# cols) = 66
+	columns := []table.Column{
+		{Title: "Error:", Width: 40},
+		{Title: "Count:", Width: 10},
+		{Title: "Recency", Width: 10},
+
+	}
+	rows := []table.MetaRow{}
+	
+
+	t := table.New(
+		table.WithColumns(columns),
+		table.WithRows(rows),
+		table.WithFocused(true),
+		// The header will take up 1 row. If we want N rows, we need to set the height to N+1
+		table.WithHeight(11),
+	)
+
+	s := table.DefaultStyles()
+	s.Header = s.Header.	
+		BorderStyle(lipgloss.NormalBorder()).
+		BorderForeground(lipgloss.Color("240")).
+		BorderBottom(true).
+		Bold(false)
+	s.Selected = s.Selected.
+		Foreground(lipgloss.Color("229")).
+		Background(lipgloss.Color("57")).
+		Bold(false)
+	t.SetStyles(s)
+	return t
+}
+
+// Initialization of the submenu
+func createSubMenu() table.Model {
+	// Submenu has 1 column meaning it's true width is 60 + 2(padding) = 62, we need to account for the padding of the main table (66), so we add 4.
+    columns := []table.Column{
+        {Title: "Ignored Errors:", Width: 60 + 4} ,
+    }
+
+    rows := []table.MetaRow{}
+	t := table.New(
+		table.WithColumns(columns),
+		table.WithRows(rows),
+		table.WithFocused(true),
+		// The header will take up 1 row. If we want N rows, we need to set the height to N+1
+		table.WithHeight(5),
+	)
+
+	s := table.DefaultStyles()
+	s.Header = s.Header.	
+		BorderStyle(lipgloss.NormalBorder()).
+		BorderForeground(lipgloss.Color("240")).
+		BorderBottom(true).
+		Bold(false)
+	s.Selected = s.Selected.
+		Foreground(lipgloss.Color("229")).
+		Background(lipgloss.Color("57")).
+		Bold(false)
+	t.SetStyles(s)
+
+    return t
+}
+
+func gracefulExit(p *tea.Program, cancel context.CancelFunc, quit chan struct{}, errMsg string, err error) {
+    if cancel != nil {
+        cancel() 
+    }
+
+    if p != nil {
+        p.Quit()
+    }
+
+    // Wait for the main loop to handle the quit signal
+    <-quit
+
+    if err != nil {
+        log.Printf("%s: %v", errMsg, err)
+    } else {
+        log.Println(errMsg)
+    }
+    os.Exit(1) 
+}
+
+func can_listener(ctx context.Context, p *tea.Program, canInterface string, errChan chan error) {
+    sock, err := unix.Socket(unix.AF_CAN, unix.SOCK_RAW, unix.CAN_RAW)
+    if err != nil {
+        errChan <- fmt.Errorf("Error creating CAN socket: %w", err)
+        return
+    }
+    defer unix.Close(sock)
+
+    ifi, err := net.InterfaceByName(canInterface)
+    if err != nil {
+        errChan <- fmt.Errorf("Error getting interface index: %w", err)
+        return
+    }
+
+    addr := &unix.SockaddrCAN{Ifindex: ifi.Index}
+    if err := unix.Bind(sock, addr); err != nil {
+        errChan <- fmt.Errorf("Error binding socket to interface: %w", err)
+        return
+    }
+
+    buf := make([]byte, canFrameSize)
+    fmt.Println("Listening for CAN messages on", canInterface)
+
+    for {
+        select {
+        case <-ctx.Done(): // Exit loop when context is canceled
+            log.Println("CAN listener shutting down...")
+            return
+        default:
+            _, err := unix.Read(sock, buf)
+            if err != nil {
+                log.Printf("Error receiving CAN message: %v", err)
+                continue
+            }
+
+            canID := binary.LittleEndian.Uint32(buf[0:4]) & 0x1FFFFFFF
+            data := bytesToUint64(buf[8:])
+            msg := CANMsg{ID: canID, Value: data}
+            p.Send(msg)
+        }
+    }
+}
+
+func main() {
+    warnFlag := flag.Int("w", 5, "warning time for the table (integer value)")
+    canInterfaceFlag := flag.String("i", "vcan0", "CAN interface to listen on")
+    flag.Parse()
+    m := initViewer(*warnFlag)
+	
+    quit := make(chan struct{})
+    errChan := make(chan error)
+    ctx, cancel := context.WithCancel(context.Background())
+
+    p := tea.NewProgram(m)
+    go func() {
+        if _, err := p.Run(); err != nil {
+            errChan <- fmt.Errorf("Error running TUI: %w", err)
+        }
+        close(quit) // Notify the main loop that TUI has exited
+    }()
+
+    go can_listener(ctx, p, *canInterfaceFlag, errChan)
+
+    select {
+    case err := <-errChan:
+        gracefulExit(p, cancel, quit, "Exiting due to error", err)
+    case <-quit:
+        cancel() // Ensure all goroutines stop
+    }
+}
\ No newline at end of file
diff --git a/scripts/can_errgo/go.mod b/scripts/can_errgo/go.mod
new file mode 100644
index 000000000..e6b67e72f
--- /dev/null
+++ b/scripts/can_errgo/go.mod
@@ -0,0 +1,24 @@
+module main
+
+go 1.23.2
+
+require (
+	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
+	github.com/charmbracelet/bubbles v0.20.0 // indirect
+	github.com/charmbracelet/bubbletea v1.1.1 // indirect
+	github.com/charmbracelet/lipgloss v0.13.0 // indirect
+	github.com/charmbracelet/x/ansi v0.2.3 // indirect
+	github.com/charmbracelet/x/term v0.2.0 // indirect
+	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-localereader v0.0.1 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/termenv v0.15.2 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	golang.org/x/sync v0.8.0 // indirect
+	golang.org/x/sys v0.26.0 // indirect
+	golang.org/x/text v0.3.8 // indirect
+)
diff --git a/scripts/can_errgo/go.sum b/scripts/can_errgo/go.sum
new file mode 100644
index 000000000..f7b3b0811
--- /dev/null
+++ b/scripts/can_errgo/go.sum
@@ -0,0 +1,49 @@
+github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/charmbracelet/bubbles v0.20.0 h1:jSZu6qD8cRQ6k9OMfR1WlM+ruM8fkPWkHvQWD9LIutE=
+github.com/charmbracelet/bubbles v0.20.0/go.mod h1:39slydyswPy+uVOHZ5x/GjwVAFkCsV8IIVy+4MhzwwU=
+github.com/charmbracelet/bubbletea v1.1.1 h1:KJ2/DnmpfqFtDNVTvYZ6zpPFL9iRCRr0qqKOCvppbPY=
+github.com/charmbracelet/bubbletea v1.1.1/go.mod h1:9Ogk0HrdbHolIKHdjfFpyXJmiCzGwy+FesYkZr7hYU4=
+github.com/charmbracelet/bubbletea v1.2.0 h1:WYHclJaFDOz4dPxiGx7owwb8P4000lYPcuXPIALS5Z8=
+github.com/charmbracelet/bubbletea v1.2.0/go.mod h1:viLoDL7hG4njLJSKU2gw7kB3LSEmWsrM80rO1dBJWBI=
+github.com/charmbracelet/lipgloss v0.13.0 h1:4X3PPeoWEDCMvzDvGmTajSyYPcZM4+y8sCA/SsA3cjw=
+github.com/charmbracelet/lipgloss v0.13.0/go.mod h1:nw4zy0SBX/F/eAO1cWdcvy6qnkDUxr8Lw7dvFrAIbbY=
+github.com/charmbracelet/lipgloss v1.0.0 h1:O7VkGDvqEdGi93X+DeqsQ7PKHDgtQfF8j8/O2qFMQNg=
+github.com/charmbracelet/lipgloss v1.0.0/go.mod h1:U5fy9Z+C38obMs+T+tJqst9VGzlOYGj4ri9reL3qUlo=
+github.com/charmbracelet/x/ansi v0.2.3 h1:VfFN0NUpcjBRd4DnKfRaIRo53KRgey/nhOoEqosGDEY=
+github.com/charmbracelet/x/ansi v0.2.3/go.mod h1:dk73KoMTT5AX5BsX0KrqhsTqAnhZZoCBjs7dGWp4Ktw=
+github.com/charmbracelet/x/ansi v0.4.5 h1:LqK4vwBNaXw2AyGIICa5/29Sbdq58GbGdFngSexTdRM=
+github.com/charmbracelet/x/ansi v0.4.5/go.mod h1:dk73KoMTT5AX5BsX0KrqhsTqAnhZZoCBjs7dGWp4Ktw=
+github.com/charmbracelet/x/term v0.2.0 h1:cNB9Ot9q8I711MyZ7myUR5HFWL/lc3OpU8jZ4hwm0x0=
+github.com/charmbracelet/x/term v0.2.0/go.mod h1:GVxgxAbjUrmpvIINHIQnJJKpMlHiZ4cktEQCN6GWyF0=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
+github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo=
+github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
diff --git a/scripts/can_errgo/setup_vcan.sh b/scripts/can_errgo/setup_vcan.sh
new file mode 100644
index 000000000..d8da66f20
--- /dev/null
+++ b/scripts/can_errgo/setup_vcan.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+
+
+CAN_PORT=$1
+
+if [ -z "$CAN_PORT" ]; then
+    echo "Error: CAN_PORT is required as an argument."
+    echo "Usage: $0 <CAN_PORT>"
+    exit 1
+fi
+
+sudo modprobe -a can can_raw vcan
+sudo ip link add dev $CAN_PORT type vcan
+sudo ip link set up $CAN_PORT
diff --git a/scripts/can_errgo/utilityFiles/test_cli.sh b/scripts/can_errgo/utilityFiles/test_cli.sh
new file mode 100644
index 000000000..ffd5535bf
--- /dev/null
+++ b/scripts/can_errgo/utilityFiles/test_cli.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Infinite loop
+while true
+do
+    # Send CAN message
+    cansend vcan0 FFF#1101
+
+    # Wait for 1 seconds
+    sleep 1
+done
+
diff --git a/scripts/can_errgo/utilityFiles/test_multi.sh b/scripts/can_errgo/utilityFiles/test_multi.sh
new file mode 100644
index 000000000..49ffc3c15
--- /dev/null
+++ b/scripts/can_errgo/utilityFiles/test_multi.sh
@@ -0,0 +1,49 @@
+
+#!/bin/bash
+
+# Infinite loop
+while true
+do
+    # Send CAN message
+    cansend vcan0 FFF#0000000000000001
+    sleep 1
+    cansend vcan0 FFF#0000000000000002
+    sleep 1
+    cansend vcan0 FFF#0000000000000004
+    sleep 1
+    cansend vcan0 FFF#0000000000000008
+    sleep 1
+    cansend vcan0 FFF#0000000000000010
+    sleep 1
+    cansend vcan0 FFF#0000000000000020
+    sleep 1
+    cansend vcan0 FFF#0000000000000040
+    sleep 1
+    cansend vcan0 FFF#0000000000000080
+    sleep 1
+    cansend vcan0 FFF#0000000000000100
+    sleep 1
+    cansend vcan0 FFF#0000000000000200
+    sleep 1
+    cansend vcan0 FFF#0000000000000400
+    sleep 1
+    cansend vcan0 FFF#0000000000000800
+    sleep 1
+    cansend vcan0 FFF#0000000000001000
+    sleep 1
+    cansend vcan0 FFF#0000000000002000
+    sleep 1
+    cansend vcan0 FFF#0000000000004000
+    sleep 1
+    cansend vcan0 FFF#0000000000008000
+    sleep 1
+    cansend vcan0 FFF#0000000000010000
+    sleep 1
+    cansend vcan0 FFF#0000000000020000
+    sleep 1
+    cansend vcan0 FFF#0000000000040000
+    sleep 1
+    cansend vcan0 FFF#0000000000080000
+    # Wait for 1 seconds
+    sleep 1
+done
\ No newline at end of file
diff --git a/scripts/can_errgo/utilityFiles/test_once.sh b/scripts/can_errgo/utilityFiles/test_once.sh
new file mode 100644
index 000000000..f62981d2c
--- /dev/null
+++ b/scripts/can_errgo/utilityFiles/test_once.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+
+sleep $1
+cansend vcan0 FFF#$2
\ No newline at end of file