func main() { eventCh := def.EventChan{ FloorReached: make(chan int), DoorTimeout: make(chan bool), DeadElevator: make(chan int, 10), } hwCh := def.HardwareChan{ MotorDir: make(chan int, 10), FloorLamp: make(chan int, 10), DoorLamp: make(chan bool, 10), BtnPressed: make(chan def.BtnPress, 10), DoorTimerReset: make(chan bool, 10), } msgCh := def.MessageChan{ Outgoing: make(chan def.Message, 10), Incoming: make(chan def.Message, 10), CostReply: make(chan def.Message, 10), NumOnline: make(chan int), } //Initialization startFloor := hw.Init() fsm.Init(eventCh, hwCh, startFloor) network.Init(msgCh.Outgoing, msgCh.Incoming) q.RunBackup(msgCh.Outgoing) go EventHandler(eventCh, msgCh, hwCh) go assigner.CollectCosts(msgCh.CostReply, msgCh.NumOnline) go safeKill() hold := make(chan bool) <-hold }
func main() { if _, err := os.Open(config.QUEUE_FILENAME); err == nil { BackupHold() queue.FileRead(config.QUEUE_FILENAME) network.Init(ch_outgoing_msg, ch_incoming_msg, ch_new_elev, ch_main_alive) } else { network.Init(ch_outgoing_msg, ch_incoming_msg, ch_new_elev, ch_main_alive) time.Sleep(time.Millisecond) if _, err := os.Create(config.QUEUE_FILENAME); err != nil { log.Fatal("FATAL: Could not create queue file!") } } backup := exec.Command("gnome-terminal", "-x", "sh", "-c", "go run main/main.go") backup.Run() if !hardware.Init() { log.Fatal("Unable to initialize elevator hardware!") } hardware.SetMotorDirection(fsm.ChooseNewDirection()) go MessageServer() go hardware.ReadButtons(ch_button_pressed) go hardware.SetLights() go hardware.FloorPoller(ch_floor_poll) go StateSpammer() go fsm.EventOrderReceived() fsm.Init(ch_outgoing_msg, ch_new_order) log.Printf("Elev addr: %s", config.Laddr) for { select { case button := <-ch_button_pressed: ch_new_order <- button if button.Button_type != config.BUTTON_COMMAND { ch_outgoing_msg <- config.Message{Msg_type: config.ADD_ORDER, Button: button} } case floor := <-ch_floor_poll: fsm.EventReachedFloor(floor) } } }
func main() { var myStateV ElevatorState myState := &myStateV for _, order := range myState.ExternalOrders { order[0] = false order[1] = false } for n, _ := range myState.InternalOrders { myState.InternalOrders[n] = false } myState.printState() // Initialize the hardware module and the channel to message with it. buttonChannel := make(chan hardware.ButtonEvent, 1) // Channel to receive buttonEvents lightChannel := make(chan hardware.LightEvent, 3) // Channel to send driver.LightEvents motorChannel := make(chan int, 1) // Channel to send MotorEvents floorChannel := make(chan hardware.FloorEvent, 1) // Channel to receive floorEvents doorTimer := time.NewTimer(5 * time.Second) // Door timer doorTimer.Stop() polldelay := time.Duration(10 * time.Millisecond) fmt.Println("ONEELEVATOR:\t Polling delay set to: %d", polldelay) defer func() { motorChannel <- typedef.DIR_STOP }() err := hardware.Init(buttonChannel, lightChannel, motorChannel, floorChannel, polldelay) // Starts the hardware polling loop. if err != nil { fmt.Println("Error initializing hardware..") return } // ---------------------- WAIT FOR EVENTS! ------------------------- for { select { case buttonEvent := <-buttonChannel: // A event has been sendt to us on the button channel. bType := buttonEvent.ButtonType if bType == typedef.BUTTON_CALL_UP || bType == typedef.BUTTON_CALL_DOWN || bType == typedef.BUTTON_COMMAND { fmt.Printf("ONEELEVATOR:\t New Order, floor: %d, buttonType: %d\n", buttonEvent.Floor, buttonEvent.ButtonType) runNow := !myState.haveOrders() fmt.Printf("ONEELEVATOR:\t Do we have other orders? \t %t\n", !runNow) lightChannel <- hardware.LightEvent{LightType: bType, Floor: buttonEvent.Floor, Value: true} if bType == typedef.BUTTON_COMMAND { myState.InternalOrders[buttonEvent.Floor] = true } else { myState.ExternalOrders[buttonEvent.Floor][bType] = true } if runNow { fmt.Println("RUNNOW: value - true") // We have no orders, exequte this one immediately. if buttonEvent.Floor > myState.Lastfloor { // We are going up! myState.Direction = typedef.DIR_UP myState.Moving = true motorChannel <- typedef.DIR_UP } else if buttonEvent.Floor < myState.Lastfloor { // We are going down. myState.Direction = typedef.DIR_DOWN myState.Moving = true motorChannel <- typedef.DIR_DOWN } else { // Ordered at current floor. motorChannel <- typedef.DIR_STOP lightChannel <- hardware.LightEvent{LightType: typedef.DOOR_LAMP, Value: true} doorTimer.Reset(5 * time.Second) myState.Moving = false myState.setOpenDoor(true) } } } else if bType == typedef.BUTTON_STOP { fmt.Printf("ONEELEVATOR:\t Received stop button event, value:\t%t\n", buttonEvent.Value) if buttonEvent.Value { motorChannel <- typedef.DIR_STOP lightChannel <- hardware.LightEvent{LightType: typedef.BUTTON_STOP, Value: true} myState.Moving = false } else { motorChannel <- myState.Direction lightChannel <- hardware.LightEvent{LightType: typedef.BUTTON_STOP, Value: false} myState.Moving = true } } myState.printState() case floorEvent := <-floorChannel: fmt.Printf("ONEELEVATOR:\t At floor: %d, direction: %d\n", floorEvent.Floor, myState.Direction) myState.setLastFloor(floorEvent.Floor) // Initialization between floors. if myState.Direction == typedef.DIR_STOP { fmt.Printf("ONEELEVATOR:\t Stopping\n") motorChannel <- typedef.DIR_STOP myState.Moving = false } if myState.shouldStop() { fmt.Printf("ONEELEVATOR:\t Stopping at this floor, direction: %d opening door for 3 sec\n", myState.Direction) // Turn off lights and clear orders. if myState.Direction == typedef.DIR_UP { lightChannel <- hardware.LightEvent{LightType: typedef.BUTTON_CALL_UP, Floor: floorEvent.Floor, Value: false} lightChannel <- hardware.LightEvent{LightType: typedef.BUTTON_COMMAND, Floor: floorEvent.Floor, Value: false} myState.InternalOrders[floorEvent.Floor] = false myState.ExternalOrders[floorEvent.Floor][1] = false // Check if we are turning around. if b := myState.nextDirection(); b == typedef.DIR_DOWN || b == typedef.DIR_STOP { lightChannel <- hardware.LightEvent{LightType: typedef.BUTTON_CALL_DOWN, Floor: floorEvent.Floor, Value: false} myState.ExternalOrders[floorEvent.Floor][0] = false } } else if myState.Direction == typedef.DIR_DOWN { lightChannel <- hardware.LightEvent{LightType: typedef.BUTTON_CALL_DOWN, Value: false} lightChannel <- hardware.LightEvent{LightType: typedef.BUTTON_COMMAND, Value: false} myState.InternalOrders[floorEvent.Floor] = false myState.ExternalOrders[floorEvent.Floor][0] = false // Check if we are turning around. if b := myState.nextDirection(); b == typedef.DIR_UP || b == typedef.DIR_STOP { lightChannel <- hardware.LightEvent{LightType: typedef.BUTTON_CALL_UP, Floor: floorEvent.Floor, Value: false} myState.ExternalOrders[floorEvent.Floor][1] = false } } motorChannel <- typedef.DIR_STOP doorTimer.Reset(3 * time.Second) lightChannel <- hardware.LightEvent{LightType: typedef.DOOR_LAMP, Value: true} myState.Moving = false myState.setOpenDoor(true) } myState.printState() case <-doorTimer.C: myState.setOpenDoor(false) lightChannel <- hardware.LightEvent{LightType: typedef.DOOR_LAMP, Value: false} fmt.Printf("ONEELEVATOR:\t Door timeout.\n") if b := myState.haveOrders(); !b { fmt.Printf("ONEELEVATOR:\t No orders, staying at floor.\n") myState.setDirection(typedef.DIR_STOP) } else if myState.Direction == typedef.DIR_UP && myState.haveOrderAbove() { fmt.Println("ONEELEVATOR:\t Have order above, and direction upwards.. Continuing.") myState.setMoving(true) motorChannel <- typedef.DIR_UP } else if myState.Direction == typedef.DIR_DOWN && myState.haveOrderBelow() { fmt.Println("ONEELEVATOR:\t Have order above, and direction downwards.. Continuing.") myState.setMoving(true) motorChannel <- typedef.DIR_DOWN } else if myState.haveOrderBelow() { fmt.Println("ONEELEVATOR:\t Have order below.. Go down.") myState.setMoving(true) motorChannel <- typedef.DIR_DOWN myState.setDirection(typedef.DIR_DOWN) } else if myState.haveOrderAbove() { fmt.Println("ONEELEVATOR:\t Have order above.. Go up.") myState.setMoving(true) motorChannel <- typedef.DIR_UP myState.setDirection(typedef.DIR_UP) } } myState.printState() } }