mesgdef

package
v0.1.3-test Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 16, 2023 License: BSD-3-Clause Imports: 5 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccelerometerData 

type AccelerometerData struct {
	Timestamp                  typedef.DateTime // Units: s; Whole second part of the timestamp
	TimestampMs                uint16           // Units: ms; Millisecond part of the timestamp.
	SampleTimeOffset           []uint16         // Array: [N]; Units: ms; Each time in the array describes the time at which the accelerometer sample with the corrosponding index was taken. Limited to 30 samples in each message. The samples may span across seconds. Array size must match the number of samples in accel_x and accel_y and accel_z
	AccelX                     []uint16         // Array: [N]; Units: counts; These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read.
	AccelY                     []uint16         // Array: [N]; Units: counts; These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read.
	AccelZ                     []uint16         // Array: [N]; Units: counts; These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read.
	CalibratedAccelX           []float32        // Array: [N]; Units: g; Calibrated accel reading
	CalibratedAccelY           []float32        // Array: [N]; Units: g; Calibrated accel reading
	CalibratedAccelZ           []float32        // Array: [N]; Units: g; Calibrated accel reading
	CompressedCalibratedAccelX []int16          // Array: [N]; Units: mG; Calibrated accel reading
	CompressedCalibratedAccelY []int16          // Array: [N]; Units: mG; Calibrated accel reading
	CompressedCalibratedAccelZ []int16          // Array: [N]; Units: mG; Calibrated accel reading

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

AccelerometerData is a AccelerometerData message.

func NewAccelerometerData 

func NewAccelerometerData(mesg proto.Message) *AccelerometerData

NewAccelerometerData creates new AccelerometerData struct based on given mesg. If mesg is nil or mesg.Num is not equal to AccelerometerData mesg number, it will return nil.

func (AccelerometerData) PutMessage 

func (m AccelerometerData) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to AccelerometerData mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumAccelerometerData)

type Activity 

type Activity struct {
	Timestamp      typedef.DateTime
	TotalTimerTime uint32 // Scale: 1000; Units: s; Exclude pauses
	NumSessions    uint16
	Type           typedef.Activity
	Event          typedef.Event
	EventType      typedef.EventType
	LocalTimestamp typedef.LocalDateTime // timestamp epoch expressed in local time, used to convert activity timestamps to local time
	EventGroup     uint8

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Activity is a Activity message.

func NewActivity 

func NewActivity(mesg proto.Message) *Activity

NewActivity creates new Activity struct based on given mesg. If mesg is nil or mesg.Num is not equal to Activity mesg number, it will return nil.

func (Activity) PutMessage 

func (m Activity) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Activity mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumActivity)

type AntChannelId 

type AntChannelId struct {
	ChannelNumber    uint8
	DeviceType       uint8
	DeviceNumber     uint16
	TransmissionType uint8
	DeviceIndex      typedef.DeviceIndex

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

AntChannelId is a AntChannelId message.

func NewAntChannelId 

func NewAntChannelId(mesg proto.Message) *AntChannelId

NewAntChannelId creates new AntChannelId struct based on given mesg. If mesg is nil or mesg.Num is not equal to AntChannelId mesg number, it will return nil.

func (AntChannelId) PutMessage 

func (m AntChannelId) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to AntChannelId mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumAntChannelId)

type AntRx 

type AntRx struct {
	Timestamp           typedef.DateTime // Units: s;
	FractionalTimestamp uint16           // Scale: 32768; Units: s;
	MesgId              byte
	MesgData            []byte // Array: [N];
	ChannelNumber       uint8
	Data                []byte // Array: [N];

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

AntRx is a AntRx message.

func NewAntRx 

func NewAntRx(mesg proto.Message) *AntRx

NewAntRx creates new AntRx struct based on given mesg. If mesg is nil or mesg.Num is not equal to AntRx mesg number, it will return nil.

func (AntRx) PutMessage 

func (m AntRx) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to AntRx mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumAntRx)

type AntTx 

type AntTx struct {
	Timestamp           typedef.DateTime // Units: s;
	FractionalTimestamp uint16           // Scale: 32768; Units: s;
	MesgId              byte
	MesgData            []byte // Array: [N];
	ChannelNumber       uint8
	Data                []byte // Array: [N];

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

AntTx is a AntTx message.

func NewAntTx 

func NewAntTx(mesg proto.Message) *AntTx

NewAntTx creates new AntTx struct based on given mesg. If mesg is nil or mesg.Num is not equal to AntTx mesg number, it will return nil.

func (AntTx) PutMessage 

func (m AntTx) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to AntTx mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumAntTx)

type AviationAttitude 

type AviationAttitude struct {
	Timestamp             typedef.DateTime           // Units: s; Timestamp message was output
	TimestampMs           uint16                     // Units: ms; Fractional part of timestamp, added to timestamp
	SystemTime            []uint32                   // Array: [N]; Units: ms; System time associated with sample expressed in ms.
	Pitch                 []int16                    // Scale: 10430.38; Array: [N]; Units: radians; Range -PI/2 to +PI/2
	Roll                  []int16                    // Scale: 10430.38; Array: [N]; Units: radians; Range -PI to +PI
	AccelLateral          []int16                    // Scale: 100; Array: [N]; Units: m/s^2; Range -78.4 to +78.4 (-8 Gs to 8 Gs)
	AccelNormal           []int16                    // Scale: 100; Array: [N]; Units: m/s^2; Range -78.4 to +78.4 (-8 Gs to 8 Gs)
	TurnRate              []int16                    // Scale: 1024; Array: [N]; Units: radians/second; Range -8.727 to +8.727 (-500 degs/sec to +500 degs/sec)
	Stage                 []typedef.AttitudeStage    // Array: [N];
	AttitudeStageComplete []uint8                    // Array: [N]; Units: %; The percent complete of the current attitude stage. Set to 0 for attitude stages 0, 1 and 2 and to 100 for attitude stage 3 by AHRS modules that do not support it. Range - 100
	Track                 []uint16                   // Scale: 10430.38; Array: [N]; Units: radians; Track Angle/Heading Range 0 - 2pi
	Validity              []typedef.AttitudeValidity // Array: [N];

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

AviationAttitude is a AviationAttitude message.

func NewAviationAttitude 

func NewAviationAttitude(mesg proto.Message) *AviationAttitude

NewAviationAttitude creates new AviationAttitude struct based on given mesg. If mesg is nil or mesg.Num is not equal to AviationAttitude mesg number, it will return nil.

func (AviationAttitude) PutMessage 

func (m AviationAttitude) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to AviationAttitude mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumAviationAttitude)

type BarometerData 

type BarometerData struct {
	Timestamp        typedef.DateTime // Units: s; Whole second part of the timestamp
	TimestampMs      uint16           // Units: ms; Millisecond part of the timestamp.
	SampleTimeOffset []uint16         // Array: [N]; Units: ms; Each time in the array describes the time at which the barometer sample with the corrosponding index was taken. The samples may span across seconds. Array size must match the number of samples in baro_cal
	BaroPres         []uint32         // Array: [N]; Units: Pa; These are the raw ADC reading. The samples may span across seconds. A conversion will need to be done on this data once read.

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

BarometerData is a BarometerData message.

func NewBarometerData 

func NewBarometerData(mesg proto.Message) *BarometerData

NewBarometerData creates new BarometerData struct based on given mesg. If mesg is nil or mesg.Num is not equal to BarometerData mesg number, it will return nil.

func (BarometerData) PutMessage 

func (m BarometerData) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to BarometerData mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumBarometerData)

type BeatIntervals 

type BeatIntervals struct {
	Timestamp   typedef.DateTime
	TimestampMs uint16   // Units: ms; Milliseconds past date_time
	Time        []uint16 // Array: [N]; Units: ms; Array of millisecond times between beats

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

BeatIntervals is a BeatIntervals message.

func NewBeatIntervals 

func NewBeatIntervals(mesg proto.Message) *BeatIntervals

NewBeatIntervals creates new BeatIntervals struct based on given mesg. If mesg is nil or mesg.Num is not equal to BeatIntervals mesg number, it will return nil.

func (BeatIntervals) PutMessage 

func (m BeatIntervals) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to BeatIntervals mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumBeatIntervals)

type BikeProfile 

type BikeProfile struct {
	MessageIndex             typedef.MessageIndex
	Name                     string
	Sport                    typedef.Sport
	SubSport                 typedef.SubSport
	Odometer                 uint32 // Scale: 100; Units: m;
	BikeSpdAntId             uint16
	BikeCadAntId             uint16
	BikeSpdcadAntId          uint16
	BikePowerAntId           uint16
	CustomWheelsize          uint16 // Scale: 1000; Units: m;
	AutoWheelsize            uint16 // Scale: 1000; Units: m;
	BikeWeight               uint16 // Scale: 10; Units: kg;
	PowerCalFactor           uint16 // Scale: 10; Units: %;
	AutoWheelCal             bool
	AutoPowerZero            bool
	Id                       uint8
	SpdEnabled               bool
	CadEnabled               bool
	SpdcadEnabled            bool
	PowerEnabled             bool
	CrankLength              uint8 // Scale: 2; Offset: -110; Units: mm;
	Enabled                  bool
	BikeSpdAntIdTransType    uint8
	BikeCadAntIdTransType    uint8
	BikeSpdcadAntIdTransType uint8
	BikePowerAntIdTransType  uint8
	OdometerRollover         uint8   // Rollover counter that can be used to extend the odometer
	FrontGearNum             uint8   // Number of front gears
	FrontGear                []uint8 // Array: [N]; Number of teeth on each gear 0 is innermost
	RearGearNum              uint8   // Number of rear gears
	RearGear                 []uint8 // Array: [N]; Number of teeth on each gear 0 is innermost
	ShimanoDi2Enabled        bool

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

BikeProfile is a BikeProfile message.

func NewBikeProfile 

func NewBikeProfile(mesg proto.Message) *BikeProfile

NewBikeProfile creates new BikeProfile struct based on given mesg. If mesg is nil or mesg.Num is not equal to BikeProfile mesg number, it will return nil.

func (BikeProfile) PutMessage 

func (m BikeProfile) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to BikeProfile mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumBikeProfile)

type BloodPressure 

type BloodPressure struct {
	Timestamp            typedef.DateTime // Units: s;
	SystolicPressure     uint16           // Units: mmHg;
	DiastolicPressure    uint16           // Units: mmHg;
	MeanArterialPressure uint16           // Units: mmHg;
	Map3SampleMean       uint16           // Units: mmHg;
	MapMorningValues     uint16           // Units: mmHg;
	MapEveningValues     uint16           // Units: mmHg;
	HeartRate            uint8            // Units: bpm;
	HeartRateType        typedef.HrType
	Status               typedef.BpStatus
	UserProfileIndex     typedef.MessageIndex // Associates this blood pressure message to a user. This corresponds to the index of the user profile message in the blood pressure file.

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

BloodPressure is a BloodPressure message.

func NewBloodPressure 

func NewBloodPressure(mesg proto.Message) *BloodPressure

NewBloodPressure creates new BloodPressure struct based on given mesg. If mesg is nil or mesg.Num is not equal to BloodPressure mesg number, it will return nil.

func (BloodPressure) PutMessage 

func (m BloodPressure) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to BloodPressure mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumBloodPressure)

type CadenceZone 

type CadenceZone struct {
	MessageIndex typedef.MessageIndex
	HighValue    uint8 // Units: rpm;
	Name         string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

CadenceZone is a CadenceZone message.

func NewCadenceZone 

func NewCadenceZone(mesg proto.Message) *CadenceZone

NewCadenceZone creates new CadenceZone struct based on given mesg. If mesg is nil or mesg.Num is not equal to CadenceZone mesg number, it will return nil.

func (CadenceZone) PutMessage 

func (m CadenceZone) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to CadenceZone mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumCadenceZone)

type CameraEvent 

type CameraEvent struct {
	Timestamp         typedef.DateTime // Units: s; Whole second part of the timestamp.
	TimestampMs       uint16           // Units: ms; Millisecond part of the timestamp.
	CameraEventType   typedef.CameraEventType
	CameraFileUuid    string
	CameraOrientation typedef.CameraOrientationType

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

CameraEvent is a CameraEvent message.

func NewCameraEvent 

func NewCameraEvent(mesg proto.Message) *CameraEvent

NewCameraEvent creates new CameraEvent struct based on given mesg. If mesg is nil or mesg.Num is not equal to CameraEvent mesg number, it will return nil.

func (CameraEvent) PutMessage 

func (m CameraEvent) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to CameraEvent mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumCameraEvent)

type Capabilities 

type Capabilities struct {
	Languages             []uint8              // Array: [N]; Use language_bits_x types where x is index of array.
	Sports                []typedef.SportBits0 // Array: [N]; Use sport_bits_x types where x is index of array.
	WorkoutsSupported     typedef.WorkoutCapabilities
	ConnectivitySupported typedef.ConnectivityCapabilities

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Capabilities is a Capabilities message.

func NewCapabilities 

func NewCapabilities(mesg proto.Message) *Capabilities

NewCapabilities creates new Capabilities struct based on given mesg. If mesg is nil or mesg.Num is not equal to Capabilities mesg number, it will return nil.

func (Capabilities) PutMessage 

func (m Capabilities) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Capabilities mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumCapabilities)

type ClimbPro 

type ClimbPro struct {
	Timestamp     typedef.DateTime // Units: s;
	PositionLat   int32            // Units: semicircles;
	PositionLong  int32            // Units: semicircles;
	ClimbProEvent typedef.ClimbProEvent
	ClimbNumber   uint16
	ClimbCategory uint8
	CurrentDist   float32 // Units: m;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

ClimbPro is a ClimbPro message.

func NewClimbPro 

func NewClimbPro(mesg proto.Message) *ClimbPro

NewClimbPro creates new ClimbPro struct based on given mesg. If mesg is nil or mesg.Num is not equal to ClimbPro mesg number, it will return nil.

func (ClimbPro) PutMessage 

func (m ClimbPro) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to ClimbPro mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumClimbPro)

type Connectivity 

type Connectivity struct {
	BluetoothEnabled            bool // Use Bluetooth for connectivity features
	BluetoothLeEnabled          bool // Use Bluetooth Low Energy for connectivity features
	AntEnabled                  bool // Use ANT for connectivity features
	Name                        string
	LiveTrackingEnabled         bool
	WeatherConditionsEnabled    bool
	WeatherAlertsEnabled        bool
	AutoActivityUploadEnabled   bool
	CourseDownloadEnabled       bool
	WorkoutDownloadEnabled      bool
	GpsEphemerisDownloadEnabled bool
	IncidentDetectionEnabled    bool
	GrouptrackEnabled           bool

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Connectivity is a Connectivity message.

func NewConnectivity 

func NewConnectivity(mesg proto.Message) *Connectivity

NewConnectivity creates new Connectivity struct based on given mesg. If mesg is nil or mesg.Num is not equal to Connectivity mesg number, it will return nil.

func (Connectivity) PutMessage 

func (m Connectivity) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Connectivity mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumConnectivity)

type Course 

type Course struct {
	Sport        typedef.Sport
	Name         string
	Capabilities typedef.CourseCapabilities
	SubSport     typedef.SubSport

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Course is a Course message.

func NewCourse 

func NewCourse(mesg proto.Message) *Course

NewCourse creates new Course struct based on given mesg. If mesg is nil or mesg.Num is not equal to Course mesg number, it will return nil.

func (Course) PutMessage 

func (m Course) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Course mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumCourse)

type CoursePoint 

type CoursePoint struct {
	MessageIndex typedef.MessageIndex
	Timestamp    typedef.DateTime
	PositionLat  int32  // Units: semicircles;
	PositionLong int32  // Units: semicircles;
	Distance     uint32 // Scale: 100; Units: m;
	Type         typedef.CoursePoint
	Name         string
	Favorite     bool

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

CoursePoint is a CoursePoint message.

func NewCoursePoint 

func NewCoursePoint(mesg proto.Message) *CoursePoint

NewCoursePoint creates new CoursePoint struct based on given mesg. If mesg is nil or mesg.Num is not equal to CoursePoint mesg number, it will return nil.

func (CoursePoint) PutMessage 

func (m CoursePoint) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to CoursePoint mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumCoursePoint)

type DeveloperDataId 

type DeveloperDataId struct {
	DeveloperId        []byte // Array: [N];
	ApplicationId      []byte // Array: [N];
	ManufacturerId     typedef.Manufacturer
	DeveloperDataIndex uint8
	ApplicationVersion uint32
}

DeveloperDataId is a DeveloperDataId message.

func NewDeveloperDataId 

func NewDeveloperDataId(mesg proto.Message) *DeveloperDataId

