NextGen-Exerciser-Tunnel.cpp

00001 
00002 // ----------------------------------------------------------------------
00003 // NextGen-Exerciser-Tunnel.cpp
00004 //
00005 // Fredric L. Rice, May 2019
00006 //
00007 // o A digital output for an LED is instantiated
00008 // o A Serial object is instantiated on Serial-2
00009 // o A thread's mailbox object is instantiated
00010 // o A Thread object is instantiated
00011 // o The serial interface is configured
00012 // o The module's thread is start()ed
00013 //
00014 // The LED is toggled according to timing established by a periodic
00015 // wait() and according to messages pending in the thread's mailbox
00016 //
00017 // The mailbox is checked for any messages that need to go out the
00018 // serial interface, and if there are any, the message is extracted
00019 // from the mailbox and gets sent out the serial interface. If there
00020 // are no messages waiting to go out, a Modbus polling message is
00021 // sent out the serial interface instead.
00022 //
00023 // If there is serial data waiting to be read, the data is collected
00024 // in to a Modbus frame and it gets handled by examining the content
00025 // of the inbound frame.
00026 //
00027 // ----------------------------------------------------------------------
00028 
00029 #include "mbed.h"                       // The mbed operating system
00030 #include "NextGen-Exerciser-Tunnel.h"   // Always include ourself
00031 #include "NextGen-Exerciser-Defines.h"  // For defined constants and MACROs
00032 
00033 // ----------------------------------------------------------------------
00034 // Allocate local data storage
00035 //
00036 // ----------------------------------------------------------------------
00037 
00038     static DigitalOut                  st_digitalOutTunnelLED(LED2);
00039     static Serial                      st_TunnelSerial(SERIAL_TX, SERIAL_RX);     // TX, RX, Serial 2 (Don't see anything)
00040     static Mail<st_pendingMessage, 16> st_TunnelMailbox;
00041     static Thread                      st_threadTunnel;
00042     static bool                        b_TunnelInitialized = false;
00043     static char                        c_flipFlop = 0;
00044     
00045     static unsigned char               uch_tunnelPollFrame[] =
00046     {
00047         0xF7, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x92, 0xDE
00048     } ;
00049     
00050 // ----------------------------------------------------------------------
00051 // TunnelCheckInbound()
00052 //
00053 // This function will:
00054 //      o Check to see if the serial interface is readable
00055 //      o If there are bytes waiting, the bytes are read and get
00056 //        assembled in to a full Modbus frame.
00057 //      o The inbound message is handled by passing it to a function
00058 //        which examines the content of the inbound message
00059 //
00060 // ----------------------------------------------------------------------
00061 static void TunnelCheckInbound(void)
00062 {   
00063     // See if there is inbound serial data
00064     if (st_TunnelSerial.readable())
00065     {
00066 
00067     }
00068 }
00069 
00070 // ----------------------------------------------------------------------
00071 // TunnelCheckOutbound()
00072 //
00073 // This function will:
00074 //      o Get a message from the thread's mailbox, waiting for up to
00075 //        2 milliseconds for a message
00076 //      o If a message is pending, the message is extracted and then
00077 //        gets formatted in to an output Modbus message frame
00078 //      o The newly-formatted Modbus frame gets transmitted out the
00079 //        serial interface
00080 //      o The mailbox message gets released back in to the memory pool
00081 //      o If there was no output message waiting in the mailbox, a
00082 //        Modbus polling message is sent out the serial interface
00083 //
00084 // ----------------------------------------------------------------------
00085 static void TunnelCheckOutbound(void)
00086 {
00087     // Is there an outbound message waiting? Wait for up to 2 milliseconds
00088     osEvent st_eventResult = st_TunnelMailbox.get(2);
00089     
00090     if (st_eventResult.status == osEventMail)
00091     {
00092         // Get a pointer to the message
00093         st_pendingMessage * pst_outFrame = (st_pendingMessage *)st_eventResult.value.p;
00094             
00095         // Format and send the Modbus Tunnel frame
00096             
00097         // Finished with the message so release it even if it was not sent
00098         st_TunnelMailbox.free(pst_outFrame);
00099     }
00100     else
00101     {
00102         // Send a poll frame
00103         st_TunnelSerial.write((uint8_t *)uch_tunnelPollFrame, sizeof(uch_tunnelPollFrame), NULL);
00104     }
00105 }
00106 
00107 // ----------------------------------------------------------------------
00108 // TunnelThread()
00109 //
00110 // This function will:
00111 //      o Get invoked as a thread under the mbed operating system
00112 //      o Turn ON the lED associated with this module and protocol
00113 //      o Enter in to a forever loop which wakes up ten times a second
00114 //      o Drives the module's LED so that it flashes frim time to time
00115 //        to indicate that the thread is running
00116 //      o Check to ensure that the module has been initialized
00117 //      o If the module is initialized (and it should be) checks to
00118 //        see if there are inbound serial Modbus messages
00119 //      o Checks to see if there are any outbound serial Modbus messages
00120 //
00121 // ----------------------------------------------------------------------
00122 static void TunnelThread(void)
00123 {
00124     char ch_halfSecond = 5;
00125     
00126     // Set the Modbus Tunnel LED to ON to indicate that the thread has started
00127     st_digitalOutTunnelLED = 1;
00128     
00129     // Enter in to a forever loop 
00130     while (true)
00131     {
00132         // Sleep for one tenth of a second
00133         wait(0.1);
00134         
00135         // Count down the half second timer and see if it expired
00136         if (0 == --ch_halfSecond)
00137         {
00138             // It has expired so restart the half second time
00139             ch_halfSecond = 5;
00140             
00141             // See if we turn on or turn off the LED
00142             if (0 == c_flipFlop)
00143             {
00144                 c_flipFlop = 1;
00145             }
00146             else
00147             {
00148                 c_flipFlop = 0;
00149             }
00150         
00151             st_digitalOutTunnelLED = c_flipFlop;
00152         }
00153         
00154         // We check to see if there is inbound or outbound serial traffic 10 times a second
00155         if (TRUE == b_TunnelInitialized)
00156         {
00157             // Check for inbound Modbus Tunnel frames
00158             TunnelCheckInbound();
00159         
00160             // See if we need to send outbound Tunnel frames
00161             TunnelCheckOutbound();
00162         }
00163     }
00164 }
00165 
00166 // ----------------------------------------------------------------------
00167 // TunnelInit()
00168 //
00169 // This function will:
00170 //      o Initialize the module protocol's serial interface
00171 //      o Flag the fact that things are initialized
00172 //      o Launch the module's thread
00173 //
00174 // ----------------------------------------------------------------------
00175 void TunnelInit(void)
00176  {
00177     // We configure the Modbus Tunnel serial interface
00178     st_TunnelSerial.baud(115200);
00179     st_TunnelSerial.format(8, SerialBase::None, 1);
00180     
00181     // Flag the fact that the module has been initialized
00182     b_TunnelInitialized = true;
00183 
00184     // Launch the Modbus Tunnel thread
00185     st_threadTunnel.start(TunnelThread);
00186 }
00187  
00188  // End of file
00189