Modules | Enumerations | Functions
Drive
Actuators

Functions which handle the simplified driving. More...

Modules

 Advanced informations
 

Enumerations

enum  eDriveStop
 clusters the modes for stopping the robot More...
 
enum  eDriveCommand
 clusters the driving states More...
 
enum  eDriveErrorMask
 clusters bit masks for the error states for driving More...
 
enum  eDriveSelectMask
 clusters bit masks for the requests of the drive module More...
 
enum  eDriveTransmitMask
 clusters bit masks for the transmitted-flags of the drive module More...
 
enum  eDriveGet
 clusters select values for reading data from the drive module More...
 

Functions

void drive_distance (int16_t distance, int16_t speed)
 Lets the robot drive for a distance. More...
 
void drive_angle (int16_t angle, int16_t speed)
 Lets the robot turn for an angle. More...
 
void drive_adjust (int16_t speed_distance, int16_t speed_angle)
 Adjusts the robots driving. More...
 
void drive_arc (int16_t radius, int16_t speed)
 Lets the robot drive an arc. More...
 
void drive_stop (eDriveStop mode)
 Lets the robot stop driving. More...
 

Request Funktions

void drive_request (eDriveSelectMask bitmask, eRequestType request)
 Requests new data from the drive module. More...
 
eDriveSelectMask drive_received (eDriveSelectMask bitmask)
 Indicates if new data for the selected data blocks were received. More...
 
eDriveSelectMask drive_changed (eDriveSelectMask bitmask)
 Indicates if new data changed the selected data blocks. More...
 
eDriveTransmitMask drive_transmitted (eDriveTransmitMask bitmask)
 Indicates if the selected data blocks were transmitted. More...
 

Access Funktions

int16_t drive_get (eDriveGet select)
 Returns the last stored version of the selected value. More...
 

Detailed Description

Functions which handle the simplified driving.

All functions and commands are only available if the programm is compiled with the pupils version of the TUC-Bot library! Additionally functions only have an effect if the mode of the TUC-Bot is set to kModePupil. Therefore use mode_set().

example 1

/*******************************************************************************
* examples/driveAdjust.pupil.c *
* ============================ *
* *
* Version: 1.0.5 *
* Date : 10.11.17 *
* Author : Peter Weissig *
* *
* The mode of TUCBot can only be changed if the programm is compiled with the *
* pupils version of the TUC-Bot library! *
* *
* If you are changing this file, you may also consider to update *
* demos/diagnosticTool/diagnosticTool.c *
*******************************************************************************/
//*********************************<Included files>*****************************
#include <tucbot/tucbot.h>
//*********************************<Methods>************************************
void testDriveAdjust_pupil(void);
int main(void);
//*********************************[testDriveAdjust_pupil]**********************
void testDriveAdjust_pupil(void) {
uint8_t menu_pos = 0;
uint8_t flag_redraw_menu = 0xFF;
lcdclr();
lcdstr_p(PSTR("Drive-Adjust" ));
mode_set(kModePupil);
drive_request(kDriveSelectAll, kRequestContinuous);
while (1) {
// redraw menu
if (flag_redraw_menu) {
flag_redraw_menu = 0x00;
lcdxy(0,1);
switch (menu_pos) {
case 0:
lcdstr_p(PSTR("a= 5" "\xDF" "/s v=25mm/s"));
break;
case 1:
lcdstr_p(PSTR("a=10" "\xDF" "/s v=50mm/s"));
break;
default:
lcdstr_p(PSTR("a=10" "\xDF" "/s v=99mm/s"));
menu_pos = 2;
break;
}
}
// check if buttons were pushed
if (buttons_get(kButtonMiddle)) {
// middle button --> increase menu
leds_set(kLedMiddle, kLedOn );
mdelay(100);
leds_set(kLedMiddle, kLedOff);
menu_pos++;
if (menu_pos > 2) {menu_pos = 0;}
flag_redraw_menu = 0xFF;
mdelay(400);
} else {
if (buttons_get(kButtonRight)) {
// right button --> start driving
leds_set(kLedLeft , kLedOn );
leds_set(kLedMiddle, kLedOn );
leds_set(kLedRight , kLedOn );
mdelay(100);
leds_set(kLedLeft , kLedOff);
leds_set(kLedMiddle, kLedOff);
lcdxy(0,1); lcdstr_p(PSTR("d:##### v:#####"));
mdelay(800);
switch (menu_pos) {
case 0 : drive_adjust(25, 5); break;
case 1 : drive_adjust(50,10); break;
default: drive_adjust(99,10); break;
}
drive_get(kDriveGetPositionDistance);
drive_get(kDriveGetCommand);
while (1) {
// wait until driving is done
if (drive_received(kDriveSelectState)) {
if (drive_get(kDriveGetError) ||
(drive_get(kDriveGetCommand) == kDriveCommandDone)) {
break;
}
}
if (drive_changed(kDriveSelectSpeed )) {
lcdxy(11,1);
int16tostr(lcdout,
drive_get(kDriveGetSpeedDistance ), 5);
}
if (drive_changed(kDriveSelectPosition)) {
lcdxy(2,1);
int16tostr(lcdout,
drive_get(kDriveGetPositionDistance), 5);
if (drive_get(kDriveGetPositionDistance) >= 500) {
drive_stop(kDriveStopNormal);
break;
}
}
mdelay(100);
}
leds_set(kLedRight , kLedOff);
flag_redraw_menu = 0xFF;
}
}
}
}
//*********************************[main]***************************************
int main (void) {
init_tucbot(0xFF);
buttons_request(kRequestContinuous);
testDriveAdjust_pupil();
return (0);
}

