//-----------------------------------------------------------------------------
// MSM_LineSensorCalibrate - Turn left, right and back.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool MSM_LineSensorCalibrate(TMissionHandler *M, int &State, int NewState)

//-----------------------------------------------------------------------------
// MSM_Cal_LineFollow - Calibrate linesensor and follow line.
//-----------------------------------------------------------------------------
// Before calling this MSM:
// * Setup the LineFollower class as desired
// * Make sure the Linesensor is on the line.
//-----------------------------------------------------------------------------
bool MSM_Cal_LineFollow(TMissionHandler *M, int &State, int NewState)

//-----------------------------------------------------------------------------
// TMissionHandler::Start - Set Mission (state machine) to execute. 
//-----------------------------------------------------------------------------
// Conventions / requirements / features:
// - The State is provided to the state machine as a parameter.
// - When the supplied State value is not equal to the previous one
//   (= state transition), the parameter NewState is non-zero.
// - State transitions are reported by the MissionHandler on behalf
//   of the state machine.
// - Hence it is adviced to avoid multiple state transitions in one 'takt'
// - State 0 is a special state:
//   * State 0 as a PARAMETER indicates reset of the state machine 
//     (first execution of state machine etc).                     
// - The state machine returns TRUE to signals the mission is done. 
//   The MissionHandler will clean up and becomes available for 
//   execution of the next mission.
//-----------------------------------------------------------------------------
void TMissionHandler::Start(bool(*NewFunction)(TMissionHandler *M, int &State, int NewState), const char *NewName)

//-----------------------------------------------------------------------------
// TMissionHandler::StartUnc - UNCONDITIONAL Set Mission (state machine) to execute. 
//-----------------------------------------------------------------------------
// See MissionHandlerStart for details.
// This function replaces a running function **so be carefull** to use this.
//-----------------------------------------------------------------------------
void TMissionHandler::StartUnc(bool(*NewFunction)(TMissionHandler *M, int &State, int NewState), const char *NewName)

//-----------------------------------------------------------------------------
// TMissionHandler::Abort - Abort running mission.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TMissionHandler::Abort(void)

//-----------------------------------------------------------------------------
// TMissionHandler::Takt - Takt (execution) of requested mission (state machine)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TMissionHandler::Takt(void)

//-----------------------------------------------------------------------------
// TMissionHandler::IsDone - true als missie is afgerond
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TMissionHandler::IsDone()

//-----------------------------------------------------------------------------
// TMissionHandler::ParamSet - Set Parameter in Store. 
//-----------------------------------------------------------------------------   
// De parameter functies Set en Get zijn de aanbevolen manier om
// parameters door te geven aan een Mission.
//-----------------------------------------------------------------------------
void TMissionHandler::ParamSet(int Nr, int Value)

//-----------------------------------------------------------------------------
// TMissionHandler::ParamGet - Get Parameter in Store. 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int  TMissionHandler::ParamGet(int Nr)

//-----------------------------------------------------------------------------
// InvalidMission - Check if a mission (sub) class is valid
//-----------------------------------------------------------------------------
// De laatste missie in de reeks is niet bruikbaar. Dit garandeert
// dat je missie altijd een geldige Sub pointer heeft.    
//
// We hebben een keten van missies, waarvan de laatste wordt gebruikt
// om te signaleren dat we aan het einde zijn gekomen. Dus als we
// 4 instanties hebben, kunnen we drie missies draaien. 
//
// Logisch gezien lijkt dit op een stack van missies, die vol kan raken.
//-----------------------------------------------------------------------------
bool TMissionHandler::InvalidMission(bool Verbose)

//-----------------------------------------------------------------------------
// MSM_PwmCurve - MissionStateMachine : Pwm / odo curve.
//-----------------------------------------------------------------------------
// With wheels off the floor or a lot of space.
// increase pwm in steps to max, decrease to -max en back to zero.
//-----------------------------------------------------------------------------
bool MSM_PwmCurve(TMissionHandler *M, int &State, int NewState)

//-----------------------------------------------------------------------------
// MSM_MotorCal - MissionStateMachine : Motor calibratie
//-----------------------------------------------------------------------------
// Met deze routine worden de motoren eerst met hoge pwm waarde vooruit
// gestuurd en daarna met lage pwm waarde achteruit.
// Na stabilisatie wordt de snelheid en pwm* gemeten.
// Met de uitkomst worden twee constantes berekend waarmee de motoren
// aangestuurd kunnen worden en de robot zonder odometrie-terugkoppeling
// zo goed mogelijk rechtuit rijdt.
// De constantes worden opgenomen in de file Prj_RobotLib_conf.h
//
// * De PWM waarde wordt tijdens het meten gecorrigeerd als de robot
//    van de rechte lijn afwijkt, om het testen op de grond in een
//    beperkte ruimte te vereenvoudigen. Deze regeling lijkt geen
//    invloed te hebben op de meting.
//-----------------------------------------------------------------------------
bool MSM_MotorCal(TMissionHandler *M, int &State, int NewState)

//-----------------------------------------------------------------------------
// MSM_MotorSlope - MissionStateMachine : Stuur motoren op PWM
//-----------------------------------------------------------------------------
// Ten behoeve van OdoCalibratie 1
//
// MsmParam[0] = PwmL setpoint
// MsmParam[1] = PwmR setpoint
// 
// Dit is een a-typische MSM routine, die gebruikt wordt om soft start/stop
// mogelijk te maken. De setpoints kunnen tussendoor worden gewijzigd door
// PfKeyOdoCalibratie1 en de MSM eindigt niet vanzelf, maar wordt gestopt
// met MissionHanderAbort().
//-----------------------------------------------------------------------------
bool MSM_MotorSlope(TMissionHandler *M, int &State, int NewState)

//-----------------------------------------------------------------------------
// MSM_MotorDrive - MissionStateMachine : Motor Drive (ca 1 meter)
//-----------------------------------------------------------------------------
// Routines voor afstand calibratie.  
// Motorregeling is zoveel mogelijk onafhankelijk van de motor karakteristiek
// zodat de routine gebruikt kan worden zonder dat de motor tuning is uitgevoerd. 
// Hierdoor is de afgelegde weg niet naukeurig vooraf te bepalen en kan ook
// per test varieeren. De afstand is per definitie (iets) langer dan de 
// ingestelde afstand. 
// Vergelijk de fysieke afstand met de positie van OdoT voor een juiste calibratie.      
//-----------------------------------------------------------------------------
bool MSM_MotorDrive(TMissionHandler *M, int &State, int NewState)

//-----------------------------------------------------------------------------
// Ump_UmbMark - Universal mover pattern: UmbMark (Bert variant)
//-----------------------------------------------------------------------------
// Bert variant: start in het midden van een lange zijde, niet op een hoek.
//
// Bij UmbMark rijdt de robot een vierkant met de klok mee en een vierkant
// tegen de klok in. Bij aankomst wordt de verschuiving in X-richting opgemeten
// en op basis van deze twee getallen (delta-X clockwise & counterclockwise)
// kan worden bepaald wat de afwijking van de wielbasis-calibratie en de 
// afwijking door wielgrootte is.                                        
//
//Params:
//    ClockWise   turn ClockWise (true) or CounterClockWise (false)
//    Distance    Lenght of square side in mm
//    Speed       Max speed in mm/sec      
//
// Note: This function fill the list and start the mover. It does not
//       wait for list execution to be completed.
//-----------------------------------------------------------------------------
void Ump_UmbMark(bool ClockWise, int Length, int Speed)

//-----------------------------------------------------------------------------
// Ump_WheelSizeCalibrate - Universal mover pattern: WheelSizeCalibrate
//-----------------------------------------------------------------------------
// Drive requested distance, turn, drive back & turn back.
//-----------------------------------------------------------------------------
void Ump_WheelSizeCalibrate(int Distance, int Speed)

//-----------------------------------------------------------------------------
// UmArc - set Universal movement - rij een boog.
//-----------------------------------------------------------------------------
// Drive an arc to the requested heading.
// - Heading   - in degrees, relative to the coordinate system.
// - Radius    - Radius of arc in mm
// - Shortest  - True selects shortest turn angle (from -180 to 180 degrees).
//               When false, the robot turns (Heading - <current heading>)
//               You might prefere UmArcRel() over UmArc() with Shortest=true.
//-----------------------------------------------------------------------------
void UmArc(int Heading, int Radius, int Speed, int EndSpeed, bool Shortest)

//-----------------------------------------------------------------------------
// UmArcRel - set Universal movement - rij een boog.
//-----------------------------------------------------------------------------
// Rij een boog tot de opgegeven richting.
// - Heading is de realtieve hoek, in graden.       
// - Radius is straal van de draaicircel in mm
//-----------------------------------------------------------------------------
void UmArcRel(int Heading, int Radius, int Speed, int EndSpeed)

//-----------------------------------------------------------------------------
// UmDistanceHeading - set Universal movement DistanceHeading
//-----------------------------------------------------------------------------
// Drive the robot with <Speed> in direction <Heading>. 
// Movement terminate at <Distance> from starting point, at <EndSpeed>.
//-----------------------------------------------------------------------------
void UmDistanceHeading(int Distance, int Heading, int Speed, int EndSpeed)

