コード例 #1
0
ファイル: Light.go プロジェクト: powareverb/driver-block
func NewLight(driver *Driver, D int, name string, port *arduino.Arduino) error {
	light, err := devices.CreateLightDevice(driver, &model.Device{
		NaturalID:     fmt.Sprintf("%s-%d", config.Serial(), D),
		NaturalIDType: "block-arduino",
		Name:          &name,
		Signatures: &map[string]string{
			"ninja:manufacturer": "Ninja Blocks Inc",
			"ninja:productType":  "Light",
			"ninja:thingType":    "light",
		},
	}, driver.Conn)

	if err != nil {
		log.FatalError(err, "Could not create light device")
	}

	if err := light.EnableOnOffChannel(); err != nil {
		log.FatalError(err, "Could not enable hue on-off channel")
	}

	if err := light.EnableBrightnessChannel(); err != nil {
		log.FatalError(err, "Could not enable hue brightness channel")
	}

	if err := light.EnableColorChannel("temperature", "hue"); err != nil {
		log.FatalError(err, "Could not enable color channel")
	}

	port.OnDeviceData(func(data arduino.DeviceData) {
		if data.D == D {
			spew.Dump("Light Data!", data)
		}
	})

	return nil
}
コード例 #2
0
ファイル: driver.go プロジェクト: ninjasphere/driver-go-lifx
func (d *LifxDriver) newLight(bulb *lifx.Bulb) (*devices.LightDevice, error) { //TODO cut this down!

	name := bulb.GetLabel()

	d.log.Infof("Making light with ID: %s Label: %s", bulb.GetLifxAddress(), name)

	light, err := devices.CreateLightDevice(d, &model.Device{
		NaturalID:     bulb.GetLifxAddress(),
		NaturalIDType: "lifx",
		Name:          &name,
		Signatures: &map[string]string{
			"ninja:manufacturer": "Lifx",
			"ninja:productName":  "Lifx Bulb",
			"ninja:productType":  "Light",
			"ninja:thingType":    "light",
		},
	}, d.conn)

	if err != nil {
		d.log.FatalError(err, "Could not create light device")
	}

	light.ApplyOnOff = func(state bool) error {
		var err error
		if state {
			err = d.client.LightOn(bulb)
		} else {
			err = d.client.LightOff(bulb)
		}
		if err != nil {
			return fmt.Errorf("Failed to set on-off state: %s", err)
		}
		return nil
	}

	light.ApplyLightState = func(state *devices.LightDeviceState) error {
		jsonState, _ := json.Marshal(state)
		d.log.Infof("Sending light state to lifx bulb: %s", jsonState)

		if state.OnOff != nil {
			err := light.ApplyOnOff(*state.OnOff)
			if err != nil {
				return err
			}
		}

		if state.Color != nil || state.Brightness != nil || state.Transition != nil {
			// pull out the origin state
			bulbState := bulb.GetState()

			if state.Brightness == nil {
				brightness := float64(bulbState.Brightness) / math.MaxUint16
				state.Brightness = &brightness
			}

			if state.Color == nil {
				// save the brightness
				brightness := state.Brightness
				state = convertState(&bulbState)
				state.Brightness = brightness
			}

			if state.Transition == nil {
				state.Transition = &defaultTransition
			}

			/*if state.Color == nil {
				return fmt.Errorf("Color value missing from batch set")
			}

			if state.Brightness == nil {
				return fmt.Errorf("Brightness value missing from batch set")
			}*/

			switch state.Color.Mode {
			case "hue":
				return d.client.LightColour(
					bulb,
					uint16(*state.Color.Hue*math.MaxUint16),
					uint16(*state.Color.Saturation*math.MaxUint16),
					uint16(*state.Brightness*math.MaxUint16),
					0,
					uint32(*state.Transition),
				)

			case "xy":
				//TODO: Lifx does not support XY color
				return fmt.Errorf("XY color mode is not yet supported in the Lifx driver")

			case "temperature":
				d.client.LightColour(
					bulb,
					0,
					0,
					uint16(*state.Brightness*math.MaxUint16),
					uint16(*state.Color.Temperature),
					uint32(*state.Transition),
				)

			default:
				return fmt.Errorf("Unknown color mode %s", state.Color.Mode)
			}

		}

		return nil
	}

	bulb.SetStateHandler(buildStateHandler(d, bulb, light))

	if err := light.EnableOnOffChannel(); err != nil {
		d.log.FatalError(err, "Could not enable lifx on-off channel")
	}
	if err := light.EnableBrightnessChannel(); err != nil {
		d.log.FatalError(err, "Could not enable lifx brightness channel")
	}
	if err := light.EnableColorChannel("temperature", "hue"); err != nil {
		d.log.FatalError(err, "Could not enable lifx color channel")
	}
	if err := light.EnableTransitionChannel(); err != nil {
		d.log.FatalError(err, "Could not enable lifx transition channel")
	}

	// extra channels for sensors
	illuminance := channels.NewIlluminanceChannel()

	if err := d.conn.ExportChannel(light, illuminance, "illuminance"); err != nil {
		d.log.FatalError(err, "Could not enable lifx illuminance channel")
	}

	d.log.Debugf("register illuminance channel for %s", bulb.GetLifxAddress())

	d.devices[bulb.GetLifxAddress()] = &lifxDevice{illuminance}

	return light, nil
}
コード例 #3
0
ファイル: driver.go プロジェクト: ninjasphere/driver-go-hue
func (d *HueDriver) newLight(bulb *hue.Light) (*HueLightContext, error) { //TODO cut this down!

	name := bulb.Name

	d.log.Infof("Making light on Bridge: %s ID: %s Label: %s", d.bridge.UniqueId, bulb.Id, name)

	attrs, _ := d.user.GetLightAttributes(bulb.Id)

	d.log.Debugf("Found hue bulb %s - %s", dump(*bulb), dump(attrs))

	sigs := map[string]string{
		"ninja:productType": "Light",
		"ninja:thingType":   "light",
		"hue:bridge":        d.user.Bridge.UniqueId,
		"hue:modelId":       attrs.ModelId,
		"hue:type":          attrs.Type,
		"hue:swversion":     attrs.SoftwareVersion,
	}

	if attrs.ModelId != "ZLL Light" {
		sigs["ninja:manufacturer"] = "Phillips"
		sigs["ninja:productName"] = "Hue"
	}

	light, err := devices.CreateLightDevice(d, &model.Device{
		NaturalID:/* SHOULD HAVE BRIDGE ID IN HERE!! d.user.Bridge.UniqueId + "-" +*/ bulb.Id,
		NaturalIDType: "hue",
		Name:          &name,
		Signatures:    &sigs,
	}, d.conn)

	if err != nil {
		d.log.FatalError(err, "Could not create light device")
	}
	//func NewLight(l *hue.Light, bus *ninja.DriverBus, bridge *hue.Bridge, user *hue.User) (*HueLightContext, error) {

	hl := &HueLightContext{
		ID:     bulb.Id,
		Name:   bulb.Name,
		Bridge: d.bridge,
		User:   d.user,
		Light:  light,
		log:    logger.GetLogger(fmt.Sprintf("huelight:%s", bulb.Id)),
	}

	if err := light.EnableOnOffChannel(); err != nil {
		d.log.FatalError(err, "Could not enable hue on-off channel")
	}

	if err := light.EnableBrightnessChannel(); err != nil {
		d.log.FatalError(err, "Could not enable hue brightness channel")
	}

	if attrs.State.ColorMode != "" {
		if err := light.EnableColorChannel("temperature", "hue"); err != nil {
			d.log.FatalError(err, "Could not enable hue color channel")
		}
		hl.colorEnabled = true
	}

	if err := light.EnableTransitionChannel(); err != nil {
		d.log.FatalError(err, "Could not enable hue transition channel")
	}

	light.ApplyIdentify = hl.ApplyIdentify

	if err := light.EnableIdentifyChannel(); err != nil {
		d.log.FatalError(err, "Could not enable identify channel")
	}

	light.ApplyLightState = hl.ApplyLightState

	return hl, hl.updateState()
}