Matthew Sims / mbed_tictactoe

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   TicTacToe

Fork of mbed by -deleted-

Embed: (wiki syntax)

« Back to documentation index

SPIHalfDuplex Class Reference
Public Member Functions | Static Public Member Functions

SPIHalfDuplex Class Reference

A SPI half-duplex master, used for communicating with SPI slave devices over a shared data line. More...

#include <SPIHalfDuplex.h>

Inherits mbed::SPI.

Public Member Functions

 SPIHalfDuplex (PinName mosi, PinName miso, PinName sclk, const char *name=NULL)
 Create a SPI half-duplex master connected to the specified pins.
void format (int bits, int mode=0)
 Configure the data transmission format.
void frequency (int hz=1000000)
 Set the spi bus clock frequency.
virtual int write (int value)
 Write to the SPI Slave and return the response.
void slave_format (int sbits)
 Set the number of databits expected from the slave, from 4-16.
virtual struct rpc_method * get_rpc_methods ()
 Returns a pointer to an array describing the rpc methods supported by this object, terminated by either RPC_METHOD_END or RPC_METHOD_SUPER(Superclass).
void register_object (const char *name)
 Registers this object with the given name, so that it can be looked up with lookup.
const char * name ()
 Returns the name of the object.
virtual bool rpc (const char *method, const char *arguments, char *result)
 Call the given method with the given arguments, and write the result into the string pointed to by result.

Static Public Member Functions

static bool rpc (const char *name, const char *method, const char *arguments, char *result)
 Use the lookup function to lookup an object and, if successful, call its rpc method.
static Base * lookup (const char *name, unsigned int len)
 Lookup and return the object that has the given name.
template<class C >
static void add_rpc_class ()
 Add the class to the list of classes which can have static methods called via rpc (the static methods which can be called are defined by that class' get_rpc_class() static method).

Detailed Description

A SPI half-duplex master, used for communicating with SPI slave devices over a shared data line.

The default format is set to 8-bits for both master and slave, and a clock frequency of 1MHz

Most SPI devies will also require Chip Select and Reset signals. These can be controlled using <DigitalOut> pins.

Although this is for a shared data line, both MISO and MOSI are defined, and should be tied together externally to the mbed. This class handles the tri-stating of the MOSI pin.

Example: 

 // Send a byte to a SPI half-duplex slave, and record the response

 #include "mbed.h"
 
 SPIHalfDuplex device(p5, p6, p7) // mosi, miso, sclk

 int main() {
     int respone = device.write(0xAA);
 }

Definition at line 43 of file SPIHalfDuplex.h.

Constructor & Destructor Documentation

SPIHalfDuplex ( PinName  mosi,
PinName  miso,
PinName  sclk,
const char *  name = NULL 
)

Create a SPI half-duplex master connected to the specified pins.

Pin Options: (5, 6, 7) or (11, 12, 13)

mosi or miso can be specfied as NC if not used

Parameters:
mosiSPI Master Out, Slave In pin
misoSPI Master In, Slave Out pin
sclkSPI Clock pin
name(optional) A string to identify the object

Member Function Documentation

static void add_rpc_class (  ) [static, inherited]

Add the class to the list of classes which can have static methods called via rpc (the static methods which can be called are defined by that class' get_rpc_class() static method).

Definition at line 143 of file Base.h.

void format ( int  bits,
int  mode = 0 
)

Configure the data transmission format.

Parameters:
bitsNumber of bits per SPI frame (4 - 16)
modeClock polarity and phase mode (0 - 3)
 mode | POL PHA
 -----+--------
   0  |  0   0
   1  |  0   1
   2  |  1   0
   3  |  1   1

Reimplemented from SPI.

void frequency ( int  hz = 1000000 )

Set the spi bus clock frequency.

Parameters:
hzSCLK frequency in hz (default = 1MHz)

Reimplemented from SPI.

virtual struct rpc_method* get_rpc_methods (  ) [read, virtual, inherited]

Returns a pointer to an array describing the rpc methods supported by this object, terminated by either RPC_METHOD_END or RPC_METHOD_SUPER(Superclass).

Example 

 class Example : public Base {
     int foo(int a, int b) { return a + b; }
     virtual const struct rpc_method *get_rpc_methods() {
         static const rpc_method rpc_methods[] = {
             { "foo", generic_caller<int, Example, int, int, &Example::foo> },
             RPC_METHOD_SUPER(Base)
         };
         return rpc_methods;
     }
 };

Reimplemented from Base.

static Base* lookup ( const char *  name,
unsigned int  len 
) [static, inherited]

Lookup and return the object that has the given name.

Parameters:
namethe name to lookup.
lenthe length of name.
const char* name (  ) [inherited]

Returns the name of the object.

Returns:
The name of the object, or NULL if it has no name.
void register_object ( const char *  name ) [inherited]

Registers this object with the given name, so that it can be looked up with lookup.

If this object has already been registered, then this just changes the name.

Parameters:
nameThe name to give the object. If NULL we do nothing.
virtual bool rpc ( const char *  method,
const char *  arguments,
char *  result 
) [virtual, inherited]

Call the given method with the given arguments, and write the result into the string pointed to by result.

The default implementation calls rpc_methods to determine the supported methods.

Parameters:
methodThe name of the method to call.
argumentsA list of arguments separated by spaces.
resultA pointer to a string to write the result into. May be NULL, in which case nothing is written.
Returns:
true if method corresponds to a valid rpc method, or false otherwise.
static bool rpc ( const char *  name,
const char *  method,
const char *  arguments,
char *  result 
) [static, inherited]

Use the lookup function to lookup an object and, if successful, call its rpc method.

Returns:
false if name does not correspond to an object, otherwise the return value of the call to the object's rpc method.
void slave_format ( int  sbits )

Set the number of databits expected from the slave, from 4-16.

Parameters:
sbitsNumber of expected bits in the slave response
virtual int write ( int  value ) [virtual]

Write to the SPI Slave and return the response.

Parameters:
valueData to be sent to the SPI slave
Returns:
Response from the SPI slave

Reimplemented from SPI.

Generated on Wed Jul 13 2022 03:42:27 by  doxygen 1.7.2