earth-1/sentinel
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added command line flags

Browse Source
This commit is contained in:
alexander-the-alright
2022-06-27 23:53:53 -04:00
parent e180cd8ea8
commit 247470dc49
30 changed files with 70 additions and 1477 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
-14
View File
@@ -1,14 +0,0 @@
# Binaries for programs and plugins
node
led
colonel
sentinel
# Test binary, built with `go test -c`
# Output of the go coverage tool, specifically when used with LiteIDE
# Dependency directories (remove the comment below to include it)
# vendor/
.gitignore
convo/Makefile
-8
View File
@@ -1,8 +0,0 @@
all: clean build
clean:
rm speak reply
build:
go build speak.go
go build reply.go
convo/convo.txt
-23
View File
@@ -1,23 +0,0 @@
# ==============================================================================
# Auth: Alex Celani
# File: convo.txt
# Revn: 05-10-2022 0.1
# Func: elaborate on how the convo Golang networks programs should run
#
# TODO: create
# ==============================================================================
# CHANGE LOG
# ------------------------------------------------------------------------------
# 05-10-2022: init
#
# ==============================================================================
uh
just send a bunch of information back and forth
A sends data to B, B receives, processes, and responds
A receives, processes, and responds
Repeat until some cutoff condition
convo/reply
BIN
View File
Binary file not shown.
convo/reply.go
-84
View File
@@ -1,84 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: reply.go
// Revn: 05-13-2022 0.1
// Func: host connection, reply to speak.go
//
// TODO: create
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-13-2022: init
//
// =============================================================================
package main
import (
"net"
"os"
"fmt"
"time"
)
func check( err error ) {
if err != nil {
fmt.Println( "Fatal: ", err.Error() )
os.Exit( 1 )
}
}
func handle( conn net.Conn ) {
table := map[string]string{ "hello":"hello",
"how are you":"fine and yourself",
"well enough for the weather":"aye it scalds",
"i lost my begonias":"exit" }
var buffer [512]byte
for {
n, err := conn.Read( buffer[:] )
check( err )
fmt.Println( "\t\t\t", string( buffer[:n] ) )
time.Sleep( 2 * time.Second )
response, present := table[string( buffer[:n] )]
if present {
_, err = conn.Write( []byte( response ) )
check( err )
if response == "exit" {
break
} else {
fmt.Println( response )
}
} else {
fmt.Println( "excuse me good sir" )
os.Exit( 2 )
}
}
}
func main() {
service := ":1200"
addr, err := net.ResolveTCPAddr( "tcp", service )
check( err )
listener, err := net.ListenTCP( "tcp", addr )
conn, err := listener.Accept()
check( err )
handle( conn )
os.Exit( 0 )
}
convo/speak
BIN
View File
Binary file not shown.
convo/speak.go
-85
View File
@@ -1,85 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: speak.go
// Revn: 05-11-2022 0.1
// Func: initiate conversation
//
// TODO: create
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-11-2022: init
// 05-17-2022: changed an entry in the response table
//
// =============================================================================
package main
import (
"net"
"os"
"fmt"
"time"
)
func check( err error ) {
if err != nil {
fmt.Println( "fatal: ", err.Error() )
os.Exit( 1 )
}
}
func handle( conn net.Conn ) {
table := map[string]string{ "hello":"how are you",
"fine and yourself":"well enough for the weather",
"aye it scalds":"i lost my begonias" }
var buffer [512]byte
for {
n, err := conn.Read( buffer[:] )
check( err )
if string( buffer[:n] ) == "exit" {
break
}
fmt.Println( "\t\t\t", string( buffer[:n] ) )
time.Sleep( 2 * time.Second )
response, present := table[string( buffer[:n] )]
if present {
_, err = conn.Write( []byte( response ) )
check( err )
fmt.Println( response )
} else {
fmt.Println( "excuse me good sir" )
os.Exit( 2 )
}
}
}
func main() {
service := ":1200"
addr, err := net.ResolveTCPAddr( "tcp", service )
check( err )
conn, err := net.DialTCP( "tcp", nil, addr )
check( err )
_, err = conn.Write( []byte( "hello" ) )
check( err )
fmt.Println( "hello" )
handle( conn )
os.Exit( 0 )
}
draft1_route/Makefile
-9
View File
@@ -1,9 +0,0 @@
all: clean build
clean:
rm colonel sentinel node
build:
go build colonel.go
go build sentinel.go
go build node.go
draft1_route/colonel.go
-96
View File
@@ -1,96 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: colonel.go
// Revn: 06-20-2022 1.0
// Func: Send message to another machine and then receive a single
// response. Extremely tight bounds, not robust at all
//
// TODO: comment
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-04-2022: init
//*06-20-2022: changed name to reflect first draft of colonel.go
//
// =============================================================================
package main
import (
"net" // ResolveTCPAddr, DialTCP, conn.Write,Read
"os" // Exit, Stdin, Stderr, Args
"fmt" // Println, Print, Fprintf
"bufio" // NewScanner, NewScanner.Scan,Text
"strings" // ToLower
"time" // Now, Sub
)
// quick function to take user input
func input( ps1 string ) string {
fmt.Print( ps1 ) // print prompt
scanner := bufio.NewScanner( os.Stdin ) // link to stdin
scanner.Scan() // pull data
return strings.ToLower( scanner.Text() ) // return lower text
}
// quick error checking
func check( err error ) {
// if user checks an error, it better be nil
if err != nil {
// put error in string, print in stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
os.Exit( 2 ) // quit
}
}
func main() {
// if len is not 2 ( ./name host:port ), print usage and quit
if len( os.Args ) != 2 {
fmt.Fprintf( os.Stderr, "Usage: %s host:port", os.Args[0] )
os.Exit( 1 )
}
service := os.Args[1] // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// "dial" ( establish connection ) to destination ip & port
// according to TCP rules
// laddr = nil -> local address is localhost
conn, err := net.DialTCP( "tcp", nil, tcpAddr )
check( err ) // check error
var in string = input( ">> " ) // get user input
start := time.Now() // start round trip timer
// convert user input to bytes and send over connection
_, err = conn.Write( []byte( in ) )
check( err ) // check error
var buf [512]byte // init byte array
// read from connection into byte array
// amount of bytes read stored in n
//n, err := conn.Read( buf[0:] )
n, err := conn.Read( buf[:] )
check( err ) // check error
t := time.Now() // stop round trip timer
// convert read bytes into string and print
fmt.Println( string( buf[:n] ) )
fmt.Println() // newline to clean up a little
fmt.Println( "rtt: ", t.Sub( start ) ) // print elapsed time
os.Exit( 0 ) // exeunt
}
draft1_route/node.go
-130
View File
@@ -1,130 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: node.go
// Revn: 06-22-2022 1.0
// Func: receive data as an endpoint, send response back to middleman
//
// TODO:
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-04-2022: init
// 05-09-2022: began commenting
// 05-10-2022: finished commenting
// added alter() and forward()
// made passed value to alter()/forward() a slice
// changed refs to recv byte array to slice of n bytes
// 06-20-2022: changed name to reflect first draft of node.go
//*06-22-2022: bug squashing and commenting
//
// =============================================================================
package main
import (
"net" // ResolveTCPAddr, conn.Write,Read,Close
// ListenTCP, listener.Accept
"os" // Args, Stderr, Exit
"fmt" // Fprintf, Println
"strings" // ToLower
)
// quick error checking
func check( err error ) {
// if user checks an error, it better be nil
if err != nil {
// put error in string, print in stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
os.Exit( 2 ) // quit
}
}
// parse incoming message, keep only second word
func parse( recv string ) string {
// split message over spaces
keywords := strings.Split( recv, " " )
return keywords[1] // return the second word
}
// function to handle incoming connections
func handleClient( conn net.Conn ) {
defer conn.Close() // barring any error, still close connection
// init map of fields to their values
reply := map[string]string{ "soc" : "30",
"batt" : "30",
"temp" : "65",
"humid" : "35",
"sun" : "10",
"list" : "soc batt temp humid sun list" }
var buf [512]byte // declare large byte array, store messages
// iterate forever to always read over connection
for {
// read n bytes from connection into buffer
n, err := conn.Read( buf[0:] )
if err != nil { // erroring on read will simply leave the
return // function so it can start again later
}
// print recv'd message
// string() only works on byte SLICES so [:] is required
fmt.Println( "recv: ", string( buf[:n] ) )
// send input to parse
recv := parse( string( buf[:n] ) )
fmt.Println( "parse: ", recv ) // print
// declare variables to grab values from field map
var resp string
var prs bool
// get values from map, prs is false if key (recv) DNE in map
resp, prs = reply[recv]
if !prs { // if key was not present
resp = "field does not exist" // response is DNE
}
fmt.Println( "answer: ", resp ) // print response
// write that response back to original client
_, err = conn.Write( []byte( resp ) )
if err != nil { // erroring on write will simply leave the
return // function so it can start again later
}
fmt.Println( "sent: ", resp ) // print response
}
}
func main() {
// ip:port
// ip doesn't exist, implies localhost
service := ":1202" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// bind and "listen" to ip and port, according to tcp rules
listener, err := net.ListenTCP( "tcp", tcpAddr )
check( err ) // check error
// iterate forever
// TODO i mean i can totally make this more user friendly
for {
// accept a connection that makes its way to bound port
conn, err := listener.Accept()
if err != nil { // if connection fails...
continue // don't quit program, not fatal error
}
// asynchronous function to handle connection to client
go handleClient( conn )
}
}
draft1_route/sent
BIN
View File
Binary file not shown.
draft1_route/sent.go
-157
View File
@@ -1,157 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: sent.go
// Revn: 06-22-2022 1.0
// Func: Receive message, play with it, send to a third place, receive
// response, send off to first place
//
// TODO: comment
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-04-2022: init
// 05-05-2022: commented
// 05-10-2022: added argument 'n' to alter() for halving purposes
// changed passed value to alter()/forward() a slice
// 06-20-2022: changed name to reflect first draft of sentinel.go
//*06-22-2022: bug fixing and commenting
//
// =============================================================================
package main
import (
"net" // ResolveTCPAddr, DialTCP, conn.Write,Read,Close
// ListenTCP, listener.Accept
"os" // Exit, Stderr, Stdin, Args
"fmt" // Println, Fprintf
"strings" // ToLower, ToUpper
)
// quick error checking
func check( err error ){
// if user checks an error, it better be nil
if err != nil {
// put error in string, print to stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
os.Exit( 1 ) // quit
}
}
// function to send message to third party and get response
func send( toSend string ) string {
// ip:port
// ip doesn't exist, implies localhost
service := "192.168.1.3:1202" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// "dial" ( establish connection ) to destination ip & port
// according to TCP rules
// laddr = nil -> local address is localhost
conn, err := net.DialTCP( "tcp", nil, tcpAddr )
check( err ) // check error
defer conn.Close() // barring any error, still close connection
// convert user input to bytes and send over connection
_, err = conn.Write( []byte( toSend ) )
check( err ) // check error
var buf [512]byte // init byte array
// read from connection into byte array
// amount of bytes read stored in n
//n, err := conn.Read( buf[0:] )
n, err := conn.Read( buf[0:] )
check( err ) // check error
return string( buf[:n] ) // return only written bytes
}
// remove the first word from the string
// actually mad inefficient tbh, but it works
func parse( recv string ) string {
// split string over spaces
keywords := strings.Split( recv, " " )
var command string // declare return variable
// iterate over all but the first word
for _, keyword := range keywords[1:] {
command = command + keyword // add word to returnable
command = command + " " // separate by spaces
}
// remove the trailing space
command = command[:len( command ) - 1]
return command // return
}
// function to handle incoming connections
func handleClient( conn net.Conn ) {
defer conn.Close() // barring any error, still close connection
var buf [512]byte // declare large byte array, store messages
// iterate forever to always read over connection
for {
// read n bytes from connection into buffer
n, err := conn.Read( buf[0:] )
if err != nil { // erroring on read will simply leave the
return // function so it can start again later
}
// instantiate receipt variable
var recv string = string( buf[:n] )
// print recv'd message
// string() only works on byte SLICES so [:] is required
fmt.Println( "recv: ", recv )
// parse the input in some way
recv = parse( recv )
fmt.Println( "parse: ", recv ) // print parse
resp := send( recv ) // send message off
fmt.Println( "node: ", resp ) // print response
// write that response back to original client
_, err = conn.Write( []byte( resp ) )
if err != nil { // erroring on write will simply leave the
return // function so it can start again later
}
}
}
func main() {
// ip:port
// ip doesn't exist, implies localhost
service := ":1201" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// bind and "listen" to ip and port, according to tcp rules
listener, err := net.ListenTCP( "tcp", tcpAddr )
check( err ) // check error
// iterate forever
// TODO i mean i can totally make this more user friendly
for {
// accept a connection that makes its way to bound port
conn, err := listener.Accept()
if err != nil { // if connection fails...
continue // don't quit program, not fatal error
}
// asynchronous function to handle connection to client
go handleClient( conn )
}
}
draft1_route/sentinel.go
-157
View File
@@ -1,157 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: sentinel.go
// Revn: 06-22-2022 1.0
// Func: Receive message, play with it, send to a third place, receive
// response, send off to first place
//
// TODO: comment
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-04-2022: init
// 05-05-2022: commented
// 05-10-2022: added argument 'n' to alter() for halving purposes
// changed passed value to alter()/forward() a slice
// 06-20-2022: changed name to reflect first draft of sentinel.go
//*06-22-2022: bug fixing and commenting
//
// =============================================================================
package main
import (
"net" // ResolveTCPAddr, DialTCP, conn.Write,Read,Close
// ListenTCP, listener.Accept
"os" // Exit, Stderr, Stdin, Args
"fmt" // Println, Fprintf
"strings" // ToLower, ToUpper
)
// quick error checking
func check( err error ){
// if user checks an error, it better be nil
if err != nil {
// put error in string, print to stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
os.Exit( 1 ) // quit
}
}
// function to send message to third party and get response
func send( toSend string ) string {
// ip:port
// ip doesn't exist, implies localhost
service := ":1202" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// "dial" ( establish connection ) to destination ip & port
// according to TCP rules
// laddr = nil -> local address is localhost
conn, err := net.DialTCP( "tcp", nil, tcpAddr )
check( err ) // check error
defer conn.Close() // barring any error, still close connection
// convert user input to bytes and send over connection
_, err = conn.Write( []byte( toSend ) )
check( err ) // check error
var buf [512]byte // init byte array
// read from connection into byte array
// amount of bytes read stored in n
//n, err := conn.Read( buf[0:] )
n, err := conn.Read( buf[0:] )
check( err ) // check error
return string( buf[:n] ) // return only written bytes
}
// remove the first word from the string
// actually mad inefficient tbh, but it works
func parse( recv string ) string {
// split string over spaces
keywords := strings.Split( recv, " " )
var command string // declare return variable
// iterate over all but the first word
for _, keyword := range keywords[1:] {
command = command + keyword // add word to returnable
command = command + " " // separate by spaces
}
// remove the trailing space
command = command[:len( command ) - 1]
return command // return
}
// function to handle incoming connections
func handleClient( conn net.Conn ) {
defer conn.Close() // barring any error, still close connection
var buf [512]byte // declare large byte array, store messages
// iterate forever to always read over connection
for {
// read n bytes from connection into buffer
n, err := conn.Read( buf[0:] )
if err != nil { // erroring on read will simply leave the
return // function so it can start again later
}
// instantiate receipt variable
var recv string = string( buf[:n] )
// print recv'd message
// string() only works on byte SLICES so [:] is required
fmt.Println( "recv: ", recv )
// parse the input in some way
recv = parse( recv )
fmt.Println( "parse: ", recv ) // print parse
resp := send( recv ) // send message off
fmt.Println( "node: ", resp ) // print response
// write that response back to original client
_, err = conn.Write( []byte( resp ) )
if err != nil { // erroring on write will simply leave the
return // function so it can start again later
}
}
}
func main() {
// ip:port
// ip doesn't exist, implies localhost
service := ":1201" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// bind and "listen" to ip and port, according to tcp rules
listener, err := net.ListenTCP( "tcp", tcpAddr )
check( err ) // check error
// iterate forever
// TODO i mean i can totally make this more user friendly
for {
// accept a connection that makes its way to bound port
conn, err := listener.Accept()
if err != nil { // if connection fails...
continue // don't quit program, not fatal error
}
// asynchronous function to handle connection to client
go handleClient( conn )
}
}
draft2_pin/Makefile
-9
View File
@@ -1,9 +0,0 @@
all: clean build
clean:
rm colonel sentinel
build:
go build colonel.go
go build sentinel.go
draft2_pin/colonel.go
-78
View File
@@ -1,78 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: colonel.go
// Revn: 06-22-2022 1.0
// Func: Send message to another machine and then receive a single
// response
//
// TODO: comment
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-04-2022: init
// 06-20-2022: changed name to reflect first draft of colonel.go
//*06-22-2022: bug fixing and commenting
//
// =============================================================================
package main
import (
"net" // ResolveTCPAddr, DialTCP, conn.Write,Read
"os" // Exit, Stdin, Stderr, Args
"fmt" // Println, Print, Fprintf
"bufio" // NewScanner, NewScanner.Scan,Text
"strings" // ToLower
)
// quick function to take user input
func input( ps1 string ) string {
fmt.Print( ps1 ) // print prompt
scanner := bufio.NewScanner( os.Stdin ) // link to stdin
scanner.Scan() // pull data
return strings.ToLower( scanner.Text() ) // return lower text
}
// quick error checking
func check( err error ) {
// if user checks an error, it better be nil
if err != nil {
// put error in string, print in stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
os.Exit( 2 ) // quit
}
}
func main() {
// if len is not 2 ( ./name host:port ), print usage and quit
if len( os.Args ) != 2 {
fmt.Fprintf( os.Stderr, "Usage: %s host:port", os.Args[0] )
os.Exit( 1 )
}
service := os.Args[1] // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// "dial" ( establish connection ) to destination ip & port
// according to TCP rules
// laddr = nil -> local address is localhost
conn, err := net.DialTCP( "tcp", nil, tcpAddr )
check( err ) // check error
var in string = input( ">> " ) // get user input
// convert user input to bytes and send over connection
_, err = conn.Write( []byte( in ) )
check( err ) // check error
os.Exit( 0 ) // exeunt
}
draft2_pin/sentinel.go
-119
View File
@@ -1,119 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: sentinel.go
// Revn: 06-22-2022 1.0
// Func: Receive message, play with it, send to a third place, receive
// response, send off to first place
//
// TODO: comment
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-04-2022: init
// 05-05-2022: commented
// 05-10-2022: added argument 'n' to alter() for halving purposes
// changed passed value to alter()/forward() a slice
// 06-20-2022: changed name to reflect first draft of sentinel.go
//*06-22-2022: bug fixing and comments
//
// =============================================================================
package main
import (
"net" // ResolveTCPAddr, DialTCP, conn.Write,Read,Close
// ListenTCP, listener.Accept
"os" // Exit, Stderr, Stdin, Args
"fmt" // Println, Fprintf
"github.com/stianeikeland/go-rpio" // talk to RasPi pins
)
// quick error checking
func check( err error ){
// if user checks an error, it better be nil
if err != nil {
// put error in string, print to stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
os.Exit( 1 ) // quit
}
}
// function to handle incoming connections
func handleClient( conn net.Conn ) {
defer conn.Close() // barring any error, still close connection
var buf [512]byte // declare large byte array, store messages
// iterate forever to always read over connection
for {
// read n bytes from connection into buffer
n, err := conn.Read( buf[0:] )
if err != nil { // erroring on read will simply leave the
return // function so it can start again later
}
// instantiate receipt variable
var recv string = string( buf[:n] )
// print recv'd message
// string() only works on byte SLICES so [:] is required
fmt.Println( "recv: ", recv )
// toggle pin on successful receipt
pin.Toggle()
}
}
// declare pin
var (
// Use mcu pin 10, corresponds to physical pin 19 on the pi
pin = rpio.Pin(10)
)
func main() {
// Open and map memory to access gpio, check for errors
// inline open gpio pin and check the error var
if err := rpio.Open(); err != nil {
// on error, print error and exit
fmt.Println(err)
os.Exit(1)
}
// Unmap gpio memory when done
defer rpio.Close()
// Set pin to output mode
pin.Output()
// ip:port
// ip doesn't exist, implies localhost
service := ":1201" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// bind and "listen" to ip and port, according to tcp rules
listener, err := net.ListenTCP( "tcp", tcpAddr )
check( err ) // check error
// iterate forever
// TODO i mean i can totally make this more user friendly
for {
// accept a connection that makes its way to bound port
conn, err := listener.Accept()
if err != nil { // if connection fails...
continue // don't quit program, not fatal error
}
// asynchronous function to handle connection to client
go handleClient( conn )
}
}
draft3_pinroute/boot.go
-55
View File
@@ -1,55 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: boot.go
// Revn: 06-23-2022 0.1
// Func: Blink a light when the pi boots (or on login, but who cares)
//
// TODO: create
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 06-23-2022: init
//
// =============================================================================
package main
import (
"github.com/stianeikeland/go-rpio"
"os"
"time"
)
/*
Toggles a LED on physical pin 19 (mcu pin 10)
Connect a LED with resistor from pin 19 to ground.
*/
// Use mcu pin 10, corresponds to physical pin 19 on the pi
var pin rpio.Pin
func main() {
pin = rpio.Pin( 10 )
// Open and map memory to access gpio, check for errors
if err := rpio.Open(); err != nil {
os.Exit(1)
}
// Unmap gpio memory when done
defer rpio.Close()
// Set pin to output mode
pin.Output()
// Toggle pin 20 times
for i := 0; i < 4; i++ {
pin.Toggle()
time.Sleep(time.Second / 10)
}
}
draft3_pinroute/config
-5
View File
@@ -1,5 +0,0 @@
color;blue green red purple teal yellow white
status;on off
&&
color;blue
status;off
draft3_pinroute/draft3_pinroute.txt
-33
View File
@@ -1,33 +0,0 @@
# ==============================================================================
# Auth: Alex Celani
# File: XXX.xx
# Revn: MM-DD-YYYY 0.0
# Func:
#
# TODO: create
# ==============================================================================
# CHANGE LOG
# ------------------------------------------------------------------------------
# MM-DD-YYYY: init
#
# ==============================================================================
literally
combine draft1 with draft2
sentinel:: your whole job, tbh, is to forward to the correct node
and there's really only one node
change stuff like "plant humid" into "plant.humid" or
"lamp color" into "lamp.color"
node:: move real parsing here
control RBG common anode led
node name -> led
fields ->^v led.color
^ on
^ off
v status
^v bright
v list
draft3_pinroute/Makefile → src/Makefile
View File
draft3_pinroute/colonel.go → src/colonel.go
+12 -14
View File
@@ -1,7 +1,7 @@
// =============================================================================
// Auth: Alex Celani
// File: colonel.go
// Revn: 06-23-2022 1.1
// Revn: 06-27-2022 1.2
// Func: Send message to another machine and then receive a single
// response. Extremely tight bounds, not robust at all
//
@@ -12,6 +12,7 @@
// 05-04-2022: init
//*06-20-2022: changed name to reflect first draft of colonel.go
// 06-23-2022: made input an infinite loop
// 06-27-2022: added flag package, assumed ip
//
// =============================================================================
@@ -24,6 +25,7 @@ import (
"bufio" // NewScanner, NewScanner.Scan,Text
"strings" // ToLower
"time" // Now, Sub
"flag" // Parse, String, Bool
)
@@ -41,7 +43,7 @@ func check( err error ) {
// if user checks an error, it better be nil
if err != nil {
// put error in string, print in stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
fmt.Fprintf( os.Stderr, "Fatal error: %s\n", err.Error() )
os.Exit( 2 ) // quit
}
}
@@ -49,16 +51,12 @@ func check( err error ) {
func main() {
// if len is not 2 ( ./name host:port ), print usage and quit
if len( os.Args ) != 2 {
fmt.Fprintf( os.Stderr, "Usage: %s host:port", os.Args[0] )
os.Exit( 1 )
}
service := os.Args[1] // capture ip address and host
// get ip from command line, or use assumed ip and port
verbose := flag.Bool( "v", false, "verbose prints" )
ip := flag.String( "ip", ":1201", "sentinel IP and port" )
flag.Parse() // parse flags
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
tcpAddr, err := net.ResolveTCPAddr( "tcp", *ip )
check( err ) // check error
// "dial" ( establish connection ) to destination ip & port
@@ -89,9 +87,9 @@ func main() {
// convert read bytes into string and print
fmt.Println( "<<", string( buf[:n] ) )
fmt.Println() // newline to clean up a little
fmt.Println( "rtt: ", t.Sub( start ) ) // print time
if *verbose {
fmt.Println( "\nrtt: ", t.Sub( start ) ) // print time
}
}
os.Exit( 0 ) // exeunt
draft3_pinroute/led.go → src/led.go
+29 -9
View File
@@ -1,7 +1,7 @@
// =============================================================================
// Auth: Alex Celani
// File: led.go
// Revn: 06-26-2022 1.2
// Revn: 06-27-2022 1.3
// Func: receive data as an endpoint, send response back to middleman
//
// TODO:
@@ -18,6 +18,7 @@
//*06-22-2022: bug squashing and commenting
// 06-23-2022: updated to produce three different colors
// 06-26-2022: commented
// 06-27-2022: added flag package
//
// =============================================================================
@@ -30,6 +31,7 @@ import (
"fmt" // Fprintf, Println
"strings" // ToLower
"github.com/stianeikeland/go-rpio" // talk to RasPi pins
"flag" // Parse, String, Int, Bool
)
@@ -66,9 +68,11 @@ func handleClient( conn net.Conn ) {
return // function so it can start again later
}
if *verbose {
// print recv'd message
// string() only works on byte SLICES so [:] is required
fmt.Println( "recv: ", string( buf[:n] ) )
}
// split command into words for ease of parsing
command := strings.Split( string( buf[:n] ), " " )
@@ -146,7 +150,9 @@ func handleClient( conn net.Conn ) {
os.Exit( 2 ) // exit in this case
}
if *verbose {
fmt.Println( "answer: ", resp ) // print response
}
// write that response back to original client
_, err = conn.Write( []byte( resp ) )
@@ -154,9 +160,11 @@ func handleClient( conn net.Conn ) {
return // function so it can start again later
}
if *verbose {
fmt.Println( "sent: ", resp ) // print response
}
}
}
//var params = make( map[string]string )
@@ -167,13 +175,29 @@ var pinB rpio.Pin // declare blue led pin
var color string // declare color variable
var status string // declare status variable
var ( // declare flag variables
lr *int
lg *int
lb *int
verbose *bool
ip *string
)
func main() {
// declare command line input variables
lr = flag.Int( "lr", 11, "GPIO pin for red LED" )
lg = flag.Int( "lg", 9, "GPIO pin for green LED" )
lb = flag.Int( "lb", 25, "GPIO pin for blue LED" )
verbose = flag.Bool( "v", false, "verbose printing" )
ip = flag.String( "ip", ":1202", "ip and port of self" )
flag.Parse()
// initialize pins to GPIO 11, 9, and 25
pinR = rpio.Pin( 11 )
pinG = rpio.Pin( 9 )
pinB = rpio.Pin( 25 )
pinR = rpio.Pin( *lr )
pinG = rpio.Pin( *lg )
pinB = rpio.Pin( *lb )
if err := rpio.Open(); err != nil {
// on error, print error and exit
@@ -189,12 +213,8 @@ func main() {
pinG.Output()
pinB.Output()
// ip:port
// ip doesn't exist, implies localhost
service := ":1202" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
tcpAddr, err := net.ResolveTCPAddr( "tcp", *ip )
check( err ) // check error
// bind and "listen" to ip and port, according to tcp rules
draft3_pinroute/sentinel.go → src/sentinel.go
+21 -11
View File
@@ -1,7 +1,7 @@
// =============================================================================
// Auth: Alex Celani
// File: sentinel.go
// Revn: 06-26-2022 1.2
// Revn: 06-27-2022 1.3
// Func: Receive message, determine recipient, forward, get response,
// forward back
//
@@ -18,6 +18,7 @@
// 06-23-2022: removed call to parse
// 06-26-2022: refined a new route() function to check for destination
// validity
// 06-27-2022: added flag package
//
// =============================================================================
@@ -29,6 +30,7 @@ import (
"os" // Exit, Stderr, Stdin, Args
"fmt" // Println, Fprintf
"strings" // ToLower, ToUpper
"flag" // Parse, String, Bool
)
@@ -51,12 +53,9 @@ func route( recv []string ) bool {
// function to send message to third party and get response
func send( toSend string ) string {
// ip:port
// ip doesn't exist, implies localhost
service := ":1202" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
tcpAddr, err := net.ResolveTCPAddr( "tcp", *ip )
check( err ) // check error
// "dial" ( establish connection ) to destination ip & port
@@ -99,9 +98,10 @@ func handleClient( conn net.Conn ) {
// instantiate receipt variable
var recv string = string( buf[:n] )
// print recv'd message
if *verbose { // print recv'd message
// string() only works on byte SLICES so [:] is required
fmt.Println( "recv: ", recv )
}
keywords := strings.Split( recv, " " )
@@ -114,8 +114,9 @@ func handleClient( conn net.Conn ) {
resp = "led" // return list of endpoints
}
if *verbose {
fmt.Println( "node: ", resp ) // print response
}
// write that response back to original client
_, err = conn.Write( []byte( resp ) )
@@ -126,14 +127,23 @@ func handleClient( conn net.Conn ) {
}
var ( // declare global variables for flag
ip *string
self *string
verbose *bool
)
func main() {
// ip:port
// ip doesn't exist, implies localhost
service := ":1201" // capture ip address and host
// get flags for verbose, self ip and destination ip
verbose = flag.Bool( "v", false, "flag to print extra info" )
ip = flag.String( "ip", "192.168.1.169:1202", "end node ip and port" )
self = flag.String( "self", ":1201", "port of self" )
flag.Parse() // parse
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
tcpAddr, err := net.ResolveTCPAddr( "tcp", *self )
check( err ) // check error
// bind and "listen" to ip and port, according to tcp rules
three/Makefile
-9
View File
@@ -1,9 +0,0 @@
all: clean build
clean:
rm messagerA messagerB messagerC
build:
go build messagerA.go
go build messagerB.go
go build messagerC.go
three/messagerA
BIN
View File
Binary file not shown.
three/messagerA.go
-95
View File
@@ -1,95 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: messagerA.go
// Revn: 05-04-2022 0.1
// Func: Send message to another machine and then receive a single
// response
//
// TODO: comment
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-04-2022: init
//
// =============================================================================
package main
import (
"net" // ResolveTCPAddr, DialTCP, conn.Write,Read
"os" // Exit, Stdin, Stderr, Args
"fmt" // Println, Print, Fprintf
"bufio" // NewScanner, NewScanner.Scan,Text
"strings" // ToLower
"time" // Now, Sub
)
// quick function to take user input
func input( ps1 string ) string {
fmt.Print( ps1 ) // print prompt
scanner := bufio.NewScanner( os.Stdin ) // link to stdin
scanner.Scan() // pull data
return strings.ToLower( scanner.Text() ) // return lower text
}
// quick error checking
func check( err error ) {
// if user checks an error, it better be nil
if err != nil {
// put error in string, print in stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
os.Exit( 2 ) // quit
}
}
func main() {
// if len is not 2 ( ./name host:port ), print usage and quit
if len( os.Args ) != 2 {
fmt.Fprintf( os.Stderr, "Usage: %s host:port", os.Args[0] )
os.Exit( 1 )
}
service := os.Args[1] // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// "dial" ( establish connection ) to destination ip & port
// according to TCP rules
// laddr = nil -> local address is localhost
conn, err := net.DialTCP( "tcp", nil, tcpAddr )
check( err ) // check error
var in string = input( ">> " ) // get user input
start := time.Now() // start round trip timer
// convert user input to bytes and send over connection
_, err = conn.Write( []byte( in ) )
check( err ) // check error
var buf [512]byte // init byte array
// read from connection into byte array
// amount of bytes read stored in n
//n, err := conn.Read( buf[0:] )
n, err := conn.Read( buf[:] )
check( err ) // check error
t := time.Now() // stop round trip timer
// convert read bytes into string and print
fmt.Println( string( buf[:n] ) )
fmt.Println() // newline to clean up a little
fmt.Println( "rtt: ", t.Sub( start ) ) // print elapsed time
os.Exit( 0 ) // exeunt
}
three/messagerB
BIN
View File
Binary file not shown.
three/messagerB.go
-151
View File
@@ -1,151 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: messagerB.go
// Revn: 05-10-2022 0.3
// Func: Receive message, play with it, send to a third place, receive
// response, send off to first place
//
// TODO: comment
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-04-2022: init
// 05-05-2022: commented
// 05-10-2022: added argument 'n' to alter() for halving purposes
// changed passed value to alter()/forward() a slice
//
// =============================================================================
package main
import (
"net" // ResolveTCPAddr, DialTCP, conn.Write,Read,Close
// ListenTCP, listener.Accept
"os" // Exit, Stderr, Stdin, Args
"fmt" // Println, Fprintf
"strings" // ToLower, ToUpper
)
// quick error checking
func check( err error ){
// if user checks an error, it better be nil
if err != nil {
// put error in string, print to stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
os.Exit( 1 ) // quit
}
}
// function to send message to third party and get response
func quickSend( send string ) string {
// ip:port
// ip doesn't exist, implies localhost
service := ":1202" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// "dial" ( establish connection ) to destination ip & port
// according to TCP rules
// laddr = nil -> local address is localhost
conn, err := net.DialTCP( "tcp", nil, tcpAddr )
check( err ) // check error
defer conn.Close() // barring any error, still close connection
// convert user input to bytes and send over connection
_, err = conn.Write( []byte( send ) )
check( err ) // check error
var buf [512]byte // init byte array
// read from connection into byte array
// amount of bytes read stored in n
//n, err := conn.Read( buf[0:] )
n, err := conn.Read( buf[0:] )
check( err ) // check error
return string( buf[:n] ) // return only written bytes
}
// function to change received message before passing it along
func alter( recv []byte, n int ) string {
var send string = string( recv[:n/2] )
send = strings.ToUpper( send )
fmt.Println( "to c: ", send )
return send
}
// function to convert message to string before forwarding
func forward( recv []byte ) string {
return string( recv[:] )
}
// function to handle incoming connections
func handleClient( conn net.Conn ) {
defer conn.Close() // barring any error, still close connection
var buf [512]byte // declare large byte array, store messages
// iterate forever to always read over connection
for {
// read n bytes from connection into buffer
n, err := conn.Read( buf[0:] )
if err != nil { // erroring on read will simply leave the
return // function so it can start again later
}
// print recv'd message
// string() only works on byte SLICES so [:] is required
fmt.Println( "recv: ", string( buf[:] ) )
// var send string = string( buf[:n/2] )
// send = strings.ToUpper( send )
send := alter( buf[:], n ) // send message to get changed
// send := forward( buf[:] )
recv := quickSend( send ) // send message off
fmt.Println( "из c: ", recv ) // print response
// write that response back to original client
_, err = conn.Write( []byte( recv ) )
if err != nil { // erroring on write will simply leave the
return // function so it can start again later
}
}
}
func main() {
// ip:port
// ip doesn't exist, implies localhost
service := ":1201" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// bind and "listen" to ip and port, according to tcp rules
listener, err := net.ListenTCP( "tcp", tcpAddr )
check( err ) // check error
// iterate forever
// TODO i mean i can totally make this more user friendly
for {
// accept a connection that makes its way to bound port
conn, err := listener.Accept()
if err != nil { // if connection fails...
continue // don't quit program, not fatal error
}
// asynchronous function to handle connection to client
go handleClient( conn )
}
}
three/messagerC
BIN
View File
Binary file not shown.
three/messagerC.go
-118
View File
@@ -1,118 +0,0 @@
// =============================================================================
// Auth: Alex Celani
// File: messagerC.go
// Revn: 05-10-2022 0.3
// Func:
//
// TODO: create
// =============================================================================
// CHANGE LOG
// -----------------------------------------------------------------------------
// 05-04-2022: init
// 05-09-2022: began commenting
// 05-10-2022: finished commenting
// added alter() and forward()
// made passed value to alter()/forward() a slice
// changed refs to recv byte array to slice of n bytes
//
// =============================================================================
package main
import (
"net" // ResolveTCPAddr, conn.Write,Read,Close
// ListenTCP, listener.Accept
"os" // Args, Stderr, Exit
"fmt" // Fprintf, Println
"strings" // ToLower
)
// quick error checking
func check( err error ) {
// if user checks an error, it better be nil
if err != nil {
// put error in string, print in stderr
fmt.Fprintf( os.Stderr, "Fatal error: %s", err.Error() )
os.Exit( 2 ) // quit
}
}
// function to change received message before passing it along
func alter( recv []byte ) string {
var send string = string( recv[:] )
send = send + " " + send
send = strings.ToLower( send )
return send
}
// function to convert message to string before forwarding
func forward( recv []byte ) string {
return string( recv[:] )
}
// function to handle incoming connections
func handleClient( conn net.Conn ) {
defer conn.Close() // barring any error, still close connection
var buf [512]byte // declare large byte array, store messages
// iterate forever to always read over connection
for {
// read n bytes from connection into buffer
n, err := conn.Read( buf[0:] )
if err != nil { // erroring on read will simply leave the
return // function so it can start again later
}
// print recv'd message
// string() only works on byte SLICES so [:] is required
fmt.Println( "recv: ", string( buf[:n] ) )
send := alter( buf[:n] ) // send message ot get changed
// send := forward( buf[:] )
// write that response back to original client
_, err = conn.Write( []byte( send ) )
if err != nil { // erroring on write will simply leave the
return // function so it can start again later
}
fmt.Println( "sent: ", send ) // print response
}
}
func main() {
// ip:port
// ip doesn't exist, implies localhost
service := ":1202" // capture ip address and host
// "resolve" ip & host according to TCP rules
tcpAddr, err := net.ResolveTCPAddr( "tcp", service )
check( err ) // check error
// bind and "listen" to ip and port, according to tcp rules
listener, err := net.ListenTCP( "tcp", tcpAddr )
check( err ) // check error
// iterate forever
// TODO i mean i can totally make this more user friendly
for {
// accept a connection that makes its way to bound port
conn, err := listener.Accept()
if err != nil { // if connection fails...
continue // don't quit program, not fatal error
}
// asynchronous function to handle connection to client
go handleClient( conn )
}
}