example 2

/*******************************************************************************
* examples/driveAngle.pupil.c *
* =========================== *
* *
* Version: 1.0.5 *
* Date : 10.11.17 *
* Author : Peter Weissig *
* *
* The mode of TUCBot can only be changed if the programm is compiled with the *
* pupils version of the TUC-Bot library! *
* *
* If you are changing this file, you may also consider to update *
* demos/diagnosticTool/diagnosticTool.c *
*******************************************************************************/
//*********************************<Included files>*****************************
#include <tucbot/tucbot.h>
//*********************************<Methods>************************************
void testDriveAngle_pupil(void);
int main(void);
//*********************************[testDriveAngle_pupil]***********************
void testDriveAngle_pupil(void) {
uint8_t menu_pos = 0;
uint8_t flag_redraw_menu = 0xFF;
lcdclr();
lcdstr_p(PSTR("Drive-Angle " ));
mode_set(kModePupil);
drive_request(kDriveSelectAll, kRequestContinuous);
while (1) {
// redraw menu
if (flag_redraw_menu) {
flag_redraw_menu = 0x00;
lcdxy(0,1);
switch (menu_pos) {
case 0:
lcdstr_p(PSTR("a= 30" "\xDF" " v= 10" "\xDF" "/s"));
break;
case 1:
lcdstr_p(PSTR("a= 90" "\xDF" " v= 30" "\xDF" "/s"));
break;
default:
lcdstr_p(PSTR("a= 360" "\xDF" " v= 90" "\xDF" "/s"));
menu_pos = 2;
break;
}
}
// check if buttons were pushed
if (buttons_get(kButtonMiddle)) {
// middle button --> increase menu
leds_set(kLedMiddle, kLedOn );
mdelay(100);
leds_set(kLedMiddle, kLedOff);
menu_pos++;
if (menu_pos > 2) {menu_pos = 0;}
flag_redraw_menu = 0xFF;
mdelay(400);
} else {
if (buttons_get(kButtonRight)) {
// right button --> start driving
leds_set(kLedLeft , kLedOn );
leds_set(kLedMiddle, kLedOn );
leds_set(kLedRight , kLedOn );
mdelay(100);
leds_set(kLedLeft , kLedOff);
leds_set(kLedMiddle, kLedOff);
lcdxy(0,1); lcdstr_p(PSTR("a:##### v:#####"));
mdelay(800);
switch (menu_pos) {
case 0 : drive_angle( 30,10); break;
case 1 : drive_angle( 90,30); break;
default: drive_angle(360,90); break;
}
drive_get(kDriveGetCommand);
while (1) {
// wait until driving is done
if (drive_received(kDriveSelectState)) {
if (drive_get(kDriveGetError) ||
(drive_get(kDriveGetCommand) == kDriveCommandDone)) {
break;
}
}
if (drive_changed(kDriveSelectSpeed )) {
lcdxy(11,1);
int16tostr(lcdout,
drive_get(kDriveGetSpeedAngle ), 5);
}
if (drive_changed(kDriveSelectPosition)) {
lcdxy(2,1);
int16tostr(lcdout,
drive_get(kDriveGetPositionAngle), 5);
}
mdelay(100);
}
leds_set(kLedRight , kLedOff);
flag_redraw_menu = 0xFF;
}
}
}
}
//*********************************[main]***************************************
int main (void) {
init_tucbot(0xFF);
buttons_request(kRequestContinuous);
testDriveAngle_pupil();
return (0);
}

