// The decode function
func decode(data []byte, uuid string) []interface{} {
var bytesRemaining C.uint32_t = 1
var returnedMsgs []interface{} = nil
var used C.uint32_t
// Holder for the extracted message
pBuffer := (*C.UlMsgUnion_t)(unsafe.Pointer(&inputBuffer))
// Loop over the messages in the datagram
pStart := (*C.char)(unsafe.Pointer(&data[0]))
pNext := pStart
ppNext := (**C.char)(unsafe.Pointer(&pNext))
hexBuffer := hex.Dump(data)
globals.Dbg.PrintfInfo("%s [decode] --> the whole input buffer:\n\n%s\n\n", globals.LogTag, hexBuffer)
var decoderCount uint32
for bytesRemaining > 0 {
decoderCount = decoderCount + 1
globals.Dbg.PrintfTrace("%s [decode] --> decoding message number %d of AMQP message number %d.\n", globals.LogTag, decoderCount, amqpMessageCount)
globals.Dbg.PrintfInfo("%s -----## show buffer data ##-----\n\n%s\n\n", globals.LogTag, spew.Sdump(inputBuffer))
used = C.pointerSub(pNext, pStart)
globals.Dbg.PrintfInfo("%s [decode] --> message data used: %d.\n", globals.LogTag, used)
bytesRemaining = C.uint32_t(len(data)) - used
globals.Dbg.PrintfInfo("%s [decode] --> %d bytes remaining out of %d.\n", globals.LogTag, bytesRemaining, len(data))
if bytesRemaining > 0 {
// A place to put the XML output from the decoder
pXmlBuffer := (*C.char)(unsafe.Pointer(&(xmlDecodeBuffer[0])))
ppXmlBuffer := (**C.char)(unsafe.Pointer(&pXmlBuffer))
xmlBufferLen := (C.uint32_t)(len(xmlDecodeBuffer))
pXmlBufferLen := (*C.uint32_t)(unsafe.Pointer(&xmlBufferLen))
result := C.decodeUlMsg(ppNext, bytesRemaining, pBuffer, ppXmlBuffer, pXmlBufferLen)
globals.Dbg.PrintfTrace("%s [decode] --> decode received uplink message: %+v.\n\n-----## %s ##----- \n\n", globals.LogTag, result, ulDecodeTypeDisplay[int(result)])
globals.Dbg.PrintfInfo("%s [decode] --> XML buffer pointer 0x%08x, used %d, left %d:.\n", globals.LogTag, *ppXmlBuffer, C.uint32_t(len(xmlDecodeBuffer))-xmlBufferLen, xmlBufferLen)
//Store XmlData in MongoDB
//XmlDataStore(xmlDecodeBuffer, uuid)
//Dbg.PrintfInfo("%s [decode] --> the XML data is:\n\n%s\n\n", logTag, spew.Sdump(xmlDecodeBuffer))
// Now decode the messages and pass them to the state table
switch int(result) {
case C.DECODE_RESULT_TRANSPARENT_UL_DATAGRAM:
// TODO
case C.DECODE_RESULT_PING_REQ_UL_MSG:
// Empty message
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &PingReqUlMsg{},
})
case C.DECODE_RESULT_PING_CNF_UL_MSG:
// Empty message
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &PingCnfUlMsg{},
})
case C.DECODE_RESULT_INIT_IND_UL_MSG:
value := C.getInitIndUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &InitIndUlMsg{
WakeUpCode: WakeUpEnum(value.wakeUpCode),
RevisionLevel: uint8(value.revisionLevel),
SdCardNotRequired: bool(value.sdCardNotRequired),
DisableModemDebug: bool(value.disableModemDebug),
DisableButton: bool(value.disableButton),
DisableServerPing: bool(value.disableServerPing),
},
})
case C.DECODE_RESULT_DATE_TIME_IND_UL_MSG:
value := C.getDateTimeIndUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &DateTimeIndUlMsg{
UtmTime: time.Unix(int64(value.time), 0).Local(),
TimeSetBy: TimeSetByEnum(value.setBy),
},
})
case C.DECODE_RESULT_DATE_TIME_SET_CNF_UL_MSG:
value := C.getDateTimeSetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &DateTimeSetCnfUlMsg{
UtmTime: time.Unix(int64(value.time), 0).Local(),
TimeSetBy: TimeSetByEnum(value.setBy),
},
})
case C.DECODE_RESULT_DATE_TIME_GET_CNF_UL_MSG:
value := C.getDateTimeGetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &DateTimeGetCnfUlMsg{
UtmTime: time.Unix(int64(value.time), 0).Local(),
TimeSetBy: TimeSetByEnum(value.setBy),
},
})
case C.DECODE_RESULT_MODE_SET_CNF_UL_MSG:
value := C.getModeSetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &ModeSetCnfUlMsg{
Mode: ModeEnum(value.mode),
},
})
case C.DECODE_RESULT_MODE_GET_CNF_UL_MSG:
value := C.getModeGetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &ModeGetCnfUlMsg{
Mode: ModeEnum(value.mode),
},
})
case C.DECODE_RESULT_HEARTBEAT_SET_CNF_UL_MSG:
value := C.getHeartbeatSetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &HeartbeatSetCnfUlMsg{
HeartbeatSeconds: uint32(value.heartbeatSeconds),
HeartbeatSnapToRtc: bool(value.heartbeatSnapToRtc),
},
})
case C.DECODE_RESULT_REPORTING_INTERVAL_SET_CNF_UL_MSG:
value := C.getReportingIntervalSetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &ReportingIntervalSetCnfUlMsg{
ReportingInterval: uint32(value.reportingInterval),
},
})
case C.DECODE_RESULT_INTERVALS_GET_CNF_UL_MSG:
value := C.getIntervalsGetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &IntervalsGetCnfUlMsg{
ReportingInterval: uint32(value.reportingInterval),
HeartbeatSeconds: uint32(value.heartbeatSeconds),
HeartbeatSnapToRtc: bool(value.heartbeatSnapToRtc),
},
})
case C.DECODE_RESULT_POLL_IND_UL_MSG:
value := C.getPollIndUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &PollIndUlMsg{
Mode: ModeEnum(value.mode),
EnergyLeft: EnergyLeftEnum(value.energyLeft),
DiskSpaceLeft: DiskSpaceLeftEnum(value.diskSpaceLeft),
},
})
case C.DECODE_RESULT_MEASUREMENTS_IND_UL_MSG:
value := C.getMeasurementsIndUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &MeasurementsIndUlMsg{ // Structure initialisation is just horrible in this language
Measurements: MeasurementData{
TimeMeasured: time.Unix(int64(value.measurements.time), 0).Local(),
GnssPositionPresent: bool(value.measurements.gnssPositionPresent),
GnssPosition: GnssPosition{
Latitude: int32(value.measurements.gnssPosition.latitude),
Longitude: int32(value.measurements.gnssPosition.longitude),
Elevation: int32(value.measurements.gnssPosition.elevation),
},
CellIdPresent: bool(value.measurements.cellIdPresent),
CellId: CellId(value.measurements.cellId),
RsrpPresent: bool(value.measurements.rsrpPresent),
Rsrp: Rsrp{
Value: Rssi(value.measurements.rsrp.value),
IsSyncedWithRssi: bool(value.measurements.rsrp.isSyncedWithRssi),
},
RssiPresent: bool(value.measurements.rssiPresent),
Rssi: Rssi(value.measurements.rssi),
TemperaturePresent: bool(value.measurements.temperaturePresent),
Temperature: Temperature(value.measurements.temperature),
PowerStatePresent: bool(value.measurements.powerStatePresent),
PowerState: PowerState{
ChargerState: ChargerStateEnum(value.measurements.powerState.chargerState),
BatteryMv: uint16(value.measurements.powerState.batteryMV),
EnergyMwh: uint32(value.measurements.powerState.energyMWh),
},
},
},
})
case C.DECODE_RESULT_MEASUREMENTS_GET_CNF_UL_MSG:
value := C.getMeasurementsGetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &MeasurementsIndUlMsg{ // Still horrible
Measurements: MeasurementData{
TimeMeasured: time.Unix(int64(value.measurements.time), 0).Local(),
GnssPositionPresent: bool(value.measurements.gnssPositionPresent),
GnssPosition: GnssPosition{
Latitude: int32(value.measurements.gnssPosition.latitude),
Longitude: int32(value.measurements.gnssPosition.longitude),
Elevation: int32(value.measurements.gnssPosition.elevation),
},
CellIdPresent: bool(value.measurements.cellIdPresent),
CellId: CellId(value.measurements.cellId),
RsrpPresent: bool(value.measurements.rsrpPresent),
Rsrp: Rsrp{
Value: Rssi(value.measurements.rsrp.value),
IsSyncedWithRssi: bool(value.measurements.rsrp.isSyncedWithRssi),
},
RssiPresent: bool(value.measurements.rssiPresent),
Rssi: Rssi(value.measurements.rssi),
TemperaturePresent: bool(value.measurements.temperaturePresent),
Temperature: Temperature(value.measurements.temperature),
PowerStatePresent: bool(value.measurements.powerStatePresent),
PowerState: PowerState{
ChargerState: ChargerStateEnum(value.measurements.powerState.chargerState),
BatteryMv: uint16(value.measurements.powerState.batteryMV),
EnergyMwh: uint32(value.measurements.powerState.energyMWh),
},
},
},
})
case C.DECODE_RESULT_MEASUREMENTS_CONTROL_IND_UL_MSG:
// TODO
case C.DECODE_RESULT_MEASUREMENT_CONTROL_SET_CNF_UL_MSG:
// TODO
case C.DECODE_RESULT_MEASUREMENTS_CONTROL_GET_CNF_UL_MSG:
// TODO
case C.DECODE_RESULT_MEASUREMENTS_CONTROL_DEFAULTS_SET_CNF_UL_MSG:
// TODO
case C.DECODE_RESULT_TRAFFIC_REPORT_IND_UL_MSG:
value := C.getTrafficReportIndUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &TrafficReportIndUlMsg{
NumDatagramsUl: uint32(value.numDatagramsUl),
NumBytesUl: uint32(value.numBytesUl),
NumDatagramsDl: uint32(value.numDatagramsDl),
NumBytesDl: uint32(value.numBytesDl),
NumDatagramsDlBadChecksum: uint32(value.numDatagramsDlBadChecksum),
},
})
case C.DECODE_RESULT_TRAFFIC_REPORT_GET_CNF_UL_MSG:
value := C.getTrafficReportGetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &TrafficReportGetCnfUlMsg{
NumDatagramsUl: uint32(value.numDatagramsUl),
NumBytesUl: uint32(value.numBytesUl),
NumDatagramsDl: uint32(value.numDatagramsDl),
NumBytesDl: uint32(value.numBytesDl),
NumDatagramsDlBadChecksum: uint32(value.numDatagramsDlBadChecksum),
},
})
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_PARAMETERS_SET_CNF_UL_MSG:
value := C.getTrafficTestModeParametersSetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &TrafficTestModeParametersSetCnfUlMsg{
NumUlDatagrams: uint32(value.numUlDatagrams),
LenUlDatagram: uint32(value.lenUlDatagram),
NumDlDatagrams: uint32(value.numDlDatagrams),
LenDlDatagram: uint32(value.lenDlDatagram),
},
})
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_PARAMETERS_GET_CNF_UL_MSG:
value := C.getTrafficTestModeParametersGetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &TrafficTestModeParametersGetCnfUlMsg{
NumUlDatagrams: uint32(value.numUlDatagrams),
LenUlDatagram: uint32(value.lenUlDatagram),
NumDlDatagrams: uint32(value.numDlDatagrams),
LenDlDatagram: uint32(value.lenDlDatagram),
},
})
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_RULE_BREAKER_UL_DATAGRAM:
// TODO
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_REPORT_IND_UL_MSG:
value := C.getTrafficTestModeReportIndUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &TrafficTestModeReportIndUlMsg{
NumTrafficTestDatagramsUl: uint32(value.numTrafficTestDatagramsUl),
NumTrafficTestBytesUl: uint32(value.numTrafficTestBytesUl),
NumTrafficTestDatagramsDl: uint32(value.numTrafficTestDatagramsDl),
NumTrafficTestBytesDl: uint32(value.numTrafficTestBytesDl),
NumTrafficTestDlDatagramsOutOfOrder: uint32(value.numTrafficTestDlDatagramsOutOfOrder),
NumTrafficTestDlDatagramsBad: uint32(value.numTrafficTestDlDatagramsBad),
NumTrafficTestDlDatagramsMissed: uint32(value.numTrafficTestDlDatagramsMissed),
TimedOut: bool(value.timedOut),
},
})
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_REPORT_GET_CNF_UL_MSG:
value := C.getTrafficTestModeReportGetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &TrafficTestModeReportGetCnfUlMsg{
NumTrafficTestDatagramsUl: uint32(value.numTrafficTestDatagramsUl),
NumTrafficTestBytesUl: uint32(value.numTrafficTestBytesUl),
NumTrafficTestDatagramsDl: uint32(value.numTrafficTestDatagramsDl),
NumTrafficTestBytesDl: uint32(value.numTrafficTestBytesDl),
NumTrafficTestDlDatagramsOutOfOrder: uint32(value.numTrafficTestDlDatagramsOutOfOrder),
NumTrafficTestDlDatagramsBad: uint32(value.numTrafficTestDlDatagramsBad),
NumTrafficTestDlDatagramsMissed: uint32(value.numTrafficTestDlDatagramsMissed),
TimedOut: bool(value.timedOut),
},
})
case C.DECODE_RESULT_ACTIVITY_REPORT_IND_UL_MSG:
value := C.getActivityReportIndUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &ActivityReportIndUlMsg{
TotalTransmitMilliseconds: uint32(value.totalTransmitMilliseconds),
TotalReceiveMilliseconds: uint32(value.totalReceiveMilliseconds),
UpTimeSeconds: uint32(value.upTimeSeconds),
TxPowerDbmPresent: bool(value.txPowerDbmPresent),
TxPowerDbm: int8(value.txPowerDbm),
UlMcsPresent: bool(value.ulMcsPresent),
UlMcs: uint8(value.ulMcs),
DlMcsPresent: bool(value.dlMcsPresent),
DlMcs: uint8(value.dlMcs),
},
})
case C.DECODE_RESULT_ACTIVITY_REPORT_GET_CNF_UL_MSG:
value := C.getActivityReportGetCnfUlMsg(inputBuffer)
returnedMsgs = append(returnedMsgs,
&MessageContainer{
DeviceUuid: uuid,
Timestamp: time.Now(),
Message: &ActivityReportGetCnfUlMsg{
TotalTransmitMilliseconds: uint32(value.totalTransmitMilliseconds),
TotalReceiveMilliseconds: uint32(value.totalReceiveMilliseconds),
UpTimeSeconds: uint32(value.upTimeSeconds),
TxPowerDbmPresent: bool(value.txPowerDbmPresent),
TxPowerDbm: int8(value.txPowerDbm),
UlMcsPresent: bool(value.ulMcsPresent),
UlMcs: uint8(value.ulMcs),
DlMcsPresent: bool(value.dlMcsPresent),
DlMcs: uint8(value.dlMcs),
},
})
case C.DECODE_RESULT_DEBUG_IND_UL_MSG:
// TODO
case C.DECODE_RESULT_FAILURE:
case C.DECODE_RESULT_INPUT_TOO_SHORT:
case C.DECODE_RESULT_OUTPUT_TOO_SHORT:
case C.DECODE_RESULT_UNKNOWN_MSG_ID:
case C.DECODE_RESULT_BAD_MSG_FORMAT:
case C.DECODE_RESULT_BAD_TRAFFIC_TEST_MODE_DATAGRAM:
// TODO
case C.DECODE_RESULT_OUT_OF_SEQUENCE_TRAFFIC_TEST_MODE_DATAGRAM:
// TODO
case C.DECODE_RESULT_BAD_CHECKSUM:
default:
// Can't decode the message, throw it away silently
}
}
}
totalUlMsgs += len(returnedMsgs)
totalUlBytes += int(used)
lastUlMsgTime = time.Now()
return returnedMsgs
}
func decode(data []byte) {
var xmlBuffer [8192]C.char
// A place to put the XML output from the decoder
// pXmlBuffer := (*C.char)(unsafe.Pointer(&(xmlBuffer[0])))
// ppXmlBuffer := (**C.char)(unsafe.Pointer(&pXmlBuffer))
// xmlBufferLen := (C.uint32_t)(len(xmlBuffer))
// pXmlBufferLen := (*C.uint32_t)(unsafe.Pointer(&xmlBufferLen))
// Holder for the extracted message
var inputBuffer C.union_UlMsgUnionTag_t
inputPointer := (*C.UlMsgUnion_t)(unsafe.Pointer(&inputBuffer))
//Row.TotalMsgs = Row.TotalMsgs + uint64(len(data))
Row.UTotalMsgs = Row.UTotalMsgs + uint64(len(data))
// Loop over the messages in the datagram
startPointer := (*C.char)(unsafe.Pointer(&data[0]))
nextPointer := (*C.char)(unsafe.Pointer(&data[0]))
nextPointerPointer := (**C.char)(unsafe.Pointer(&nextPointer))
hexBuffer := hex.Dump(data)
fmt.Printf("\n\n===>The Whole Input Butter (%s) \n", hexBuffer)
var decoderCount int
for {
decoderCount = decoderCount + 1
//TotalMsgs = TotalMsgs + 1
now := time.Now()
Row.LastMsgReceived = &now
fmt.Printf("\n\n===>DECODING MESSAGE NO (%v) OF AMQP DATAGRAM NO (%v) \n", decoderCount, amqpCount)
fmt.Printf("\n%s -----## SHOW BUFFER DATA ##----- \n\n %s\n\n", logTag, spew.Sdump(inputBuffer))
used := C.pointerSub(nextPointer, startPointer)
fmt.Printf("%s MESSAGE DATA USED %s\n", logTag, spew.Sdump(used))
remaining := C.uint32_t(len(data)) - used
fmt.Printf("%s MESSAGE DATA REMAINING %s\n", logTag, spew.Sdump(remaining))
if remaining == 0 {
break
}
//result := C.decodeUlMsg(nextPointerPointer, remaining, inputPointer, ppXmlBuffer, pXmlBufferLen)
result := C.decodeUlMsg(nextPointerPointer, remaining, inputPointer, nil, nil)
//Store XmlData in MongoDB
XmlDataStore(xmlBuffer)
fmt.Printf("\n%s -----+++ THE XML DATA IS ++----- \n\n %s\n\n", logTag, spew.Sdump(xmlBuffer))
fmt.Printf("%s DECODE RECEIVED UPLINK MESSAGE %+v \n\n -----## %s ##----- \n\n", logTag, result, ulDecodeTypeDisplay[int(result)])
// Extract any data to be recorded; the C symbols are not available outside
// the package so convert into concrete go types
var data interface{} = nil
var rawData interface{} = nil
var multipleRecords []interface{} = nil
switch int(result) {
case C.DECODE_RESULT_INIT_IND_UL_MSG:
value := C.getInitIndUlMsg(inputBuffer)
rawData = value
data = &InitIndUlMsg{
Timestamp: time.Now(),
WakeUpCode: WakeUpEnum(value.wakeUpCode),
RevisionLevel: uint16(value.revisionLevel),
sdCardNotRequired: bool(value.sdCardNotRequired),
}
case C.DECODE_RESULT_INTERVALS_GET_CNF_UL_MSG:
value := C.getIntervalsGetCnfUlMsg(inputBuffer)
rawData = value
data = &IntervalsGetCnfUlMsg{
ReportingInterval: uint32(value.reportingInterval),
HeartbeatSeconds: uint32(value.heartbeatSeconds),
HeartbeatSnapToRtc: bool(value.heartbeatSnapToRtc),
}
Row.ReportingInterval = uint32(value.reportingInterval)
Row.HeartbeatSeconds = uint32(value.heartbeatSeconds)
Row.HeartbeatSnapToRtc = bool(value.heartbeatSnapToRtc)
multipleRecords = append(multipleRecords, Row)
fmt.Printf("%s RECEIVED INTERVAL REQUEST CONFIRM %s\n", logTag, spew.Sdump(Row))
case C.DECODE_RESULT_REPORTING_INTERVAL_SET_CNF_UL_MSG:
value := C.getReportingIntervalSetCnfUlMsg(inputBuffer)
rawData = value
data = &ReportingIntervalSetCnfUlMsg{
Timestamp: time.Now(),
//ReportingIntervalMinutes: uint32(value.reportingInterval),
}
case C.DECODE_RESULT_HEARTBEAT_SET_CNF_UL_MSG:
rawData = C.getHeartbeatSetCnfUlMsg(inputBuffer)
case C.DECODE_RESULT_POLL_IND_UL_MSG:
value := C.getPollIndUlMsg(inputBuffer)
rawData = value
data = &PollIndUlMsg{
Mode: string(ModeEnum(value.mode)),
EnergyLeft: string(EnergyLeftEnum(value.energyLeft)),
DiskSpaceLeft: string(DiskSpaceLeft(value.diskSpaceLeft)),
}
//Row.UTotalMsgs = TotalMsgs
Row.Mode = ModeLookUp[string(ModeEnum(value.mode))]
Row.BatteryLevel = EnergyLeftLookUP[int(EnergyLeftEnum(value.energyLeft))]
Row.DiskSpaceLeft = DiskSpaceLookUP[int(DiskSpaceLeft(value.diskSpaceLeft))]
multipleRecords = append(multipleRecords, Row)
//encodeAndEnqueueIntervalGetReq(Row.Uuid)
case C.DECODE_RESULT_DEBUG_IND_UL_MSG:
rawData = C.getDebugIndUlMsg(inputBuffer)
case C.DECODE_RESULT_TRAFFIC_REPORT_GET_CNF_UL_MSG:
rawData = C.getTrafficReportGetCnfUlMsg(inputBuffer)
case C.DECODE_RESULT_TRAFFIC_REPORT_IND_UL_MSG:
value := C.getTrafficReportIndUlMsg(inputBuffer)
rawData = value
data = &TrafficReportIndUlMsg{
numDatagramsUl: int32(value.numDatagramsUl),
numBytesUl: int32(value.numBytesUl),
numDatagramsDl: int32(value.numDatagramsDl),
numBytesDl: int32(value.numBytesDl),
}
case C.DECODE_RESULT_TRANSPARENT_UL_DATAGRAM:
rawData = "value"
//encodeAndEnqueueIntervalGetReq(Row.Uuid)
case C.DECODE_RESULT_DATE_TIME_IND_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_DATE_TIME_SET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_DATE_TIME_GET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_MODE_SET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_MODE_GET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_MEASUREMENTS_GET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_MEASUREMENTS_IND_UL_MSG:
value := C.getMeasurementsIndUlMsg(inputBuffer)
rawData = value
Row.RSRP = int32(value.measurements.rsrp.value) / 10
case C.DECODE_RESULT_MEASUREMENT_CONTROL_SET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_MEASUREMENTS_CONTROL_GET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_MEASUREMENTS_CONTROL_IND_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_MEASUREMENTS_CONTROL_DEFAULTS_SET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_PARAMETERS_SET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_PARAMETERS_GET_CNF_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_RULE_BREAKER_UL_DATAGRAM:
rawData = "value"
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_REPORT_IND_UL_MSG:
rawData = "value"
case C.DECODE_RESULT_TRAFFIC_TEST_MODE_REPORT_GET_CNF_UL_MSG:
rawData = "value"
default:
// Can't decode the uplink; this case is here to avoid a panic,
// the code below will handle this situation fine
}
// Send any data to be recorded
if multipleRecords != nil {
// Iterate once to get a description of the objects to be recorded and display it
txt := ""
for _, record := range multipleRecords {
txt = fmt.Sprintf("%s%+v ", txt, record)
}
fmt.Printf("%s MULTIPLE DECODED ENTRIES BEING RECORDED = %s\n", logTag, txt)
// Then record the objects
for _, record := range multipleRecords {
StateTableCmds <- record
}
} else if data != nil {
fmt.Printf("%s DECODED DATA BEING RECORDED = %+v\n", logTag, data)
StateTableCmds <- data
} else if rawData != nil {
fmt.Printf("%s DATA NOT BEING RECORDED = %+v\n", logTag, rawData)
} else {
fmt.Printf("%s ERROR: UNDECODABLE MESSGE RECEIVED %s\n", logTag, spew.Sdump(inputBuffer))
//if you get here, break from this loop;
break
}
}
decoderCount = 0
}