Ejemplo n.º 1
0
Archivo: blink.go Proyecto: FyIoT/hwio
func main() {
	// get a pin by name. You could also just use the logical pin number, but this is
	// more readable. On BeagleBone, USR0 is an on-board LED.
	ledPin, err := hwio.GetPin("USR1")

	// Generally we wouldn't expect an error, but perhaps someone is running this a
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	// Set the mode of the pin to output. This will return an error if, for example,
	// we were trying to set an analog input to an output.
	err = hwio.PinMode(ledPin, hwio.OUTPUT)

	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	// Run the blink forever
	for {
		hwio.DigitalWrite(ledPin, hwio.HIGH)
		hwio.Delay(1000)
		hwio.DigitalWrite(ledPin, hwio.LOW)
		hwio.Delay(1000)
	}
}
Ejemplo n.º 2
0
func readButton(name string, buttonPin hwio.Pin, ledPin hwio.Pin) {

	//value readed from button, initially set to 0, because the button will not pressed
	oldValue := 0

	t1 := time.Now()

	// loop
	for {
		// Read the button value
		value, e := hwio.DigitalRead(buttonPin)
		if e != nil {
			panic(e)
		}
		t1 = time.Now() // time at this point
		// Did value change?
		if value != oldValue {
			fmt.Printf("[%s] %v (%d)\n", name, t1.Sub(t0), value)
			oldValue = value

			// Write the value to the led.
			if value == 1 {
				hwio.DigitalWrite(ledPin, hwio.HIGH)
			} else {
				hwio.DigitalWrite(ledPin, hwio.LOW)
			}
		}
	}

}
Ejemplo n.º 3
0
func readTracker(name string, trackerPin hwio.Pin) {

	oldValue := 0            //value readed from tracker, initially set to 0, because the tracker was innactive
	timeAction := time.Now() // time of the action detected

	// loop
	for theAcq.getState() != stateSTOPPED {
		// Read the tracker value
		value, e := hwio.DigitalRead(trackerPin)
		if e != nil {
			panic(e)
		}
		//timeActionOld=timeAction //store the last time
		timeAction = time.Now() // time at this point
		// Did value change?
		if (value == 1) && (value != oldValue) {
			if theAcq.getState() != statePAUSED {
				dataString := fmt.Sprintf("[%s], %v, %d\n",
					name, timeAction.Sub(theAcq.getTime0()), value)
				log.Println(dataString)
				theAcq.outputFile.WriteString(dataString)
			}

			// Write the value to the led indicating somewhat is happened
			if value == 1 {
				hwio.DigitalWrite(theOshi.actionLed, hwio.HIGH)
			} else {
				hwio.DigitalWrite(theOshi.actionLed, hwio.LOW)
			}
		}
		oldValue = value
	}
}
Ejemplo n.º 4
0
func blinkingLed(ledPin hwio.Pin) int {
	// loop
	for {
		hwio.DigitalWrite(ledPin, hwio.HIGH)
		hwio.Delay(500)
		hwio.DigitalWrite(ledPin, hwio.LOW)
		hwio.Delay(500)
	}
}
Ejemplo n.º 5
0
func (h *Hardware) SetStrike(state string) {
	switch state {
	case "unlocked":
		hwio.DigitalWrite(h.OutStrike, 1)
	case "locked":
		hwio.DigitalWrite(h.OutStrike, 0)
	default:
		panic(errors.New("unknown state"))
	}
	h.LastOutStrike = state
}
Ejemplo n.º 6
0
func (h *Hardware) SetLed(state string) {
	switch state {
	case "on":
		hwio.DigitalWrite(h.OutLed, 1)
	case "off":
		hwio.DigitalWrite(h.OutLed, 0)
	default:
		panic(errors.New("unknown state"))
	}
	h.LastOutLed = state
}
Ejemplo n.º 7
0
func resumeHandler(w http.ResponseWriter, r *http.Request) {

	theAcq.setStateRUNNING()

	p := &Page{Title: "Start", Body: "State: " + theAcq.state}
	hwio.DigitalWrite(theOshi.statusLed, hwio.HIGH)

	renderTemplate(w, "start", p)
}
Ejemplo n.º 8
0
func main() {

	//value readed from button, initially set to 0, because the button will not pressed
	oldValue := 0

	// Set up 'button' as an input
	button, e := hwio.GetPinWithMode(buttonPin, hwio.INPUT)
	if e != nil {
		panic(e)
	}

	// Set up 'led' as an output
	led, e := hwio.GetPinWithMode(ledPin, hwio.OUTPUT)
	if e != nil {
		panic(e)
	}

	fmt.Printf("Beginning.....\n")
	t0 := time.Now() // time 0

	for {
		// Read the button value
		value, e := hwio.DigitalRead(button)
		t1 := time.Now() // time at this point
		if e != nil {
			panic(e)
		}

		// Did value change?
		if value != oldValue {
			fmt.Printf("[%v] %d\n", t1.Sub(t0), value)
			oldValue = value

			// Write the value to the led.
			if value == 1 {
				hwio.DigitalWrite(led, hwio.HIGH)
			} else {
				hwio.DigitalWrite(led, hwio.LOW)
			}
		}

	}
}
Ejemplo n.º 9
0
func stopHandler(w http.ResponseWriter, r *http.Request) {

	theAcq.setStateSTOPPED()
	hwio.DigitalWrite(theOshi.statusLed, hwio.LOW)
	log.Println("Finnishing.....")
	// close the GPIO pins
	//hwio.CloseAll()
	theAcq.closeOutputFile() //close the file when finished
	p := &Page{Title: "Stop", Body: "State: " + theAcq.state}
	renderTemplate(w, "stop", p)
	//log.Printf("There are %v goroutines", runtime.NumGoroutine())
}
Ejemplo n.º 10
0
func readTracker(name string, trackerPin hwio.Pin) {

	//value readed from tracker, initially set to 0, because the tracker was innactive
	oldValue := 0

	timeAction := time.Now()    // time of the action detected
	timeActionOld := time.Now() // time of the action-1 detected

	//fmt.Printf("[%s] File: %s\n",name,outputFile)

	// loop
	for {
		// Read the tracker value
		value, e := hwio.DigitalRead(trackerPin)
		if e != nil {
			panic(e)
		}
		timeActionOld = timeAction //store the last time
		timeAction = time.Now()    // time at this point
		// Did value change?
		if value != oldValue {
			dataString := fmt.Sprintf("[%s] %v (%v) -> %d\n",
				name, timeAction.Sub(t0), timeAction.Sub(timeActionOld), value)
			//fmt.Printf("[%s] %v (%v) -> %d\n",
			//           name,timeAction.Sub(t0),timeAction.Sub(timeActionOld),value)
			fmt.Printf(dataString)
			outputFile.WriteString(dataString)
			oldValue = value

			// Write the value to the led indicating somewhat is happened
			if value == 1 {
				hwio.DigitalWrite(actionLed, hwio.HIGH)
			} else {
				hwio.DigitalWrite(actionLed, hwio.LOW)
			}
		}
	}
}
Ejemplo n.º 11
0
func main() {
	// Get the pins we're going to use. These are on a beaglebone.
	sinPin, _ := hwio.GetPin("P9.11")
	sclkPin, _ := hwio.GetPin("P9.12")
	xlatPin, _ := hwio.GetPin("P9.13")
	gsclkPin, _ := hwio.GetPin("P9.14")
	blankPin, _ := hwio.GetPin("P9.15")

	fmt.Printf("Pins are: sin=%d, sclk=%d, xlat=%d, gsclk=%d, blank=%d", sinPin, sclkPin, xlatPin, gsclkPin, blankPin)
	// Make them all outputs
	e := hwio.PinMode(sinPin, hwio.OUTPUT)
	if e == nil {
		hwio.PinMode(sclkPin, hwio.OUTPUT)
	}
	if e == nil {
		hwio.PinMode(xlatPin, hwio.OUTPUT)
	}
	if e == nil {
		hwio.PinMode(gsclkPin, hwio.OUTPUT)
	}
	if e == nil {
		hwio.PinMode(blankPin, hwio.OUTPUT)
	}
	if e != nil {
		fmt.Printf("Could not initialise pins: %s", e)
		return
	}

	// set clocks low
	hwio.DigitalWrite(sclkPin, hwio.LOW)
	hwio.DigitalWrite(xlatPin, hwio.LOW)
	hwio.DigitalWrite(gsclkPin, hwio.LOW)

	// run GS clock in it's own space
	hwio.DigitalWrite(blankPin, hwio.HIGH)
	hwio.DigitalWrite(blankPin, hwio.LOW)
	clockData(gsclkPin)

	for b := 0; b < 4096; b++ {
		writeData(uint(b), sinPin, sclkPin, xlatPin)

		for j := 0; j < 10; j++ {
			hwio.DigitalWrite(blankPin, hwio.HIGH)
			hwio.DigitalWrite(blankPin, hwio.LOW)
			clockData(gsclkPin)
		}

		//		hwio.Delay(100)
	}

	//		hwio.ShiftOut(dataPin, clockPin, uint(data), hwio.MSBFIRST)
}
Ejemplo n.º 12
0
func main() {
	// Get the pins we're going to use. These are on a beaglebone.
	dataPin, _ := hwio.GetPin("P8.3")  // connected to pin 14
	clockPin, _ := hwio.GetPin("P8.4") // connected to pin 11
	storePin, _ := hwio.GetPin("P8.5") // connected to pin 12

	// Make them all outputs
	hwio.PinMode(dataPin, hwio.OUTPUT)
	hwio.PinMode(clockPin, hwio.OUTPUT)
	hwio.PinMode(storePin, hwio.OUTPUT)

	data := 0

	// Set the initial state of the clock and store pins to low. These both
	// trigger on the rising edge.
	hwio.DigitalWrite(clockPin, hwio.LOW)
	hwio.DigitalWrite(storePin, hwio.LOW)

	for {
		// Shift out 8 bits
		hwio.ShiftOut(dataPin, clockPin, uint(data), hwio.MSBFIRST)

		// You can use this line instead to clock out 16 bits if you have
		// two 74HC595's chained together
		// hwio.ShiftOutSize(dataPin, clockPin, uint(data), hwio.MSBFIRST, 16)

		// Pulse the store pin once
		hwio.DigitalWrite(storePin, hwio.HIGH)
		hwio.DigitalWrite(storePin, hwio.LOW)

		// Poor humans cannot read binary as fast as the machine can display it
		hwio.Delay(100)

		data++
	}
}
Ejemplo n.º 13
0
func startHandler(w http.ResponseWriter, r *http.Request) {

	// manage file depending the previous state
	if theAcq.getState() == stateSTOPPED {
		theAcq.reopenOutputFile()
		log.Printf("Reopen file %s\n", theAcq.outputFile)
	}

	// sets the new time0 only with a new scenery
	if theAcq.getState() == stateNEW {
		theAcq.setTime0()
	}

	theAcq.setStateRUNNING()

	//waitTillButtonPushed(buttonA)
	p := &Page{Title: "Start", Body: "State: " + theAcq.state}
	hwio.DigitalWrite(theOshi.statusLed, hwio.HIGH)
	log.Println("Beginning.....")

	renderTemplate(w, "start", p)

	// launch the trackers

	log.Printf("There are %v goroutines", runtime.NumGoroutine())
	log.Printf("Launching the Gourutines")

	go theAcq.readFromArduino2()
	log.Println("Started Arduino")
	go readTracker("A", theOshi.trackerA)
	log.Println("Started Tracker A")
	go readTracker("B", theOshi.trackerB)
	log.Println("Started Tracker B")
	go readTracker("C", theOshi.trackerC)
	log.Println("Started Tracker C")
	go readTracker("D", theOshi.trackerD)
	log.Println("Started Tracker D")

	log.Printf("There are %v goroutines", runtime.NumGoroutine())
}
Ejemplo n.º 14
0
// val is a 12-bit int
func writeData(val uint, sinPin hwio.Pin, sclkPin hwio.Pin, xlatPin hwio.Pin) {
	fmt.Printf("writing data %d\n", val)
	bits := 0
	mask := uint(1) << 11
	for i := 0; i < 16; i++ {
		v := val
		for j := 0; j < 12; j++ {
			if (v & mask) != 0 {
				hwio.DigitalWrite(sinPin, hwio.HIGH)
			} else {
				hwio.DigitalWrite(sinPin, hwio.HIGH)
			}
			hwio.DigitalWrite(sclkPin, hwio.HIGH)
			hwio.DigitalWrite(sclkPin, hwio.LOW)

			v = v << 1
			bits++
		}
	}

	hwio.DigitalWrite(xlatPin, hwio.HIGH)
	hwio.DigitalWrite(xlatPin, hwio.LOW)
	fmt.Printf("Wrote %d bits\n", bits)
}
Ejemplo n.º 15
0
func clockData(gsclkPin hwio.Pin) {
	for g := 0; g < 4096; g++ {
		hwio.DigitalWrite(gsclkPin, hwio.HIGH)
		hwio.DigitalWrite(gsclkPin, hwio.LOW)
	}
}
Ejemplo n.º 16
0
Archivo: car.go Proyecto: arges/cargo
func (c *Car) Motor(v1, v2, v3, v4 int) {
	hwio.DigitalWrite(c.pins[in1], v1)
	hwio.DigitalWrite(c.pins[in2], v2)
	hwio.DigitalWrite(c.pins[in3], v3)
	hwio.DigitalWrite(c.pins[in4], v4)
}
Ejemplo n.º 17
0
func (acq *Acquisition) readFromArduino() {

	var register, reg []byte
	// operate with the gobal variables theSensorData and theSensorDataInBytes; more speed?

	// don't use the first readding ??  I'm not sure about that
	reader := bufio.NewReader(acq.serialPort)
	// find the begging of an stream of data from the sensors
	register, err := reader.ReadBytes('\x24')
	if err != nil {
		log.Fatal(err)
	}
	//log.Println(register)
	//log.Printf(">>>>>>>>>>>>>>")

	// loop
	for acq.getState() != stateSTOPPED {
		// Read the serial and decode

		register = nil
		reg = nil

		//n, err = s.Read(register)
		for len(register) < 38 { // in case of \x24 chars repeted the length will be less than the expected 38 bytes
			reg, err = reader.ReadBytes('\x24')
			if err != nil {
				log.Fatal(err)
			}
			register = append(register, reg...)
		}

		receptionTime := time.Now() // time of the action detected

		if register[0] == '\x23' { // if first byte is '#', lets decode the stream of bytes in register

			//decode the register

			theSensorDataInBytes.sincroMicroSecondsInBytes = register[1:5]
			buf := bytes.NewReader(theSensorDataInBytes.sincroMicroSecondsInBytes)
			err = binary.Read(buf, binary.LittleEndian, &theSensorData.sincroMicroSeconds)

			theSensorDataInBytes.sensorMicroSecondsInBytes = register[5:9]
			buf = bytes.NewReader(theSensorDataInBytes.sensorMicroSecondsInBytes)
			err = binary.Read(buf, binary.LittleEndian, &theSensorData.sensorMicroSeconds)

			theSensorDataInBytes.distanceInBytes = register[9:13]
			buf = bytes.NewReader(theSensorDataInBytes.distanceInBytes)
			err = binary.Read(buf, binary.LittleEndian, &theSensorData.distance)

			theSensorDataInBytes.accXInBytes = register[13:17]
			buf = bytes.NewReader(theSensorDataInBytes.accXInBytes)
			err = binary.Read(buf, binary.LittleEndian, &theSensorData.accX)

			theSensorDataInBytes.accYInBytes = register[17:21]
			buf = bytes.NewReader(theSensorDataInBytes.accYInBytes)
			err = binary.Read(buf, binary.LittleEndian, &theSensorData.accY)

			theSensorDataInBytes.accZInBytes = register[21:25]
			buf = bytes.NewReader(theSensorDataInBytes.accZInBytes)
			err = binary.Read(buf, binary.LittleEndian, &theSensorData.accZ)

			theSensorDataInBytes.gyrXInBytes = register[25:29]
			buf = bytes.NewReader(theSensorDataInBytes.gyrXInBytes)
			err = binary.Read(buf, binary.LittleEndian, &theSensorData.gyrX)

			theSensorDataInBytes.gyrYInBytes = register[29:33]
			buf = bytes.NewReader(theSensorDataInBytes.gyrYInBytes)
			err = binary.Read(buf, binary.LittleEndian, &theSensorData.gyrY)

			theSensorDataInBytes.gyrZInBytes = register[33:37]
			buf = bytes.NewReader(theSensorDataInBytes.gyrZInBytes)
			err = binary.Read(buf, binary.LittleEndian, &theSensorData.gyrZ)

		} // if

		if acq.getState() != statePAUSED {
			//compound the dataline and write to the output
			//receptionTime= time.Now() // Alternative: time at this point
			dataString := fmt.Sprintf("[%s], %d, %d, %d, %d, %f, %f, %f, %f, %f, %f\n",
				"Ard", int64(receptionTime.Sub(theAcq.getTime0())/time.Microsecond),
				theSensorData.sincroMicroSeconds, theSensorData.sensorMicroSeconds, theSensorData.distance,
				theSensorData.accX, theSensorData.accY, theSensorData.accZ,
				theSensorData.gyrX, theSensorData.gyrY, theSensorData.gyrZ)

			log.Println(dataString)
			acq.outputFile.WriteString(dataString)
		}
		// Write the value to the led indicating somewhat is happened
		hwio.DigitalWrite(theOshi.actionLed, hwio.HIGH)
		hwio.DigitalWrite(theOshi.actionLed, hwio.LOW)
	}
}
Ejemplo n.º 18
0
// Run is the block's main loop. Here we listen on the different channels we set up.
func (b *ToDigitalPin) Run() {
	var pin hwio.Pin
	var pinStr string
	var tree *jee.TokenTree
	var path string
	var err error
	for {
		select {
		case ruleI := <-b.inrule:
			path, err = util.ParseString(ruleI, "Path")
			if err != nil {
				b.Error(err)
				continue
			}
			token, err := jee.Lexer(path)
			if err != nil {
				b.Error(err)
				continue
			}
			tree, err = jee.Parser(token)
			if err != nil {
				b.Error(err)
				continue
			}
			if pinStr != "" {
				b.Log("closing pin " + pinStr)
				err = hwio.ClosePin(pin)
				if err != nil {
					b.Error(err)
				}
			}
			pinStr, err = util.ParseString(ruleI, "Pin")
			if err != nil {
				b.Error(err)
				continue
			}
			pin, err = hwio.GetPin(pinStr)
			if err != nil {
				pinStr = ""
				pin = 0
				b.Error(err)
				continue
			}
			err = hwio.PinMode(pin, hwio.OUTPUT)
			if err != nil {
				b.Error(err)
				continue
			}
		case <-b.quit:
			// quit the block
			err = hwio.ClosePin(pin)
			b.Error(err)
			return
		case c := <-b.queryrule:
			// deal with a query request
			c <- map[string]interface{}{
				"Pin":  pinStr,
				"Path": path,
			}
		case msg := <-b.in:
			if tree == nil {
				continue
			}
			valI, err := jee.Eval(tree, msg)
			if err != nil {
				b.Error(err)
				continue
			}
			val, ok := valI.(float64)
			if !ok {
				log.Println(msg)
				b.Error(errors.New("couldn't assert value to a float"))
				continue
			}
			if int(val) == 0 {
				hwio.DigitalWrite(pin, hwio.LOW)
			} else if int(val) == 1 {
				hwio.DigitalWrite(pin, hwio.HIGH)
			} else {
				b.Error(errors.New("value must be 0 for LOW and 1 for HIGH"))
				continue
			}

		}
	}
}
Ejemplo n.º 19
0
func (acq *Acquisition) readFromArduino2() {

	var register, reg []byte
	var microSecondsInBytes []byte
	var distanceInBytes []byte
	var accXInBytes []byte
	var accYInBytes []byte
	var accZInBytes []byte
	var gyrXInBytes []byte
	var gyrYInBytes []byte
	var gyrZInBytes []byte
	var sincro byte
	var microSeconds uint32
	var distance uint32
	var accX float32
	var accY float32
	var accZ float32
	var gyrX float32
	var gyrY float32
	var gyrZ float32

	// don't use the first readding ??  I'm not sure about that
	reader := bufio.NewReader(acq.serialPort)
	// find the begging of an stream of data from the sensors
	register, err := reader.ReadBytes('\x24')
	if err != nil {
		log.Fatal(err)
	}
	//log.Println(register)
	//log.Printf(">>>>>>>>>>>>>>")

	// loop
	for acq.getState() != stateSTOPPED {
		// Read the serial and decode

		register = nil
		reg = nil

		//n, err = s.Read(register)
		for len(register) < 34 { // in case of \x24 chars repeted
			reg, err = reader.ReadBytes('\x24')
			if err != nil {
				log.Fatal(err)
			}
			register = append(register, reg...)
		}

		timeAction := time.Now() // time of the action detected

		if register[0] == '\x23' || register[0] == '\x64' {

			//decode the register

			if register[0] == '\x64' {
				sincro = 1 //sincro signal
			} else {
				sincro = 0
			}
			microSecondsInBytes = register[1:5]
			buf := bytes.NewReader(microSecondsInBytes)
			err = binary.Read(buf, binary.LittleEndian, &microSeconds)

			distanceInBytes = register[5:9]
			buf = bytes.NewReader(distanceInBytes)
			err = binary.Read(buf, binary.LittleEndian, &distance)

			accXInBytes = register[9:13]
			buf = bytes.NewReader(accXInBytes)
			err = binary.Read(buf, binary.LittleEndian, &accX)

			accYInBytes = register[13:17]
			buf = bytes.NewReader(accYInBytes)
			err = binary.Read(buf, binary.LittleEndian, &accY)

			accZInBytes = register[17:21]
			buf = bytes.NewReader(accZInBytes)
			err = binary.Read(buf, binary.LittleEndian, &accZ)

			gyrXInBytes = register[21:25]
			buf = bytes.NewReader(gyrXInBytes)
			err = binary.Read(buf, binary.LittleEndian, &gyrX)

			gyrYInBytes = register[25:29]
			buf = bytes.NewReader(gyrYInBytes)
			err = binary.Read(buf, binary.LittleEndian, &gyrY)

			gyrZInBytes = register[29:33]
			buf = bytes.NewReader(gyrZInBytes)
			err = binary.Read(buf, binary.LittleEndian, &gyrZ)

		} // if

		if acq.getState() != statePAUSED {
			//compound the dataline and write to the output
			//timeAction= time.Now() // Alternative: time at this point
			dataString := fmt.Sprintf("[%s], %v, %v, %v, %v, %v, %v, %v, %v, %v, %v\n",
				"Ard", timeAction.Sub(theAcq.getTime0()),
				sincro, microSeconds, distance,
				accX, accY, accZ,
				gyrX, gyrY, gyrZ)

			log.Println(dataString)
			acq.outputFile.WriteString(dataString)
		}
		// Write the value to the led indicating somewhat is happened
		hwio.DigitalWrite(theOshi.actionLed, hwio.HIGH)
		hwio.DigitalWrite(theOshi.actionLed, hwio.LOW)
	}
}
Ejemplo n.º 20
0
func main() {

	// setup

	// open file (create if not exists!)
	if len(os.Args) != 2 {

		fmt.Printf("Usage: %s fileBaseName\n", os.Args[0])
		os.Exit(1)
	}

	t := time.Now()
	thisOutputFileName := fmt.Sprintf("%s_%d%02d%02d%02d%02d%02d.csv", os.Args[1], t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
	thisOutputFile, e := os.Create(thisOutputFileName)
	if e != nil {
		panic(e)
	}
	fmt.Printf("File: %s\n", thisOutputFileName)

	outputFile = thisOutputFile

	// Set up 'trakers' as inputs
	trackerA, e := hwio.GetPinWithMode(trackerAPin, hwio.INPUT)
	if e != nil {
		panic(e)
	}
	trackerB, e := hwio.GetPinWithMode(trackerBPin, hwio.INPUT)
	if e != nil {
		panic(e)
	}
	trackerC, e := hwio.GetPinWithMode(trackerCPin, hwio.INPUT)
	if e != nil {
		panic(e)
	}
	trackerD, e := hwio.GetPinWithMode(trackerDPin, hwio.INPUT)
	if e != nil {
		panic(e)
	}

	// Set up 'buttons' as inputs
	buttonA, e := hwio.GetPinWithMode(buttonAPin, hwio.INPUT)
	if e != nil {
		panic(e)
	}
	buttonB, e := hwio.GetPinWithMode(buttonBPin, hwio.INPUT)
	if e != nil {
		panic(e)
	}

	// Set up 'leds' as outputs
	statusLed, e := hwio.GetPinWithMode(statusLedPin, hwio.OUTPUT)
	if e != nil {
		panic(e)
	}
	thisActionLed, e := hwio.GetPinWithMode(actionLedPin, hwio.OUTPUT)
	if e != nil {
		panic(e)
	}
	actionLed = thisActionLed

	fmt.Printf("Push button A to start, B to finish...\n")

	// read the button A change to init the data readdings
	waitTillButtonPushed(buttonA)
	hwio.DigitalWrite(statusLed, hwio.HIGH)
	t0 = time.Now()
	fmt.Printf("Beginning.....\n")

	// launch the trackers

	go readTracker("A", trackerA)
	go readTracker("B", trackerB)
	go readTracker("C", trackerC)
	go readTracker("D", trackerD)

	// wait till button B is pushed
	waitTillButtonPushed(buttonB)
	hwio.DigitalWrite(statusLed, hwio.LOW)
	fmt.Printf("Finnishing.....\n")

	//fmt.Print("Enter to finish: ")
	//var input string
	//fmt.Scanln(&input)

	// close the GPIO pins
	defer hwio.CloseAll()

	defer thisOutputFile.Close() //close the file when main finished

}