example 3

/*******************************************************************************
* examples/driveArc.pupil.c *
* ========================= *
* *
* Version: 1.0.5 *
* Date : 10.11.17 *
* Author : Peter Weissig *
* *
* The mode of TUCBot can only be changed if the programm is compiled with the *
* pupils version of the TUC-Bot library! *
* *
* If you are changing this file, you may also consider to update *
* demos/diagnosticTool/diagnosticTool.c *
*******************************************************************************/
//*********************************<Included files>*****************************
#include <tucbot/tucbot.h>
//*********************************<Methods>************************************
void testDriveArc_pupil(void);
int main(void);
//*********************************[testDriveArc_pupil]*************************
void testDriveArc_pupil(void) {
uint8_t menu_pos = 0;
uint8_t flag_redraw_menu = 0xFF;
lcdclr();
lcdstr_p(PSTR("Drive-Arc " ));
mode_set(kModePupil);
drive_request(kDriveSelectAll, kRequestContinuous);
while (1) {
// redraw menu
if (flag_redraw_menu) {
flag_redraw_menu = 0x00;
lcdxy(0,1);
switch (menu_pos) {
case 0:
lcdstr_p(PSTR("r=100mm v=25mm/s"));
break;
case 1:
lcdstr_p(PSTR("r=250mm v=50mm/s"));
break;
default:
lcdstr_p(PSTR("r=999mm v=99mm/s"));
menu_pos = 2;
break;
}
}
// check if buttons were pushed
if (buttons_get(kButtonMiddle)) {
// middle button --> increase menu
leds_set(kLedMiddle, kLedOn );
mdelay(100);
leds_set(kLedMiddle, kLedOff);
menu_pos++;
if (menu_pos > 2) {menu_pos = 0;}
flag_redraw_menu = 0xFF;
mdelay(400);
} else {
if (buttons_get(kButtonRight)) {
// right button --> start driving
leds_set(kLedLeft , kLedOn );
leds_set(kLedMiddle, kLedOn );
leds_set(kLedRight , kLedOn );
mdelay(100);
leds_set(kLedLeft , kLedOff);
leds_set(kLedMiddle, kLedOff);
lcdxy(0,1); lcdstr_p(PSTR("d:##### v:#####"));
mdelay(800);
switch (menu_pos) {
case 0 : drive_arc(100,25); break;
case 1 : drive_arc(250,50); break;
default: drive_arc(999,99); break;
}
drive_get(kDriveGetPositionDistance);
drive_get(kDriveGetCommand);
while (1) {
// wait until driving is done
if (drive_received(kDriveSelectState)) {
if (drive_get(kDriveGetError) ||
(drive_get(kDriveGetCommand) == kDriveCommandDone)) {
break;
}
}
if (drive_changed(kDriveSelectSpeed )) {
lcdxy(11,1);
int16tostr(lcdout,
drive_get(kDriveGetSpeedDistance ), 5);
}
if (drive_changed(kDriveSelectPosition)) {
lcdxy(2,1);
int16tostr(lcdout,
drive_get(kDriveGetPositionDistance), 5);
if (drive_get(kDriveGetPositionDistance) >= 500) {
drive_stop(kDriveStopNormal);
break;
}
}
mdelay(100);
}
leds_set(kLedRight , kLedOff);
flag_redraw_menu = 0xFF;
}
}
}
}
//*********************************[main]***************************************
int main (void) {
init_tucbot(0xFF);
buttons_request(kRequestContinuous);
testDriveArc_pupil();
return (0);
}

