Esempio n. 1
0
func main() {
	if len(os.Args) != 4 {
		fmt.Fprintf(os.Stderr, "%v <device> <baud> <data>\n", os.Args[0])
		os.Exit(1)
	}

	baud, err := strconv.Atoi(os.Args[2])
	if err != nil {
		fmt.Fprintf(os.Stderr, "baud must be numerical\n")
		os.Exit(1)
	}

	c := &goserial.Config{Name: os.Args[1], Baud: baud}
	s, err := goserial.OpenPort(c)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error connecting to device: %v\n", err)
		os.Exit(2)
	}

	err = sendBytes(s, []byte(os.Args[3]))
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error writing data: %v\n", err)
		os.Exit(3)
	}
}
Esempio n. 2
0
func openSerialPortOrExit() io.ReadWriteCloser {
	c := &goserial.Config{Name: serialPort, Baud: serialBaud}
	ser, err := goserial.OpenPort(c)
	if err != nil {
		log.Printf("Could not connect to serial port %s.", serialPort)
		log.Fatal(err)
	}
	return ser
}
Esempio n. 3
0
func main() {
	flag.Parse()

	sink, err := carbon.DialClient(net.TCPAddr{net.IPv4(127, 0, 0, 1), 2003})
	if err != nil {
		log.Fatal(err)
	}

	routerAddr := net.UDPAddr{net.IPv4(192, 168, 1, 1), 161}
	routerScrapers := scraper.ScrapingPoller{
		Ticks: time.Tick(10 * time.Second),
		Scrapers: []scraper.PolledScraper{
			&snmp.Counter32Scraper{
				Sender: sink.NewUint32Sender("network.router.wan.inBytes"),
				Addr:   routerAddr,
				OID:    []int{1, 3, 6, 1, 2, 1, 2, 2, 1, 10, 2},
			},
			&snmp.Counter32Scraper{
				Sender: sink.NewUint32Sender("network.router.wan.outBytes"),
				Addr:   routerAddr,
				OID:    []int{1, 3, 6, 1, 2, 1, 2, 2, 1, 16, 2},
			},
		},
	}

	allScrapers := []scraper.PassiveScraper{
		&routerScrapers,
	}

	// TODO: Use a serial port instead. For now this just reads and parses data
	// from the given file for testing.
	if *currentCostFile != "" {
		serialConfig := &goserial.Config{
			Name:     *currentCostFile,
			Baud:     57600,
			Parity:   goserial.ParityNone,
			Size:     goserial.ByteSize8,
			StopBits: goserial.StopBits1,
		}
		if serial, err := goserial.OpenPort(serialConfig); err != nil {
			log.Print(err)
		} else {
			defer serial.Close()
			allScrapers = append(allScrapers, cc.NewScraper(cc.Config{
				Serial: serial,
			}))
		}
	}

	for _, s := range allScrapers {
		fmt.Printf("scraper: %s\n", s)
	}

	scraper.RunPassiveScrapers(allScrapers)

	select {}
}
// Open a device and set various control parameters, such as baud rate.
func open(tty string) io.ReadWriteCloser {
	c := &serial.Config{Name: tty, Baud: 115200}
	// out, err = os.OpenFile(tty, os.O_RDWR, 0x666) // ,
	out, err := serial.OpenPort(c)
	if err != nil {
		log.Fatalf("Unable to open %s: %v", tty, err)
	}
	return out
}
Esempio n. 5
0
func sendLCDStr(serialConfigure *goserial.Config, str *lcdString, fin chan bool) {
	for {
		str = lcdStringBuffer
		shiftCoord := len(str.c) * 16
		for i := 0; i < shiftCoord+96+1; i++ {
			serialPort, _ := goserial.OpenPort(serialConfigure)
			packet := createPacket(*str, i-96)
			writeLCDMatrix(packet, serialPort)
			//time.Sleep(1 * time.Millisecond)
			serialPort.Close()
		}
	}
	fin <- true
}
Esempio n. 6
0
// Axon listens to the dentrites on the deltaE channel, and embodies an artificial neurone. When the energy
// of the neurone reaches a maximum, it fires into the axon (the web dendites of adjacent neurones).
func axon(deltaE chan float32, config Configuration) {
	// Find the device that represents the arduino serial connection.
	c := &goserial.Config{Name: findArduino(), Baud: 9600}
	s, _ := goserial.OpenPort(c)

	// When connecting to an older revision arduino, you need to wait a little while it resets.
	time.Sleep(1 * time.Second)

	neurone := Neurone{-2.0, deltaE, waitLength, time.Now().UnixNano(), config}
	state := wait

	for {
		state, neurone = state(neurone, s)

		fmt.Printf("INFO: e[%f]\n", neurone.energy)
	}
}
Esempio n. 7
0
File: gocc.go Progetto: huin/gocc
// NewSerialMessageReader opens the named serial port, configures it for
// reading Current Cost data, and returns a MessageReader for doing so.
func NewSerialMessageReader(serialPath string) (*MessageReader, error) {
	serialConfig := &goserial.Config{
		Name:     serialPath,
		Baud:     57600,
		Parity:   goserial.ParityNone,
		Size:     goserial.Byte8,
		StopBits: goserial.StopBits1,
	}

	var serial io.ReadCloser
	var err error
	if serial, err = goserial.OpenPort(serialConfig); err != nil {
		return nil, err
	}

	return NewMessageReader(serial), nil
}
Esempio n. 8
0
func NewMcs() *Mcs {
	m := new(Mcs)
	m.Tree = typefaster.NewDiskTree(*treename)
	m.Cnode = m.Tree.Root()
	c := new(goserial.Config)
	c.Name = "/dev/ttyAMA0"
	c.Baud = 9600
	s, err := goserial.OpenPort(c)
	if err != nil {
		log.Fatal(err)
	}

	n, err := s.Write([]byte{97})
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("serial write got back", n)
	}
	m.serial = s

	return m
}
Esempio n. 9
0
func NewUART(nr UARTNr, baud int, size UARTByteSize, parity UARTParityMode, stopBits UARTStopBits) (*UART, error) {
	dt := fmt.Sprintf("ADAFRUIT-UART%d", nr)
	err := LoadDeviceTree(dt)
	if err != nil {
		return nil, err
	}

	uart := &UART{nr: nr}

	config := &goserial.Config{
		Name:     fmt.Sprintf("/dev/ttyO%d", nr),
		Baud:     baud,
		Size:     goserial.ByteSize(size),
		Parity:   goserial.ParityMode(parity),
		StopBits: goserial.StopBits(stopBits),
	}
	uart.serial, err = goserial.OpenPort(config)
	if err != nil {
		return nil, err
	}

	return uart, nil
}
Esempio n. 10
0
func (mod *SerialBee) Run(eventChan chan bees.Event) {
	if mod.baudrate == 0 || mod.device == "" {
		return
	}

	var err error
	c := &goserial.Config{Name: mod.device, Baud: mod.baudrate}
	mod.conn, err = goserial.OpenPort(c)
	if err != nil {
		log.Fatal(err)
	}
	time.Sleep(1 * time.Second)

	for {
		//FIXME: don't block
		select {
		case <-mod.SigChan:
			return

		default:
		}

		text := ""
		c := []byte{0}
		for {
			_, err := mod.conn.Read(c)
			if err != nil {
				time.Sleep(1 * time.Second)
				continue
			}
			if c[0] == 10 || c[0] == 13 {
				break
			}

			text += string(c[0])
		}

		if len(text) > 0 {
			text = strings.TrimSpace(text)

			ev := bees.Event{
				Bee:  mod.Name(),
				Name: "message",
				Options: []bees.Placeholder{
					bees.Placeholder{
						Name:  "port",
						Type:  "string",
						Value: mod.device,
					},
					bees.Placeholder{
						Name:  "text",
						Type:  "string",
						Value: text,
					},
				},
			}
			eventChan <- ev
		}
		time.Sleep(1 * time.Second)
	}
}