//-----------------------------------------------------------------------------
// UmDistanceHeadingUpdate - Update Universal movement parameters
//-----------------------------------------------------------------------------  
// Met deze Update functie kan de snelheid en afstand worden aangepast terwijl
// de beweging 'UmDistanceHeading' actief is.
//
// Voorzichtig met update functie: verandering van parameters tijdens de rit
// zijn direct actief en kunnen daardoor abrubte wijzigingen in snelheid
// en richting geven.
//-----------------------------------------------------------------------------
void UmDistanceHeadingUpdate(bool FirstCall, int Distance, int Heading, int Speed, int EndSpeed)

//-----------------------------------------------------------------------------
// UmDistanceHeadingRel - set Universal movement DistanceHeadingRel
//-----------------------------------------------------------------------------
// Drive the robot with <Speed>. The direction, relative to the start position,
// is specified by <Heading>. 
// Movement terminate at <Distance> from starting point, at <EndSpeed>.
//-----------------------------------------------------------------------------
void UmDistanceHeadingRel(int Distance, int Heading, int Speed, int EndSpeed)

//-----------------------------------------------------------------------------
// UmDistanceHeadingRelUpdate - Update Universal movement parameters
//-----------------------------------------------------------------------------  
// Met deze Update functie kan de snelheid en afstand worden aangepast terwijl
// de beweging 'UmDistanceHeadingRel' actief is.
//
// Voorzichtig met update functie: verandering van parameters tijdens de rit
// zijn direct actief en kunnen daardoor abrubte wijzigingen in snelheid
// en richting geven.
//-----------------------------------------------------------------------------
void UmDistanceHeadingRelUpdate(bool FirstCall, int Distance, int Heading, int Speed, int EndSpeed)

//-----------------------------------------------------------------------------
// UmLineFollower - set Universal movement LineFollower
//-----------------------------------------------------------------------------
// Calls the instance LineFollower of TLineFollower
// Configure this class to modify the behaviour of this movement
//-----------------------------------------------------------------------------
void UmLineFollower()

//-----------------------------------------------------------------------------
// UmPwm - set Universal movement PWM
//-----------------------------------------------------------------------------    
// Drive each of the motors with the pwm provided (-4095...4095).
//
// Note: indefinite movement (no end specified, should be terminated by user)
//-----------------------------------------------------------------------------
void UmPwm(int PwmL, int PwmR)

//-----------------------------------------------------------------------------
// UmPwmUpdate - Update Universal movement parameters
//-----------------------------------------------------------------------------
// Met deze Update functie kan de pwm waarde worden aangepast terwijl de 
// beweging 'UmPwm' actief is.
//-----------------------------------------------------------------------------
void UmPwmUpdate(bool FirstCall, int PwmL, int PwmR)

//-----------------------------------------------------------------------------
// UmRobotPosition - set Position via Universal Mover
//-----------------------------------------------------------------------------    
// Changes the robot position information. Hardly a mover, but quite usefull
// to mix in a list of movements while running tests on the simulator or on the
// robot with its wheels off the floor.
//-----------------------------------------------------------------------------
void UmRobotPosition(int XPos, int YPos, int Angle)

//-----------------------------------------------------------------------------
// UmRotate - set Universal movement - draai naar heading (graden).
//-----------------------------------------------------------------------------
// Draai de stilstaande robot naar opgegeven richting.
// - 'Heading' is de absolute hoek, in graden.       
//
// Gebruikte constantes: ROTATE_P_GAIN, ROTATE_D_GAIN, ROTATE_CLIP
//-----------------------------------------------------------------------------
void UmRotate(int Heading, bool Shortest)

//-----------------------------------------------------------------------------
// UmRotateRel - set Universal movement - draai gegeven hoek (graden).
//-----------------------------------------------------------------------------
// Draai de stilstaande robot naar opgegeven richting.
// - 'Heading' is de absolute hoek, in graden.       
//
// Gebruikte constantes: ROTATE_P_GAIN, ROTATE_D_GAIN, ROTATE_CLIP
//-----------------------------------------------------------------------------
void UmRotateRel(int Heading)

//-----------------------------------------------------------------------------
// UmSpeedHeading - set Universal movement SpeedHeading
//-----------------------------------------------------------------------------
// Drive the robot with <Speed> in direction <Heading>.
//
// Note: indefinite movement (no end specified, should be terminated by user)
//-----------------------------------------------------------------------------
void UmSpeedHeading(int Speed, int Heading)

//-----------------------------------------------------------------------------
// UmSpeedHeadingUpdate - Update Universal movement parameters
//-----------------------------------------------------------------------------  
// Met deze Update functie kan de snelheid en richting worden aangepast terwijl
// de beweging 'UmSpeedHeading' actief is.
//
// Voorzichtig met update functie: verandering van parameters tijdens de rit
// zijn direct actief en kunnen daardoor abrubte wijzigingen in snelheid
// en richting geven.
//-----------------------------------------------------------------------------
void UmSpeedHeadingUpdate(bool FirstCall, int Speed, int Heading)

//-----------------------------------------------------------------------------
// UmSpeedLR - set Universal movement SpeedLRSet
//-----------------------------------------------------------------------------
// Drive each of the wheels with the speed provided.
//
// Note: indefinite movement (no end specified, should be terminated by user)
//-----------------------------------------------------------------------------
void UmSpeedLR(int SpeedL, int SpeedR)

//-----------------------------------------------------------------------------
// UmSpeedLRUpdate - Update Universal movement parameters
//-----------------------------------------------------------------------------
// Met deze Update functie kan de snelheid van ieder wiel worden aangepast 
// terwijl de beweging 'UmSpeedLR' actief is.
//
// Voorzichtig met update functie: verandering van parameters tijdens de rit
// zijn direct actief en kunnen daardoor abrubte wijzigingen in snelheid geven.
//-----------------------------------------------------------------------------
void UmSpeedLRUpdate(bool FirstCall, int SpeedL, int SpeedR)

//-----------------------------------------------------------------------------
// UmSpeedRotation - set Universal movement SpeedRotation
//-----------------------------------------------------------------------------
// Drive the robot with the <Speed> and turn rate <RotationRate> (degrees/sec).
//
// Note: indefinite movement (no end specified, should be terminated by user)
//-----------------------------------------------------------------------------
void UmSpeedRotation(int Speed, int RotationRate)

//-----------------------------------------------------------------------------
// UmSpeedRotationUpdate - Update Universal movement parameters
//-----------------------------------------------------------------------------  
// Met deze Update functie kan de snelheid en richting worden aangepast terwijl
// de beweging 'UmSpeedRotation' actief is.
//
// Voorzichtig met update functie: verandering van parameters tijdens de rit
// zijn direct actief en kunnen daardoor abrubte wijzigingen in snelheid
// en richting geven.
//-----------------------------------------------------------------------------
void UmSpeedRotationUpdate(bool FirstCall, int Speed, int RotationRate)

//-----------------------------------------------------------------------------
// UmStop - set Universal movement STOP 
//-----------------------------------------------------------------------------
// Decelerate (smoothly) to  0.
// - During deceleration, the robot heading is maintained.
// - Standstill/heading is activly enforced after the stop for the time specified
// - After this delay, the movement is done.
//-----------------------------------------------------------------------------
void UmStop(int MilliSeconds)

//-----------------------------------------------------------------------------
// UmXY - set Universal movement XY (naar punt (X, Y))
//-----------------------------------------------------------------------------
// Rij robot naar opgegeven punt.
// - EndSpeed geeft gewenste eindsnelheid aan. De snelheid wordt geleidelijk 
//   afgebouwd als de afstand tot het eindpunt afneemt.
// - Het gedrag aan het begin van deze beweging is afhankelijk van de actuele
//   snelheid en de hoek tussen de rijrichting en punt (X, Y). 
//   Zorg er bij voorkeur voor dat de rijrichting ongeveer in richting van
//   (X, Y) is.
//-----------------------------------------------------------------------------
void UmXY(int X, int Y, int Speed, int EndSpeed)

//-----------------------------------------------------------------------------
// UmXYUpdate - Update Universal movement parameters
//----------------------------------------------------------------------------- 
// Werk het doel (X, Y) bij tijdens de beweging.
// 
// Let op: voorzichtig update functie: verandering van parameters tijdens de rit
// kan ongewenste bij-effecten geven, zoals plotselinge snelheidswijzigingen en
// het missen van het doel. Ook kan een wijziging van het eindpunt de beweging 
// voortijdig beeindigen.
// Overweeg om, in plaats van update, de beweging voortijdig opnieuw te starten
// met UmXYSet()
//-----------------------------------------------------------------------------
void UmXYUpdate(bool FirstCall, int X, int Y, int Speed, int EndSpeed)

//-----------------------------------------------------------------------------
// UmXYTaktFunct - Rij naar punt (X, Y) (het echte werk)
//-----------------------------------------------------------------------------
// Bereken de gewenste snelheid en richting naar punt en bepaal of we het 
// doel bereikt hebben. Wordt gebruikt door UmXYTakt(), maar kan ook 
// in andere functies worden gebruikt, waarin de snelheid en richting naar
// een punt verder bewerkt worden.
// 
// Parameters:
//    R           - structure voor resultaat
//    FirstCall   - geef aan dat X/Y gewijzigd zijn (nieuw doel)
//    Speed       - Gewenste (maximale) snelheid
//    EndSpeed    - Gewenste snelheid op eindpunt
//-----------------------------------------------------------------------------
void UmXYTaktFunct(tUmResult &R, bool FirstCall, int TargetX, int TargetY, int Speed, int EndSpeed)