NewDeveloperDataId creates new DeveloperDataId struct based on given mesg. If mesg is nil or mesg.Num is not equal to DeveloperDataId mesg number, it will return nil.

func (DeveloperDataId) PutMessage 

func (m DeveloperDataId) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to DeveloperDataId mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumDeveloperDataId)

type DeviceAuxBatteryInfo 

type DeviceAuxBatteryInfo struct {
	Timestamp         typedef.DateTime
	DeviceIndex       typedef.DeviceIndex
	BatteryVoltage    uint16 // Scale: 256; Units: V;
	BatteryStatus     typedef.BatteryStatus
	BatteryIdentifier uint8

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

DeviceAuxBatteryInfo is a DeviceAuxBatteryInfo message.

func NewDeviceAuxBatteryInfo 

func NewDeviceAuxBatteryInfo(mesg proto.Message) *DeviceAuxBatteryInfo

NewDeviceAuxBatteryInfo creates new DeviceAuxBatteryInfo struct based on given mesg. If mesg is nil or mesg.Num is not equal to DeviceAuxBatteryInfo mesg number, it will return nil.

func (DeviceAuxBatteryInfo) PutMessage 

func (m DeviceAuxBatteryInfo) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to DeviceAuxBatteryInfo mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumDeviceAuxBatteryInfo)

type DeviceInfo 

type DeviceInfo struct {
	Timestamp           typedef.DateTime // Units: s;
	DeviceIndex         typedef.DeviceIndex
	DeviceType          uint8
	Manufacturer        typedef.Manufacturer
	SerialNumber        uint32
	Product             uint16
	SoftwareVersion     uint16 // Scale: 100;
	HardwareVersion     uint8
	CumOperatingTime    uint32 // Units: s; Reset by new battery or charge.
	BatteryVoltage      uint16 // Scale: 256; Units: V;
	BatteryStatus       typedef.BatteryStatus
	SensorPosition      typedef.BodyLocation // Indicates the location of the sensor
	Descriptor          string               // Used to describe the sensor or location
	AntTransmissionType uint8
	AntDeviceNumber     uint16
	AntNetwork          typedef.AntNetwork
	SourceType          typedef.SourceType
	ProductName         string // Optional free form string to indicate the devices name or model
	BatteryLevel        uint8  // Units: %;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

DeviceInfo is a DeviceInfo message.

func NewDeviceInfo 

func NewDeviceInfo(mesg proto.Message) *DeviceInfo

NewDeviceInfo creates new DeviceInfo struct based on given mesg. If mesg is nil or mesg.Num is not equal to DeviceInfo mesg number, it will return nil.

func (DeviceInfo) PutMessage 

func (m DeviceInfo) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to DeviceInfo mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumDeviceInfo)

type DeviceSettings 

type DeviceSettings struct {
	ActiveTimeZone                      uint8                 // Index into time zone arrays.
	UtcOffset                           uint32                // Offset from system time. Required to convert timestamp from system time to UTC.
	TimeOffset                          []uint32              // Array: [N]; Units: s; Offset from system time.
	TimeMode                            []typedef.TimeMode    // Array: [N]; Display mode for the time
	TimeZoneOffset                      []int8                // Scale: 4; Array: [N]; Units: hr; timezone offset in 1/4 hour increments
	BacklightMode                       typedef.BacklightMode // Mode for backlight
	ActivityTrackerEnabled              bool                  // Enabled state of the activity tracker functionality
	ClockTime                           typedef.DateTime      // UTC timestamp used to set the devices clock and date
	PagesEnabled                        []uint16              // Array: [N]; Bitfield to configure enabled screens for each supported loop
	MoveAlertEnabled                    bool                  // Enabled state of the move alert
	DateMode                            typedef.DateMode      // Display mode for the date
	DisplayOrientation                  typedef.DisplayOrientation
	MountingSide                        typedef.Side
	DefaultPage                         []uint16                   // Array: [N]; Bitfield to indicate one page as default for each supported loop
	AutosyncMinSteps                    uint16                     // Units: steps; Minimum steps before an autosync can occur
	AutosyncMinTime                     uint16                     // Units: minutes; Minimum minutes before an autosync can occur
	LactateThresholdAutodetectEnabled   bool                       // Enable auto-detect setting for the lactate threshold feature.
	BleAutoUploadEnabled                bool                       // Automatically upload using BLE
	AutoSyncFrequency                   typedef.AutoSyncFrequency  // Helps to conserve battery by changing modes
	AutoActivityDetect                  typedef.AutoActivityDetect // Allows setting specific activities auto-activity detect enabled/disabled settings
	NumberOfScreens                     uint8                      // Number of screens configured to display
	SmartNotificationDisplayOrientation typedef.DisplayOrientation // Smart Notification display orientation
	TapInterface                        typedef.Switch
	TapSensitivity                      typedef.TapSensitivity // Used to hold the tap threshold setting

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

DeviceSettings is a DeviceSettings message.

func NewDeviceSettings 

func NewDeviceSettings(mesg proto.Message) *DeviceSettings

NewDeviceSettings creates new DeviceSettings struct based on given mesg. If mesg is nil or mesg.Num is not equal to DeviceSettings mesg number, it will return nil.

func (DeviceSettings) PutMessage 

func (m DeviceSettings) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to DeviceSettings mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumDeviceSettings)

type DiveAlarm 

type DiveAlarm struct {
	MessageIndex     typedef.MessageIndex  // Index of the alarm
	Depth            uint32                // Scale: 1000; Units: m; Depth setting (m) for depth type alarms
	Time             int32                 // Units: s; Time setting (s) for time type alarms
	Enabled          bool                  // Enablement flag
	AlarmType        typedef.DiveAlarmType // Alarm type setting
	Sound            typedef.Tone          // Tone and Vibe setting for the alarm
	DiveTypes        []typedef.SubSport    // Array: [N]; Dive types the alarm will trigger on
	Id               uint32                // Alarm ID
	PopupEnabled     bool                  // Show a visible pop-up for this alarm
	TriggerOnDescent bool                  // Trigger the alarm on descent
	TriggerOnAscent  bool                  // Trigger the alarm on ascent
	Repeating        bool                  // Repeat alarm each time threshold is crossed?
	Speed            int32                 // Scale: 1000; Units: mps; Ascent/descent rate (mps) setting for speed type alarms

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

DiveAlarm is a DiveAlarm message.

func NewDiveAlarm 

func NewDiveAlarm(mesg proto.Message) *DiveAlarm

NewDiveAlarm creates new DiveAlarm struct based on given mesg. If mesg is nil or mesg.Num is not equal to DiveAlarm mesg number, it will return nil.

func (DiveAlarm) PutMessage 

func (m DiveAlarm) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to DiveAlarm mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumDiveAlarm)

type DiveApneaAlarm 

type DiveApneaAlarm struct {
	MessageIndex     typedef.MessageIndex  // Index of the alarm
	Depth            uint32                // Scale: 1000; Units: m; Depth setting (m) for depth type alarms
	Time             int32                 // Units: s; Time setting (s) for time type alarms
	Enabled          bool                  // Enablement flag
	AlarmType        typedef.DiveAlarmType // Alarm type setting
	Sound            typedef.Tone          // Tone and Vibe setting for the alarm.
	DiveTypes        []typedef.SubSport    // Array: [N]; Dive types the alarm will trigger on
	Id               uint32                // Alarm ID
	PopupEnabled     bool                  // Show a visible pop-up for this alarm
	TriggerOnDescent bool                  // Trigger the alarm on descent
	TriggerOnAscent  bool                  // Trigger the alarm on ascent
	Repeating        bool                  // Repeat alarm each time threshold is crossed?
	Speed            int32                 // Scale: 1000; Units: mps; Ascent/descent rate (mps) setting for speed type alarms

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

DiveApneaAlarm is a DiveApneaAlarm message.

func NewDiveApneaAlarm 

func NewDiveApneaAlarm(mesg proto.Message) *DiveApneaAlarm

NewDiveApneaAlarm creates new DiveApneaAlarm struct based on given mesg. If mesg is nil or mesg.Num is not equal to DiveApneaAlarm mesg number, it will return nil.

func (DiveApneaAlarm) PutMessage 

func (m DiveApneaAlarm) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to DiveApneaAlarm mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumDiveApneaAlarm)

type DiveGas 

type DiveGas struct {
	MessageIndex  typedef.MessageIndex
	HeliumContent uint8 // Units: percent;
	OxygenContent uint8 // Units: percent;
	Status        typedef.DiveGasStatus
	Mode          typedef.DiveGasMode

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

DiveGas is a DiveGas message.

func NewDiveGas 

func NewDiveGas(mesg proto.Message) *DiveGas

NewDiveGas creates new DiveGas struct based on given mesg. If mesg is nil or mesg.Num is not equal to DiveGas mesg number, it will return nil.

func (DiveGas) PutMessage 

func (m DiveGas) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to DiveGas mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumDiveGas)

type DiveSettings 

type DiveSettings struct {
	Timestamp                 typedef.DateTime
	MessageIndex              typedef.MessageIndex
	Name                      string
	Model                     typedef.TissueModelType
	GfLow                     uint8 // Units: percent;
	GfHigh                    uint8 // Units: percent;
	WaterType                 typedef.WaterType
	WaterDensity              float32 // Units: kg/m^3; Fresh water is usually 1000; salt water is usually 1025
	Po2Warn                   uint8   // Scale: 100; Units: percent; Typically 1.40
	Po2Critical               uint8   // Scale: 100; Units: percent; Typically 1.60
	Po2Deco                   uint8   // Scale: 100; Units: percent;
	SafetyStopEnabled         bool
	BottomDepth               float32
	BottomTime                uint32
	ApneaCountdownEnabled     bool
	ApneaCountdownTime        uint32
	BacklightMode             typedef.DiveBacklightMode
	BacklightBrightness       uint8
	BacklightTimeout          typedef.BacklightTimeout
	RepeatDiveInterval        uint16 // Units: s; Time between surfacing and ending the activity
	SafetyStopTime            uint16 // Units: s; Time at safety stop (if enabled)
	HeartRateSourceType       typedef.SourceType
	HeartRateSource           uint8
	TravelGas                 typedef.MessageIndex           // Index of travel dive_gas message
	CcrLowSetpointSwitchMode  typedef.CcrSetpointSwitchMode  // If low PO2 should be switched to automatically
	CcrLowSetpoint            uint8                          // Scale: 100; Units: percent; Target PO2 when using low setpoint
	CcrLowSetpointDepth       uint32                         // Scale: 1000; Units: m; Depth to switch to low setpoint in automatic mode
	CcrHighSetpointSwitchMode typedef.CcrSetpointSwitchMode  // If high PO2 should be switched to automatically
	CcrHighSetpoint           uint8                          // Scale: 100; Units: percent; Target PO2 when using high setpoint
	CcrHighSetpointDepth      uint32                         // Scale: 1000; Units: m; Depth to switch to high setpoint in automatic mode
	GasConsumptionDisplay     typedef.GasConsumptionRateType // Type of gas consumption rate to display. Some values are only valid if tank volume is known.
	UpKeyEnabled              bool                           // Indicates whether the up key is enabled during dives
	DiveSounds                typedef.Tone                   // Sounds and vibration enabled or disabled in-dive
	LastStopMultiple          uint8                          // Scale: 10; Usually 1.0/1.5/2.0 representing 3/4.5/6m or 10/15/20ft
	NoFlyTimeMode             typedef.NoFlyTimeMode          // Indicates which guidelines to use for no-fly surface interval.

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

DiveSettings is a DiveSettings message.

func NewDiveSettings 

func NewDiveSettings(mesg proto.Message) *DiveSettings

NewDiveSettings creates new DiveSettings struct based on given mesg. If mesg is nil or mesg.Num is not equal to DiveSettings mesg number, it will return nil.

func (DiveSettings) PutMessage 

func (m DiveSettings) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to DiveSettings mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumDiveSettings)

type DiveSummary 

type DiveSummary struct {
	Timestamp       typedef.DateTime // Units: s;
	ReferenceMesg   typedef.MesgNum
	ReferenceIndex  typedef.MessageIndex
	AvgDepth        uint32 // Scale: 1000; Units: m; 0 if above water
	MaxDepth        uint32 // Scale: 1000; Units: m; 0 if above water
	SurfaceInterval uint32 // Units: s; Time since end of last dive
	StartCns        uint8  // Units: percent;
	EndCns          uint8  // Units: percent;
	StartN2         uint16 // Units: percent;
	EndN2           uint16 // Units: percent;
	O2Toxicity      uint16 // Units: OTUs;
	DiveNumber      uint32
	BottomTime      uint32 // Scale: 1000; Units: s;
	AvgPressureSac  uint16 // Scale: 100; Units: bar/min; Average pressure-based surface air consumption
	AvgVolumeSac    uint16 // Scale: 100; Units: L/min; Average volumetric surface air consumption
	AvgRmv          uint16 // Scale: 100; Units: L/min; Average respiratory minute volume
	DescentTime     uint32 // Scale: 1000; Units: s; Time to reach deepest level stop
	AscentTime      uint32 // Scale: 1000; Units: s; Time after leaving bottom until reaching surface
	AvgAscentRate   int32  // Scale: 1000; Units: m/s; Average ascent rate, not including descents or stops
	AvgDescentRate  uint32 // Scale: 1000; Units: m/s; Average descent rate, not including ascents or stops
	MaxAscentRate   uint32 // Scale: 1000; Units: m/s; Maximum ascent rate
	MaxDescentRate  uint32 // Scale: 1000; Units: m/s; Maximum descent rate
	HangTime        uint32 // Scale: 1000; Units: s; Time spent neither ascending nor descending

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

DiveSummary is a DiveSummary message.

func NewDiveSummary 

func NewDiveSummary(mesg proto.Message) *DiveSummary

NewDiveSummary creates new DiveSummary struct based on given mesg. If mesg is nil or mesg.Num is not equal to DiveSummary mesg number, it will return nil.

func (DiveSummary) PutMessage 

func (m DiveSummary) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to DiveSummary mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumDiveSummary)

type Event 

type Event struct {
	Timestamp                   typedef.DateTime // Units: s;
	Event                       typedef.Event
	EventType                   typedef.EventType
	Data16                      uint16
	Data                        uint32
	EventGroup                  uint8
	Score                       uint16 // Do not populate directly. Autogenerated by decoder for sport_point subfield components
	OpponentScore               uint16 // Do not populate directly. Autogenerated by decoder for sport_point subfield components
	FrontGearNum                uint8  // Do not populate directly. Autogenerated by decoder for gear_change subfield components. Front gear number. 1 is innermost.
	FrontGear                   uint8  // Do not populate directly. Autogenerated by decoder for gear_change subfield components. Number of front teeth.
	RearGearNum                 uint8  // Do not populate directly. Autogenerated by decoder for gear_change subfield components. Rear gear number. 1 is innermost.
	RearGear                    uint8  // Do not populate directly. Autogenerated by decoder for gear_change subfield components. Number of rear teeth.
	DeviceIndex                 typedef.DeviceIndex
	ActivityType                typedef.ActivityType         // Activity Type associated with an auto_activity_detect event
	StartTimestamp              typedef.DateTime             // Units: s; Timestamp of when the event started
	RadarThreatLevelMax         typedef.RadarThreatLevelType // Do not populate directly. Autogenerated by decoder for threat_alert subfield components.
	RadarThreatCount            uint8                        // Do not populate directly. Autogenerated by decoder for threat_alert subfield components.
	RadarThreatAvgApproachSpeed uint8                        // Scale: 10; Units: m/s; Do not populate directly. Autogenerated by decoder for radar_threat_alert subfield components
	RadarThreatMaxApproachSpeed uint8                        // Scale: 10; Units: m/s; Do not populate directly. Autogenerated by decoder for radar_threat_alert subfield components

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Event is a Event message.

func NewEvent 

func NewEvent(mesg proto.Message) *Event

NewEvent creates new Event struct based on given mesg. If mesg is nil or mesg.Num is not equal to Event mesg number, it will return nil.

func (Event) PutMessage 

func (m Event) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Event mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumEvent)

type ExdDataConceptConfiguration 

type ExdDataConceptConfiguration struct {
	ScreenIndex  uint8
	ConceptField byte
	FieldId      uint8
	ConceptIndex uint8
	DataPage     uint8
	ConceptKey   uint8
	Scaling      uint8
	DataUnits    typedef.ExdDataUnits
	Qualifier    typedef.ExdQualifiers
	Descriptor   typedef.ExdDescriptors
	IsSigned     bool

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

ExdDataConceptConfiguration is a ExdDataConceptConfiguration message.

func NewExdDataConceptConfiguration 

func NewExdDataConceptConfiguration(mesg proto.Message) *ExdDataConceptConfiguration

NewExdDataConceptConfiguration creates new ExdDataConceptConfiguration struct based on given mesg. If mesg is nil or mesg.Num is not equal to ExdDataConceptConfiguration mesg number, it will return nil.

func (ExdDataConceptConfiguration) PutMessage 

func (m ExdDataConceptConfiguration) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to ExdDataConceptConfiguration mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumExdDataConceptConfiguration)

