RobotLib Reference
Uit RobotMC.be
Zie deze pagina voor een overzicht van alle RobotLib documentatie op deze wiki.
Dit is een automatisch gegenereerde pagina.
Missions
MSM_LineSensorCalibrate
File: C:\RobotLib\RobotLib\LineSensorGeneric.cpp
//-----------------------------------------------------------------------------
// MSM_LineSensorCalibrate - Turn left, right and back.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool MSM_LineSensorCalibrate(TMissionHandler *M, int &State, int NewState)MSM_Cal_LineFollow
File: C:\RobotLib\RobotLib\LineSensorGeneric.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MissionHandler.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MissionHandler.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MissionHandler.cpp
//-----------------------------------------------------------------------------
// TMissionHandler::Abort - Abort running mission.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TMissionHandler::Abort(void)TMissionHandler::Takt
File: C:\RobotLib\RobotLib\MissionHandler.cpp
//-----------------------------------------------------------------------------
// TMissionHandler::Takt - Takt (execution) of requested mission (state machine)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TMissionHandler::Takt(void)TMissionHandler::IsDone
File: C:\RobotLib\RobotLib\MissionHandler.cpp
//-----------------------------------------------------------------------------
// TMissionHandler::IsDone - true als missie is afgerond
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TMissionHandler::IsDone()TMissionHandler::ParamSet
File: C:\RobotLib\RobotLib\MissionHandler.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MissionHandler.cpp
//-----------------------------------------------------------------------------
// TMissionHandler::ParamGet - Get Parameter in Store.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TMissionHandler::ParamGet(int Nr)InvalidMission
File: C:\RobotLib\RobotLib\MissionHandler.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MotorCalibrate.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MotorCalibrate.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MotorCalibrate.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MotorCalibrate.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Um_Patterns.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Um_Patterns.cpp
//-----------------------------------------------------------------------------
// Ump_WheelSizeCalibrate - Universal mover pattern: WheelSizeCalibrate
//-----------------------------------------------------------------------------
// Drive requested distance, turn, drive back & turn back.
//-----------------------------------------------------------------------------
void Ump_WheelSizeCalibrate(int Distance, int Speed)UniversalMovers
UmArc
File: C:\RobotLib\RobotLib\UmArc.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmArcRel.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmDistanceHeading.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmDistanceHeading.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmDistanceHeadingRel.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmDistanceHeadingRel.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmLineFollower.cpp
//-----------------------------------------------------------------------------
// UmLineFollower - set Universal movement LineFollower
//-----------------------------------------------------------------------------
// Calls the instance LineFollower of TLineFollower
// Configure this class to modify the behaviour of this movement
//-----------------------------------------------------------------------------
void UmLineFollower()UmPwm
File: C:\RobotLib\RobotLib\UmPwm.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmPwm.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmRobotPosition.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmRotate.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmRotateRel.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmSpeedHeading.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmSpeedHeading.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmSpeedLR.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmSpeedLR.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmSpeedRotation.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmSpeedRotation.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmStop.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmXY.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmXY.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmXY.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmXYPhi.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\UmXYPhi2.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Um_Mover.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Um_Mover.cpp
//-----------------------------------------------------------------------------
// TUniversalMover::List - List current movement / list of movements
//-----------------------------------------------------------------------------
// The active movement is pre-pended with an '*', others with '>'.
//-----------------------------------------------------------------------------
void TUniversalMover::List()TUniversalMover::IsDone
File: C:\RobotLib\RobotLib\Um_Mover.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Um_Mover.cpp
//-----------------------------------------------------------------------------
// TUniversalMover::SetCallBack - Provide call-back function for last movement
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TUniversalMover::SetCallBack(void (*NewFunction)(), const char *NewName)TUniversalMover::StepDone
File: C:\RobotLib\RobotLib\Um_Mover.cpp
//-----------------------------------------------------------------------------
// TUniversalMover::StepDone - Tell Mover current step is done
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TUniversalMover::StepDone()Positie
TPosition::Reset
File: C:\RobotLib\RobotLib\Position.cpp
//------------------------------------------------------------------------
// TPosition::Reset - Set current pose at 0, 0, 0
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void TPosition::Reset()TPosition::Takt
File: C:\RobotLib\RobotLib\Position.cpp
//-----------------------------------------------------------------------------
// TPosition::Takt - Read encoders & update robot position / pose
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPosition::Takt()TPosition::Print
File: C:\RobotLib\RobotLib\Position.cpp
//-----------------------------------------------------------------------------
// TPosition::Print - print X/Y/hoek
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPosition::Print()TPosition::CorrectPose
File: C:\RobotLib\RobotLib\Position.cpp
//------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Position.cpp
//------------------------------------------------------------------------
// 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)Points
IcpAlign
File: C:\RobotLib\RobotLib\Icp.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList Constructor - create list with space for InSize points.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TPointList::TPointList(int InSize)TPointList::Count
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::Count - Nr of (active) items in list.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TPointList::Count()TPointList::Size
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::Size - Retun size of list.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TPointList::Size()TPointList::Clear
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::Clear - Erase list (delete all points)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::Clear()TPointList::ClearGroup
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::ClearGroup - set groupcode of all points to zero
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::ClearGroup()TPointList::DeleteGroup
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::DeleteGroup - Delete points with groupcode
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::DeleteGroup(unsigned char InGroup)TPointList::DumpGroup
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::DumpGroup - Dump points with groupcode
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::DumpGroup(unsigned char InGroup, int PresentationGroup)TPointList::DumpAll
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::DumpAll - Dump all points in list
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::DumpAll(int PresentationGroup)TPointList::Add
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::Add - Add point to list
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::Add(const TPoint &p_in)TPointList::Add
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::Add - Add point to list
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPointList::Add(int X, int Y)TPointList::Search
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::Search - Search for closest point in list
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TPoint *TPointList::Search(const TPoint &Point)TPointList::TransformPose
File: C:\RobotLib\RobotLib\PointList.cpp
//-----------------------------------------------------------------------------
// TPointList::TransformPose - Translate & (then) rotate (not commutative)
//-----------------------------------------------------------------------------
// voorheen icp_transform_pose()
//-----------------------------------------------------------------------------
void TPointList::TransformPose(const TPose &pose)Sensor
TLineSensorQrt8a::Clear
File: C:\RobotLib\RobotLib\LineSensorQRT8A.cpp
//-----------------------------------------------------------------------------
// TLineSensorQrt8a::Clear - sensor off & clear data
//-----------------------------------------------------------------------------
// * calibration data is cleared.
// * Configuration data (normal/reverse) is *NOT* cleared
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::Clear()TLineSensorQrt8a::SetCalibration
File: C:\RobotLib\RobotLib\LineSensorQRT8A.cpp
//-----------------------------------------------------------------------------
// TLineSensorQrt8a::SetCalibration -
//-----------------------------------------------------------------------------
// Stores min and max value.
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::SetCalibration(int Min, int Max)TLineSensorQrt8a::Calibrate
File: C:\RobotLib\RobotLib\LineSensorQRT8A.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\LineSensorQRT8A.cpp
//-----------------------------------------------------------------------------
// TLineSensorQrt8a::On - Turn on sensor
//-----------------------------------------------------------------------------
// See methods Calibrate(), On(), Off()
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::On()TLineSensorQrt8a::Off
File: C:\RobotLib\RobotLib\LineSensorQRT8A.cpp
//-----------------------------------------------------------------------------
// TLineSensorQrt8a::Off - Turn sensor off
//-----------------------------------------------------------------------------
// See methods Calibrate(), On(), Off()
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::Off()TLineSensorQrt8a::Dump
File: C:\RobotLib\RobotLib\LineSensorQRT8A.cpp
//-----------------------------------------------------------------------------
// TLineSensorQrt8a::Dump - Dump all sensor data
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TLineSensorQrt8a::Dump()Max127Read
File: C:\RobotLib\RobotLib\MAX127.cpp
//-----------------------------------------------------------------------------
// Max127Read - Read Max127 i2c ADC convertor
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int Max127Read(int Channel)TPID::SetInputRefs
File: C:\RobotLib\RobotLib\PID.cpp
//-----------------------------------------------------------------------------
// TPID::SetInputRefs -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPID::SetInputRefs(int &InInput, int &InSetpoint)TPID::PrintStat
File: C:\RobotLib\RobotLib\PID.cpp
//-----------------------------------------------------------------------------
// TPID::PrintStat - one line to reflect the internal status
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPID::PrintStat()TPID::Print
File: C:\RobotLib\RobotLib\PID.cpp
//-----------------------------------------------------------------------------
// TPID::Print -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPID::Print()TRpLidar::GetState
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// TRpLidar::Start - Start lidar op
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRpLidar::Start()TRpLidar::Stop
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// TRpLidar::Stop - Stop / Reset lidar
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRpLidar::Stop()TRpLidar::PrintDebugInfo
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// TRpLidar::PrintDebugInfo - Status details van de class
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRpLidar::PrintDebugInfo()TRpLidar::Takt
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// TRpLidar::GetSample - all sample data, for degrees
//-----------------------------------------------------------------------------
// return NULL if no valid sample for requested degrees
//-----------------------------------------------------------------------------
const tLidarSample *TRpLidar::GetSample(int InDegrees)TRpLidar::GetDistance
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// TRpLidar::GetDistance - for degrees
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TRpLidar::GetDistance(int InDegrees)TRpLidar::GetDistance
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\RpLidar.cpp
//-----------------------------------------------------------------------------
// TRpLidar::Dump - Dump stored samples
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRpLidar::Dump(int Mode)TRpLidarSim::GetDistance
File: C:\RobotLib\RobotLib\SensorSimulator.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\SharpSensor.cpp
//-----------------------------------------------------------------------------
// TSharpSensor::Print -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TSharpSensor::Print()TSharpSensor::SetTimeConstant
File: C:\RobotLib\RobotLib\SharpSensor.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\SharpSensor.cpp
//-----------------------------------------------------------------------------
// 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()Output
TArIo::digitalWrite
File: C:\RobotLib\RobotLib\ArIo.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\ArIo.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\ArIo.cpp
//-----------------------------------------------------------------------------
// TArIo::pinMode - Set pinmode for remote IO
//-----------------------------------------------------------------------------
// This function immediately triggers an i2c message.
//-----------------------------------------------------------------------------
void TArIo::pinMode(int Pin, int Mode)TArIo::analogRead
File: C:\RobotLib\RobotLib\ArIo.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\ArIo.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// TAx12::Enable - Enable Torque of AX12 with ID
//-----------------------------------------------------------------------------
// This function immediately triggers an i2c message.
//-----------------------------------------------------------------------------
void TAx12::Enable(int Id, int EnableIn)TAx12::MotorMode
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Ax12.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MedianFilter.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MedianFilter.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MedianFilter.cpp
//-----------------------------------------------------------------------------
// TMedianFilter3::Median - Return median value of Median3 filter
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float TMedianFilter3::Median()TMedianFilter::Add
File: C:\RobotLib\RobotLib\MedianFilter.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MedianFilter.cpp
//-----------------------------------------------------------------------------
// TMedianFilter::Add - Add sample to Median filter and return new median
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float TMedianFilter::Add(float datum)TMedianFilter::Dump
File: C:\RobotLib\RobotLib\MedianFilter.cpp
//-----------------------------------------------------------------------------
// TMedianFilter::Dump -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TMedianFilter::Dump()TPCA9685::Init
File: C:\RobotLib\RobotLib\PCA9685.cpp
//-----------------------------------------------------------------------------
// TPCA9685::Init - Init device with I2C address param
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TPCA9685::Init(int i2cAddress)TPCA9685::DumpRegisters
File: C:\RobotLib\RobotLib\PCA9685.cpp
//-----------------------------------------------------------------------------
// TPCA9685::DumpRegisters - Dump setup registers & pwm values of channel 0-4
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCA9685::DumpRegisters()TPCA9685::SetPwm
File: C:\RobotLib\RobotLib\PCA9685.cpp
//-----------------------------------------------------------------------------
// TPCA9685::SetPwm - Set pulse width, Amount [0..4095], PinNumber [0..15]
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCA9685::SetPwm(int PinNumber, int Amount)TPCA9685::SetPwm
File: C:\RobotLib\RobotLib\PCA9685.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\PCA9685.cpp
//-----------------------------------------------------------------------------
// TPCA9685::SetFrequency - Set PWM Frequency (assuming internal 25 MHz clock)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCA9685::SetFrequency(int f)PCA9685_ServoInit
File: C:\RobotLib\RobotLib\PCA9685.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\PCA9685.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\PCF8574.cpp
//-----------------------------------------------------------------------------
// TPCF8574::Print - Print data about this class instance
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCF8574::Print()TPCF8574::Commit
File: C:\RobotLib\RobotLib\PCF8574.cpp
//-----------------------------------------------------------------------------
// TPCF8574::Commit - Write local copy to device
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPCF8574::Commit()TServo::Print
File: C:\RobotLib\RobotLib\Servo.cpp
//-----------------------------------------------------------------------------
// TServo::Print - print servo configuration
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TServo::Print()TServo::Angle
File: C:\RobotLib\RobotLib\Servo.cpp
//-----------------------------------------------------------------------------
// TServo::Angle - Set angle
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TServo::Angle(int Degrees)TServo::Raw
File: C:\RobotLib\RobotLib\Servo.cpp
//-----------------------------------------------------------------------------
// TServo::Raw - set Raw (microseconden, within limits of Min, Max)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TServo::Raw(int Value)TServo::Enable
File: C:\RobotLib\RobotLib\Servo.cpp
//-----------------------------------------------------------------------------
// TServo::Enable - Enable (true) or Disable (false) servo output.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TServo::Enable(bool E)TServo::IsDone
File: C:\RobotLib\RobotLib\Servo.cpp
//-----------------------------------------------------------------------------
// TServo::IsDone - true when movement... is done.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TServo::IsDone()TServo::GetRaw
File: C:\RobotLib\RobotLib\Servo.cpp
//-----------------------------------------------------------------------------
// TServo::GetRaw - return raw value (setpoint)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TServo::GetRaw()TServo::GetAngle
File: C:\RobotLib\RobotLib\Servo.cpp
//-----------------------------------------------------------------------------
// TServo::GetAngle - return angle value (setpoint)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TServo::GetAngle()PfKey
PFKeyMotorCalibrate1
File: C:\RobotLib\RobotLib\MotorCalibrate.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\MotorCalibrate.cpp
//-----------------------------------------------------------------------------
// 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";Utilities
TDebug::SetLevel
File: C:\RobotLib\RobotLib\Debug.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Debug.cpp
//-----------------------------------------------------------------------------
// TDebug::GetLevel - get debug level of module
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TDebug::GetLevel(int module)TDebug::IsLevel
File: C:\RobotLib\RobotLib\Debug.cpp
//-----------------------------------------------------------------------------
// TDebug::IsLevel - return true if debug level of module is >= Level
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TDebug::IsLevel(int Module, int Level)TDebug::HeaderFormat
File: C:\RobotLib\RobotLib\Debug.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Debug.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\DynamicPfKey.cpp
//-----------------------------------------------------------------------------
// SetDynamicPFKey - Set Dynamic PFKey <Nr> to <String>
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void SetDynamicPFKey(int Nr, const char *SrcString)I2cIsDeviceConnected
File: C:\RobotLib\RobotLib\Hal_System.cpp
//-----------------------------------------------------------------------------
// I2cIsDeviceConnected - return true if slave # is responding
//-----------------------------------------------------------------------------
// Read one char from slave to see if it is present.
//-----------------------------------------------------------------------------
bool I2cIsDeviceConnected(int I2cSlaveAddress)TInterval
File: C:\RobotLib\RobotLib\Interval.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Interval.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Interval.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Interval.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\LipoBattery.cpp
//-----------------------------------------------------------------------------
// TLipoBattery::Print - Print battery status
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TLipoBattery::Print()TLipoBattery::Dump
File: C:\RobotLib\RobotLib\LipoBattery.cpp
//-----------------------------------------------------------------------------
// TLipoBattery::Dump - Dump battery class settings
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TLipoBattery::Dump()TLipoBattery::SetCallBack
File: C:\RobotLib\RobotLib\LipoBattery.cpp
//-----------------------------------------------------------------------------
// TLipoBattery::SetCallBack - Provide call-back function for battery check
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TLipoBattery::SetCallBack(void (*NewFunction)(), const char *NewName)Beep
File: C:\RobotLib\RobotLib\Morse.cpp
//-----------------------------------------------------------------------------
// Beep - sound nr of beeps.
//-----------------------------------------------------------------------------
// duration = time length for sound and silence (in ms)
//-----------------------------------------------------------------------------
void Beep(int number_of_beeps, int duration)MorseChar
File: C:\RobotLib\RobotLib\Morse.cpp
//-----------------------------------------------------------------------------
// MorseChar - send char in morse via buzzer
//-----------------------------------------------------------------------------
// Note: defineer MORSE_WPM om Morse ondersteuning in te schakelen.
//-----------------------------------------------------------------------------
void MorseChar(char ch)MorseCode
File: C:\RobotLib\RobotLib\Morse.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Morse.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\PfKey.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\PfKey.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::Print -
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void TPoint::Print()TPoint::operator
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::operator =
//----------------------------------------------------------------------------
// this = Vector
//----------------------------------------------------------------------------
void TPoint::operator = (const TVector &Vector)TPoint::operator
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::operator +=
//----------------------------------------------------------------------------
// this = this + Point
//----------------------------------------------------------------------------
void TPoint::operator += (const TPoint &Point)TPoint::operator
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::operator +=
//----------------------------------------------------------------------------
// this = this + Vector
//----------------------------------------------------------------------------
void TPoint::operator += (const TVector &Vector)TPoint::operator
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::operator -=
//----------------------------------------------------------------------------
// this = this - Point
//----------------------------------------------------------------------------
void TPoint::operator -= (const TPoint &Point)TPoint::operator
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::operator -=
//----------------------------------------------------------------------------
// this = this - Vector
//----------------------------------------------------------------------------
void TPoint::operator -= (const TVector &Vector)TPoint::operator
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::operator +
//----------------------------------------------------------------------------
// return (this + Point)
//----------------------------------------------------------------------------
TPoint TPoint::operator + (const TPoint &Point)TPoint::operator
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::operator +
//----------------------------------------------------------------------------
// return (this + Vector)
//----------------------------------------------------------------------------
TPoint TPoint::operator + (const TVector &Vector)TPoint::operator
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::operator -
//----------------------------------------------------------------------------
// return (this - Point)
//----------------------------------------------------------------------------
TPoint TPoint::operator - (const TPoint &Point)TPoint::operator
File: C:\RobotLib\RobotLib\Point.cpp
//----------------------------------------------------------------------------
// TPoint::operator -
//----------------------------------------------------------------------------
// return (this - Vector)
//----------------------------------------------------------------------------
TPoint TPoint::operator - (const TVector &Vector)TPresentation::Add
File: C:\RobotLib\RobotLib\Presentation.cpp
//-----------------------------------------------------------------------------
// TPresentation::Add - Add / update data fields for reporting
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPresentation::Add(const char *Tag, int &Value)TPresentation::Delete
File: C:\RobotLib\RobotLib\Presentation.cpp
//-----------------------------------------------------------------------------
// TPresentation::Delete - Delete data fields from reporting
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TPresentation::Delete(const char *Tag)TSensor2Abs::Point
File: C:\RobotLib\RobotLib\Sensor2Abs.cpp
//-----------------------------------------------------------------------------
// TSensor2Abs::Point - Return (abs) point coordinates of input
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TPoint TSensor2Abs::Point()TSensor2Abs::Print
File: C:\RobotLib\RobotLib\Sensor2Abs.cpp
//-----------------------------------------------------------------------------
// TSensor2Abs::Print - Print battery status
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TSensor2Abs::Print()TSensor2Abs::Dump
File: C:\RobotLib\RobotLib\Sensor2Abs.cpp
//-----------------------------------------------------------------------------
// TSensor2Abs::Dump - Dump battery class settings
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TSensor2Abs::Dump()TTaktList::Add
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// TTaktList::Print - Print names & stats of all tasks
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TTaktList::Print()TTaktList::ClearStats
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// TTaktList::ClearStats -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TTaktList::ClearStats()TTaktList::Report
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// TTaktList::Report - Print name of active task
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TTaktList::Report()TTaktList::Takt
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// TTaktList::TaktFirst - execute first task from the list
//-----------------------------------------------------------------------------
// reset list & execute first task from the list
//-----------------------------------------------------------------------------
void TTaktList::TaktFirst()TTaktList::TaktNext
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// TTaktList::TaktNext - execute next task from the list
//-----------------------------------------------------------------------------
// Stops when all tasks are executed, call TaktFirst() to restart
//-----------------------------------------------------------------------------
void TTaktList::TaktNext()TTaktList::TaktLoop
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// TTaktList::TaktLoop - execute next task from the list
//-----------------------------------------------------------------------------
// restart with 1th task when all tasks are executed
//-----------------------------------------------------------------------------
void TTaktList::TaktLoop()TTaktList::IsLastDone
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// TTaktList::IsLastDone - true if the last task of the list has been executed.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TTaktList::IsLastDone()TTaktObject::Takt
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\TaktList.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// StopWatchReset - Set start time to current
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void StopWatchReset()StopWatchGet
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// StopWatchGet - return microseconds since last StopWatchReset
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
long StopWatchGet()wait_ms
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//----------------------------------------------------------------------------
// Clip - return input, begrensd bij (min, max)
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
int Clip(int input, int min, int max)fClip
File: C:\RobotLib\RobotLib\Utilities1.cpp
//----------------------------------------------------------------------------
// fClip - return input, begrensd bij (min, max)
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
float fClip(float input, float min, float max)Map
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// Slope - Gradually increment / decrement to Setpoint.
//-----------------------------------------------------------------------------
// Step is positive value.
// SlopeInOut follows setpoint
//-----------------------------------------------------------------------------
void Slope(int &SlopeInOut, int Setpoint, int Step)NormAngle
File: C:\RobotLib\RobotLib\Utilities1.cpp
//----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// Normalize - map Value from 0 (<= Null) to 1000 (>= Full)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int Normalize(int Value, int Null, int Full)HexDump
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// HexDump - dump data, max 16 bytes in a row, with address prefix
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void HexDump(const void *Data, int Length, int Address )I2cSendReceive
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities1.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities2.cpp
//----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities2.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities2.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Utilities2.cpp
//----------------------------------------------------------------------------
// iRad2Deg - convert radial (float) angle to degree (int) angle
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
int iRad2Deg(float Angle)fRad2Deg
File: C:\RobotLib\RobotLib\Utilities2.cpp
//----------------------------------------------------------------------------
// fRad2Deg - convert radial (float) angle to degree (float) angle
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
float fRad2Deg(float Angle)Deg2Rad
File: C:\RobotLib\RobotLib\Utilities2.cpp
//----------------------------------------------------------------------------
// Deg2Rad - convert degree (int) angle to radial (float) angle
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
float Deg2Rad(int Degrees)Deg2Rad
File: C:\RobotLib\RobotLib\Utilities2.cpp
//----------------------------------------------------------------------------
// Deg2Rad - convert degree (float) angle to radial (float) angle
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
float Deg2Rad(float Degrees)CalcCrc16
File: C:\RobotLib\RobotLib\Utilities2.cpp
//-----------------------------------------------------------------------------
// CalcCrc16 - Add char to CRC
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CalcCrc16(unsigned char InByte, int &crc)TVector::Degrees
File: C:\RobotLib\RobotLib\Vector.cpp
//------------------------------------------------------------------------
// TVector::Degrees - return vector angle in degrees
//------------------------------------------------------------------------
//------------------------------------------------------------------------
int TVector::Degrees()TVector::Degrees
File: C:\RobotLib\RobotLib\Vector.cpp
//------------------------------------------------------------------------
// TVector::Degrees - Set vector angle to degrees param
//------------------------------------------------------------------------
//------------------------------------------------------------------------
void TVector::Degrees(int InDegrees)TVector::Print
File: C:\RobotLib\RobotLib\Vector.cpp
//----------------------------------------------------------------------------
// TVector::Print - print (converting angle to degrees)
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void TVector::Print()TVector::operator
File: C:\RobotLib\RobotLib\Vector.cpp
//----------------------------------------------------------------------------
// TVector::operator =
//----------------------------------------------------------------------------
// this = Point
//----------------------------------------------------------------------------
void TVector::operator = (const TPoint &Point)TVector::operator
File: C:\RobotLib\RobotLib\Vector.cpp
//----------------------------------------------------------------------------
// TVector::operator +=
//----------------------------------------------------------------------------
// this = this + Point
//----------------------------------------------------------------------------
void TVector::operator += (const TPoint &Point)TVector::operator
File: C:\RobotLib\RobotLib\Vector.cpp
//----------------------------------------------------------------------------
// TVector::operator +=
//----------------------------------------------------------------------------
// this = this + Vector
//----------------------------------------------------------------------------
void TVector::operator += (const TVector &Vector)TVector::operator
File: C:\RobotLib\RobotLib\Vector.cpp
//----------------------------------------------------------------------------
// TVector::operator +
//----------------------------------------------------------------------------
// return (this + Vector)
//----------------------------------------------------------------------------
TPoint TVector::operator + (const TVector &Vector)TVector::operator
File: C:\RobotLib\RobotLib\Vector.cpp
//----------------------------------------------------------------------------
// TVector::operator +
//----------------------------------------------------------------------------
// return (this + point)
//----------------------------------------------------------------------------
TPoint TVector::operator + (const TPoint &Point)Commandinput
TRegistry::AddInt
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::AddInt - Add integer to registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::AddInt (const char *InName)TRegistry::AddFloat
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::AddFloat - Add float to registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::AddFloat (const char *InName)TRegistry::Add
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::Add - Add exisiting integer to registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::Add (const char *InName, int &_var)TRegistry::Add
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::Add - Add existing to registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::Add (const char *InName, float &_var)TRegistry::GetSize
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::GetSize - nr of entries in registry
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int TRegistry::GetSize()TRegistry::Exists
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::Exists - Check if name exists
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool TRegistry::Exists (const char *InName)TRegistry::SetValue
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::SetValue - by Name
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::SetValue (const char *InName, float InValue)TRegistry::SetDialog
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::SetDialog - by Name
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::SetDialog(const char *InName, const char *InDialog)TRegistry::GetValue
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::GetValue - by Name
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float TRegistry::GetValue (const char *InName)TRegistry::GetDialog
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::GetDialog - by Name
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
const char *TRegistry::GetDialog(const char *InName)TRegistry::Dump
File: C:\RobotLib\RobotLib\Registry.cpp
//-----------------------------------------------------------------------------
// TRegistry::Dump -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void TRegistry::Dump()HAL
A2UartQueuedInit
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_A2Usart.cpp
//-----------------------------------------------------------------------------
// A2UartQueuedInit - Auxiliary uart queued (interrupt based)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern "C" void A2UartQueuedInit(void)A2UartQueuedGetChar
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_A2Usart.cpp
//-----------------------------------------------------------------------------
// A2UartQueuedGetChar -
//-----------------------------------------------------------------------------
// return data, -1 if no data.
//-----------------------------------------------------------------------------
int A2UartQueuedGetChar()A2UartQueuedPutChar
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_A2Usart.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_ADC.cpp
//-----------------------------------------------------------------------------
// HalAdcInit - Init ADC ** do not forget to configure the input pins ***
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void HalAdcInit(void)HalAdcRead
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_ADC.cpp
//-----------------------------------------------------------------------------
// HalAdcRead - read ADC input <Nr>
//-----------------------------------------------------------------------------
// returns: 12 bit value
//-----------------------------------------------------------------------------
int HalAdcRead(int Nr)AUartQueuedInit
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_AUsart.cpp
//-----------------------------------------------------------------------------
// AUartQueuedInit - Auxiliary uart queued (interrupt based)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern "C" void AUartQueuedInit(void)AUartQueuedGetChar
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_AUsart.cpp
//-----------------------------------------------------------------------------
// AUartQueuedGetChar -
//-----------------------------------------------------------------------------
// return data, -1 if no data.
//-----------------------------------------------------------------------------
int AUartQueuedGetChar()AUartQueuedPutChar
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_AUsart.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Core.cpp
//-----------------------------------------------------------------------------
// HalCoreInit - Init of all mandatory HAL parts
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void HalCoreInit()HalGetUsCounter
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Core.cpp
//-----------------------------------------------------------------------------
// HalGetUsCounter - return value of 1 MHz free running counter
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
unsigned long HalGetUsCounter()Rc5PinInit
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_GPIO.cpp
//-----------------------------------------------------------------------------
// Rc5PinInit -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void Rc5PinInit()Rc5PinGet
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_GPIO.cpp
//-----------------------------------------------------------------------------
// Rc5PinGet -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int Rc5PinGet()BuzzerPinInit
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_GPIO.cpp
//-----------------------------------------------------------------------------
// BuzzerPinInit -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void BuzzerPinInit()BuzzerPinSet
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_GPIO.cpp
//-----------------------------------------------------------------------------
// BuzzerPinSet -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void BuzzerPinSet(int i)HalI2cInit
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_I2c.cpp
//-----------------------------------------------------------------------------
// HalI2cInit - init I2c
//-----------------------------------------------------------------------------
// #1 on PB6 (SCL) & PB7 (SDA)
//-----------------------------------------------------------------------------
void HalI2cInit()HalI2cSendReceive
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_I2c.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Servo.cpp
//-----------------------------------------------------------------------------
// HalServoInit - Setup Servo Pulse (pwm) output
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void HalServoInit(void)HalServoSet
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Servo.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Usart.cpp
//-----------------------------------------------------------------------------
// CUartQueuedInit - Console uart queued (interrupt based)
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern "C" void CUartQueuedInit(void)CUartQueuedGetChar
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Usart.cpp
//-----------------------------------------------------------------------------
// CUartQueuedGetChar -
//-----------------------------------------------------------------------------
// return data, -1 if no data.
//-----------------------------------------------------------------------------
int CUartQueuedGetChar()CUartQueuedPutChar
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Usart.cpp
//-----------------------------------------------------------------------------
// 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
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Usart.cpp
//-----------------------------------------------------------------------------
// CUartPolledInit - Console Uart Polled (no interrupt) init.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern "C" void CUartPolledInit(void)CUartPolledGetChar
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Usart.cpp
//-----------------------------------------------------------------------------
// CUartPolledGetChar -
//-----------------------------------------------------------------------------
// return data, -1 if no data.
//-----------------------------------------------------------------------------
int CUartPolledGetChar()CUartPolledPutChar
File: C:\RobotLib\Boards\stm32f4_discovery\hal_stm32f4d\Hal_Usart.cpp
//-----------------------------------------------------------------------------
// CUartPolledPutChar -
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CUartPolledPutChar(char charToSend)