example 4

/*******************************************************************************
* examples/driveDist.pupil.c *
* ========================== *
* *
* Version: 1.0.5 *
* Date : 06.12.17 *
* Author : Peter Weissig *
* *
* The mode of TUCBot can only be changed if the programm is compiled with the *
* pupils version of the TUC-Bot library! *
* *
* If you are changing this file, you may also consider to update *
* demos/diagnosticTool/diagnosticTool.c *
*******************************************************************************/
//*********************************<Included files>*****************************
#include <tucbot/tucbot.h>
//*********************************<Methods>************************************
void testDriveDist_pupil(void);
int main(void);
//*********************************[testDriveDist_pupil]************************
void testDriveDist_pupil(void) {
uint8_t menu_pos = 0;
uint8_t flag_redraw_menu = 0xFF;
lcdclr();
lcdstr_p(PSTR("Drive-Dist " ));
mode_set(kModePupil);
drive_request(kDriveSelectAll, kRequestContinuous);
while (1) {
// redraw menu
if (flag_redraw_menu) {
flag_redraw_menu = 0x00;
lcdxy(0,1);
switch (menu_pos) {
case 0:
lcdstr_p(PSTR("d=100mm v=10mm/s"));
break;
case 1:
lcdstr_p(PSTR("d=200mm v=50mm/s"));
break;
default:
lcdstr_p(PSTR("d=999mm v=99mm/s"));
menu_pos = 2;
break;
}
}
// check if buttons were pushed
if (buttons_get(kButtonMiddle)) {
// middle button --> increase menu
leds_set(kLedMiddle, kLedOn );
mdelay(100);
leds_set(kLedMiddle, kLedOff);
menu_pos++;
if (menu_pos > 2) {menu_pos = 0;}
flag_redraw_menu = 0xFF;
mdelay(400);
} else {
if (buttons_get(kButtonRight)) {
// right button --> start driving
leds_set(kLedLeft , kLedOn );
leds_set(kLedMiddle, kLedOn );
leds_set(kLedRight , kLedOn );
mdelay(100);
leds_set(kLedLeft , kLedOff);
leds_set(kLedMiddle, kLedOff);
lcdxy(0,1); lcdstr_p(PSTR("d:##### v:#####"));
mdelay(800);
switch (menu_pos) {
case 0 : drive_distance(100,10); break;
case 1 : drive_distance(200,50); break;
default: drive_distance(999,99); break;
}
drive_get(kDriveGetCommand);
while (1) {
// wait until driving is done
if (drive_received(kDriveSelectState)) {
if (drive_get(kDriveGetError) ||
(drive_get(kDriveGetCommand) == kDriveCommandDone)) {
break;
}
}
if (drive_changed(kDriveSelectSpeed )) {
lcdxy(11,1);
int16tostr(lcdout,
drive_get(kDriveGetSpeedDistance ), 5);
}
if (drive_changed(kDriveSelectPosition)) {
lcdxy(2,1);
int16tostr(lcdout,
drive_get(kDriveGetPositionDistance), 5);
}
mdelay(100);
}
leds_set(kLedRight , kLedOff);
flag_redraw_menu = 0xFF;
}
}
}
}
//*********************************[main]***************************************
int main (void) {
init_tucbot(0xFF);
buttons_request(kRequestContinuous);
testDriveDist_pupil();
return (0);
}