type ExdDataFieldConfiguration 

type ExdDataFieldConfiguration struct {
	ScreenIndex  uint8
	ConceptField byte
	FieldId      uint8
	ConceptCount uint8
	DisplayType  typedef.ExdDisplayType
	Title        string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

ExdDataFieldConfiguration is a ExdDataFieldConfiguration message.

func NewExdDataFieldConfiguration 

func NewExdDataFieldConfiguration(mesg proto.Message) *ExdDataFieldConfiguration

NewExdDataFieldConfiguration creates new ExdDataFieldConfiguration struct based on given mesg. If mesg is nil or mesg.Num is not equal to ExdDataFieldConfiguration mesg number, it will return nil.

func (ExdDataFieldConfiguration) PutMessage 

func (m ExdDataFieldConfiguration) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to ExdDataFieldConfiguration mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumExdDataFieldConfiguration)

type ExdScreenConfiguration 

type ExdScreenConfiguration struct {
	ScreenIndex   uint8
	FieldCount    uint8 // number of fields in screen
	Layout        typedef.ExdLayout
	ScreenEnabled bool

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

ExdScreenConfiguration is a ExdScreenConfiguration message.

func NewExdScreenConfiguration 

func NewExdScreenConfiguration(mesg proto.Message) *ExdScreenConfiguration

NewExdScreenConfiguration creates new ExdScreenConfiguration struct based on given mesg. If mesg is nil or mesg.Num is not equal to ExdScreenConfiguration mesg number, it will return nil.

func (ExdScreenConfiguration) PutMessage 

func (m ExdScreenConfiguration) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to ExdScreenConfiguration mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumExdScreenConfiguration)

type ExerciseTitle 

type ExerciseTitle struct {
	MessageIndex     typedef.MessageIndex
	ExerciseCategory typedef.ExerciseCategory
	ExerciseName     uint16
	WktStepName      string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

ExerciseTitle is a ExerciseTitle message.

func NewExerciseTitle 

func NewExerciseTitle(mesg proto.Message) *ExerciseTitle

NewExerciseTitle creates new ExerciseTitle struct based on given mesg. If mesg is nil or mesg.Num is not equal to ExerciseTitle mesg number, it will return nil.

func (ExerciseTitle) PutMessage 

func (m ExerciseTitle) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to ExerciseTitle mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumExerciseTitle)

type FieldCapabilities 

type FieldCapabilities struct {
	MessageIndex typedef.MessageIndex
	File         typedef.File
	MesgNum      typedef.MesgNum
	FieldNum     uint8
	Count        uint16

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

FieldCapabilities is a FieldCapabilities message.

func NewFieldCapabilities 

func NewFieldCapabilities(mesg proto.Message) *FieldCapabilities

NewFieldCapabilities creates new FieldCapabilities struct based on given mesg. If mesg is nil or mesg.Num is not equal to FieldCapabilities mesg number, it will return nil.

func (FieldCapabilities) PutMessage 

func (m FieldCapabilities) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to FieldCapabilities mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumFieldCapabilities)

type FieldDescription 

type FieldDescription struct {
	DeveloperDataIndex    uint8
	FieldDefinitionNumber uint8
	FitBaseTypeId         basetype.BaseType
	FieldName             string
	Array                 uint8
	Components            string
	Scale                 uint8
	Offset                int8
	Units                 string
	Bits                  string
	Accumulate            string
	FitBaseUnitId         typedef.FitBaseUnit
	NativeMesgNum         typedef.MesgNum
	NativeFieldNum        uint8
}

FieldDescription is a FieldDescription message.

func NewFieldDescription 

func NewFieldDescription(mesg proto.Message) *FieldDescription

NewFieldDescription creates new FieldDescription struct based on given mesg. If mesg is nil or mesg.Num is not equal to FieldDescription mesg number, it will return nil.

func (FieldDescription) PutMessage 

func (m FieldDescription) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to FieldDescription mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumFieldDescription)

type FileCapabilities 

type FileCapabilities struct {
	MessageIndex typedef.MessageIndex
	Type         typedef.File
	Flags        typedef.FileFlags
	Directory    string
	MaxCount     uint16
	MaxSize      uint32 // Units: bytes;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

FileCapabilities is a FileCapabilities message.

func NewFileCapabilities 

func NewFileCapabilities(mesg proto.Message) *FileCapabilities

NewFileCapabilities creates new FileCapabilities struct based on given mesg. If mesg is nil or mesg.Num is not equal to FileCapabilities mesg number, it will return nil.

func (FileCapabilities) PutMessage 

func (m FileCapabilities) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to FileCapabilities mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumFileCapabilities)

type FileCreator 

type FileCreator struct {
	SoftwareVersion uint16
	HardwareVersion uint8

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

FileCreator is a FileCreator message.

func NewFileCreator 

func NewFileCreator(mesg proto.Message) *FileCreator

NewFileCreator creates new FileCreator struct based on given mesg. If mesg is nil or mesg.Num is not equal to FileCreator mesg number, it will return nil.

func (FileCreator) PutMessage 

func (m FileCreator) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to FileCreator mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumFileCreator)

type FileId 

type FileId struct {
	Type         typedef.File
	Manufacturer typedef.Manufacturer
	Product      uint16
	SerialNumber uint32
	TimeCreated  typedef.DateTime // Only set for files that are can be created/erased.
	Number       uint16           // Only set for files that are not created/erased.
	ProductName  string           // Optional free form string to indicate the devices name or model
}

FileId is a FileId message.

func NewFileId 

func NewFileId(mesg proto.Message) *FileId

NewFileId creates new FileId struct based on given mesg. If mesg is nil or mesg.Num is not equal to FileId mesg number, it will return nil.

func (FileId) PutMessage 

func (m FileId) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to FileId mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumFileId)

type Goal 

type Goal struct {
	MessageIndex    typedef.MessageIndex
	Sport           typedef.Sport
	SubSport        typedef.SubSport
	StartDate       typedef.DateTime
	EndDate         typedef.DateTime
	Type            typedef.Goal
	Value           uint32
	Repeat          bool
	TargetValue     uint32
	Recurrence      typedef.GoalRecurrence
	RecurrenceValue uint16
	Enabled         bool
	Source          typedef.GoalSource

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Goal is a Goal message.

func NewGoal 

func NewGoal(mesg proto.Message) *Goal

NewGoal creates new Goal struct based on given mesg. If mesg is nil or mesg.Num is not equal to Goal mesg number, it will return nil.

func (Goal) PutMessage 

func (m Goal) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Goal mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumGoal)

type GpsMetadata 

type GpsMetadata struct {
	Timestamp        typedef.DateTime // Units: s; Whole second part of the timestamp.
	TimestampMs      uint16           // Units: ms; Millisecond part of the timestamp.
	PositionLat      int32            // Units: semicircles;
	PositionLong     int32            // Units: semicircles;
	EnhancedAltitude uint32           // Scale: 5; Offset: 500; Units: m;
	EnhancedSpeed    uint32           // Scale: 1000; Units: m/s;
	Heading          uint16           // Scale: 100; Units: degrees;
	UtcTimestamp     typedef.DateTime // Units: s; Used to correlate UTC to system time if the timestamp of the message is in system time. This UTC time is derived from the GPS data.
	Velocity         []int16          // Scale: 100; Array: [3]; Units: m/s; velocity[0] is lon velocity. Velocity[1] is lat velocity. Velocity[2] is altitude velocity.

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

GpsMetadata is a GpsMetadata message.

func NewGpsMetadata 

func NewGpsMetadata(mesg proto.Message) *GpsMetadata

NewGpsMetadata creates new GpsMetadata struct based on given mesg. If mesg is nil or mesg.Num is not equal to GpsMetadata mesg number, it will return nil.

func (GpsMetadata) PutMessage 

func (m GpsMetadata) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to GpsMetadata mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumGpsMetadata)

type GyroscopeData 

type GyroscopeData struct {
	Timestamp        typedef.DateTime // Units: s; Whole second part of the timestamp
	TimestampMs      uint16           // Units: ms; Millisecond part of the timestamp.
	SampleTimeOffset []uint16         // Array: [N]; Units: ms; Each time in the array describes the time at which the gyro sample with the corrosponding index was taken. Limited to 30 samples in each message. The samples may span across seconds. Array size must match the number of samples in gyro_x and gyro_y and gyro_z
	GyroX            []uint16         // Array: [N]; Units: counts; These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read.
	GyroY            []uint16         // Array: [N]; Units: counts; These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read.
	GyroZ            []uint16         // Array: [N]; Units: counts; These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read.
	CalibratedGyroX  []float32        // Array: [N]; Units: deg/s; Calibrated gyro reading
	CalibratedGyroY  []float32        // Array: [N]; Units: deg/s; Calibrated gyro reading
	CalibratedGyroZ  []float32        // Array: [N]; Units: deg/s; Calibrated gyro reading

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

GyroscopeData is a GyroscopeData message.

func NewGyroscopeData 

func NewGyroscopeData(mesg proto.Message) *GyroscopeData

NewGyroscopeData creates new GyroscopeData struct based on given mesg. If mesg is nil or mesg.Num is not equal to GyroscopeData mesg number, it will return nil.

func (GyroscopeData) PutMessage 

func (m GyroscopeData) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to GyroscopeData mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumGyroscopeData)

type Hr 

type Hr struct {
	Timestamp           typedef.DateTime
	FractionalTimestamp uint16   // Scale: 32768; Units: s;
	Time256             uint8    // Scale: 256; Units: s;
	FilteredBpm         []uint8  // Array: [N]; Units: bpm;
	EventTimestamp      []uint32 // Scale: 1024; Array: [N]; Units: s;
	EventTimestamp12    []byte   // Scale: 1024; Array: [N]; Units: s;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Hr is a Hr message.

func NewHr 

func NewHr(mesg proto.Message) *Hr

NewHr creates new Hr struct based on given mesg. If mesg is nil or mesg.Num is not equal to Hr mesg number, it will return nil.

func (Hr) PutMessage 

func (m Hr) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Hr mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumHr)

type HrZone 

type HrZone struct {
	MessageIndex typedef.MessageIndex
	HighBpm      uint8 // Units: bpm;
	Name         string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

HrZone is a HrZone message.

func NewHrZone 

func NewHrZone(mesg proto.Message) *HrZone

NewHrZone creates new HrZone struct based on given mesg. If mesg is nil or mesg.Num is not equal to HrZone mesg number, it will return nil.

func (HrZone) PutMessage 

func (m HrZone) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to HrZone mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumHrZone)

type HrmProfile 

type HrmProfile struct {
	MessageIndex      typedef.MessageIndex
	Enabled           bool
	HrmAntId          uint16
	LogHrv            bool
	HrmAntIdTransType uint8

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

HrmProfile is a HrmProfile message.

func NewHrmProfile 

func NewHrmProfile(mesg proto.Message) *HrmProfile

NewHrmProfile creates new HrmProfile struct based on given mesg. If mesg is nil or mesg.Num is not equal to HrmProfile mesg number, it will return nil.

func (HrmProfile) PutMessage 

func (m HrmProfile) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to HrmProfile mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumHrmProfile)

type Hrv 

type Hrv struct {
	Time []uint16 // Scale: 1000; Array: [N]; Units: s; Time between beats

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Hrv is a Hrv message.

func NewHrv 

func NewHrv(mesg proto.Message) *Hrv

NewHrv creates new Hrv struct based on given mesg. If mesg is nil or mesg.Num is not equal to Hrv mesg number, it will return nil.

func (Hrv) PutMessage 

func (m Hrv) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Hrv mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumHrv)

type HrvStatusSummary 

type HrvStatusSummary struct {
	Timestamp             typedef.DateTime
	WeeklyAverage         uint16 // Scale: 128; Units: ms; 7 day RMSSD average over sleep
	LastNightAverage      uint16 // Scale: 128; Units: ms; Last night RMSSD average over sleep
	LastNight5MinHigh     uint16 // Scale: 128; Units: ms; 5 minute high RMSSD value over sleep
	BaselineLowUpper      uint16 // Scale: 128; Units: ms; 3 week baseline, upper boundary of low HRV status
	BaselineBalancedLower uint16 // Scale: 128; Units: ms; 3 week baseline, lower boundary of balanced HRV status
	BaselineBalancedUpper uint16 // Scale: 128; Units: ms; 3 week baseline, upper boundary of balanced HRV status
	Status                typedef.HrvStatus

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

HrvStatusSummary is a HrvStatusSummary message.

func NewHrvStatusSummary 

func NewHrvStatusSummary(mesg proto.Message) *HrvStatusSummary

NewHrvStatusSummary creates new HrvStatusSummary struct based on given mesg. If mesg is nil or mesg.Num is not equal to HrvStatusSummary mesg number, it will return nil.

func (HrvStatusSummary) PutMessage 

func (m HrvStatusSummary) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to HrvStatusSummary mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumHrvStatusSummary)

type HrvValue 

type HrvValue struct {
	Timestamp typedef.DateTime
	Value     uint16 // Scale: 128; Units: ms; 5 minute RMSSD

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

HrvValue is a HrvValue message.

func NewHrvValue 

func NewHrvValue(mesg proto.Message) *HrvValue

NewHrvValue creates new HrvValue struct based on given mesg. If mesg is nil or mesg.Num is not equal to HrvValue mesg number, it will return nil.

func (HrvValue) PutMessage 

func (m HrvValue) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to HrvValue mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumHrvValue)

type Jump 

type Jump struct {
	Timestamp     typedef.DateTime // Units: s;
	Distance      float32          // Units: m;
	Height        float32          // Units: m;
	Rotations     uint8
	HangTime      float32 // Units: s;
	Score         float32 // A score for a jump calculated based on hang time, rotations, and distance.
	PositionLat   int32   // Units: semicircles;
	PositionLong  int32   // Units: semicircles;
	Speed         uint16  // Scale: 1000; Units: m/s;
	EnhancedSpeed uint32  // Scale: 1000; Units: m/s;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Jump is a Jump message.

func NewJump 

func NewJump(mesg proto.Message) *Jump

NewJump creates new Jump struct based on given mesg. If mesg is nil or mesg.Num is not equal to Jump mesg number, it will return nil.

func (Jump) PutMessage 

func (m Jump) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Jump mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumJump)

type Lap 