//-----------------------------------------------------------------------------
// UmXYPhi - set Universal movement UmXYPhiSet
//-----------------------------------------------------------------------------        
// Rij robot naar opgegeven punt met gevraagde orientatie Phi.
//
// - EndSpeed geeft gewenste eindsnelheid aan. De snelheid wordt geleidelijk 
//   afgebouwd als de afstand tot het eindpunt afneemt. Ook neemt de snelheid 
//   verder af naar mate de robot sterker draait.
// 
// - Het eindpunt en de waarde Phi geven een virtuele 'aanvliegroute'.
// - K1 bepaalt hoe belangrijk deze aanvliegroute is.
// - Als K1=0, dan rijdt de robot naar het gevraagde punt, zonder rekening 
//   te houden met de aanvliegroute.
// - Bij een grote waarde van K1 (>100) rijdt de robot zo snel mogelijk naar
//   de aanvliegroute c.q. naar een punt op de route op relatief grote afstand 
//   van het eindpunt (afhankelijk van startpositie en -orientatie).
//   De robot zal hierdoor in het algemeen een lang stuk van de aanvliegroute 
//   rijden.
// - Het gedrag van de robot op de parameters wordt beinvloedt door de 
//   reactiesnelheid van de robot (mechanische + electrische eigenschappen,
//   configuratie motorregeling).
//
// - Parameter K2 bepaalt hoe sterk de robot bij aanvang stuurt in de gewenste
//   richting van de aanvliegroute (en dus niet het eindpunt!). 
//-----------------------------------------------------------------------------
void UmXYPhi(int X, int Y, int Degrees, short Speed, short EndSpeed, short XypK1, short XypK2)

//-----------------------------------------------------------------------------
// UmXYPhi2 - set Universal movement UmXYPhi2
//-----------------------------------------------------------------------------        
// Rij robot naar opgegeven punt met gevraagde orientatie Phi. 
//
// - rij met Speed1 naar rand (raaklijn) van circel met straal R.
// - volg de circel met Speed2 tot afstand D van eindpunt.
// - rij afstand D met heading Phi tot eindpunt XY, start met Speed2, eindig
//   met EndSpeed.
// 
// - Het eindpunt en de waarde Phi geven een virtuele 'aanvliegroute'.
//-----------------------------------------------------------------------------
void UmXYPhi2(int X, int Y, short Degrees, short Speed1, short Speed2, short EndSpeed, short Radius, short Distance)

//-----------------------------------------------------------------------------
// TUniversalMover::Reset - stop takt, set pointer to start of list 
//-----------------------------------------------------------------------------
// Note: A call to this methode won't stop the robot, but most likely just a
//       updates of motorspeed. Call UmStop() or UmPwm(0,0) to stop the robot.
//-----------------------------------------------------------------------------
void TUniversalMover::Reset()

//-----------------------------------------------------------------------------
// TUniversalMover::List - List current movement / list of movements
//-----------------------------------------------------------------------------
// The active movement is pre-pended with an '*', others with '>'.
//-----------------------------------------------------------------------------
void TUniversalMover::List()

//-----------------------------------------------------------------------------
// TUniversalMover::IsDone - Vraag op of de beweging gereed is.   
//-----------------------------------------------------------------------------
// return: true = beweging gereed.
// Opmerkingen:
// - in DIRECT mode geeft deze functie aan of die ene, gevraagde beweging 
//   gereed is.
// - in LIST mode geeft deze functie aan of de lijst met bewegingen gereed is.
// - Sommige bewegingen (zoals UmPwm) hebben geen gedefinieerd einde. Bij deze
//   bewegingen zal deze functie altijd false terugggeven (nooit klaar).
//-----------------------------------------------------------------------------
bool TUniversalMover::IsDone()

//-----------------------------------------------------------------------------
// TUniversalMover::SetCallBack - Provide call-back function for last movement
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TUniversalMover::SetCallBack(void (*NewFunction)(), const char *NewName)

//-----------------------------------------------------------------------------
// TUniversalMover::StepDone - Tell Mover current step is done
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TUniversalMover::StepDone()

//------------------------------------------------------------------------
// TPosition::Reset - Set current pose at 0, 0, 0
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void TPosition::Reset()

//-----------------------------------------------------------------------------
// TPosition::Takt - Read encoders & update robot position / pose 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPosition::Takt()

//-----------------------------------------------------------------------------
// TPosition::Print - print X/Y/hoek
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPosition::Print()

//------------------------------------------------------------------------
// TPosition::CorrectPose - Set new pose (position) of robot
//------------------------------------------------------------------------
// Use this methode to update the robot pose, e.g. based on landmark info
// (lines, walls etc) or gps or alike.
// Params: X, Y in mm, Angle in degrees
//------------------------------------------------------------------------
void TPosition::CorrectPose(int InX, int InY, int InDegrees)

//------------------------------------------------------------------------
// TPosition::CorrectPose - Set new pose (position) of robot
//------------------------------------------------------------------------
// Use this methode to update the robot pose, e.g. based on landmark info
// (lines, walls etc) or gps or alike.
// Params: X, Y in mm, Angle in degrees
//------------------------------------------------------------------------
void TPosition::CorrectPose(TPose p)

//-----------------------------------------------------------------------------  
// IcpAlign - Allign target points (sensor data) to reference (map)
//-----------------------------------------------------------------------------
// Return: allignment 
//
// Note: target points are alligned during the process.
//-----------------------------------------------------------------------------
void IcpAlign(TPointList &Ref, TPointList &targets, TPose &pose_acc, int iteration)

//-----------------------------------------------------------------------------
// TPointList Constructor - create list with space for InSize points.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TPointList::TPointList(int InSize)

//-----------------------------------------------------------------------------
// TPointList::Count - Nr of (active) items in list.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TPointList::Count()

//-----------------------------------------------------------------------------
// TPointList::Size - Retun size of list.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TPointList::Size()

//-----------------------------------------------------------------------------
// TPointList::Clear - Erase list (delete all points)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::Clear()

//-----------------------------------------------------------------------------
// TPointList::ClearGroup - set groupcode of all points to zero
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::ClearGroup()

//-----------------------------------------------------------------------------
// TPointList::DeleteGroup - Delete points with groupcode
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::DeleteGroup(unsigned char InGroup)

//-----------------------------------------------------------------------------
// TPointList::DumpGroup - Dump points with groupcode
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::DumpGroup(unsigned char InGroup, int PresentationGroup)

//-----------------------------------------------------------------------------
// TPointList::DumpAll - Dump all points in list 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::DumpAll(int PresentationGroup)

//-----------------------------------------------------------------------------
// TPointList::Add - Add point to list
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::Add(const TPoint &p_in)

//----------------------------------------------------------------------------- 
// TPointList::Add - Add point to list
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::Add(int X, int Y)

//-----------------------------------------------------------------------------
// TPointList::Search - Search for closest point in list
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TPoint *TPointList::Search(const TPoint &Point)

//-----------------------------------------------------------------------------
// TPointList::TransformPose - Translate & (then) rotate (not commutative)
//-----------------------------------------------------------------------------
// voorheen icp_transform_pose() 
//-----------------------------------------------------------------------------
void TPointList::TransformPose(const TPose &pose)

//----------------------------------------------------------------------------- 
// TLineSensorQrt8a::Clear - sensor off & clear data
//-----------------------------------------------------------------------------
// * calibration data is cleared.
// * Configuration data (normal/reverse) is *NOT* cleared
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::Clear()

//----------------------------------------------------------------------------- 
// TLineSensorQrt8a::SetCalibration - 
//-----------------------------------------------------------------------------
// Stores min and max value.
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::SetCalibration(int Min, int Max)

//----------------------------------------------------------------------------- 
// TLineSensorQrt8a::Calibrate - Turn on sensor calibration.
//-----------------------------------------------------------------------------
// Calibration stores min and max value, seen on any of the sensor inputs.
// 'Calibrate' is a variation of 'on'.
// See methods Calibrate(), On(), Off()
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::Calibrate()

//----------------------------------------------------------------------------- 
// TLineSensorQrt8a::On - Turn on sensor 
//-----------------------------------------------------------------------------
// See methods Calibrate(), On(), Off()
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::On()

//----------------------------------------------------------------------------- 
// TLineSensorQrt8a::Off - Turn sensor off
//-----------------------------------------------------------------------------
// See methods Calibrate(), On(), Off()
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::Off()

//----------------------------------------------------------------------------- 
// TLineSensorQrt8a::Dump - Dump all sensor data
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::Dump()

//----------------------------------------------------------------------------- 
// Max127Read - Read Max127 i2c ADC convertor
//----------------------------------------------------------------------------- 
//----------------------------------------------------------------------------- 
int Max127Read(int Channel)

//-----------------------------------------------------------------------------
// TPID::SetInputRefs -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPID::SetInputRefs(int &InInput, int &InSetpoint)

//-----------------------------------------------------------------------------
// TPID::PrintStat - one line to reflect the internal status
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPID::PrintStat()

//-----------------------------------------------------------------------------
// TPID::Print -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPID::Print()