Enumeration Type Documentation

◆ eDriveCommand

enum eDriveCommand

clusters the driving states

See also
drive_get()
Enumerator
kDriveCommandDone 

constant (0): no driving

kDriveCommandDistance 

constant (1): robot is driving straight
see also drive_distance()

kDriveCommandAdjust 

constant (2): robot is in adjust-drive mode
see also drive_adjust()

kDriveCommandAngle 

constant (3): robot is turning
see also drive_angle()

kDriveCommandArc 

constant (4): robot is driving along an arc
see also drive_arc()

kDriveCommandStop 

constant (5): robot is stopping
see also drive_stop()

◆ eDriveErrorMask

enum eDriveErrorMask

clusters bit masks for the error states for driving

See also
drive_get()
Enumerator
kDriveErrorNone 

bit mask (0x00): no error

kDriveErrorBumper 

bit mask (0x01): bumper pushed

kDriveErrorCurrent 

bit mask (0x02): motor current to high

kDriveErrorAll 

bit mask (0x03): all flags are set

◆ eDriveGet

enum eDriveGet

clusters select values for reading data from the drive module

See also
drive_get()
Enumerator
kDriveGetPositionDistance 

constant ( 1): driven distance in mm

kDriveGetPositionAngle 

constant ( 2): turned angle in degrees

kDriveGetSpeedDistance 

constant ( 3): current speed in mm/s

kDriveGetSpeedAngle 

constant ( 4): current angular speed in degrees/s

kDriveGetCommand 

constant ( 5): current executed drive command (8-bit)
see also: eDriveCommand

kDriveGetError 

constant ( 6): last error while driving (8-bit)
see also: eDriveErrorMask

kDriveGetDistanceTotal 

constant ( 7): total distance in mm as set by drive_distance()

kDriveGetDistanceSpeed 

constant ( 8): tangential speed in mm/s as set by drive_distance()

kDriveGetAngleTotal 

constant ( 9): total angle in degrees as set by drive_angle()

kDriveGetAngleSpeed 

constant (10): angular speed in degrees/s as set by drive_angle()

kDriveGetAdjustTangential 

constant (11): tangential speed in mm/s as set by drive_adjust()

kDriveGetAdjustAngular 

constant (12): angular speed in degrees/s as set by drive_adjust()

kDriveGetArcRadius 

constant (13): radius in mm as set by drive_arc()

kDriveGetArcSpeed 

constant (14): tangential speed in mm/s as set by drive_arc()

kDriveGetStop 

constant (15): stop mode (8-bit) as set by drive_stop()
see also: eDriveStop

◆ eDriveSelectMask

enum eDriveSelectMask

clusters bit masks for the requests of the drive module

See also
drive_request(), drive_received() and drive_changed()
Enumerator
kDriveSelectNone 

bit mask (0x00): select no data block

kDriveSelectState 

bit mask (0x01): select data block for the driving state
see also sMD_State

kDriveSelectPosition 

bit mask (0x02): select data block for the travelled distance
see also sMD_WayAngle

kDriveSelectSpeed 

bit mask (0x04): select data block for the speed
see also sMD_Speed

kDriveSelectAll 

bit mask (0x07): select all data blocks (except for the drive commands)

kDriveSelectDistance 

bit mask (0x10): select data block for driving a distance
no continuous requests are allowed
see also sMD_DriveDist

kDriveSelectAngle 

bit mask (0x20): select data block for turning
no continuous requests are allowed
see also sMD_DriveAngle

kDriveSelectAdjust 

bit mask (0x40): select data block for drive-adjust
no continuous requests are allowed
see also sMD_DriveAdjust

kDriveSelectArc 

bit mask (0x80): select data block for driving along an arc
no continuous requests are allowed
see also sMD_DriveArc

kDriveSelectStop 

bit mask (0x10): select data block for stopping
no continuous requests are allowed
see also sMD_DriveStop