type Lap struct {
	MessageIndex                  typedef.MessageIndex
	Timestamp                     typedef.DateTime // Units: s; Lap end time.
	Event                         typedef.Event
	EventType                     typedef.EventType
	StartTime                     typedef.DateTime
	StartPositionLat              int32  // Units: semicircles;
	StartPositionLong             int32  // Units: semicircles;
	EndPositionLat                int32  // Units: semicircles;
	EndPositionLong               int32  // Units: semicircles;
	TotalElapsedTime              uint32 // Scale: 1000; Units: s; Time (includes pauses)
	TotalTimerTime                uint32 // Scale: 1000; Units: s; Timer Time (excludes pauses)
	TotalDistance                 uint32 // Scale: 100; Units: m;
	TotalCycles                   uint32 // Units: cycles;
	TotalCalories                 uint16 // Units: kcal;
	TotalFatCalories              uint16 // Units: kcal; If New Leaf
	AvgSpeed                      uint16 // Scale: 1000; Units: m/s;
	MaxSpeed                      uint16 // Scale: 1000; Units: m/s;
	AvgHeartRate                  uint8  // Units: bpm;
	MaxHeartRate                  uint8  // Units: bpm;
	AvgCadence                    uint8  // Units: rpm; total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time
	MaxCadence                    uint8  // Units: rpm;
	AvgPower                      uint16 // Units: watts; total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time
	MaxPower                      uint16 // Units: watts;
	TotalAscent                   uint16 // Units: m;
	TotalDescent                  uint16 // Units: m;
	Intensity                     typedef.Intensity
	LapTrigger                    typedef.LapTrigger
	Sport                         typedef.Sport
	EventGroup                    uint8
	NumLengths                    uint16 // Units: lengths; # of lengths of swim pool
	NormalizedPower               uint16 // Units: watts;
	LeftRightBalance              typedef.LeftRightBalance100
	FirstLengthIndex              uint16
	AvgStrokeDistance             uint16 // Scale: 100; Units: m;
	SwimStroke                    typedef.SwimStroke
	SubSport                      typedef.SubSport
	NumActiveLengths              uint16   // Units: lengths; # of active lengths of swim pool
	TotalWork                     uint32   // Units: J;
	AvgAltitude                   uint16   // Scale: 5; Offset: 500; Units: m;
	MaxAltitude                   uint16   // Scale: 5; Offset: 500; Units: m;
	GpsAccuracy                   uint8    // Units: m;
	AvgGrade                      int16    // Scale: 100; Units: %;
	AvgPosGrade                   int16    // Scale: 100; Units: %;
	AvgNegGrade                   int16    // Scale: 100; Units: %;
	MaxPosGrade                   int16    // Scale: 100; Units: %;
	MaxNegGrade                   int16    // Scale: 100; Units: %;
	AvgTemperature                int8     // Units: C;
	MaxTemperature                int8     // Units: C;
	TotalMovingTime               uint32   // Scale: 1000; Units: s;
	AvgPosVerticalSpeed           int16    // Scale: 1000; Units: m/s;
	AvgNegVerticalSpeed           int16    // Scale: 1000; Units: m/s;
	MaxPosVerticalSpeed           int16    // Scale: 1000; Units: m/s;
	MaxNegVerticalSpeed           int16    // Scale: 1000; Units: m/s;
	TimeInHrZone                  []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInSpeedZone               []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInCadenceZone             []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInPowerZone               []uint32 // Scale: 1000; Array: [N]; Units: s;
	RepetitionNum                 uint16
	MinAltitude                   uint16 // Scale: 5; Offset: 500; Units: m;
	MinHeartRate                  uint8  // Units: bpm;
	WktStepIndex                  typedef.MessageIndex
	OpponentScore                 uint16
	StrokeCount                   []uint16 // Array: [N]; Units: counts; stroke_type enum used as the index
	ZoneCount                     []uint16 // Array: [N]; Units: counts; zone number used as the index
	AvgVerticalOscillation        uint16   // Scale: 10; Units: mm;
	AvgStanceTimePercent          uint16   // Scale: 100; Units: percent;
	AvgStanceTime                 uint16   // Scale: 10; Units: ms;
	AvgFractionalCadence          uint8    // Scale: 128; Units: rpm; fractional part of the avg_cadence
	MaxFractionalCadence          uint8    // Scale: 128; Units: rpm; fractional part of the max_cadence
	TotalFractionalCycles         uint8    // Scale: 128; Units: cycles; fractional part of the total_cycles
	PlayerScore                   uint16
	AvgTotalHemoglobinConc        []uint16 // Scale: 100; Array: [N]; Units: g/dL; Avg saturated and unsaturated hemoglobin
	MinTotalHemoglobinConc        []uint16 // Scale: 100; Array: [N]; Units: g/dL; Min saturated and unsaturated hemoglobin
	MaxTotalHemoglobinConc        []uint16 // Scale: 100; Array: [N]; Units: g/dL; Max saturated and unsaturated hemoglobin
	AvgSaturatedHemoglobinPercent []uint16 // Scale: 10; Array: [N]; Units: %; Avg percentage of hemoglobin saturated with oxygen
	MinSaturatedHemoglobinPercent []uint16 // Scale: 10; Array: [N]; Units: %; Min percentage of hemoglobin saturated with oxygen
	MaxSaturatedHemoglobinPercent []uint16 // Scale: 10; Array: [N]; Units: %; Max percentage of hemoglobin saturated with oxygen
	AvgLeftTorqueEffectiveness    uint8    // Scale: 2; Units: percent;
	AvgRightTorqueEffectiveness   uint8    // Scale: 2; Units: percent;
	AvgLeftPedalSmoothness        uint8    // Scale: 2; Units: percent;
	AvgRightPedalSmoothness       uint8    // Scale: 2; Units: percent;
	AvgCombinedPedalSmoothness    uint8    // Scale: 2; Units: percent;
	TimeStanding                  uint32   // Scale: 1000; Units: s; Total time spent in the standing position
	StandCount                    uint16   // Number of transitions to the standing state
	AvgLeftPco                    int8     // Units: mm; Average left platform center offset
	AvgRightPco                   int8     // Units: mm; Average right platform center offset
	AvgLeftPowerPhase             []uint8  // Scale: 0.7111111; Array: [N]; Units: degrees; Average left power phase angles. Data value indexes defined by power_phase_type.
	AvgLeftPowerPhasePeak         []uint8  // Scale: 0.7111111; Array: [N]; Units: degrees; Average left power phase peak angles. Data value indexes defined by power_phase_type.
	AvgRightPowerPhase            []uint8  // Scale: 0.7111111; Array: [N]; Units: degrees; Average right power phase angles. Data value indexes defined by power_phase_type.
	AvgRightPowerPhasePeak        []uint8  // Scale: 0.7111111; Array: [N]; Units: degrees; Average right power phase peak angles. Data value indexes defined by power_phase_type.
	AvgPowerPosition              []uint16 // Array: [N]; Units: watts; Average power by position. Data value indexes defined by rider_position_type.
	MaxPowerPosition              []uint16 // Array: [N]; Units: watts; Maximum power by position. Data value indexes defined by rider_position_type.
	AvgCadencePosition            []uint8  // Array: [N]; Units: rpm; Average cadence by position. Data value indexes defined by rider_position_type.
	MaxCadencePosition            []uint8  // Array: [N]; Units: rpm; Maximum cadence by position. Data value indexes defined by rider_position_type.
	EnhancedAvgSpeed              uint32   // Scale: 1000; Units: m/s;
	EnhancedMaxSpeed              uint32   // Scale: 1000; Units: m/s;
	EnhancedAvgAltitude           uint32   // Scale: 5; Offset: 500; Units: m;
	EnhancedMinAltitude           uint32   // Scale: 5; Offset: 500; Units: m;
	EnhancedMaxAltitude           uint32   // Scale: 5; Offset: 500; Units: m;
	AvgLevMotorPower              uint16   // Units: watts; lev average motor power during lap
	MaxLevMotorPower              uint16   // Units: watts; lev maximum motor power during lap
	LevBatteryConsumption         uint8    // Scale: 2; Units: percent; lev battery consumption during lap
	AvgVerticalRatio              uint16   // Scale: 100; Units: percent;
	AvgStanceTimeBalance          uint16   // Scale: 100; Units: percent;
	AvgStepLength                 uint16   // Scale: 10; Units: mm;
	AvgVam                        uint16   // Scale: 1000; Units: m/s;
	AvgDepth                      uint32   // Scale: 1000; Units: m; 0 if above water
	MaxDepth                      uint32   // Scale: 1000; Units: m; 0 if above water
	MinTemperature                int8     // Units: C;
	EnhancedAvgRespirationRate    uint16   // Scale: 100; Units: Breaths/min;
	EnhancedMaxRespirationRate    uint16   // Scale: 100; Units: Breaths/min;
	AvgRespirationRate            uint8
	MaxRespirationRate            uint8
	TotalGrit                     float32 // Units: kGrit; The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.
	TotalFlow                     float32 // Units: Flow; The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.
	JumpCount                     uint16
	AvgGrit                       float32 // Units: kGrit; The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.
	AvgFlow                       float32 // Units: Flow; The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.
	TotalFractionalAscent         uint8   // Scale: 100; Units: m; fractional part of total_ascent
	TotalFractionalDescent        uint8   // Scale: 100; Units: m; fractional part of total_descent
	AvgCoreTemperature            uint16  // Scale: 100; Units: C;
	MinCoreTemperature            uint16  // Scale: 100; Units: C;
	MaxCoreTemperature            uint16  // Scale: 100; Units: C;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Lap is a Lap message.

func NewLap 

func NewLap(mesg proto.Message) *Lap

NewLap creates new Lap struct based on given mesg. If mesg is nil or mesg.Num is not equal to Lap mesg number, it will return nil.

func (Lap) PutMessage 

func (m Lap) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Lap mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumLap)

type Length 

type Length struct {
	MessageIndex               typedef.MessageIndex
	Timestamp                  typedef.DateTime
	Event                      typedef.Event
	EventType                  typedef.EventType
	StartTime                  typedef.DateTime
	TotalElapsedTime           uint32             // Scale: 1000; Units: s;
	TotalTimerTime             uint32             // Scale: 1000; Units: s;
	TotalStrokes               uint16             // Units: strokes;
	AvgSpeed                   uint16             // Scale: 1000; Units: m/s;
	SwimStroke                 typedef.SwimStroke // Units: swim_stroke;
	AvgSwimmingCadence         uint8              // Units: strokes/min;
	EventGroup                 uint8
	TotalCalories              uint16 // Units: kcal;
	LengthType                 typedef.LengthType
	PlayerScore                uint16
	OpponentScore              uint16
	StrokeCount                []uint16 // Array: [N]; Units: counts; stroke_type enum used as the index
	ZoneCount                  []uint16 // Array: [N]; Units: counts; zone number used as the index
	EnhancedAvgRespirationRate uint16   // Scale: 100; Units: Breaths/min;
	EnhancedMaxRespirationRate uint16   // Scale: 100; Units: Breaths/min;
	AvgRespirationRate         uint8
	MaxRespirationRate         uint8

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Length is a Length message.

func NewLength 

func NewLength(mesg proto.Message) *Length

NewLength creates new Length struct based on given mesg. If mesg is nil or mesg.Num is not equal to Length mesg number, it will return nil.

func (Length) PutMessage 

func (m Length) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Length mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumLength)

type MagnetometerData 

type MagnetometerData struct {
	Timestamp        typedef.DateTime // Units: s; Whole second part of the timestamp
	TimestampMs      uint16           // Units: ms; Millisecond part of the timestamp.
	SampleTimeOffset []uint16         // Array: [N]; Units: ms; Each time in the array describes the time at which the compass sample with the corrosponding index was taken. Limited to 30 samples in each message. The samples may span across seconds. Array size must match the number of samples in cmps_x and cmps_y and cmps_z
	MagX             []uint16         // Array: [N]; Units: counts; These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read.
	MagY             []uint16         // Array: [N]; Units: counts; These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read.
	MagZ             []uint16         // Array: [N]; Units: counts; These are the raw ADC reading. Maximum number of samples is 30 in each message. The samples may span across seconds. A conversion will need to be done on this data once read.
	CalibratedMagX   []float32        // Array: [N]; Units: G; Calibrated Magnetometer reading
	CalibratedMagY   []float32        // Array: [N]; Units: G; Calibrated Magnetometer reading
	CalibratedMagZ   []float32        // Array: [N]; Units: G; Calibrated Magnetometer reading

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

MagnetometerData is a MagnetometerData message.

func NewMagnetometerData 

func NewMagnetometerData(mesg proto.Message) *MagnetometerData

NewMagnetometerData creates new MagnetometerData struct based on given mesg. If mesg is nil or mesg.Num is not equal to MagnetometerData mesg number, it will return nil.

func (MagnetometerData) PutMessage 

func (m MagnetometerData) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to MagnetometerData mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumMagnetometerData)

type MaxMetData 

type MaxMetData struct {
	UpdateTime     typedef.DateTime // Time maxMET and vo2 were calculated
	Vo2Max         uint16           // Scale: 10; Units: mL/kg/min;
	Sport          typedef.Sport
	SubSport       typedef.SubSport
	MaxMetCategory typedef.MaxMetCategory
	CalibratedData bool                          // Indicates if calibrated data was used in the calculation
	HrSource       typedef.MaxMetHeartRateSource // Indicates if the estimate was obtained using a chest strap or wrist heart rate
	SpeedSource    typedef.MaxMetSpeedSource     // Indidcates if the estimate was obtained using onboard GPS or connected GPS

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

MaxMetData is a MaxMetData message.

func NewMaxMetData 

func NewMaxMetData(mesg proto.Message) *MaxMetData

NewMaxMetData creates new MaxMetData struct based on given mesg. If mesg is nil or mesg.Num is not equal to MaxMetData mesg number, it will return nil.

func (MaxMetData) PutMessage 

func (m MaxMetData) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to MaxMetData mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumMaxMetData)

type MemoGlob 

type MemoGlob struct {
	PartIndex   uint32               // Sequence number of memo blocks
	Memo        []byte               // Array: [N]; Deprecated. Use data field.
	MesgNum     typedef.MesgNum      // Message Number of the parent message
	ParentIndex typedef.MessageIndex // Index of mesg that this glob is associated with.
	FieldNum    uint8                // Field within the parent that this glob is associated with
	Data        []uint8              // Array: [N]; Block of utf8 bytes. Note, mutltibyte characters may be split across adjoining memo_glob messages.

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

MemoGlob is a MemoGlob message.

func NewMemoGlob 

func NewMemoGlob(mesg proto.Message) *MemoGlob

NewMemoGlob creates new MemoGlob struct based on given mesg. If mesg is nil or mesg.Num is not equal to MemoGlob mesg number, it will return nil.

func (MemoGlob) PutMessage 

func (m MemoGlob) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to MemoGlob mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumMemoGlob)

type MesgCapabilities 

type MesgCapabilities struct {
	MessageIndex typedef.MessageIndex
	File         typedef.File
	MesgNum      typedef.MesgNum
	CountType    typedef.MesgCount
	Count        uint16

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

MesgCapabilities is a MesgCapabilities message.

func NewMesgCapabilities 

func NewMesgCapabilities(mesg proto.Message) *MesgCapabilities

NewMesgCapabilities creates new MesgCapabilities struct based on given mesg. If mesg is nil or mesg.Num is not equal to MesgCapabilities mesg number, it will return nil.

func (MesgCapabilities) PutMessage 

func (m MesgCapabilities) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to MesgCapabilities mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumMesgCapabilities)

type MetZone 

type MetZone struct {
	MessageIndex typedef.MessageIndex
	HighBpm      uint8
	Calories     uint16 // Scale: 10; Units: kcal / min;
	FatCalories  uint8  // Scale: 10; Units: kcal / min;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

MetZone is a MetZone message.

func NewMetZone 

func NewMetZone(mesg proto.Message) *MetZone

NewMetZone creates new MetZone struct based on given mesg. If mesg is nil or mesg.Num is not equal to MetZone mesg number, it will return nil.

func (MetZone) PutMessage 

func (m MetZone) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to MetZone mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumMetZone)

type Monitoring 

type Monitoring struct {
	Timestamp                    typedef.DateTime    // Units: s; Must align to logging interval, for example, time must be 00:00:00 for daily log.
	DeviceIndex                  typedef.DeviceIndex // Associates this data to device_info message. Not required for file with single device (sensor).
	Calories                     uint16              // Units: kcal; Accumulated total calories. Maintained by MonitoringReader for each activity_type. See SDK documentation
	Distance                     uint32              // Scale: 100; Units: m; Accumulated distance. Maintained by MonitoringReader for each activity_type. See SDK documentation.
	Cycles                       uint32              // Scale: 2; Units: cycles; Accumulated cycles. Maintained by MonitoringReader for each activity_type. See SDK documentation.
	ActiveTime                   uint32              // Scale: 1000; Units: s;
	ActivityType                 typedef.ActivityType
	ActivitySubtype              typedef.ActivitySubtype
	ActivityLevel                typedef.ActivityLevel
	Distance16                   uint16                // Units: 100 * m;
	Cycles16                     uint16                // Units: 2 * cycles (steps);
	ActiveTime16                 uint16                // Units: s;
	LocalTimestamp               typedef.LocalDateTime // Must align to logging interval, for example, time must be 00:00:00 for daily log.
	Temperature                  int16                 // Scale: 100; Units: C; Avg temperature during the logging interval ended at timestamp
	TemperatureMin               int16                 // Scale: 100; Units: C; Min temperature during the logging interval ended at timestamp
	TemperatureMax               int16                 // Scale: 100; Units: C; Max temperature during the logging interval ended at timestamp
	ActivityTime                 []uint16              // Array: [8]; Units: minutes; Indexed using minute_activity_level enum
	ActiveCalories               uint16                // Units: kcal;
	CurrentActivityTypeIntensity byte                  // Indicates single type / intensity for duration since last monitoring message.
	TimestampMin8                uint8                 // Units: min;
	Timestamp16                  uint16                // Units: s;
	HeartRate                    uint8                 // Units: bpm;
	Intensity                    uint8                 // Scale: 10;
	DurationMin                  uint16                // Units: min;
	Duration                     uint32                // Units: s;
	Ascent                       uint32                // Scale: 1000; Units: m;
	Descent                      uint32                // Scale: 1000; Units: m;
	ModerateActivityMinutes      uint16                // Units: minutes;
	VigorousActivityMinutes      uint16                // Units: minutes;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Monitoring is a Monitoring message.

func NewMonitoring 

func NewMonitoring(mesg proto.Message) *Monitoring

NewMonitoring creates new Monitoring struct based on given mesg. If mesg is nil or mesg.Num is not equal to Monitoring mesg number, it will return nil.

func (Monitoring) PutMessage 

func (m Monitoring) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Monitoring mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumMonitoring)