//-----------------------------------------------------------------------------
// TRpLidar::GetState - Vraag state van Lidar
//-----------------------------------------------------------------------------
// Returns:
// RPLIDAR_STATE_OFF
// RPLIDAR_STATE_BUSY   (probably starting up or pause)
// RPLIDAR_STATE_ON
// RPLIDAR_STATE_ERROR
//
//-----------------------------------------------------------------------------
int TRpLidar::GetState()

//-----------------------------------------------------------------------------
// TRpLidar::PrintHealth - Vraag Health op & print result.
//-----------------------------------------------------------------------------
// Eigenlijk wordt hier alleen de takt state gezet.
// Takt verstuurd het request, wacht op het antwoord en zal dit printen.
//-----------------------------------------------------------------------------
void TRpLidar::PrintHealth()

//-----------------------------------------------------------------------------
// TRpLidar::PrintHwInfo - Vraag hardware Info op & print result.
//-----------------------------------------------------------------------------
// Eigenlijk wordt hier alleen de takt state gezet.
// Takt verstuurd het request, wacht op het antwoord en zal dit printen.
//-----------------------------------------------------------------------------
void TRpLidar::PrintHwInfo()

//-----------------------------------------------------------------------------
// TRpLidar::Start - Start lidar op
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRpLidar::Start()

//-----------------------------------------------------------------------------
// TRpLidar::Stop - Stop / Reset lidar
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRpLidar::Stop()

//-----------------------------------------------------------------------------
// TRpLidar::PrintDebugInfo - Status details van de class
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRpLidar::PrintDebugInfo()

//-----------------------------------------------------------------------------
// TRpLidar::Takt - Handel communicatie met RpLidar af
//-----------------------------------------------------------------------------
// De RpLidar class communiceert via een seriele poort met de RpLidar en gebruikt
// een GPIO lijn om de motor van de RpLidar te schakelen.
// De class slaat samples per graad op, waardoor steeds (maximaal) 360 samples
// beschikbaar zijn als de RpLidar actief is. Per sample wordt zowel de ruwe
// waarde (hoek & afstand) opgeslagen, als de XY coordinaten van de punt
// op het assenstelsel. Deze laatste behouden hun nauwkeurigheid als de
// robot beweegt.
//
// * Gebruik verandering van de var Revolution om te bepalen of een nieuwe scan
//   voltooid is.
//
// * Setup variabelen:
//    DegreesOffset     - rotation of sensor
//    OffsetVector      - Lidar displacement vector from robot center (len in mm)
//    UpsideDown        - Indicate the sensor is mouned upside down.
//
// Details:
// * De RpLidar geeft 2000 metingen/seconde. De hoek tussen twee metingen
//   is (o.a.) afhankelijk van de draaisnelheid (voedingsspanning motor).
// * De metingen van de RpLidar zijn niet altijd gesorteerd op hoek.
// * In de datastroom van de RpLidar ontbreekt af en toe een karakter. De
//   class probeert opnieuw te synchroniseren. Normaal lukt dat en gaan
//   een of twee samples verloren. Als dit niet lukt, wordt de lidar
//   herstart. Dit vraagt tussen 600 en 800 milliseconde.
//-----------------------------------------------------------------------------
void TRpLidar::Takt()

//-----------------------------------------------------------------------------
// TRpLidar::GetSample - all sample data, for degrees
//-----------------------------------------------------------------------------
// return NULL if no valid sample for requested degrees
//-----------------------------------------------------------------------------
const tLidarSample *TRpLidar::GetSample(int InDegrees)

//-----------------------------------------------------------------------------
// TRpLidar::GetDistance - for degrees
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TRpLidar::GetDistance(int InDegrees)

//-----------------------------------------------------------------------------
// TRpLidar::GetDistance - for degrees +/- MaxDelta
//-----------------------------------------------------------------------------
// MaxDelta = max +/- delta of InDegrees to get a *valid* reading
// First (lowest delta) valid reading is supplied
//-----------------------------------------------------------------------------
int TRpLidar::GetDistance(int InDegrees, int MaxDelta)

//-----------------------------------------------------------------------------
// TRpLidar::Dump - Dump stored samples
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRpLidar::Dump(int Mode)

//-----------------------------------------------------------------------------
// TRpLidarSim::GetDistance - for degrees +/- MaxDelta
//-----------------------------------------------------------------------------
// MaxDelta = max +/- delta of InDegrees to get a *valid* reading
// First (lowest delta) valid reading is supplied
//-----------------------------------------------------------------------------
int TRpLidarSim::GetDistance(int InDegrees, int MaxDelta)

//-----------------------------------------------------------------------------
// TSharpSensor::Print -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TSharpSensor::Print()

//-----------------------------------------------------------------------------
// TSharpSensor::SetTimeConstant -
//-----------------------------------------------------------------------------
// Tau = 2 exp TC
// Stel:
//  TC = 3
//  Takt interval = 1 ms
//  dan Tau = 2^3 * 1 ms = 8ms
// => in 1 tau /  8 ms wordt 63% van een spanningssprong overgenomen
// => in 3 tau / 24 ms wordt 95% van een spanningssprong overgenomen
//-----------------------------------------------------------------------------
void TSharpSensor::SetTimeConstant(int TC)

//-----------------------------------------------------------------------------
// TSharpSensor::Raw - geef gemiddelde input-waarde (ADC waarde) terug
//-----------------------------------------------------------------------------
// Let op: dit is de gemiddelde waarde, niet de waarde van Capacitor.
//
// Calibration = Raw() * Distance (mm)
//-----------------------------------------------------------------------------
int TSharpSensor::Raw()

//-----------------------------------------------------------------------------
// TArIo::digitalWrite - Set pin of remote IO
//-----------------------------------------------------------------------------
// This function writes to the buffered data. The takt() function updates
// the IO from the buffer.
//-----------------------------------------------------------------------------
void TArIo::digitalWrite(int Pin, bool Value)

//-----------------------------------------------------------------------------
// TArIo::digitalRead - Read pin from remote IO
//-----------------------------------------------------------------------------
// This function reads reads the buffered data. The takt() function updates
// the buffer.
//-----------------------------------------------------------------------------
bool TArIo::digitalRead(int Pin)

//-----------------------------------------------------------------------------
// TArIo::pinMode -  Set pinmode for remote IO
//-----------------------------------------------------------------------------
// This function immediately triggers an i2c message.
//-----------------------------------------------------------------------------
void TArIo::pinMode(int Pin, int Mode)

//-----------------------------------------------------------------------------
// TArIo::analogRead - Read 10 bit analog from remote IO
//-----------------------------------------------------------------------------
// This function reads reads the buffered data. The takt() function updates
// the buffer.
//-----------------------------------------------------------------------------
int TArIo::analogRead(int Pin)

//-----------------------------------------------------------------------------
// TArIo::analogWrite -  Write 8 bit pwm value to remote IO
//-----------------------------------------------------------------------------
// This function immediately triggers an i2c message.   
// Note: PWM is supported on a limited number of pins. See arduino 
//       documentation for details.
//-----------------------------------------------------------------------------
void TArIo::analogWrite(int Pin, int Value)

//-----------------------------------------------------------------------------
// TAx12::ReadByte -  Read 1 register (8 bit) from AX12 with ID
//-----------------------------------------------------------------------------
// Return byte value, -1 on error.
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
int TAx12::ReadByte(int Id, int Address)

//-----------------------------------------------------------------------------
// TAx12::ReadWord -  Read 2 registers (16 bit) from AX12 with ID
//-----------------------------------------------------------------------------
// Return word value, -1 on error.
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
int TAx12::ReadWord(int Id, int Address)

//-----------------------------------------------------------------------------
// TAx12::WriteByte -  Write 1 register (8 bit) to AX12 with ID
//-----------------------------------------------------------------------------
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
void TAx12::WriteByte(int Id, int Address, int Data)

//-----------------------------------------------------------------------------
// TAx12::WriteWord -  Write 2 registers (16 bit) to AX12 with ID
//-----------------------------------------------------------------------------
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
void TAx12::WriteWord(int Id, int Address, int Data)

//-----------------------------------------------------------------------------
// TAx12::SetAngle -  Set Target Angle limit of AX12 with ID
//-----------------------------------------------------------------------------
// Angle value 0..1023 maps to 0..300 degrees
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
void TAx12::SetAngle(int Id, int Angle)

//-----------------------------------------------------------------------------
// TAx12::SetSpeed -  Set Target Angle limit of AX12 with ID
//-----------------------------------------------------------------------------
// Speed value -511..511
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
void TAx12::SetSpeed(int Id, int Speed)

//-----------------------------------------------------------------------------
// TAx12::SetCwLimit -  Set Cw Angle limit of AX12 with ID
//-----------------------------------------------------------------------------
// Angle value 0..1023 maps to 0..300 degrees
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
void TAx12::SetCwLimit(int Id, int Limit)

//-----------------------------------------------------------------------------
// TAx12::SetCcwLimit -  Set Ccw Angle limit of AX12 with ID
//-----------------------------------------------------------------------------
// Angle value 0..1023 maps to 0..300 degrees
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
void TAx12::SetCcwLimit(int Id, int Limit)

//-----------------------------------------------------------------------------
// TAx12::Enable -  Enable Torque of AX12 with ID
//-----------------------------------------------------------------------------
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
void TAx12::Enable(int Id, int EnableIn)

//-----------------------------------------------------------------------------
// TAx12::MotorMode -  Enable/Disable MotorMode of AX12 with ID
//----------------------------------------------------------------------------- 
// Note: this clears CwLimit and CcwLimit.
// This function immediately triggers an i2c message.   
//-----------------------------------------------------------------------------
void TAx12::MotorMode(int Id, int EnableIn)