kDriveSelectAllWithCmd 

bit mask (0xFF): select all data blocks (including the drive commands)

◆ eDriveStop

enum eDriveStop

clusters the modes for stopping the robot

See also
drive_stop() and drive_get()
Enumerator
kDriveStopNormal 

constant (0): continuously decreasing the speed

kDriveStopFast 

constant (1): instantly stopping

◆ eDriveTransmitMask

enum eDriveTransmitMask

clusters bit masks for the transmitted-flags of the drive module

See also
drive_transmitted()
Enumerator
kDriveTransmitNone 

bit mask (0x00): select no data block

kDriveTransmitDistance 

bit mask: select data block for driving a distance
see also drive_distance() and sMD_DriveDist

kDriveTransmitAngle 

bit mask: select data block for turning
see also drive_angle() and sMD_DriveAngle

kDriveTransmitAdjust 

bit mask: select data block for drive-adjust
see also drive_adjust() and sMD_DriveAdjust

kDriveTransmitArc 

bit mask: select data block for driving along an arc
see also drive_arc() and sMD_DriveArc

kDriveTransmitStop 

bit mask: select data block for stopping
see also drive_stop() and sMD_DriveStop

kDriveTransmitAll 

bit mask: select all data blocks

Function Documentation

◆ drive_adjust()

void drive_adjust ( int16_t  speed_distance,
int16_t  speed_angle 
)

Adjusts the robots driving.

This command will modify and transmit the data block sMD_DriveAdjust.

If one of the bumpers in driving direction is pushed the robot will stop immediately.

Note
This command only has an effect if the mode of the TUC-Bot is set to kModePupil.
Parameters
speed_distance16-bit integer
The tangential speed is measured in millimeters per second.
speed_angle16-bit integer
The angular speed is measured degrees per second.
See also
drive_get() and mode_set()
Examples
driveAdjust.pupil.c, and remoteControl.c.

◆ drive_angle()

void drive_angle ( int16_t  angle,
int16_t  speed 
)

Lets the robot turn for an angle.

This command will modify and transmit the data block sMD_DriveAngle.

If one of the bumpers in driving direction is pushed the robot will stop immediately.

Note
This command only has an effect if the mode of the TUC-Bot is set to kModePupil.
Parameters
angle16-bit integer
The angle is measured in degrees.
speed16-bit integer
The speed is measured in degrees per second.
See also
drive_get() and mode_set()
Examples
driveAngle.pupil.c.

◆ drive_arc()

void drive_arc ( int16_t  radius,
int16_t  speed 
)

Lets the robot drive an arc.

This command will modify and transmit the data block sMD_DriveArc.

If one of the bumpers in driving direction is pushed the robot will stop immediately.

Note
This command only has an effect if the mode of the TUC-Bot is set to kModePupil.
Parameters
radius16-bit integer
The radius is measured in millimeters.
speed16-bit integer
The speed is measured in millimeters per second.
See also
drive_get() and mode_set()
Examples
driveArc.pupil.c.

◆ drive_changed()

eDriveSelectMask drive_changed ( eDriveSelectMask  bitmask)

Indicates if new data changed the selected data blocks.

Parameters
bitmaskbit mask of the selected data blocks - see also eDriveSelectMask
The parameter is used to only return the value of the masked changed-bits. All other values(bits) are set to 0.
Returns
bitfield of the selected data blocks - see also eDriveSelectMask
If a data block is changed its related bit will be 1, otherwise 0.
If only one data block is selected the return value can be interpreted as a boolean expression.
See also
drive_received(), drive_request(), drive_get()
Examples
driveAdjust.pupil.c, driveAngle.pupil.c, driveArc.pupil.c, and driveDist.pupil.c.

◆ drive_distance()

void drive_distance ( int16_t  distance,
int16_t  speed 
)

Lets the robot drive for a distance.

This command will modify and transmit the data block sMD_DriveDist.

If one of the bumpers in driving direction is pushed the robot will stop immediately.