type MonitoringHrData 

type MonitoringHrData struct {
	Timestamp                  typedef.DateTime // Units: s; Must align to logging interval, for example, time must be 00:00:00 for daily log.
	RestingHeartRate           uint8            // Units: bpm; 7-day rolling average
	CurrentDayRestingHeartRate uint8            // Units: bpm; RHR for today only. (Feeds into 7-day average)

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

MonitoringHrData is a MonitoringHrData message.

func NewMonitoringHrData 

func NewMonitoringHrData(mesg proto.Message) *MonitoringHrData

NewMonitoringHrData creates new MonitoringHrData struct based on given mesg. If mesg is nil or mesg.Num is not equal to MonitoringHrData mesg number, it will return nil.

func (MonitoringHrData) PutMessage 

func (m MonitoringHrData) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to MonitoringHrData mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumMonitoringHrData)

type MonitoringInfo 

type MonitoringInfo struct {
	Timestamp            typedef.DateTime       // Units: s;
	LocalTimestamp       typedef.LocalDateTime  // Units: s; Use to convert activity timestamps to local time if device does not support time zone and daylight savings time correction.
	ActivityType         []typedef.ActivityType // Array: [N];
	CyclesToDistance     []uint16               // Scale: 5000; Array: [N]; Units: m/cycle; Indexed by activity_type
	CyclesToCalories     []uint16               // Scale: 5000; Array: [N]; Units: kcal/cycle; Indexed by activity_type
	RestingMetabolicRate uint16                 // Units: kcal / day;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

MonitoringInfo is a MonitoringInfo message.

func NewMonitoringInfo 

func NewMonitoringInfo(mesg proto.Message) *MonitoringInfo

NewMonitoringInfo creates new MonitoringInfo struct based on given mesg. If mesg is nil or mesg.Num is not equal to MonitoringInfo mesg number, it will return nil.

func (MonitoringInfo) PutMessage 

func (m MonitoringInfo) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to MonitoringInfo mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumMonitoringInfo)

type NmeaSentence 

type NmeaSentence struct {
	Timestamp   typedef.DateTime // Units: s; Timestamp message was output
	TimestampMs uint16           // Units: ms; Fractional part of timestamp, added to timestamp
	Sentence    string           // NMEA sentence

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

NmeaSentence is a NmeaSentence message.

func NewNmeaSentence 

func NewNmeaSentence(mesg proto.Message) *NmeaSentence

NewNmeaSentence creates new NmeaSentence struct based on given mesg. If mesg is nil or mesg.Num is not equal to NmeaSentence mesg number, it will return nil.

func (NmeaSentence) PutMessage 

func (m NmeaSentence) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to NmeaSentence mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumNmeaSentence)

type ObdiiData 

type ObdiiData struct {
	Timestamp        typedef.DateTime // Units: s; Timestamp message was output
	TimestampMs      uint16           // Units: ms; Fractional part of timestamp, added to timestamp
	TimeOffset       []uint16         // Array: [N]; Units: ms; Offset of PID reading [i] from start_timestamp+start_timestamp_ms. Readings may span accross seconds.
	Pid              byte             // Parameter ID
	RawData          []byte           // Array: [N]; Raw parameter data
	PidDataSize      []uint8          // Array: [N]; Optional, data size of PID[i]. If not specified refer to SAE J1979.
	SystemTime       []uint32         // Array: [N]; System time associated with sample expressed in ms, can be used instead of time_offset. There will be a system_time value for each raw_data element. For multibyte pids the system_time is repeated.
	StartTimestamp   typedef.DateTime // Timestamp of first sample recorded in the message. Used with time_offset to generate time of each sample
	StartTimestampMs uint16           // Units: ms; Fractional part of start_timestamp

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

ObdiiData is a ObdiiData message.

func NewObdiiData 

func NewObdiiData(mesg proto.Message) *ObdiiData

NewObdiiData creates new ObdiiData struct based on given mesg. If mesg is nil or mesg.Num is not equal to ObdiiData mesg number, it will return nil.

func (ObdiiData) PutMessage 

func (m ObdiiData) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to ObdiiData mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumObdiiData)

type OhrSettings 

type OhrSettings struct {
	Timestamp typedef.DateTime // Units: s;
	Enabled   typedef.Switch

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

OhrSettings is a OhrSettings message.

func NewOhrSettings 

func NewOhrSettings(mesg proto.Message) *OhrSettings

NewOhrSettings creates new OhrSettings struct based on given mesg. If mesg is nil or mesg.Num is not equal to OhrSettings mesg number, it will return nil.

func (OhrSettings) PutMessage 

func (m OhrSettings) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to OhrSettings mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumOhrSettings)

type OneDSensorCalibration 

type OneDSensorCalibration struct {
	Timestamp          typedef.DateTime   // Units: s; Whole second part of the timestamp
	SensorType         typedef.SensorType // Indicates which sensor the calibration is for
	CalibrationFactor  uint32             // Calibration factor used to convert from raw ADC value to degrees, g, etc.
	CalibrationDivisor uint32             // Units: counts; Calibration factor divisor
	LevelShift         uint32             // Level shift value used to shift the ADC value back into range
	OffsetCal          int32              // Internal Calibration factor

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

OneDSensorCalibration is a OneDSensorCalibration message.

func NewOneDSensorCalibration 

func NewOneDSensorCalibration(mesg proto.Message) *OneDSensorCalibration

NewOneDSensorCalibration creates new OneDSensorCalibration struct based on given mesg. If mesg is nil or mesg.Num is not equal to OneDSensorCalibration mesg number, it will return nil.

func (OneDSensorCalibration) PutMessage 

func (m OneDSensorCalibration) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to OneDSensorCalibration mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumOneDSensorCalibration)

type PowerZone 

type PowerZone struct {
	MessageIndex typedef.MessageIndex
	HighValue    uint16 // Units: watts;
	Name         string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

PowerZone is a PowerZone message.

func NewPowerZone 

func NewPowerZone(mesg proto.Message) *PowerZone

NewPowerZone creates new PowerZone struct based on given mesg. If mesg is nil or mesg.Num is not equal to PowerZone mesg number, it will return nil.

func (PowerZone) PutMessage 

func (m PowerZone) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to PowerZone mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumPowerZone)

type Record 

type Record struct {
	Timestamp                     typedef.DateTime // Units: s;
	PositionLat                   int32            // Units: semicircles;
	PositionLong                  int32            // Units: semicircles;
	Altitude                      uint16           // Scale: 5; Offset: 500; Units: m;
	HeartRate                     uint8            // Units: bpm;
	Cadence                       uint8            // Units: rpm;
	Distance                      uint32           // Scale: 100; Units: m;
	Speed                         uint16           // Scale: 1000; Units: m/s;
	Power                         uint16           // Units: watts;
	CompressedSpeedDistance       []byte           // Scale: 100; Array: [3]; Units: m/s,m;
	Grade                         int16            // Scale: 100; Units: %;
	Resistance                    uint8            // Relative. 0 is none 254 is Max.
	TimeFromCourse                int32            // Scale: 1000; Units: s;
	CycleLength                   uint8            // Scale: 100; Units: m;
	Temperature                   int8             // Units: C;
	Speed1S                       []uint8          // Scale: 16; Array: [N]; Units: m/s; Speed at 1s intervals. Timestamp field indicates time of last array element.
	Cycles                        uint8            // Units: cycles;
	TotalCycles                   uint32           // Units: cycles;
	CompressedAccumulatedPower    uint16           // Units: watts;
	AccumulatedPower              uint32           // Units: watts;
	LeftRightBalance              typedef.LeftRightBalance
	GpsAccuracy                   uint8  // Units: m;
	VerticalSpeed                 int16  // Scale: 1000; Units: m/s;
	Calories                      uint16 // Units: kcal;
	VerticalOscillation           uint16 // Scale: 10; Units: mm;
	StanceTimePercent             uint16 // Scale: 100; Units: percent;
	StanceTime                    uint16 // Scale: 10; Units: ms;
	ActivityType                  typedef.ActivityType
	LeftTorqueEffectiveness       uint8 // Scale: 2; Units: percent;
	RightTorqueEffectiveness      uint8 // Scale: 2; Units: percent;
	LeftPedalSmoothness           uint8 // Scale: 2; Units: percent;
	RightPedalSmoothness          uint8 // Scale: 2; Units: percent;
	CombinedPedalSmoothness       uint8 // Scale: 2; Units: percent;
	Time128                       uint8 // Scale: 128; Units: s;
	StrokeType                    typedef.StrokeType
	Zone                          uint8
	BallSpeed                     uint16 // Scale: 100; Units: m/s;
	Cadence256                    uint16 // Scale: 256; Units: rpm; Log cadence and fractional cadence for backwards compatability
	FractionalCadence             uint8  // Scale: 128; Units: rpm;
	TotalHemoglobinConc           uint16 // Scale: 100; Units: g/dL; Total saturated and unsaturated hemoglobin
	TotalHemoglobinConcMin        uint16 // Scale: 100; Units: g/dL; Min saturated and unsaturated hemoglobin
	TotalHemoglobinConcMax        uint16 // Scale: 100; Units: g/dL; Max saturated and unsaturated hemoglobin
	SaturatedHemoglobinPercent    uint16 // Scale: 10; Units: %; Percentage of hemoglobin saturated with oxygen
	SaturatedHemoglobinPercentMin uint16 // Scale: 10; Units: %; Min percentage of hemoglobin saturated with oxygen
	SaturatedHemoglobinPercentMax uint16 // Scale: 10; Units: %; Max percentage of hemoglobin saturated with oxygen
	DeviceIndex                   typedef.DeviceIndex
	LeftPco                       int8    // Units: mm; Left platform center offset
	RightPco                      int8    // Units: mm; Right platform center offset
	LeftPowerPhase                []uint8 // Scale: 0.7111111; Array: [N]; Units: degrees; Left power phase angles. Data value indexes defined by power_phase_type.
	LeftPowerPhasePeak            []uint8 // Scale: 0.7111111; Array: [N]; Units: degrees; Left power phase peak angles. Data value indexes defined by power_phase_type.
	RightPowerPhase               []uint8 // Scale: 0.7111111; Array: [N]; Units: degrees; Right power phase angles. Data value indexes defined by power_phase_type.
	RightPowerPhasePeak           []uint8 // Scale: 0.7111111; Array: [N]; Units: degrees; Right power phase peak angles. Data value indexes defined by power_phase_type.
	EnhancedSpeed                 uint32  // Scale: 1000; Units: m/s;
	EnhancedAltitude              uint32  // Scale: 5; Offset: 500; Units: m;
	BatterySoc                    uint8   // Scale: 2; Units: percent; lev battery state of charge
	MotorPower                    uint16  // Units: watts; lev motor power
	VerticalRatio                 uint16  // Scale: 100; Units: percent;
	StanceTimeBalance             uint16  // Scale: 100; Units: percent;
	StepLength                    uint16  // Scale: 10; Units: mm;
	CycleLength16                 uint16  // Scale: 100; Units: m; Supports larger cycle sizes needed for paddlesports. Max cycle size: 655.35
	AbsolutePressure              uint32  // Units: Pa; Includes atmospheric pressure
	Depth                         uint32  // Scale: 1000; Units: m; 0 if above water
	NextStopDepth                 uint32  // Scale: 1000; Units: m; 0 if above water
	NextStopTime                  uint32  // Units: s;
	TimeToSurface                 uint32  // Units: s;
	NdlTime                       uint32  // Units: s;
	CnsLoad                       uint8   // Units: percent;
	N2Load                        uint16  // Units: percent;
	RespirationRate               uint8   // Units: s;
	EnhancedRespirationRate       uint16  // Scale: 100; Units: Breaths/min;
	Grit                          float32 // The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.
	Flow                          float32 // The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.
	CurrentStress                 uint16  // Scale: 100; Current Stress value
	EbikeTravelRange              uint16  // Units: km;
	EbikeBatteryLevel             uint8   // Units: percent;
	EbikeAssistMode               uint8   // Units: depends on sensor;
	EbikeAssistLevelPercent       uint8   // Units: percent;
	AirTimeRemaining              uint32  // Units: s;
	PressureSac                   uint16  // Scale: 100; Units: bar/min; Pressure-based surface air consumption
	VolumeSac                     uint16  // Scale: 100; Units: L/min; Volumetric surface air consumption
	Rmv                           uint16  // Scale: 100; Units: L/min; Respiratory minute volume
	AscentRate                    int32   // Scale: 1000; Units: m/s;
	Po2                           uint8   // Scale: 100; Units: percent; Current partial pressure of oxygen
	CoreTemperature               uint16  // Scale: 100; Units: C;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Record is a Record message.

func NewRecord 

func NewRecord(mesg proto.Message) *Record

NewRecord creates new Record struct based on given mesg. If mesg is nil or mesg.Num is not equal to Record mesg number, it will return nil.

func (Record) PutMessage 

func (m Record) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Record mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumRecord)

type RespirationRate 

type RespirationRate struct {
	Timestamp       typedef.DateTime
	RespirationRate int16 // Scale: 100; Units: breaths/min; Breaths * 100 /min, -300 indicates invalid, -200 indicates large motion, -100 indicates off wrist

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

RespirationRate is a RespirationRate message.

func NewRespirationRate 

func NewRespirationRate(mesg proto.Message) *RespirationRate

NewRespirationRate creates new RespirationRate struct based on given mesg. If mesg is nil or mesg.Num is not equal to RespirationRate mesg number, it will return nil.

func (RespirationRate) PutMessage 

func (m RespirationRate) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to RespirationRate mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumRespirationRate)

type Schedule 

type Schedule struct {
	Manufacturer  typedef.Manufacturer // Corresponds to file_id of scheduled workout / course.
	Product       uint16               // Corresponds to file_id of scheduled workout / course.
	SerialNumber  uint32               // Corresponds to file_id of scheduled workout / course.
	TimeCreated   typedef.DateTime     // Corresponds to file_id of scheduled workout / course.
	Completed     bool                 // TRUE if this activity has been started
	Type          typedef.Schedule
	ScheduledTime typedef.LocalDateTime

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Schedule is a Schedule message.

func NewSchedule 

func NewSchedule(mesg proto.Message) *Schedule

NewSchedule creates new Schedule struct based on given mesg. If mesg is nil or mesg.Num is not equal to Schedule mesg number, it will return nil.

func (Schedule) PutMessage 

func (m Schedule) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Schedule mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSchedule)

type SdmProfile 

type SdmProfile struct {
	MessageIndex      typedef.MessageIndex
	Enabled           bool
	SdmAntId          uint16
	SdmCalFactor      uint16 // Scale: 10; Units: %;
	Odometer          uint32 // Scale: 100; Units: m;
	SpeedSource       bool   // Use footpod for speed source instead of GPS
	SdmAntIdTransType uint8
	OdometerRollover  uint8 // Rollover counter that can be used to extend the odometer

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SdmProfile is a SdmProfile message.

func NewSdmProfile 

func NewSdmProfile(mesg proto.Message) *SdmProfile

NewSdmProfile creates new SdmProfile struct based on given mesg. If mesg is nil or mesg.Num is not equal to SdmProfile mesg number, it will return nil.

func (SdmProfile) PutMessage 

func (m SdmProfile) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SdmProfile mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSdmProfile)

type SegmentFile 

type SegmentFile struct {
	MessageIndex           typedef.MessageIndex
	FileUuid               string                           // UUID of the segment file
	Enabled                bool                             // Enabled state of the segment file
	UserProfilePrimaryKey  uint32                           // Primary key of the user that created the segment file
	LeaderType             []typedef.SegmentLeaderboardType // Array: [N]; Leader type of each leader in the segment file
	LeaderGroupPrimaryKey  []uint32                         // Array: [N]; Group primary key of each leader in the segment file
	LeaderActivityId       []uint32                         // Array: [N]; Activity ID of each leader in the segment file
	LeaderActivityIdString string                           // String version of the activity ID of each leader in the segment file. 21 characters long for each ID, express in decimal
	DefaultRaceLeader      uint8                            // Index for the Leader Board entry selected as the default race participant

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SegmentFile is a SegmentFile message.

func NewSegmentFile 

func NewSegmentFile(mesg proto.Message) *SegmentFile

NewSegmentFile creates new SegmentFile struct based on given mesg. If mesg is nil or mesg.Num is not equal to SegmentFile mesg number, it will return nil.

func (SegmentFile) PutMessage 

func (m SegmentFile) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SegmentFile mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSegmentFile)

type SegmentId 