//-----------------------------------------------------------------------------
// Ax12_ServoSet - Stub to call standard Ax12 interface for Servo PWM value
//-----------------------------------------------------------------------------
// Note: void function(int, int) format is compatible with HAL servo functions.
//-----------------------------------------------------------------------------
void Ax12_ServoSet(int Nr, int Value)

//-----------------------------------------------------------------------------
// TMedianFilter3::Add - Add sample to Median3 filter and return new median 
//-----------------------------------------------------------------------------
// TMedianFilter3 is a 3 slot fixed size median filter for floating point values.
// This stub function takes int inputs and returns int result.
//-----------------------------------------------------------------------------
int TMedianFilter3::Add(int Value)

//-----------------------------------------------------------------------------
// TMedianFilter3::Add - Add sample to Median3 filter and return new median 
//-----------------------------------------------------------------------------
// TMedianFilter3 is a 3 slot fixed size median filter for floating point values.
//-----------------------------------------------------------------------------
float TMedianFilter3::Add(float Value)

//-----------------------------------------------------------------------------
// TMedianFilter3::Median - Return median value of Median3 filter
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float TMedianFilter3::Median()

//-----------------------------------------------------------------------------
// TMedianFilter::Add - Add sample to Median filter and return new median 
//-----------------------------------------------------------------------------
// This stub function takes int inputs and returns int result.
//-----------------------------------------------------------------------------
int TMedianFilter::Add(int Value)

//-----------------------------------------------------------------------------
// TMedianFilter::Add - Add sample to Median filter and return new median 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float TMedianFilter::Add(float datum)

//-----------------------------------------------------------------------------
// TMedianFilter::Dump -  
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TMedianFilter::Dump()

//-----------------------------------------------------------------------------
// TPCA9685::Init - Init device with I2C address param
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TPCA9685::Init(int i2cAddress)

//-----------------------------------------------------------------------------
// TPCA9685::DumpRegisters - Dump setup registers & pwm values of channel 0-4
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCA9685::DumpRegisters()

//-----------------------------------------------------------------------------
// TPCA9685::SetPwm - Set pulse width, Amount [0..4095], PinNumber [0..15]
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCA9685::SetPwm(int PinNumber, int Amount)

//-----------------------------------------------------------------------------
// TPCA9685::SetPwm - Set Start & End of pulse op PinNumber
//-----------------------------------------------------------------------------
// PwmStart, PwmEnd: [0..4095]
// PinNumber: [0..15]
//-----------------------------------------------------------------------------
void TPCA9685::SetPwm(int PinNumber, int PwmStart, int PwmEnd)

//-----------------------------------------------------------------------------
// TPCA9685::SetFrequency - Set PWM Frequency (assuming internal 25 MHz clock)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCA9685::SetFrequency(int f)

//-----------------------------------------------------------------------------
// PCA9685_ServoInit - Init standard PCA9685 instance voor Servo PWM
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void PCA9685_ServoInit(void)
{
   PCA9685.Init(0);
   PCA9685.SetFrequency(60); // default frequency for servo control	  
}

//-----------------------------------------------------------------------------
// PCA9685_ServoSet - Stub to call standard PCA9685 instance for Servo PWM value
//-----------------------------------------------------------------------------
// Note: void function(int, int) format is compatible with HAL servo functions.
//-----------------------------------------------------------------------------
void PCA9685_ServoSet(int Nr, int Value)

//-----------------------------------------------------------------------------
// TPCF8574::Print - Print data about this class instance
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCF8574::Print()

//-----------------------------------------------------------------------------
// TPCF8574::Commit - Write local copy to device
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCF8574::Commit()

//-----------------------------------------------------------------------------
// TServo::Print - print servo configuration
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TServo::Print()

//-----------------------------------------------------------------------------
// TServo::Angle - Set angle
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TServo::Angle(int Degrees)

//-----------------------------------------------------------------------------
// TServo::Raw - set Raw (microseconden, within limits of Min, Max)
//-----------------------------------------------------------------------------   
//-----------------------------------------------------------------------------
void TServo::Raw(int Value)

//-----------------------------------------------------------------------------
// TServo::Enable - Enable (true) or Disable (false) servo output. 
//-----------------------------------------------------------------------------   
//-----------------------------------------------------------------------------
void TServo::Enable(bool E)

//-----------------------------------------------------------------------------
// TServo::IsDone - true when movement... is done.
//-----------------------------------------------------------------------------   
//-----------------------------------------------------------------------------
bool TServo::IsDone()

//-----------------------------------------------------------------------------
// TServo::GetRaw - return raw value (setpoint)
//-----------------------------------------------------------------------------   
//-----------------------------------------------------------------------------
int TServo::GetRaw()

//-----------------------------------------------------------------------------
// TServo::GetAngle - return angle value (setpoint)
//-----------------------------------------------------------------------------   
//-----------------------------------------------------------------------------
int TServo::GetAngle()

