started to implement reading characteristics values

added record manager.go to get characteristics data.
added toHashmap method to a2l.A2L.

Author: asap2Go

a2l/a2l.go

@@ -1,6 +1,7 @@
 package a2l
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"os"
@@ -32,6 +33,23 @@ type A2L struct {
 	Project      Project
 }
 
+// toHashMap recursively generates a HashMap of all structs and their values in the a2l struct
+// potentially useful if goPy is used to build a python library of calibrationReader
+func (a *A2L) toHashMap() (map[string]interface{}, error) {
+	var m map[string]interface{}
+	bytes, err := json.Marshal(a)
+	if err != nil {
+		log.Err(err).Msg("could not serialize a2l struct into json")
+		return m, err
+	}
+	err = json.Unmarshal(bytes, &m)
+	if err != nil {
+		log.Err(err).Msg("could not deserialize json into hashmap")
+		return m, err
+	}
+	return m, err
+}
+
 // ParseFromFile is the main exported function to be called from a2l package.
 // it takes an .a2l file and parses it
 func ParseFromFile(filepath string) (A2L, error) {

a2l/a2l_test.go

@@ -26,6 +26,30 @@ func TestParseFromFile(t *testing.T) {
 	log.Info().Msg("time for parsing a2l test file: " + fmt.Sprint(elapsed.Milliseconds()) + "[ms]")
 }
 
+func TestMapify(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.InfoLevel)
+	a2lPath := "testing/ASAP2_Demo_V171_allKeywords.a2l"
+	a, err := ParseFromFile(a2lPath)
+	if err != nil {
+		t.Fatalf("failed parsing with error: %s.", err)
+	}
+	startTime := time.Now()
+	hm, err := a.toHashMap()
+	if err != nil {
+		t.Fatalf("failed to convert a2l struct into hashmap %s.", err)
+	}
+	endTime := time.Now()
+	elapsed := endTime.Sub(startTime)
+	_, err = fmt.Println(hm)
+	if err != nil {
+		log.Err(err).Msg("failed to print hashmap")
+		t.Fatalf("failed to print a2l struct hashmap %s.", err)
+	}
+	log.Info().Str("project name", a.Project.Name).Msg("finished parsing:")
+	log.Info().Msg("time for parsing a2l test file: " + fmt.Sprint(elapsed.Milliseconds()) + "[ms]")
+}
+
 func FuzzParseA2L(f *testing.F) {
 	configureLogger()
 	zerolog.SetGlobalLevel(zerolog.WarnLevel)

a2l/a2ml_version.go

@@ -7,7 +7,8 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
-/*a2mlVersion exists in order to declare what kind of BLOBs should be generated from
+/*
+a2mlVersion exists in order to declare what kind of BLOBs should be generated from
 the AML parts. Since ASAP2 version 1.3.1 a specification for the storage layout of the
 BLOBs exist. The keyword is optional. When the keyword is omitted, or the version
 number is below 1.3.1 then the old BLOB format is used. When the A2ML version number
@@ -17,13 +18,14 @@ The A2ML version can be expressed by two numerals:
 - UpgradeNo
 where ‘VersionNo’ represents the main version number and ‘UpgradeNo’ the upgrade
 number (fractional part of version number).
-This keyword will not be interpreted semantically anymore.*/
+This keyword will not be interpreted semantically anymore.
+*/
 type a2mlVersion struct {
-	//versionNo contains the Version number of AML part
-	versionNo    uint16
+	//VersionNo contains the Version number of AML part
+	VersionNo    uint16
 	versionNoSet bool
-	//upgradeNo contains the Upgrade number of AML part
-	upgradeNo    uint16
+	//UpgradeNo contains the Upgrade number of AML part
+	UpgradeNo    uint16
 	upgradeNoSet bool
 }
 
@@ -48,7 +50,7 @@ forLoop:
 				log.Err(err).Msg("a2mlVersion versionNo could not be parsed")
 				break forLoop
 			}
-			av.versionNo = uint16(buf)
+			av.VersionNo = uint16(buf)
 			av.versionNoSet = true
 			log.Info().Msg("a2mlVersion versionNo successfully parsed")
 		} else if !av.upgradeNoSet {
@@ -58,7 +60,7 @@ forLoop:
 				log.Err(err).Msg("a2mlVersion upgradeNo could not be parsed")
 				break forLoop
 			}
-			av.upgradeNo = uint16(buf)
+			av.UpgradeNo = uint16(buf)
 			av.upgradeNoSet = true
 			log.Info().Msg("a2mlVersion upgradeNo successfully parsed")
 			break forLoop

a2l/mod_par.go