type SegmentId struct {
	Name                  string                       // Friendly name assigned to segment
	Uuid                  string                       // UUID of the segment
	Sport                 typedef.Sport                // Sport associated with the segment
	Enabled               bool                         // Segment enabled for evaluation
	UserProfilePrimaryKey uint32                       // Primary key of the user that created the segment
	DeviceId              uint32                       // ID of the device that created the segment
	DefaultRaceLeader     uint8                        // Index for the Leader Board entry selected as the default race participant
	DeleteStatus          typedef.SegmentDeleteStatus  // Indicates if any segments should be deleted
	SelectionType         typedef.SegmentSelectionType // Indicates how the segment was selected to be sent to the device

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SegmentId is a SegmentId message.

func NewSegmentId 

func NewSegmentId(mesg proto.Message) *SegmentId

NewSegmentId creates new SegmentId struct based on given mesg. If mesg is nil or mesg.Num is not equal to SegmentId mesg number, it will return nil.

func (SegmentId) PutMessage 

func (m SegmentId) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SegmentId mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSegmentId)

type SegmentLap 

type SegmentLap struct {
	MessageIndex                typedef.MessageIndex
	Timestamp                   typedef.DateTime // Units: s; Lap end time.
	Event                       typedef.Event
	EventType                   typedef.EventType
	StartTime                   typedef.DateTime
	StartPositionLat            int32  // Units: semicircles;
	StartPositionLong           int32  // Units: semicircles;
	EndPositionLat              int32  // Units: semicircles;
	EndPositionLong             int32  // Units: semicircles;
	TotalElapsedTime            uint32 // Scale: 1000; Units: s; Time (includes pauses)
	TotalTimerTime              uint32 // Scale: 1000; Units: s; Timer Time (excludes pauses)
	TotalDistance               uint32 // Scale: 100; Units: m;
	TotalCycles                 uint32 // Units: cycles;
	TotalCalories               uint16 // Units: kcal;
	TotalFatCalories            uint16 // Units: kcal; If New Leaf
	AvgSpeed                    uint16 // Scale: 1000; Units: m/s;
	MaxSpeed                    uint16 // Scale: 1000; Units: m/s;
	AvgHeartRate                uint8  // Units: bpm;
	MaxHeartRate                uint8  // Units: bpm;
	AvgCadence                  uint8  // Units: rpm; total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time
	MaxCadence                  uint8  // Units: rpm;
	AvgPower                    uint16 // Units: watts; total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time
	MaxPower                    uint16 // Units: watts;
	TotalAscent                 uint16 // Units: m;
	TotalDescent                uint16 // Units: m;
	Sport                       typedef.Sport
	EventGroup                  uint8
	NecLat                      int32 // Units: semicircles; North east corner latitude.
	NecLong                     int32 // Units: semicircles; North east corner longitude.
	SwcLat                      int32 // Units: semicircles; South west corner latitude.
	SwcLong                     int32 // Units: semicircles; South west corner latitude.
	Name                        string
	NormalizedPower             uint16 // Units: watts;
	LeftRightBalance            typedef.LeftRightBalance100
	SubSport                    typedef.SubSport
	TotalWork                   uint32   // Units: J;
	AvgAltitude                 uint16   // Scale: 5; Offset: 500; Units: m;
	MaxAltitude                 uint16   // Scale: 5; Offset: 500; Units: m;
	GpsAccuracy                 uint8    // Units: m;
	AvgGrade                    int16    // Scale: 100; Units: %;
	AvgPosGrade                 int16    // Scale: 100; Units: %;
	AvgNegGrade                 int16    // Scale: 100; Units: %;
	MaxPosGrade                 int16    // Scale: 100; Units: %;
	MaxNegGrade                 int16    // Scale: 100; Units: %;
	AvgTemperature              int8     // Units: C;
	MaxTemperature              int8     // Units: C;
	TotalMovingTime             uint32   // Scale: 1000; Units: s;
	AvgPosVerticalSpeed         int16    // Scale: 1000; Units: m/s;
	AvgNegVerticalSpeed         int16    // Scale: 1000; Units: m/s;
	MaxPosVerticalSpeed         int16    // Scale: 1000; Units: m/s;
	MaxNegVerticalSpeed         int16    // Scale: 1000; Units: m/s;
	TimeInHrZone                []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInSpeedZone             []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInCadenceZone           []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInPowerZone             []uint32 // Scale: 1000; Array: [N]; Units: s;
	RepetitionNum               uint16
	MinAltitude                 uint16 // Scale: 5; Offset: 500; Units: m;
	MinHeartRate                uint8  // Units: bpm;
	ActiveTime                  uint32 // Scale: 1000; Units: s;
	WktStepIndex                typedef.MessageIndex
	SportEvent                  typedef.SportEvent
	AvgLeftTorqueEffectiveness  uint8 // Scale: 2; Units: percent;
	AvgRightTorqueEffectiveness uint8 // Scale: 2; Units: percent;
	AvgLeftPedalSmoothness      uint8 // Scale: 2; Units: percent;
	AvgRightPedalSmoothness     uint8 // Scale: 2; Units: percent;
	AvgCombinedPedalSmoothness  uint8 // Scale: 2; Units: percent;
	Status                      typedef.SegmentLapStatus
	Uuid                        string
	AvgFractionalCadence        uint8 // Scale: 128; Units: rpm; fractional part of the avg_cadence
	MaxFractionalCadence        uint8 // Scale: 128; Units: rpm; fractional part of the max_cadence
	TotalFractionalCycles       uint8 // Scale: 128; Units: cycles; fractional part of the total_cycles
	FrontGearShiftCount         uint16
	RearGearShiftCount          uint16
	TimeStanding                uint32               // Scale: 1000; Units: s; Total time spent in the standing position
	StandCount                  uint16               // Number of transitions to the standing state
	AvgLeftPco                  int8                 // Units: mm; Average left platform center offset
	AvgRightPco                 int8                 // Units: mm; Average right platform center offset
	AvgLeftPowerPhase           []uint8              // Scale: 0.7111111; Array: [N]; Units: degrees; Average left power phase angles. Data value indexes defined by power_phase_type.
	AvgLeftPowerPhasePeak       []uint8              // Scale: 0.7111111; Array: [N]; Units: degrees; Average left power phase peak angles. Data value indexes defined by power_phase_type.
	AvgRightPowerPhase          []uint8              // Scale: 0.7111111; Array: [N]; Units: degrees; Average right power phase angles. Data value indexes defined by power_phase_type.
	AvgRightPowerPhasePeak      []uint8              // Scale: 0.7111111; Array: [N]; Units: degrees; Average right power phase peak angles. Data value indexes defined by power_phase_type.
	AvgPowerPosition            []uint16             // Array: [N]; Units: watts; Average power by position. Data value indexes defined by rider_position_type.
	MaxPowerPosition            []uint16             // Array: [N]; Units: watts; Maximum power by position. Data value indexes defined by rider_position_type.
	AvgCadencePosition          []uint8              // Array: [N]; Units: rpm; Average cadence by position. Data value indexes defined by rider_position_type.
	MaxCadencePosition          []uint8              // Array: [N]; Units: rpm; Maximum cadence by position. Data value indexes defined by rider_position_type.
	Manufacturer                typedef.Manufacturer // Manufacturer that produced the segment
	TotalGrit                   float32              // Units: kGrit; The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.
	TotalFlow                   float32              // Units: Flow; The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.
	AvgGrit                     float32              // Units: kGrit; The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.
	AvgFlow                     float32              // Units: Flow; The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.
	TotalFractionalAscent       uint8                // Scale: 100; Units: m; fractional part of total_ascent
	TotalFractionalDescent      uint8                // Scale: 100; Units: m; fractional part of total_descent
	EnhancedAvgAltitude         uint32               // Scale: 5; Offset: 500; Units: m;
	EnhancedMaxAltitude         uint32               // Scale: 5; Offset: 500; Units: m;
	EnhancedMinAltitude         uint32               // Scale: 5; Offset: 500; Units: m;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SegmentLap is a SegmentLap message.

func NewSegmentLap 

func NewSegmentLap(mesg proto.Message) *SegmentLap

NewSegmentLap creates new SegmentLap struct based on given mesg. If mesg is nil or mesg.Num is not equal to SegmentLap mesg number, it will return nil.

func (SegmentLap) PutMessage 

func (m SegmentLap) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SegmentLap mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSegmentLap)

type SegmentLeaderboardEntry 

type SegmentLeaderboardEntry struct {
	MessageIndex     typedef.MessageIndex
	Name             string                         // Friendly name assigned to leader
	Type             typedef.SegmentLeaderboardType // Leader classification
	GroupPrimaryKey  uint32                         // Primary user ID of this leader
	ActivityId       uint32                         // ID of the activity associated with this leader time
	SegmentTime      uint32                         // Scale: 1000; Units: s; Segment Time (includes pauses)
	ActivityIdString string                         // String version of the activity_id. 21 characters long, express in decimal

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SegmentLeaderboardEntry is a SegmentLeaderboardEntry message.

func NewSegmentLeaderboardEntry 

func NewSegmentLeaderboardEntry(mesg proto.Message) *SegmentLeaderboardEntry

NewSegmentLeaderboardEntry creates new SegmentLeaderboardEntry struct based on given mesg. If mesg is nil or mesg.Num is not equal to SegmentLeaderboardEntry mesg number, it will return nil.

func (SegmentLeaderboardEntry) PutMessage 

func (m SegmentLeaderboardEntry) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SegmentLeaderboardEntry mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSegmentLeaderboardEntry)

type SegmentPoint 

type SegmentPoint struct {
	MessageIndex     typedef.MessageIndex
	PositionLat      int32    // Units: semicircles;
	PositionLong     int32    // Units: semicircles;
	Distance         uint32   // Scale: 100; Units: m; Accumulated distance along the segment at the described point
	Altitude         uint16   // Scale: 5; Offset: 500; Units: m; Accumulated altitude along the segment at the described point
	LeaderTime       []uint32 // Scale: 1000; Array: [N]; Units: s; Accumualted time each leader board member required to reach the described point. This value is zero for all leader board members at the starting point of the segment.
	EnhancedAltitude uint32   // Scale: 5; Offset: 500; Units: m; Accumulated altitude along the segment at the described point

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SegmentPoint is a SegmentPoint message.

func NewSegmentPoint 

func NewSegmentPoint(mesg proto.Message) *SegmentPoint

NewSegmentPoint creates new SegmentPoint struct based on given mesg. If mesg is nil or mesg.Num is not equal to SegmentPoint mesg number, it will return nil.

func (SegmentPoint) PutMessage 

func (m SegmentPoint) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SegmentPoint mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSegmentPoint)

type Session 

type Session struct {
	MessageIndex                  typedef.MessageIndex // Selected bit is set for the current session.
	Timestamp                     typedef.DateTime     // Units: s; Sesson end time.
	Event                         typedef.Event        // session
	EventType                     typedef.EventType    // stop
	StartTime                     typedef.DateTime
	StartPositionLat              int32 // Units: semicircles;
	StartPositionLong             int32 // Units: semicircles;
	Sport                         typedef.Sport
	SubSport                      typedef.SubSport
	TotalElapsedTime              uint32 // Scale: 1000; Units: s; Time (includes pauses)
	TotalTimerTime                uint32 // Scale: 1000; Units: s; Timer Time (excludes pauses)
	TotalDistance                 uint32 // Scale: 100; Units: m;
	TotalCycles                   uint32 // Units: cycles;
	TotalCalories                 uint16 // Units: kcal;
	TotalFatCalories              uint16 // Units: kcal;
	AvgSpeed                      uint16 // Scale: 1000; Units: m/s; total_distance / total_timer_time
	MaxSpeed                      uint16 // Scale: 1000; Units: m/s;
	AvgHeartRate                  uint8  // Units: bpm; average heart rate (excludes pause time)
	MaxHeartRate                  uint8  // Units: bpm;
	AvgCadence                    uint8  // Units: rpm; total_cycles / total_timer_time if non_zero_avg_cadence otherwise total_cycles / total_elapsed_time
	MaxCadence                    uint8  // Units: rpm;
	AvgPower                      uint16 // Units: watts; total_power / total_timer_time if non_zero_avg_power otherwise total_power / total_elapsed_time
	MaxPower                      uint16 // Units: watts;
	TotalAscent                   uint16 // Units: m;
	TotalDescent                  uint16 // Units: m;
	TotalTrainingEffect           uint8  // Scale: 10;
	FirstLapIndex                 uint16
	NumLaps                       uint16
	EventGroup                    uint8
	Trigger                       typedef.SessionTrigger
	NecLat                        int32  // Units: semicircles; North east corner latitude
	NecLong                       int32  // Units: semicircles; North east corner longitude
	SwcLat                        int32  // Units: semicircles; South west corner latitude
	SwcLong                       int32  // Units: semicircles; South west corner longitude
	NumLengths                    uint16 // Units: lengths; # of lengths of swim pool
	NormalizedPower               uint16 // Units: watts;
	TrainingStressScore           uint16 // Scale: 10; Units: tss;
	IntensityFactor               uint16 // Scale: 1000; Units: if;
	LeftRightBalance              typedef.LeftRightBalance100
	EndPositionLat                int32              // Units: semicircles;
	EndPositionLong               int32              // Units: semicircles;
	AvgStrokeCount                uint32             // Scale: 10; Units: strokes/lap;
	AvgStrokeDistance             uint16             // Scale: 100; Units: m;
	SwimStroke                    typedef.SwimStroke // Units: swim_stroke;
	PoolLength                    uint16             // Scale: 100; Units: m;
	ThresholdPower                uint16             // Units: watts;
	PoolLengthUnit                typedef.DisplayMeasure
	NumActiveLengths              uint16   // Units: lengths; # of active lengths of swim pool
	TotalWork                     uint32   // Units: J;
	AvgAltitude                   uint16   // Scale: 5; Offset: 500; Units: m;
	MaxAltitude                   uint16   // Scale: 5; Offset: 500; Units: m;
	GpsAccuracy                   uint8    // Units: m;
	AvgGrade                      int16    // Scale: 100; Units: %;
	AvgPosGrade                   int16    // Scale: 100; Units: %;
	AvgNegGrade                   int16    // Scale: 100; Units: %;
	MaxPosGrade                   int16    // Scale: 100; Units: %;
	MaxNegGrade                   int16    // Scale: 100; Units: %;
	AvgTemperature                int8     // Units: C;
	MaxTemperature                int8     // Units: C;
	TotalMovingTime               uint32   // Scale: 1000; Units: s;
	AvgPosVerticalSpeed           int16    // Scale: 1000; Units: m/s;
	AvgNegVerticalSpeed           int16    // Scale: 1000; Units: m/s;
	MaxPosVerticalSpeed           int16    // Scale: 1000; Units: m/s;
	MaxNegVerticalSpeed           int16    // Scale: 1000; Units: m/s;
	MinHeartRate                  uint8    // Units: bpm;
	TimeInHrZone                  []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInSpeedZone               []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInCadenceZone             []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInPowerZone               []uint32 // Scale: 1000; Array: [N]; Units: s;
	AvgLapTime                    uint32   // Scale: 1000; Units: s;
	BestLapIndex                  uint16
	MinAltitude                   uint16 // Scale: 5; Offset: 500; Units: m;
	PlayerScore                   uint16
	OpponentScore                 uint16
	OpponentName                  string
	StrokeCount                   []uint16 // Array: [N]; Units: counts; stroke_type enum used as the index
	ZoneCount                     []uint16 // Array: [N]; Units: counts; zone number used as the index
	MaxBallSpeed                  uint16   // Scale: 100; Units: m/s;
	AvgBallSpeed                  uint16   // Scale: 100; Units: m/s;
	AvgVerticalOscillation        uint16   // Scale: 10; Units: mm;
	AvgStanceTimePercent          uint16   // Scale: 100; Units: percent;
	AvgStanceTime                 uint16   // Scale: 10; Units: ms;
	AvgFractionalCadence          uint8    // Scale: 128; Units: rpm; fractional part of the avg_cadence
	MaxFractionalCadence          uint8    // Scale: 128; Units: rpm; fractional part of the max_cadence
	TotalFractionalCycles         uint8    // Scale: 128; Units: cycles; fractional part of the total_cycles
	AvgTotalHemoglobinConc        []uint16 // Scale: 100; Array: [N]; Units: g/dL; Avg saturated and unsaturated hemoglobin
	MinTotalHemoglobinConc        []uint16 // Scale: 100; Array: [N]; Units: g/dL; Min saturated and unsaturated hemoglobin
	MaxTotalHemoglobinConc        []uint16 // Scale: 100; Array: [N]; Units: g/dL; Max saturated and unsaturated hemoglobin
	AvgSaturatedHemoglobinPercent []uint16 // Scale: 10; Array: [N]; Units: %; Avg percentage of hemoglobin saturated with oxygen
	MinSaturatedHemoglobinPercent []uint16 // Scale: 10; Array: [N]; Units: %; Min percentage of hemoglobin saturated with oxygen
	MaxSaturatedHemoglobinPercent []uint16 // Scale: 10; Array: [N]; Units: %; Max percentage of hemoglobin saturated with oxygen
	AvgLeftTorqueEffectiveness    uint8    // Scale: 2; Units: percent;
	AvgRightTorqueEffectiveness   uint8    // Scale: 2; Units: percent;
	AvgLeftPedalSmoothness        uint8    // Scale: 2; Units: percent;
	AvgRightPedalSmoothness       uint8    // Scale: 2; Units: percent;
	AvgCombinedPedalSmoothness    uint8    // Scale: 2; Units: percent;
	SportProfileName              string   // Sport name from associated sport mesg
	SportIndex                    uint8
	TimeStanding                  uint32   // Scale: 1000; Units: s; Total time spend in the standing position
	StandCount                    uint16   // Number of transitions to the standing state
	AvgLeftPco                    int8     // Units: mm; Average platform center offset Left
	AvgRightPco                   int8     // Units: mm; Average platform center offset Right
	AvgLeftPowerPhase             []uint8  // Scale: 0.7111111; Array: [N]; Units: degrees; Average left power phase angles. Indexes defined by power_phase_type.
	AvgLeftPowerPhasePeak         []uint8  // Scale: 0.7111111; Array: [N]; Units: degrees; Average left power phase peak angles. Data value indexes defined by power_phase_type.
	AvgRightPowerPhase            []uint8  // Scale: 0.7111111; Array: [N]; Units: degrees; Average right power phase angles. Data value indexes defined by power_phase_type.
	AvgRightPowerPhasePeak        []uint8  // Scale: 0.7111111; Array: [N]; Units: degrees; Average right power phase peak angles data value indexes defined by power_phase_type.
	AvgPowerPosition              []uint16 // Array: [N]; Units: watts; Average power by position. Data value indexes defined by rider_position_type.
	MaxPowerPosition              []uint16 // Array: [N]; Units: watts; Maximum power by position. Data value indexes defined by rider_position_type.
	AvgCadencePosition            []uint8  // Array: [N]; Units: rpm; Average cadence by position. Data value indexes defined by rider_position_type.
	MaxCadencePosition            []uint8  // Array: [N]; Units: rpm; Maximum cadence by position. Data value indexes defined by rider_position_type.
	EnhancedAvgSpeed              uint32   // Scale: 1000; Units: m/s; total_distance / total_timer_time
	EnhancedMaxSpeed              uint32   // Scale: 1000; Units: m/s;
	EnhancedAvgAltitude           uint32   // Scale: 5; Offset: 500; Units: m;
	EnhancedMinAltitude           uint32   // Scale: 5; Offset: 500; Units: m;
	EnhancedMaxAltitude           uint32   // Scale: 5; Offset: 500; Units: m;
	AvgLevMotorPower              uint16   // Units: watts; lev average motor power during session
	MaxLevMotorPower              uint16   // Units: watts; lev maximum motor power during session
	LevBatteryConsumption         uint8    // Scale: 2; Units: percent; lev battery consumption during session
	AvgVerticalRatio              uint16   // Scale: 100; Units: percent;
	AvgStanceTimeBalance          uint16   // Scale: 100; Units: percent;
	AvgStepLength                 uint16   // Scale: 10; Units: mm;
	TotalAnaerobicTrainingEffect  uint8    // Scale: 10;
	AvgVam                        uint16   // Scale: 1000; Units: m/s;
	AvgDepth                      uint32   // Scale: 1000; Units: m; 0 if above water
	MaxDepth                      uint32   // Scale: 1000; Units: m; 0 if above water
	SurfaceInterval               uint32   // Units: s; Time since end of last dive
	StartCns                      uint8    // Units: percent;
	EndCns                        uint8    // Units: percent;
	StartN2                       uint16   // Units: percent;
	EndN2                         uint16   // Units: percent;
	AvgRespirationRate            uint8
	MaxRespirationRate            uint8
	MinRespirationRate            uint8
	MinTemperature                int8   // Units: C;
	O2Toxicity                    uint16 // Units: OTUs;
	DiveNumber                    uint32
	TrainingLoadPeak              int32   // Scale: 65536;
	EnhancedAvgRespirationRate    uint16  // Scale: 100; Units: Breaths/min;
	EnhancedMaxRespirationRate    uint16  // Scale: 100; Units: Breaths/min;
	EnhancedMinRespirationRate    uint16  // Scale: 100;
	TotalGrit                     float32 // Units: kGrit; The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.
	TotalFlow                     float32 // Units: Flow; The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.
	JumpCount                     uint16
	AvgGrit                       float32 // Units: kGrit; The grit score estimates how challenging a route could be for a cyclist in terms of time spent going over sharp turns or large grade slopes.
	AvgFlow                       float32 // Units: Flow; The flow score estimates how long distance wise a cyclist deaccelerates over intervals where deacceleration is unnecessary such as smooth turns or small grade angle intervals.
	AvgSpo2                       uint8   // Units: percent; Average SPO2 for the monitoring session
	AvgStress                     uint8   // Units: percent; Average stress for the monitoring session
	SdrrHrv                       uint8   // Units: mS; Standard deviation of R-R interval (SDRR) - Heart rate variability measure most useful for wellness users.
	RmssdHrv                      uint8   // Units: mS; Root mean square successive difference (RMSSD) - Heart rate variability measure most useful for athletes
	TotalFractionalAscent         uint8   // Scale: 100; Units: m; fractional part of total_ascent
	TotalFractionalDescent        uint8   // Scale: 100; Units: m; fractional part of total_descent
	AvgCoreTemperature            uint16  // Scale: 100; Units: C;
	MinCoreTemperature            uint16  // Scale: 100; Units: C;
	MaxCoreTemperature            uint16  // Scale: 100; Units: C;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Session is a Session message.

func NewSession 

func NewSession(mesg proto.Message) *Session

NewSession creates new Session struct based on given mesg. If mesg is nil or mesg.Num is not equal to Session mesg number, it will return nil.

func (Session) PutMessage 

func (m Session) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Session mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSession)