//-----------------------------------------------------------------------------
// PFKeyMotorCalibrate1 - Fkeys handler
//-----------------------------------------------------------------------------
// Function keys for the first step of calibration, wheels off the floor*. 
// - Test if the motors work correctly.
// - MotorCal - determine 2 characteristic parameters per motor.
// Optional: Print motorcurve data.                         
//                                                                 
// See the calibration procedure on
// http://wiki.robotmc.org/index.php?title=RobotLib_MotorCalibratie
//                                        
// * MotorCal can be run on the floor, when you have enough space...
//-----------------------------------------------------------------------------
const char *PFKeyMotorCalibrate1(int Nr, bool InfoOnly)
>> case 1 : {  Ret = "MotorL Step up (for Motorcontroller integration)";
>> case 2 : {  Ret = "MotorL Step down";
>> case 3 : {  Ret = "MotorR Step up";
>> case 4 : {  Ret = "MotorR Step down";
>> case 7 : {  Ret = "Start MSM_MotorCal";
>> case 8 : {  Ret = "Start MSM_PwmCurve";
>> case 9 : {  Ret = "Activate PFKeyMotorCalibrate2";
>> case 10 : { Ret = "(EMERGENCY) Stop";

//-----------------------------------------------------------------------------
// PFKeyMotorCalibrate2 - Fkeys handler
//-----------------------------------------------------------------------------
// Functionkeys for the 2nd step in calibration, wheels ON the floor
//                                                                 
// See calibration procedure on
// http://wiki.robotmc.org/index.php?title=RobotLib_MotorCalibratie                                        
//-----------------------------------------------------------------------------
const char *PFKeyMotorCalibrate2(int Nr, bool InfoOnly)
>> case 1 : {  Ret = "Drive (about) straight (does not stop on it's own!)";
>> case 2 : {  Ret = "Drive abt 1 meter forward";
>> case 4 : {  Ret = "UmbMark CounterClockWise, 1 meter";
>> case 5 : {  Ret = "UmbMark ClockWise, 1 meter";
>> case 6 : {  Ret = "UmbMark CounterClockWise, 2 meter";
>> case 7 : {  Ret = "UmbMark ClockWise, 2 meter";
>> case 8 : {  Ret = "reset robot position";
>> case 9 : {  Ret = "Activate PFKeyMotorCalibrate1";
>> case 10 : { Ret = "Stop";

//-----------------------------------------------------------------------------
// TDebug::SetLevel - Set debug-level of module
//-----------------------------------------------------------------------------
// Levels: ERROR (0), WARN(1), INFO (2) or DEBUG (3)
//-----------------------------------------------------------------------------
void TDebug::SetLevel(int module, unsigned int level)

//-----------------------------------------------------------------------------
// TDebug::GetLevel - get debug level of module
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TDebug::GetLevel(int module)

//-----------------------------------------------------------------------------
// TDebug::IsLevel - return true if  debug level of module is >= Level 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TDebug::IsLevel(int Module, int Level)

//-----------------------------------------------------------------------------
// TDebug::HeaderFormat - Select header format (layout)
//-----------------------------------------------------------------------------    
// 0 : printf ("[%d.%d-%s:%d] ", level, module, fname, lineno) ;
// 1 : printf ("[%d:%c] ", module, l[level]) ;
// 2 : printf("D%02d ", module);
//-----------------------------------------------------------------------------
void TDebug::HeaderFormat(int Nr) {

//----------------------------------------------------------------------------- 
// TDebug::MyPrintf - The core function, called via marco's
//-----------------------------------------------------------------------------  
// Marco's using this function:
//    DEBUG_printf
//    INFO_printf
//    WARN_printf
//    ERROR_printf 
//-----------------------------------------------------------------------------
void TDebug::MyPrintf (int level, const char *fname, int lineno, unsigned int module, const char *fmt, ...)

//-----------------------------------------------------------------------------
// SetDynamicPFKey - Set Dynamic PFKey <Nr> to <String>
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void SetDynamicPFKey(int Nr, const char *SrcString)

//-----------------------------------------------------------------------------
// I2cIsDeviceConnected - return true if slave # is responding
//-----------------------------------------------------------------------------
// Read one char from slave to see if it is present.
//-----------------------------------------------------------------------------
bool I2cIsDeviceConnected(int I2cSlaveAddress)

//-----------------------------------------------------------------------------
// TInterval constructor / init
//-----------------------------------------------------------------------------   
// Params: 
//    Ival  - interval time in ms (default: 1)
//    IMode - INTERVAL (true, default) or DELAY (false) mode.
//-----------------------------------------------------------------------------
TInterval::TInterval(int Ival, bool IMode)

//-----------------------------------------------------------------------------
// TInterval::SetMs - desired interval in ms 
//-----------------------------------------------------------------------------
// New interval value is set and current interval period is restarted.
// The value is saved for future intervals, so no need to set the 
// interval each time the interval expires. 
//-----------------------------------------------------------------------------
void TInterval::SetMs(int Ival)

//-----------------------------------------------------------------------------
// TInterval::SetNext - Start next interval
//-----------------------------------------------------------------------------
// Automaticly called by Due. A use call results in restart of the current
// interval.
//
// Note: Different behaviour in INTERVAL or DELAY mode.  
// See header of this file for details.
//-----------------------------------------------------------------------------
void TInterval::SetNext()

//-----------------------------------------------------------------------------
// TInterval::Due - return true als interval has expired.
//-----------------------------------------------------------------------------
// Before 'true' is returned, Next() is called to start a new interval.
//-----------------------------------------------------------------------------
bool TInterval::Due()

//-----------------------------------------------------------------------------
// TLipoBattery::Print - Print battery status
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TLipoBattery::Print()

//-----------------------------------------------------------------------------
// TLipoBattery::Dump - Dump battery class settings
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TLipoBattery::Dump()

//-----------------------------------------------------------------------------
// TLipoBattery::SetCallBack - Provide call-back function for battery check
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TLipoBattery::SetCallBack(void (*NewFunction)(), const char *NewName)

//-----------------------------------------------------------------------------
// Beep - sound nr of beeps.
//-----------------------------------------------------------------------------
//    duration = time length for sound and silence (in ms)
//-----------------------------------------------------------------------------
void Beep(int number_of_beeps, int duration)

//-----------------------------------------------------------------------------
// MorseChar - send char in morse via buzzer
//-----------------------------------------------------------------------------
// Note: defineer MORSE_WPM om Morse ondersteuning in te schakelen.
//-----------------------------------------------------------------------------
void MorseChar(char ch)

//-----------------------------------------------------------------------------
// MorseCode - send code in morse via buzzer
//-----------------------------------------------------------------------------
// Note: defineer MORSE_WPM om Morse ondersteuning in te schakelen.
//
// use constants from morse.h
// format: 	- bit 0 is first to send
//				 	- 0 = dot, 1 = dash
//					- code 0x0001 means done
// INT in queue zetten, MSB eerst.
//-----------------------------------------------------------------------------
void MorseCode(int code)

//-----------------------------------------------------------------------------
// BuzzerTakt - call once every ms, to send beep() OR morse code
//-----------------------------------------------------------------------------
// Note: defineer MORSE_WPM om Morse ondersteuning in te schakelen.
//-----------------------------------------------------------------------------
void BuzzerTakt(void)

//-----------------------------------------------------------------------------
// PFKeyHandlerSet - set Programmable Function Key handler (table)
//-----------------------------------------------------------------------------
// Store the given PFKeyHandler in the table & activate it.
// A second call with the same handler activates it (again).
//-----------------------------------------------------------------------------
void PFKeyHandlerSet(const TPfKeyTable &Table)

//-----------------------------------------------------------------------------
// PFKeyHandlerSet - set Programmable Function Key handler (function)
//-----------------------------------------------------------------------------
// Store the given PFKeyHandler in the table & activate it.
// A second call with the same handler activates it (again).
//-----------------------------------------------------------------------------
void PFKeyHandlerSet(const char *(*NewFunction)(int PFKey, bool InfoOnly), const char *NewName)

//----------------------------------------------------------------------------
// TPoint::Print - 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void TPoint::Print()

//----------------------------------------------------------------------------
// TPoint::operator = 
//----------------------------------------------------------------------------
// this = Vector
//----------------------------------------------------------------------------
void TPoint::operator = (const TVector &Vector)

//----------------------------------------------------------------------------
// TPoint::operator += 
//----------------------------------------------------------------------------
// this = this + Point
//----------------------------------------------------------------------------
void TPoint::operator += (const TPoint &Point)

//----------------------------------------------------------------------------
// TPoint::operator += 
//----------------------------------------------------------------------------
// this = this + Vector
//----------------------------------------------------------------------------
void TPoint::operator += (const TVector &Vector)

//----------------------------------------------------------------------------
// TPoint::operator -= 
//----------------------------------------------------------------------------
// this = this - Point
//----------------------------------------------------------------------------
void TPoint::operator -= (const TPoint &Point)

//----------------------------------------------------------------------------
// TPoint::operator -= 
//----------------------------------------------------------------------------
// this = this - Vector
//----------------------------------------------------------------------------
void TPoint::operator -= (const TVector &Vector)

//----------------------------------------------------------------------------
// TPoint::operator +
//----------------------------------------------------------------------------
// return (this + Point)
//----------------------------------------------------------------------------
TPoint TPoint::operator + (const TPoint &Point)

//----------------------------------------------------------------------------
// TPoint::operator +
//----------------------------------------------------------------------------
// return (this + Vector)
//----------------------------------------------------------------------------
TPoint TPoint::operator + (const TVector   &Vector)

//----------------------------------------------------------------------------
// TPoint::operator -
//----------------------------------------------------------------------------
// return (this - Point)
//----------------------------------------------------------------------------
TPoint TPoint::operator - (const TPoint &Point)

//----------------------------------------------------------------------------
// TPoint::operator -
//----------------------------------------------------------------------------
// return (this - Vector)
//----------------------------------------------------------------------------
TPoint TPoint::operator - (const TVector   &Vector)

//-----------------------------------------------------------------------------                   
// TPresentation::Add - Add / update data fields for reporting
//-----------------------------------------------------------------------------                   
//-----------------------------------------------------------------------------                   
void TPresentation::Add(const char *Tag, int &Value)

//-----------------------------------------------------------------------------                   
// TPresentation::Delete - Delete data fields from reporting
//-----------------------------------------------------------------------------                   
//-----------------------------------------------------------------------------                   
void TPresentation::Delete(const char *Tag)

//-----------------------------------------------------------------------------
// TSensor2Abs::Point - Return (abs) point coordinates of input
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TPoint TSensor2Abs::Point()

//-----------------------------------------------------------------------------
// TSensor2Abs::Print - Print battery status
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TSensor2Abs::Print()

//-----------------------------------------------------------------------------
// TSensor2Abs::Dump - Dump battery class settings
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TSensor2Abs::Dump()

//-----------------------------------------------------------------------------
// TTaktList::Add - Add a takt FUNCTION to the list
//-----------------------------------------------------------------------------
// Params: 
//    NewFunction : Takt function pointer
//    Name        : Takt Name
//    Order       : Takt Order (lower number == earlier, default = 0)
//-----------------------------------------------------------------------------
void TTaktList::Add(void (*NewFunction)(), const char *TaskName, int Order)

//-----------------------------------------------------------------------------
// TTaktList::Add - Add a takt CLASS to the list
//-----------------------------------------------------------------------------
// Params: 
//    NewObject   : Takt class reference
//    Name        : Takt Name
//    Order       : Takt Order (lower number == earlier, default = 0)
//-----------------------------------------------------------------------------
void TTaktList::Add(TTaktObject &NewObject, const char *TaskName, int Order)

//-----------------------------------------------------------------------------
// TTaktList::Print - Print names & stats of all tasks
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TTaktList::Print()

//-----------------------------------------------------------------------------
// TTaktList::ClearStats -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TTaktList::ClearStats()

//-----------------------------------------------------------------------------
// TTaktList::Report - Print name of active task
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TTaktList::Report()

//-----------------------------------------------------------------------------
// TTaktList::Takt - execute all tasks in the list
//-----------------------------------------------------------------------------
// * always start with the first one
// * call all tasks in one pass / without interruption
//-----------------------------------------------------------------------------
void TTaktList::Takt()

//-----------------------------------------------------------------------------
// TTaktList::TaktFirst - execute first task from the list
//-----------------------------------------------------------------------------
// reset list & execute first task from the list
//-----------------------------------------------------------------------------
void TTaktList::TaktFirst()

//-----------------------------------------------------------------------------
// TTaktList::TaktNext - execute next task from the list
//-----------------------------------------------------------------------------
// Stops when all tasks are executed, call TaktFirst() to restart
//-----------------------------------------------------------------------------
void TTaktList::TaktNext()

//-----------------------------------------------------------------------------
// TTaktList::TaktLoop -  execute next task from the list
//-----------------------------------------------------------------------------
// restart with 1th task when all tasks are executed
//-----------------------------------------------------------------------------
void TTaktList::TaktLoop()

//-----------------------------------------------------------------------------
// TTaktList::IsLastDone - true if the last task of the list has been executed.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TTaktList::IsLastDone()

//-----------------------------------------------------------------------------
// TTaktObject::Takt - pure virtual function for takt
//-----------------------------------------------------------------------------
// Please do not create instances of TaskObject. This class is a base class
// for classes that need to be called by a TaktList. Each derived class must
// implement its own Takt() methode.
//-----------------------------------------------------------------------------
void TTaktObject::Takt()

//-----------------------------------------------------------------------------
// TaskManager - Listen in on the console port & trigger ReportTasks
//-----------------------------------------------------------------------------
// Magic string "!@#$%" on console triggers ReportTasks. Usefull to
// track down blocking tasks!
//-----------------------------------------------------------------------------
void TaskManager(char ch)

//-----------------------------------------------------------------------------
// IntervalGuardTakt - Guard duration of main takt.
//-----------------------------------------------------------------------------
// Measure average time between calls and print warning if
// * Average  > MAIN_TAKT_INTERVAL + 10%
// * Duration > MAIN_TAKT_INTERVAL + 100%
//-----------------------------------------------------------------------------
void IntervalGuardTakt()

//-----------------------------------------------------------------------------
// StopWatchReset - Set start time to current 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void StopWatchReset()

//-----------------------------------------------------------------------------
// StopWatchGet - return microseconds since last StopWatchReset
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
long StopWatchGet()

//-----------------------------------------------------------------------------
// wait_ms - blokkerend x milliseconden wachten
//-----------------------------------------------------------------------------
// Deze functie is bedoeld voor gebruik bij opstarten; na het opstarten 
// verstoort een blokkerende wachttijd de werking van andere processen.
//-----------------------------------------------------------------------------
void wait_ms(long delay)

//-----------------------------------------------------------------------------
// wait_us - blokkerend x microseconden wachten
//-----------------------------------------------------------------------------
// Deze functie is bedoeld voor gebruik bij opstarten of korte delays; na het 
// opstarten verstoort een blokkerende wachttijd de werking van andere processen.    
// Wachttijden tot 100 us zijn normaal geen probleem.
//-----------------------------------------------------------------------------
void wait_us(long delay)

//----------------------------------------------------------------------------
// PermanentString - Make string permanent (if it is not)
//----------------------------------------------------------------------------
// Check if string is in ROM or RAM. A pointer to a ROM string is returned.
// When the string is in RAM, memory is allocacted, the content is copied and
// a pointer to the newly allocated memory is provided.
//----------------------------------------------------------------------------
const char *PermanentString(const char *InString)

//----------------------------------------------------------------------------
// Clip - return input, begrensd bij (min, max)
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
int Clip(int input, int min, int max)

//----------------------------------------------------------------------------
// fClip - return input, begrensd bij (min, max)
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
float fClip(float input, float min, float max)

//-----------------------------------------------------------------------------
//  Map - map variable from one range to another.
//-----------------------------------------------------------------------------
// From: https://www.arduino.cc/en/reference/map
// Params:
//    x                 - input value
//    in_min, in_max    - input range
//    out_min, out_max  - output range
//
// Returns: scaled value
//
// Note: the output value is NOT clipped to the output range, 
//       see MapClip() for clipped version.
//-----------------------------------------------------------------------------
int Map(int x, int in_min, int in_max, int out_min, int out_max)

//-----------------------------------------------------------------------------
//  MapClip - map variable from one range to another & clip it to output range.
//-----------------------------------------------------------------------------
// Params:
//    x                 - input value
//    in_min, in_max    - input range
//    out_min, out_max  - output range
//
// Returns: scaled value
//
// Note: the output value is clipped to the output range, 
//       see Map() for unclipped version.
//-----------------------------------------------------------------------------
int MapClip(int x, int in_min, int in_max, int out_min, int out_max)

//-----------------------------------------------------------------------------
// Slope - Gradually increment / decrement to Setpoint.
//-----------------------------------------------------------------------------
// Step is positive value.                             
// SlopeInOut follows setpoint 
//-----------------------------------------------------------------------------
void Slope(int &SlopeInOut, int Setpoint, int Step)

//----------------------------------------------------------------------------
// NormAngle - Normalize angle around 0 (+/- half circel).
//----------------------------------------------------------------------------
// Return: normalized hoek, between PI and -PI
//
// See NormHoek() for integer (degree) version.
//---------------------------------------------------------------------------- 
float NormAngle(float Angle)

//----------------------------------------------------------------------------
// NormDegrees - Normeer een hoek in graden (degrees) rond nulpunt (+/- halve circel).
//----------------------------------------------------------------------------
// Param
//    degrees = input, 
//
// Return: normalized degrees
//
// See NormAngle() for float (RAD) version.
//---------------------------------------------------------------------------- 
int NormDegrees(int Degrees)

//-----------------------------------------------------------------------------
// Normalize - map Value from 0 (<= Null) to 1000 (>= Full)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int Normalize(int Value, int Null, int Full)

//-----------------------------------------------------------------------------
//  HexDump - dump data, max 16 bytes in a row, with address prefix
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void HexDump(const void *Data, int Length, int Address )

//-----------------------------------------------------------------------------
// I2cSendReceive - equivalent of HalI2cSendReceive, but without the RESTART
//-----------------------------------------------------------------------------
// Some i2c slaves (like Arduino / Atmega) do't support restart and require 
// some time to respond to a message. This function provides this delay.
//  
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cSendReceive(int I2cSlaveAddress, int TxCount, int RxCount, char *TxBuffer, char *RxBuffer)

//-----------------------------------------------------------------------------
// I2cRead_Byte_Byte - Send a Byte address, then read a Byte of data.
//-----------------------------------------------------------------------------
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cRead_Byte_Byte(int I2cSlaveAddress, int RegAddr, int &Data)

//-----------------------------------------------------------------------------
// I2cRead_Word_Byte - Send a Word address, then read a Byte of data.
//-----------------------------------------------------------------------------
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cRead_Word_Byte(int I2cSlaveAddress, int RegAddr, int &Data)

//-----------------------------------------------------------------------------
// I2cRead_Byte_Word - Send a Word address, then read a Word of data.
//-----------------------------------------------------------------------------
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cRead_Byte_Word(int I2cSlaveAddress, int RegAddr, int &Data)

//-----------------------------------------------------------------------------
// I2cRead_Word_Word - Send a Word address, then read a Word of data.
//-----------------------------------------------------------------------------
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cRead_Word_Word(int I2cSlaveAddress, int RegAddr, int &Data)

//-----------------------------------------------------------------------------
// I2cWrite_Byte_Byte - Send a Byte address, then write a Byte of data.
//-----------------------------------------------------------------------------
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cWrite_Byte_Byte(int I2cSlaveAddress, int RegAddr, int Data)

//-----------------------------------------------------------------------------
// I2cWrite_Word_Byte - Send a Word address, then write a Byte of data.
//-----------------------------------------------------------------------------
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cWrite_Word_Byte(int I2cSlaveAddress, int RegAddr, int Data)

//-----------------------------------------------------------------------------
// I2cWrite_Byte_Word - Send a Byte address, then write a Word of data.
//-----------------------------------------------------------------------------
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cWrite_Byte_Word(int I2cSlaveAddress, int RegAddr, int Data)

//-----------------------------------------------------------------------------
// I2cWrite_Word_Word - Send a Word address, then write a Word of data.
//-----------------------------------------------------------------------------
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cWrite_Word_Word(int I2cSlaveAddress, int RegAddr, int Data)

//-----------------------------------------------------------------------------
// I2cReadRegisters - Send register byte addres, then read one or more register.
//-----------------------------------------------------------------------------
// Param: Reg is a BYTE address.
//  
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cReadRegisters(int I2cSlaveAddress, char Reg, int RxCount, char *RxBuffer)

//-----------------------------------------------------------------------------
// I2cWriteRegisters - Send register byte addres, then write one or more register.
//-----------------------------------------------------------------------------
// Param: Reg is a BYTE address.
// Note: max message size limited to 32 bytes. 
// return: true on succes
//-----------------------------------------------------------------------------
bool I2cWriteRegisters(int I2cSlaveAddress, char Reg, int TxCount, char *InTxBuffer)

//----------------------------------------------------------------------------
// EenparigVertragen - Limit speed, dependant on the distance to endpoint
//----------------------------------------------------------------------------  
// Parameters:
//       Distance    - Distance to endpoint (mm)
//       SetSpeed    - desired (maximal) speed (mm/s)
//       EndSpeed    - desired speed at endpoint (mm/s)
//       MaxSlopeIn  - deceleratation in mm/s^2 
//
// return Speed, met sign of SetSpeed
//----------------------------------------------------------------------------
int EenparigVertragen(int Distance, int SetSpeed, int EndSpeed, int MaxSlopeIn)

//-----------------------------------------------------------------------------
// LipoBatteryPercentage - Percentage resterende capaciteit 
//-----------------------------------------------------------------------------
// Returns value from 0 to 100 for remaining capacity.
// 100% is 4.2V or more per cell
//   0% is 3.2V or less per cell
//
// Params:
//    AdcValue  - raw adc reading
//    Calibrate - Volts / AdcValue 
//    Cells     - nr of cells in pack
// Example
//
// int Percent = LipoBatteryPercentage(AdcRead(1), (16.35 / 3800), 4);
//
// Note: calibration based on AdcRead(1) value of 3800 when battery
//       voltage is 16.35V. Provide voltage as float (with decimal point)
//       for proper operation.
//-----------------------------------------------------------------------------
int LipoBatteryPercentage(int AdcValue, float Calibrate, int Cells)

//-----------------------------------------------------------------------------
// PointsToAB - Two points (x,y) -> (a, b) y = ax + b
//-----------------------------------------------------------------------------
// bepaal de formule van een lijn door de twee gegeven punten.
//-----------------------------------------------------------------------------
void PointsToAB(int x1, int y1, int x2, int y2, float &a, float &b)

//----------------------------------------------------------------------------
// iRad2Deg - convert radial (float) angle to degree (int) angle
//----------------------------------------------------------------------------  
//----------------------------------------------------------------------------  
int iRad2Deg(float Angle)

//----------------------------------------------------------------------------
// fRad2Deg - convert radial (float) angle to degree (float) angle
//----------------------------------------------------------------------------  
//----------------------------------------------------------------------------  
float fRad2Deg(float Angle)

//----------------------------------------------------------------------------
// Deg2Rad - convert degree (int) angle to radial (float) angle
//----------------------------------------------------------------------------  
//----------------------------------------------------------------------------  
float Deg2Rad(int Degrees)

//----------------------------------------------------------------------------
// Deg2Rad - convert degree (float) angle to radial (float) angle
//----------------------------------------------------------------------------  
//----------------------------------------------------------------------------  
float Deg2Rad(float Degrees)

//-----------------------------------------------------------------------------   
// CalcCrc16 - Add char to CRC
//-----------------------------------------------------------------------------   
//-----------------------------------------------------------------------------   
void CalcCrc16(unsigned char InByte, int &crc)

//------------------------------------------------------------------------
// TVector::Degrees - return vector angle in degrees
//------------------------------------------------------------------------
//------------------------------------------------------------------------
int TVector::Degrees()

//------------------------------------------------------------------------
// TVector::Degrees - Set vector angle to degrees param
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void TVector::Degrees(int InDegrees)

//----------------------------------------------------------------------------
// TVector::Print - print (converting angle to degrees)
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void TVector::Print()

//----------------------------------------------------------------------------
// TVector::operator =  
//----------------------------------------------------------------------------
// this = Point
//----------------------------------------------------------------------------
void TVector::operator = (const TPoint &Point)

//----------------------------------------------------------------------------
// TVector::operator +=
//----------------------------------------------------------------------------
// this = this + Point
//----------------------------------------------------------------------------
void TVector::operator += (const TPoint &Point)

//----------------------------------------------------------------------------
// TVector::operator +=
//----------------------------------------------------------------------------
// this = this + Vector
//----------------------------------------------------------------------------
void TVector::operator += (const TVector   &Vector)

//----------------------------------------------------------------------------
// TVector::operator +
//----------------------------------------------------------------------------
// return (this + Vector)
//----------------------------------------------------------------------------
TPoint TVector::operator + (const TVector   &Vector)

//----------------------------------------------------------------------------
// TVector::operator +
//----------------------------------------------------------------------------
// return (this + point)
//----------------------------------------------------------------------------
TPoint TVector::operator + (const TPoint   &Point)

//-----------------------------------------------------------------------------
// TRegistry::AddInt - Add integer to registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::AddInt (const char *InName)

//-----------------------------------------------------------------------------
// TRegistry::AddFloat - Add float to registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::AddFloat (const char *InName)

//-----------------------------------------------------------------------------
// TRegistry::Add - Add exisiting integer to registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::Add (const char *InName, int &_var)

//-----------------------------------------------------------------------------
// TRegistry::Add - Add existing to registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::Add (const char *InName, float &_var)

//-----------------------------------------------------------------------------
// TRegistry::GetSize - nr of entries in registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TRegistry::GetSize()

//-----------------------------------------------------------------------------
// TRegistry::Exists - Check if name exists
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TRegistry::Exists (const char *InName)

//-----------------------------------------------------------------------------
// TRegistry::SetValue - by Index 
//-----------------------------------------------------------------------------
// 'by Index' is intended for Kdu. Please use 'by Name' interface when possible
//-----------------------------------------------------------------------------
void TRegistry::SetValue (int Index, float InValue)

//-----------------------------------------------------------------------------
// TRegistry::SetValue - by Name
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::SetValue (const char *InName, float InValue)

//-----------------------------------------------------------------------------
// TRegistry::SetDialog - by Name
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::SetDialog(const char *InName, const char *InDialog)

//-----------------------------------------------------------------------------
// TRegistry::GetValue - by Name
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float TRegistry::GetValue (const char *InName)

//-----------------------------------------------------------------------------
// TRegistry::GetDialog - by Name
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
const char *TRegistry::GetDialog(const char *InName)

//-----------------------------------------------------------------------------
// TRegistry::Dump -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::Dump()

//-----------------------------------------------------------------------------
// A2UartQueuedInit - Auxiliary uart queued (interrupt based)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern "C" void A2UartQueuedInit(void)

//-----------------------------------------------------------------------------
// A2UartQueuedGetChar -
//-----------------------------------------------------------------------------
// return data, -1 if no data.
//-----------------------------------------------------------------------------
int A2UartQueuedGetChar()

//-----------------------------------------------------------------------------
// A2UartQueuedPutChar - Console Uart Queued PutChar (interrupt based)
//-----------------------------------------------------------------------------
// stm32 specifics from:
// http://www.embedds.com/programming-stm32-usart-using-gcc-tools-part-2/
//-----------------------------------------------------------------------------
void A2UartQueuedPutChar(char charToSend)

//----------------------------------------------------------------------------- 
// HalAdcInit - Init ADC ** do not forget to configure the input pins ***
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void HalAdcInit(void)

//----------------------------------------------------------------------------- 
// HalAdcRead - read ADC input <Nr>
//-----------------------------------------------------------------------------
// returns: 12 bit value 
//----------------------------------------------------------------------------- 
int HalAdcRead(int Nr)

//-----------------------------------------------------------------------------
// AUartQueuedInit - Auxiliary uart queued (interrupt based)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern "C" void AUartQueuedInit(void)

//-----------------------------------------------------------------------------
// AUartQueuedGetChar -
//-----------------------------------------------------------------------------
// return data, -1 if no data.
//-----------------------------------------------------------------------------
int AUartQueuedGetChar()

//-----------------------------------------------------------------------------
// AUartQueuedPutChar - Console Uart Queued PutChar (interrupt based)
//-----------------------------------------------------------------------------
// stm32 specifics from:
// http://www.embedds.com/programming-stm32-usart-using-gcc-tools-part-2/
//-----------------------------------------------------------------------------
void AUartQueuedPutChar(char charToSend)

//-----------------------------------------------------------------------------
// HalCoreInit - Init of all mandatory HAL parts
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void HalCoreInit()

//-----------------------------------------------------------------------------
// HalGetUsCounter - return value of 1 MHz free running counter
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned long HalGetUsCounter()

//-----------------------------------------------------------------------------
// Rc5PinInit -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void Rc5PinInit()

//-----------------------------------------------------------------------------
// Rc5PinGet -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int Rc5PinGet()

//-----------------------------------------------------------------------------
// BuzzerPinInit -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void BuzzerPinInit()

//-----------------------------------------------------------------------------
// BuzzerPinSet - 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void BuzzerPinSet(int i)

//-----------------------------------------------------------------------------
// HalI2cInit - init I2c 
//----------------------------------------------------------------------------- 
// #1 on PB6 (SCL) & PB7 (SDA)
//-----------------------------------------------------------------------------
void  HalI2cInit()

//-----------------------------------------------------------------------------
// HalI2cSendReceive - send a string to an i2c slave and receive bytes back
//-----------------------------------------------------------------------------
// This funtion uses two global i2c buffers, one for transmit (tx) and one for
// receive (rx). The address of the slave (higher 7 bits), number of bytes to
// transmit and number of bytes to receive are parameters.  
//
// return: true if all went well.
//-----------------------------------------------------------------------------
int HalI2cSendReceive(int I2cSlaveAddress, int TxCount, int RxCount, char *TxBuffer, char *RxBuffer)

//-----------------------------------------------------------------------------
// HalServoInit - Setup Servo Pulse (pwm) output
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void HalServoInit(void)

//-----------------------------------------------------------------------------
// HalServoSet - Set pulstijd voor gegeven servo
//-----------------------------------------------------------------------------
// Nr: servo nummer (1-4, conform TIM1 CH nummers)
// value: in microsondend, 0...3000 (500...2500, 0 = off)
//-----------------------------------------------------------------------------
void HalServoSet(int Nr, int Value)

//-----------------------------------------------------------------------------
// CUartQueuedInit - Console uart queued (interrupt based)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern "C" void CUartQueuedInit(void)

//-----------------------------------------------------------------------------
// CUartQueuedGetChar -
//-----------------------------------------------------------------------------
// return data, -1 if no data.
//-----------------------------------------------------------------------------
int CUartQueuedGetChar()

//-----------------------------------------------------------------------------
// CUartQueuedPutChar - Console Uart Queued PutChar (interrupt based)
//-----------------------------------------------------------------------------
// stm32 specifics from:
// http://www.embedds.com/programming-stm32-usart-using-gcc-tools-part-2/
//-----------------------------------------------------------------------------
void CUartQueuedPutChar(char charToSend)

//-----------------------------------------------------------------------------
// CUartPolledInit - Console Uart Polled (no interrupt) init.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern "C" void CUartPolledInit(void)

//-----------------------------------------------------------------------------
// CUartPolledGetChar -
//-----------------------------------------------------------------------------
// return data, -1 if no data.
//-----------------------------------------------------------------------------
int CUartPolledGetChar()

//-----------------------------------------------------------------------------
// CUartPolledPutChar -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CUartPolledPutChar(char charToSend)