@@ -22,14 +22,14 @@ type modPar struct {
 	noOfInterfaces       noOfInterfaces
 	phoneNo              phoneNo
 	supplier             supplier
-	SystemConstants      map[string]systemConstant
+	SystemConstants      map[string]SystemConstant
 	user                 user
 	version              version
 }
 
 func parseModPar(tok *tokenGenerator) (modPar, error) {
 	mp := modPar{}
-	mp.SystemConstants = make(map[string]systemConstant, 2000)
+	mp.SystemConstants = make(map[string]SystemConstant, 2000)
 	var err error
 forLoop:
 	for {
@@ -134,7 +134,7 @@ forLoop:
 			}
 			log.Info().Msg("modPar supplier successfully parsed")
 		case systemConstantToken:
-			var buf systemConstant
+			var buf SystemConstant
 			buf, err = parseSystemConstant(tok)
 			if err != nil {
 				log.Err(err).Msg("modPar systemConstant could not be parsed")

a2l/system_constant.go

@@ -6,15 +6,15 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
-type systemConstant struct {
+type SystemConstant struct {
 	name     string
 	nameSet  bool
 	value    string
 	valueSet bool
 }
 
-func parseSystemConstant(tok *tokenGenerator) (systemConstant, error) {
-	sc := systemConstant{}
+func parseSystemConstant(tok *tokenGenerator) (SystemConstant, error) {
+	sc := SystemConstant{}
 	var err error
 forLoop:
 	for {

calib_data.go

@@ -29,15 +29,17 @@ import (
 // CalibrationData contains the parsed structs from the a2l as well as the byte data from the hex file
 // that are parsed by ReadCalibration()
 type CalibrationData struct {
-	A2l a2l.A2L
-	Hex map[uint32]byte
+	A2l         a2l.A2L
+	ModuleIndex uint8
+	Hex         map[uint32]byte
 }
 
 // ReadCalibration takes filepaths to the a2l file and the hex file,
 // parses them in parallel and returns a CalibrationData struct
 func ReadCalibration(a2lFilePath string, hexFilePath string) (CalibrationData, error) {
 	var err error
 	var cd CalibrationData
+	cd.ModuleIndex = 0
 	var errChan = make(chan error, 2)
 	var a2lChan = make(chan a2l.A2L, 1)
 	var hexChan = make(chan map[uint32]byte, 1)

characteristic_types.go

@@ -4,22 +4,58 @@ import (
 	"errors"
 
 	"github.com/asap2Go/calibrationReader/a2l"
+	"github.com/rs/zerolog/log"
 )
 
-func getValue(m *a2l.Module, c *a2l.Characteristic) (error, interface{}) {
+func (cd *CalibrationData) getSystemConstant(ident string) (a2l.SystemConstant, error) {
+	modPar := cd.A2l.Project.Modules[cd.ModuleIndex].ModPar
+	s, exists := modPar.SystemConstants[ident]
+	if !exists {
+		err := errors.New("no system constant with name " + ident)
+		log.Err(err).Msg("system constant not found")
+		return s, err
+	}
+	return s, nil
+}
+
+func (cd *CalibrationData) getCharacteristicValueBinary(c a2l.Characteristic) (interface{}, error) {
 	var err error
+	rl, err := cd.getRecordLayout(c)
+	if err != nil {
+		return nil, err
+	}
+	log.Debug().Msg("record layout " + rl.Name + "found")
+	return err, nil
+}
+
+func (cd *CalibrationData) getCharacteristicValueDecimal() (interface{}, error) {
+	return nil, nil
+}
 
-	//get record layout for characteristic
+func (cd *CalibrationData) getCharacteristicValueDisplay() (interface{}, error) {
+	return nil, nil
+}
+
+func (cd *CalibrationData) getCharacteristicValueHex() (interface{}, error) {
+	return nil, nil
+}
+
+// get record layout for a specified characteristic
+func (cd *CalibrationData) getRecordLayout(c a2l.Characteristic) (a2l.RecordLayout, error) {
+	var err error
+	var rl a2l.RecordLayout
+	module := cd.A2l.Project.Modules[cd.ModuleIndex]
 	if !c.DepositSet {
 		err = errors.New("no deposit set in characteristic " + c.Name)
-		return err, nil
+		log.Err(err).Msg("record layout not found")
+		return rl, err
 	}
-
-	rl, exists := m.RecordLayouts[c.Deposit]
+	var exists bool
+	rl, exists = module.RecordLayouts[c.Deposit]
 	if !exists {
 		err = errors.New("no record layout found for deposit identifier" + c.Deposit + " of characteristic " + c.Name)
-		return err, nil
+		log.Err(err).Msg("record layout not found")
+		return rl, err
 	}
-
-	return err, nil
+	return rl, nil
 }