type Set 

type Set struct {
	Timestamp         typedef.DateTime // Timestamp of the set
	Duration          uint32           // Scale: 1000; Units: s;
	Repetitions       uint16           // # of repitions of the movement
	Weight            uint16           // Scale: 16; Units: kg; Amount of weight applied for the set
	SetType           typedef.SetType
	StartTime         typedef.DateTime           // Start time of the set
	Category          []typedef.ExerciseCategory // Array: [N];
	CategorySubtype   []uint16                   // Array: [N]; Based on the associated category, see [category]_exercise_names
	WeightDisplayUnit typedef.FitBaseUnit
	MessageIndex      typedef.MessageIndex
	WktStepIndex      typedef.MessageIndex

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Set is a Set message.

func NewSet 

func NewSet(mesg proto.Message) *Set

NewSet creates new Set struct based on given mesg. If mesg is nil or mesg.Num is not equal to Set mesg number, it will return nil.

func (Set) PutMessage 

func (m Set) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Set mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSet)

type SlaveDevice 

type SlaveDevice struct {
	Manufacturer typedef.Manufacturer
	Product      uint16

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SlaveDevice is a SlaveDevice message.

func NewSlaveDevice 

func NewSlaveDevice(mesg proto.Message) *SlaveDevice

NewSlaveDevice creates new SlaveDevice struct based on given mesg. If mesg is nil or mesg.Num is not equal to SlaveDevice mesg number, it will return nil.

func (SlaveDevice) PutMessage 

func (m SlaveDevice) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SlaveDevice mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSlaveDevice)

type SleepAssessment 

type SleepAssessment struct {
	CombinedAwakeScore       uint8  // Average of awake_time_score and awakenings_count_score. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	AwakeTimeScore           uint8  // Score that evaluates the total time spent awake between sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	AwakeningsCountScore     uint8  // Score that evaluates the number of awakenings that interrupt sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	DeepSleepScore           uint8  // Score that evaluates the amount of deep sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	SleepDurationScore       uint8  // Score that evaluates the quality of sleep based on sleep stages, heart-rate variability and possible awakenings during the night. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	LightSleepScore          uint8  // Score that evaluates the amount of light sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	OverallSleepScore        uint8  // Total score that summarizes the overall quality of sleep, combining sleep duration and quality. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	SleepQualityScore        uint8  // Score that evaluates the quality of sleep based on sleep stages, heart-rate variability and possible awakenings during the night. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	SleepRecoveryScore       uint8  // Score that evaluates stress and recovery during sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	RemSleepScore            uint8  // Score that evaluates the amount of REM sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	SleepRestlessnessScore   uint8  // Score that evaluates the amount of restlessness during sleep. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	AwakeningsCount          uint8  // The number of awakenings during sleep.
	InterruptionsScore       uint8  // Score that evaluates the sleep interruptions. If valid: 0 (worst) to 100 (best). If unknown: FIT_UINT8_INVALID.
	AverageStressDuringSleep uint16 // Scale: 100; Excludes stress during awake periods in the sleep window

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SleepAssessment is a SleepAssessment message.

func NewSleepAssessment 

func NewSleepAssessment(mesg proto.Message) *SleepAssessment

NewSleepAssessment creates new SleepAssessment struct based on given mesg. If mesg is nil or mesg.Num is not equal to SleepAssessment mesg number, it will return nil.

func (SleepAssessment) PutMessage 

func (m SleepAssessment) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SleepAssessment mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSleepAssessment)

type SleepLevel 

type SleepLevel struct {
	Timestamp  typedef.DateTime // Units: s;
	SleepLevel typedef.SleepLevel

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SleepLevel is a SleepLevel message.

func NewSleepLevel 

func NewSleepLevel(mesg proto.Message) *SleepLevel

NewSleepLevel creates new SleepLevel struct based on given mesg. If mesg is nil or mesg.Num is not equal to SleepLevel mesg number, it will return nil.

func (SleepLevel) PutMessage 

func (m SleepLevel) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SleepLevel mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSleepLevel)

type Software 

type Software struct {
	MessageIndex typedef.MessageIndex
	Version      uint16 // Scale: 100;
	PartNumber   string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Software is a Software message.

func NewSoftware 

func NewSoftware(mesg proto.Message) *Software

NewSoftware creates new Software struct based on given mesg. If mesg is nil or mesg.Num is not equal to Software mesg number, it will return nil.

func (Software) PutMessage 

func (m Software) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Software mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSoftware)

type SpeedZone 

type SpeedZone struct {
	MessageIndex typedef.MessageIndex
	HighValue    uint16 // Scale: 1000; Units: m/s;
	Name         string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

SpeedZone is a SpeedZone message.

func NewSpeedZone 

func NewSpeedZone(mesg proto.Message) *SpeedZone

NewSpeedZone creates new SpeedZone struct based on given mesg. If mesg is nil or mesg.Num is not equal to SpeedZone mesg number, it will return nil.

func (SpeedZone) PutMessage 

func (m SpeedZone) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to SpeedZone mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSpeedZone)

type Split 

type Split struct {
	SplitType        typedef.SplitType
	TotalElapsedTime uint32 // Scale: 1000; Units: s;
	TotalTimerTime   uint32 // Scale: 1000; Units: s;
	TotalDistance    uint32 // Scale: 100; Units: m;
	StartTime        typedef.DateTime

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Split is a Split message.

func NewSplit 

func NewSplit(mesg proto.Message) *Split

NewSplit creates new Split struct based on given mesg. If mesg is nil or mesg.Num is not equal to Split mesg number, it will return nil.

func (Split) PutMessage 

func (m Split) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Split mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSplit)

type Spo2Data 

type Spo2Data struct {
	Timestamp         typedef.DateTime // Units: s;
	ReadingSpo2       uint8            // Units: percent;
	ReadingConfidence uint8
	Mode              typedef.Spo2MeasurementType // Mode when data was captured

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Spo2Data is a Spo2Data message.

func NewSpo2Data 

func NewSpo2Data(mesg proto.Message) *Spo2Data

NewSpo2Data creates new Spo2Data struct based on given mesg. If mesg is nil or mesg.Num is not equal to Spo2Data mesg number, it will return nil.

func (Spo2Data) PutMessage 

func (m Spo2Data) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Spo2Data mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSpo2Data)

type Sport 

type Sport struct {
	Sport    typedef.Sport
	SubSport typedef.SubSport
	Name     string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Sport is a Sport message.

func NewSport 

func NewSport(mesg proto.Message) *Sport

NewSport creates new Sport struct based on given mesg. If mesg is nil or mesg.Num is not equal to Sport mesg number, it will return nil.

func (Sport) PutMessage 

func (m Sport) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Sport mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumSport)

type StressLevel 

type StressLevel struct {
	StressLevelValue int16
	StressLevelTime  typedef.DateTime // Units: s; Time stress score was calculated

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

StressLevel is a StressLevel message.

func NewStressLevel 

func NewStressLevel(mesg proto.Message) *StressLevel

NewStressLevel creates new StressLevel struct based on given mesg. If mesg is nil or mesg.Num is not equal to StressLevel mesg number, it will return nil.

func (StressLevel) PutMessage 

func (m StressLevel) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to StressLevel mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumStressLevel)

type TankSummary 

type TankSummary struct {
	Timestamp     typedef.DateTime // Units: s;
	Sensor        typedef.AntChannelId
	StartPressure uint16 // Scale: 100; Units: bar;
	EndPressure   uint16 // Scale: 100; Units: bar;
	VolumeUsed    uint32 // Scale: 100; Units: L;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

TankSummary is a TankSummary message.

func NewTankSummary 

func NewTankSummary(mesg proto.Message) *TankSummary

NewTankSummary creates new TankSummary struct based on given mesg. If mesg is nil or mesg.Num is not equal to TankSummary mesg number, it will return nil.

func (TankSummary) PutMessage 

func (m TankSummary) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to TankSummary mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumTankSummary)

type TankUpdate 

type TankUpdate struct {
	Timestamp typedef.DateTime // Units: s;
	Sensor    typedef.AntChannelId
	Pressure  uint16 // Scale: 100; Units: bar;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

TankUpdate is a TankUpdate message.

func NewTankUpdate 

func NewTankUpdate(mesg proto.Message) *TankUpdate

NewTankUpdate creates new TankUpdate struct based on given mesg. If mesg is nil or mesg.Num is not equal to TankUpdate mesg number, it will return nil.

func (TankUpdate) PutMessage 

func (m TankUpdate) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to TankUpdate mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumTankUpdate)

type ThreeDSensorCalibration 

type ThreeDSensorCalibration struct {
	Timestamp          typedef.DateTime   // Units: s; Whole second part of the timestamp
	SensorType         typedef.SensorType // Indicates which sensor the calibration is for
	CalibrationFactor  uint32             // Calibration factor used to convert from raw ADC value to degrees, g, etc.
	CalibrationDivisor uint32             // Units: counts; Calibration factor divisor
	LevelShift         uint32             // Level shift value used to shift the ADC value back into range
	OffsetCal          []int32            // Array: [3]; Internal calibration factors, one for each: xy, yx, zx
	OrientationMatrix  []int32            // Scale: 65535; Array: [9]; 3 x 3 rotation matrix (row major)

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

ThreeDSensorCalibration is a ThreeDSensorCalibration message.

func NewThreeDSensorCalibration 

func NewThreeDSensorCalibration(mesg proto.Message) *ThreeDSensorCalibration

NewThreeDSensorCalibration creates new ThreeDSensorCalibration struct based on given mesg. If mesg is nil or mesg.Num is not equal to ThreeDSensorCalibration mesg number, it will return nil.

func (ThreeDSensorCalibration) PutMessage 

func (m ThreeDSensorCalibration) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to ThreeDSensorCalibration mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumThreeDSensorCalibration)

type TimeInZone 

type TimeInZone struct {
	Timestamp                typedef.DateTime // Units: s;
	ReferenceMesg            typedef.MesgNum
	ReferenceIndex           typedef.MessageIndex
	TimeInHrZone             []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInSpeedZone          []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInCadenceZone        []uint32 // Scale: 1000; Array: [N]; Units: s;
	TimeInPowerZone          []uint32 // Scale: 1000; Array: [N]; Units: s;
	HrZoneHighBoundary       []uint8  // Array: [N]; Units: bpm;
	SpeedZoneHighBoundary    []uint16 // Scale: 1000; Array: [N]; Units: m/s;
	CadenceZoneHighBondary   []uint8  // Array: [N]; Units: rpm;
	PowerZoneHighBoundary    []uint16 // Array: [N]; Units: watts;
	HrCalcType               typedef.HrZoneCalc
	MaxHeartRate             uint8
	RestingHeartRate         uint8
	ThresholdHeartRate       uint8
	PwrCalcType              typedef.PwrZoneCalc
	FunctionalThresholdPower uint16

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

TimeInZone is a TimeInZone message.

func NewTimeInZone 

func NewTimeInZone(mesg proto.Message) *TimeInZone

NewTimeInZone creates new TimeInZone struct based on given mesg. If mesg is nil or mesg.Num is not equal to TimeInZone mesg number, it will return nil.

func (TimeInZone) PutMessage 

func (m TimeInZone) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to TimeInZone mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumTimeInZone)