Note
This command only has an effect if the mode of the TUC-Bot is set to kModePupil.
Parameters
distance16-bit integer
The distance is measured in millimeters.
speed16-bit integer
The speed is measured in millimeters per second.
See also
drive_get() and mode_set()
Examples
driveDist.pupil.c.

◆ drive_get()

int16_t drive_get ( eDriveGet  select)

Returns the last stored version of the selected value.

This function relies on the internal data blocks sMD_State, sMD_WayAngle, sMD_Speed, sMD_DriveDist, sMD_DriveAdjust, sMD_DriveAngle, sMD_DriveArc and sMD_DriveStop - for new data use drive_request().

Parameters
selectvalue of the selected data - see also eDriveGet
Returns
16-bit integer
See also
drive_request()
Examples
driveAdjust.pupil.c, driveAngle.pupil.c, driveArc.pupil.c, and driveDist.pupil.c.

◆ drive_received()

eDriveSelectMask drive_received ( eDriveSelectMask  bitmask)

Indicates if new data for the selected data blocks were received.

Parameters
bitmaskbit mask of the selected data blocks - see also eDriveSelectMask
The parameter is used to only return the value of the masked received-bits. All other values(bits) are set to 0.
Returns
bitfield of the selected data blocks - see also eDriveSelectMask
If a data block is received its related bit will be 1, otherwise 0.
If only one data block is selected the return value can be interpreted as a boolean expression.
See also
drive_changed(), drive_request(), drive_get()
Examples
driveAdjust.pupil.c, driveAngle.pupil.c, driveArc.pupil.c, and driveDist.pupil.c.

◆ drive_request()

void drive_request ( eDriveSelectMask  bitmask,
eRequestType  request 
)

Requests new data from the drive module.

For details on the request schema see The general request.

Involved data blocks are :
sMD_State, sMD_WayAngle and sMD_Speed.

Additionally the following data blocks can also be requested. This is usually not necessary at all and those can not be requested continuously:
sMD_DriveDist, sMD_DriveAdjust, sMD_DriveAngle, sMD_DriveArc and sMD_DriveStop

Parameters
bitmaskbit mask of the selected data blocks - see also eDriveSelectMask
Note
There two different bit masks for all data blocks: kDriveSelectAll and kDriveSelectAllWithCmd
Parameters
requestSee also eRequestType
See also
drive_get()
Examples
driveAdjust.pupil.c, driveAngle.pupil.c, driveArc.pupil.c, and driveDist.pupil.c.

◆ drive_stop()

void drive_stop ( eDriveStop  mode)

Lets the robot stop driving.

This command will modify and transmit the data block sMD_DriveStop.

Note
This command only has an effect if the mode of the TUC-Bot is set to kModePupil.
Parameters
modevalue representing the mode of stopping - see also eDriveStop
See also
drive_get() and mode_set()
Examples
driveAdjust.pupil.c, driveArc.pupil.c, and remoteControl.c.

◆ drive_transmitted()

eDriveTransmitMask drive_transmitted ( eDriveTransmitMask  bitmask)

Indicates if the selected data blocks were transmitted.