type TimestampCorrelation 

type TimestampCorrelation struct {
	Timestamp                 typedef.DateTime      // Units: s; Whole second part of UTC timestamp at the time the system timestamp was recorded.
	FractionalTimestamp       uint16                // Scale: 32768; Units: s; Fractional part of the UTC timestamp at the time the system timestamp was recorded.
	SystemTimestamp           typedef.DateTime      // Units: s; Whole second part of the system timestamp
	FractionalSystemTimestamp uint16                // Scale: 32768; Units: s; Fractional part of the system timestamp
	LocalTimestamp            typedef.LocalDateTime // Units: s; timestamp epoch expressed in local time used to convert timestamps to local time
	TimestampMs               uint16                // Units: ms; Millisecond part of the UTC timestamp at the time the system timestamp was recorded.
	SystemTimestampMs         uint16                // Units: ms; Millisecond part of the system timestamp

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

TimestampCorrelation is a TimestampCorrelation message.

func NewTimestampCorrelation 

func NewTimestampCorrelation(mesg proto.Message) *TimestampCorrelation

NewTimestampCorrelation creates new TimestampCorrelation struct based on given mesg. If mesg is nil or mesg.Num is not equal to TimestampCorrelation mesg number, it will return nil.

func (TimestampCorrelation) PutMessage 

func (m TimestampCorrelation) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to TimestampCorrelation mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumTimestampCorrelation)

type Totals 

type Totals struct {
	MessageIndex typedef.MessageIndex
	Timestamp    typedef.DateTime // Units: s;
	TimerTime    uint32           // Units: s; Excludes pauses
	Distance     uint32           // Units: m;
	Calories     uint32           // Units: kcal;
	Sport        typedef.Sport
	ElapsedTime  uint32 // Units: s; Includes pauses
	Sessions     uint16
	ActiveTime   uint32 // Units: s;
	SportIndex   uint8

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Totals is a Totals message.

func NewTotals 

func NewTotals(mesg proto.Message) *Totals

NewTotals creates new Totals struct based on given mesg. If mesg is nil or mesg.Num is not equal to Totals mesg number, it will return nil.

func (Totals) PutMessage 

func (m Totals) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Totals mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumTotals)

type TrainingFile 

type TrainingFile struct {
	Timestamp    typedef.DateTime
	Type         typedef.File
	Manufacturer typedef.Manufacturer
	Product      uint16
	SerialNumber uint32
	TimeCreated  typedef.DateTime

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

TrainingFile is a TrainingFile message.

func NewTrainingFile 

func NewTrainingFile(mesg proto.Message) *TrainingFile

NewTrainingFile creates new TrainingFile struct based on given mesg. If mesg is nil or mesg.Num is not equal to TrainingFile mesg number, it will return nil.

func (TrainingFile) PutMessage 

func (m TrainingFile) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to TrainingFile mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumTrainingFile)

type UserProfile 

type UserProfile struct {
	MessageIndex               typedef.MessageIndex
	FriendlyName               string
	Gender                     typedef.Gender
	Age                        uint8  // Units: years;
	Height                     uint8  // Scale: 100; Units: m;
	Weight                     uint16 // Scale: 10; Units: kg;
	Language                   typedef.Language
	ElevSetting                typedef.DisplayMeasure
	WeightSetting              typedef.DisplayMeasure
	RestingHeartRate           uint8 // Units: bpm;
	DefaultMaxRunningHeartRate uint8 // Units: bpm;
	DefaultMaxBikingHeartRate  uint8 // Units: bpm;
	DefaultMaxHeartRate        uint8 // Units: bpm;
	HrSetting                  typedef.DisplayHeart
	SpeedSetting               typedef.DisplayMeasure
	DistSetting                typedef.DisplayMeasure
	PowerSetting               typedef.DisplayPower
	ActivityClass              typedef.ActivityClass
	PositionSetting            typedef.DisplayPosition
	TemperatureSetting         typedef.DisplayMeasure
	LocalId                    typedef.UserLocalId
	GlobalId                   []byte                   // Array: [6];
	WakeTime                   typedef.LocaltimeIntoDay // Typical wake time
	SleepTime                  typedef.LocaltimeIntoDay // Typical bed time
	HeightSetting              typedef.DisplayMeasure
	UserRunningStepLength      uint16 // Scale: 1000; Units: m; User defined running step length set to 0 for auto length
	UserWalkingStepLength      uint16 // Scale: 1000; Units: m; User defined walking step length set to 0 for auto length
	DepthSetting               typedef.DisplayMeasure
	DiveCount                  uint32

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

UserProfile is a UserProfile message.

func NewUserProfile 

func NewUserProfile(mesg proto.Message) *UserProfile

NewUserProfile creates new UserProfile struct based on given mesg. If mesg is nil or mesg.Num is not equal to UserProfile mesg number, it will return nil.

func (UserProfile) PutMessage 

func (m UserProfile) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to UserProfile mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumUserProfile)

type Video 

type Video struct {
	Url             string
	HostingProvider string
	Duration        uint32 // Units: ms; Playback time of video

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Video is a Video message.

func NewVideo 

func NewVideo(mesg proto.Message) *Video

NewVideo creates new Video struct based on given mesg. If mesg is nil or mesg.Num is not equal to Video mesg number, it will return nil.

func (Video) PutMessage 

func (m Video) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Video mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumVideo)

type VideoClip 

type VideoClip struct {
	ClipNumber       uint16
	StartTimestamp   typedef.DateTime
	StartTimestampMs uint16
	EndTimestamp     typedef.DateTime
	EndTimestampMs   uint16
	ClipStart        uint32 // Units: ms; Start of clip in video time
	ClipEnd          uint32 // Units: ms; End of clip in video time

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

VideoClip is a VideoClip message.

func NewVideoClip 

func NewVideoClip(mesg proto.Message) *VideoClip

NewVideoClip creates new VideoClip struct based on given mesg. If mesg is nil or mesg.Num is not equal to VideoClip mesg number, it will return nil.

func (VideoClip) PutMessage 

func (m VideoClip) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to VideoClip mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumVideoClip)

type VideoDescription 

type VideoDescription struct {
	MessageIndex typedef.MessageIndex // Long descriptions will be split into multiple parts
	MessageCount uint16               // Total number of description parts
	Text         string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

VideoDescription is a VideoDescription message.

func NewVideoDescription 

func NewVideoDescription(mesg proto.Message) *VideoDescription

NewVideoDescription creates new VideoDescription struct based on given mesg. If mesg is nil or mesg.Num is not equal to VideoDescription mesg number, it will return nil.

func (VideoDescription) PutMessage 

func (m VideoDescription) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to VideoDescription mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumVideoDescription)

type VideoFrame 

type VideoFrame struct {
	Timestamp   typedef.DateTime // Units: s; Whole second part of the timestamp
	TimestampMs uint16           // Units: ms; Millisecond part of the timestamp.
	FrameNumber uint32           // Number of the frame that the timestamp and timestamp_ms correlate to

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

VideoFrame is a VideoFrame message.

func NewVideoFrame 

func NewVideoFrame(mesg proto.Message) *VideoFrame

NewVideoFrame creates new VideoFrame struct based on given mesg. If mesg is nil or mesg.Num is not equal to VideoFrame mesg number, it will return nil.

func (VideoFrame) PutMessage 

func (m VideoFrame) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to VideoFrame mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumVideoFrame)

type VideoTitle 

type VideoTitle struct {
	MessageIndex typedef.MessageIndex // Long titles will be split into multiple parts
	MessageCount uint16               // Total number of title parts
	Text         string

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

VideoTitle is a VideoTitle message.

func NewVideoTitle 

func NewVideoTitle(mesg proto.Message) *VideoTitle

NewVideoTitle creates new VideoTitle struct based on given mesg. If mesg is nil or mesg.Num is not equal to VideoTitle mesg number, it will return nil.

func (VideoTitle) PutMessage 

func (m VideoTitle) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to VideoTitle mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumVideoTitle)

type WatchfaceSettings 

type WatchfaceSettings struct {
	MessageIndex typedef.MessageIndex
	Mode         typedef.WatchfaceMode
	Layout       byte

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

WatchfaceSettings is a WatchfaceSettings message.

func NewWatchfaceSettings 

func NewWatchfaceSettings(mesg proto.Message) *WatchfaceSettings

NewWatchfaceSettings creates new WatchfaceSettings struct based on given mesg. If mesg is nil or mesg.Num is not equal to WatchfaceSettings mesg number, it will return nil.

func (WatchfaceSettings) PutMessage 

func (m WatchfaceSettings) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to WatchfaceSettings mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumWatchfaceSettings)

type WeatherAlert 

type WeatherAlert struct {
	Timestamp  typedef.DateTime
	ReportId   string                    // Unique identifier from GCS report ID string, length is 12
	IssueTime  typedef.DateTime          // Time alert was issued
	ExpireTime typedef.DateTime          // Time alert expires
	Severity   typedef.WeatherSeverity   // Warning, Watch, Advisory, Statement
	Type       typedef.WeatherSevereType // Tornado, Severe Thunderstorm, etc.

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

WeatherAlert is a WeatherAlert message.

func NewWeatherAlert 

func NewWeatherAlert(mesg proto.Message) *WeatherAlert

NewWeatherAlert creates new WeatherAlert struct based on given mesg. If mesg is nil or mesg.Num is not equal to WeatherAlert mesg number, it will return nil.

func (WeatherAlert) PutMessage 

func (m WeatherAlert) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to WeatherAlert mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumWeatherAlert)

type WeatherConditions 

type WeatherConditions struct {
	Timestamp                typedef.DateTime      // time of update for current conditions, else forecast time
	WeatherReport            typedef.WeatherReport // Current or forecast
	Temperature              int8                  // Units: C;
	Condition                typedef.WeatherStatus // Corresponds to GSC Response weatherIcon field
	WindDirection            uint16                // Units: degrees;
	WindSpeed                uint16                // Scale: 1000; Units: m/s;
	PrecipitationProbability uint8                 // range 0-100
	TemperatureFeelsLike     int8                  // Units: C; Heat Index if GCS heatIdx above or equal to 90F or wind chill if GCS windChill below or equal to 32F
	RelativeHumidity         uint8
	Location                 string // string corresponding to GCS response location string
	ObservedAtTime           typedef.DateTime
	ObservedLocationLat      int32 // Units: semicircles;
	ObservedLocationLong     int32 // Units: semicircles;
	DayOfWeek                typedef.DayOfWeek
	HighTemperature          int8 // Units: C;
	LowTemperature           int8 // Units: C;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

WeatherConditions is a WeatherConditions message.

func NewWeatherConditions 

func NewWeatherConditions(mesg proto.Message) *WeatherConditions

NewWeatherConditions creates new WeatherConditions struct based on given mesg. If mesg is nil or mesg.Num is not equal to WeatherConditions mesg number, it will return nil.

func (WeatherConditions) PutMessage 

func (m WeatherConditions) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to WeatherConditions mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumWeatherConditions)

type WeightScale 

type WeightScale struct {
	Timestamp         typedef.DateTime // Units: s;
	Weight            typedef.Weight   // Scale: 100; Units: kg;
	PercentFat        uint16           // Scale: 100; Units: %;
	PercentHydration  uint16           // Scale: 100; Units: %;
	VisceralFatMass   uint16           // Scale: 100; Units: kg;
	BoneMass          uint16           // Scale: 100; Units: kg;
	MuscleMass        uint16           // Scale: 100; Units: kg;
	BasalMet          uint16           // Scale: 4; Units: kcal/day;
	PhysiqueRating    uint8
	ActiveMet         uint16 // Scale: 4; Units: kcal/day; ~4kJ per kcal, 0.25 allows max 16384 kcal
	MetabolicAge      uint8  // Units: years;
	VisceralFatRating uint8
	UserProfileIndex  typedef.MessageIndex // Associates this weight scale message to a user. This corresponds to the index of the user profile message in the weight scale file.
	Bmi               uint16               // Scale: 10; Units: kg/m^2;

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

WeightScale is a WeightScale message.

func NewWeightScale 

func NewWeightScale(mesg proto.Message) *WeightScale

NewWeightScale creates new WeightScale struct based on given mesg. If mesg is nil or mesg.Num is not equal to WeightScale mesg number, it will return nil.

func (WeightScale) PutMessage 

func (m WeightScale) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to WeightScale mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumWeightScale)

type Workout 

type Workout struct {
	MessageIndex   typedef.MessageIndex
	Sport          typedef.Sport
	Capabilities   typedef.WorkoutCapabilities
	NumValidSteps  uint16 // number of valid steps
	WktName        string
	SubSport       typedef.SubSport
	PoolLength     uint16 // Scale: 100; Units: m;
	PoolLengthUnit typedef.DisplayMeasure

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

Workout is a Workout message.

func NewWorkout 

func NewWorkout(mesg proto.Message) *Workout

NewWorkout creates new Workout struct based on given mesg. If mesg is nil or mesg.Num is not equal to Workout mesg number, it will return nil.

func (Workout) PutMessage 

func (m Workout) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to Workout mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumWorkout)

type WorkoutSession 

type WorkoutSession struct {
	MessageIndex   typedef.MessageIndex
	Sport          typedef.Sport
	SubSport       typedef.SubSport
	NumValidSteps  uint16
	FirstStepIndex uint16
	PoolLength     uint16 // Scale: 100; Units: m;
	PoolLengthUnit typedef.DisplayMeasure

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

WorkoutSession is a WorkoutSession message.

func NewWorkoutSession 

func NewWorkoutSession(mesg proto.Message) *WorkoutSession

NewWorkoutSession creates new WorkoutSession struct based on given mesg. If mesg is nil or mesg.Num is not equal to WorkoutSession mesg number, it will return nil.

func (WorkoutSession) PutMessage 

func (m WorkoutSession) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to WorkoutSession mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumWorkoutSession)

type WorkoutStep 

type WorkoutStep struct {
	MessageIndex                   typedef.MessageIndex
	WktStepName                    string
	DurationType                   typedef.WktStepDuration
	DurationValue                  uint32
	TargetType                     typedef.WktStepTarget
	TargetValue                    uint32
	CustomTargetValueLow           uint32
	CustomTargetValueHigh          uint32
	Intensity                      typedef.Intensity
	Notes                          string
	Equipment                      typedef.WorkoutEquipment
	ExerciseCategory               typedef.ExerciseCategory
	ExerciseName                   uint16
	ExerciseWeight                 uint16 // Scale: 100; Units: kg;
	WeightDisplayUnit              typedef.FitBaseUnit
	SecondaryTargetType            typedef.WktStepTarget
	SecondaryTargetValue           uint32
	SecondaryCustomTargetValueLow  uint32
	SecondaryCustomTargetValueHigh uint32

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

WorkoutStep is a WorkoutStep message.

func NewWorkoutStep 

func NewWorkoutStep(mesg proto.Message) *WorkoutStep

NewWorkoutStep creates new WorkoutStep struct based on given mesg. If mesg is nil or mesg.Num is not equal to WorkoutStep mesg number, it will return nil.

func (WorkoutStep) PutMessage 

func (m WorkoutStep) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to WorkoutStep mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumWorkoutStep)

type ZonesTarget 

type ZonesTarget struct {
	MaxHeartRate             uint8
	ThresholdHeartRate       uint8
	FunctionalThresholdPower uint16
	HrCalcType               typedef.HrZoneCalc
	PwrCalcType              typedef.PwrZoneCalc

	// Developer Fields are dynamic, can't be mapped as struct's fields.
	// [Added since protocol version 2.0]
	DeveloperFields []proto.DeveloperField
}

ZonesTarget is a ZonesTarget message.

func NewZonesTarget 

func NewZonesTarget(mesg proto.Message) *ZonesTarget

NewZonesTarget creates new ZonesTarget struct based on given mesg. If mesg is nil or mesg.Num is not equal to ZonesTarget mesg number, it will return nil.

func (ZonesTarget) PutMessage 

func (m ZonesTarget) PutMessage(mesg *proto.Message)

PutMessage puts fields's value into mesg. If mesg is nil or mesg.Num is not equal to ZonesTarget mesg number, it will return nil. It is the caller responsibility to provide the appropriate mesg, it's recommended to create mesg using factory: 

factory.CreateMesg(typedef.MesgNumZonesTarget)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.