Parameters
bitmaskbit mask of the selected data blocks - see also eDriveTransmitMask
The parameter is used to only return the value of the masked transmitted-bits. All other values(bits) are set to 0.
Returns
bitfield of the selected data blocks - see also eDriveTransmitMask
If a data block is transmitted its related bit will be 1, otherwise 0.
If only one data block is selected the return value can be interpreted as a boolean expression.
See also
drive_distance(), drive_angle(), drive_adjust(), drive_arc() and drive_stop()
leds_set
void leds_set(eLedMask bitmask, uint8_t bool)
Sets the selected leds on or off.
buttons_get
eButtonMask buttons_get(eButtonMask bitmask)
Returns the last stored value of the selected buttons.
kButtonMiddle
@ kButtonMiddle
bit mask (0x08): middle button
Definition: buttons.h:35
kDriveGetSpeedDistance
@ kDriveGetSpeedDistance
constant ( 3): current speed in mm/s
Definition: drive.h:195
kDriveGetPositionDistance
@ kDriveGetPositionDistance
constant ( 1): driven distance in mm
Definition: drive.h:191
drive_angle
void drive_angle(int16_t angle, int16_t speed)
Lets the robot turn for an angle.
kDriveCommandDone
@ kDriveCommandDone
constant (0): no driving
Definition: drive.h:43
kLedOn
@ kLedOn
constant (0xFF): turn leds on
Definition: leds.h:63
kLedRight
@ kLedRight
bit mask (0x04): right led
Definition: leds.h:46
kDriveSelectState
@ kDriveSelectState
Definition: drive.h:120
kModePupil
@ kModePupil
constant (0): robot is in pupil mode
Definition: mode.h:29
drive_received
eDriveSelectMask drive_received(eDriveSelectMask bitmask)
Indicates if new data for the selected data blocks were received.
kDriveGetSpeedAngle
@ kDriveGetSpeedAngle
constant ( 4): current angular speed in degrees/s
Definition: drive.h:197
kButtonRight
@ kButtonRight
bit mask (0x10): right button
Definition: buttons.h:37
drive_request
void drive_request(eDriveSelectMask bitmask, eRequestType request)
Requests new data from the drive module.
buttons_request
void buttons_request(eRequestType request)
Requests new data from the buttons.
int16tostr
void int16tostr(void *out, int16_t number, uint8_t digits)
Converts an integer to a string and passes it to an output function.
drive_changed
eDriveSelectMask drive_changed(eDriveSelectMask bitmask)
Indicates if new data changed the selected data blocks.
drive_get
int16_t drive_get(eDriveGet select)
Returns the last stored version of the selected value.
kDriveSelectPosition
@ kDriveSelectPosition
Definition: drive.h:123
kLedLeft
@ kLedLeft
bit mask (0x10): left led
Definition: leds.h:42
kRequestContinuous
@ kRequestContinuous
constant (3): request continuous updates
Definition: update.h:37
drive_distance
void drive_distance(int16_t distance, int16_t speed)
Lets the robot drive for a distance.
kLedMiddle
@ kLedMiddle
bit mask (0x08): middle led
Definition: leds.h:44
kLedOff
@ kLedOff
constant (0x00): turn leds off
Definition: leds.h:61
kDriveSelectSpeed
@ kDriveSelectSpeed
Definition: drive.h:126
drive_arc
void drive_arc(int16_t radius, int16_t speed)
Lets the robot drive an arc.
lcdclr
void lcdclr(void)
Clears the display.
kDriveGetCommand
@ kDriveGetCommand
Definition: drive.h:199
lcdxy
void lcdxy(uint8_t x, uint8_t y)
Moves the cursor to a postion on the display.
mode_set
void mode_set(eMode mode)
Sets the mode of the TUC-Bot.
kDriveSelectAll
@ kDriveSelectAll
Definition: drive.h:129
drive_stop
void drive_stop(eDriveStop mode)
Lets the robot stop driving.
kDriveStopNormal
@ kDriveStopNormal
constant (0): continuously decreasing the speed
Definition: drive.h:31
lcdstr_p
void lcdstr_p(const char *send_data)
Writes a string located in the flash to the display.
lcdout
void lcdout(uint8_t data)
Writes one byte to the display.
init_tucbot
void init_tucbot(uint8_t enable_interrupts)
Initiates the TUC-Bot.
mdelay
void mdelay(uint16_t mseconds)
Waits for the given time in milliseconds.
drive_adjust
void drive_adjust(int16_t speed_distance, int16_t speed_angle)
Adjusts the robots driving.
kDriveGetError
@ kDriveGetError
Definition: drive.h:202
kDriveGetPositionAngle
@ kDriveGetPositionAngle
constant ( 2): turned angle in degrees
Definition: drive.h:193
Generated on Wed Mar 1 2023 09:00:05 for TUC-Bot library by   doxygen 1.8.17