Subversion Repositories utosnet

/*

* uTosNet_spi Digi application

* root.cxx

* File created by:

*       Simon Falsig

*       University of Southern Denmark

*       Copyright 2010

*

*       This program is free software: you can redistribute it and/or modify

*       it under the terms of the GNU Lesser General Public License as published by

*       the Free Software Foundation, either version 3 of the License, or

*       (at your option) any later version.

*

*       This program is distributed in the hope that it will be useful,

*       but WITHOUT ANY WARRANTY; without even the implied warranty of

*       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

*       GNU Lesser General Public License for more details.

*

*       You should have received a copy of the GNU Lesser General Public License

*       along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include <stdio.h>

#include <stdlib.h>

#include <tx_api.h>

#include <sockapi.h>

#include <pthread.h>

#include <netoserr.h>

#include <string> 

#include <appservices.h>

#include <wxroot.h>

#include "spi_master_api.h"

#include "gpiomux_def.h"

#include "appconf.h"

#include "iam.hh"

#include "Npttypes.h"

#include "cliapi.h"                     //Needed for custom cli functions

#define APP_SPI_MASTER_GPIO_CS      0

#define APP_SPI_MASTER_GPIO_CLK     5

#define APP_SPI_MASTER_GPIO_RXD     3

#define APP_SPI_MASTER_GPIO_TXD     7

#define MAX_CONNECTIONS 16              //The maximum number of simultaneous connections, may be adjusted

#define PACKETSIZE 8                    //Do not change

#define DO_COMMIT_READ_PRE (1<<28)

#define DO_READ (1<<27)

#define DO_COMMIT_READ_POST (1<<26)

#define DO_COMMIT_WRITE_PRE (1<<12)

#define DO_WRITE (1<<11)

#define DO_COMMIT_WRITE_POST (1<<10)

enum THREAD_STATUS_TYPES

{

        FREE,

        RUNNING,

        TERMINATED

};

struct sockAddrIn

{

   short                        sin_family;                             // address family

   unsigned short   sin_port;                           // port

   struct                       in_addr  sin_addr;              // ip address

   char                         sin_zero[8];

   /*

    * Adding constructors to sockaddr_in structure

    */

   sockAddrIn(){sin_family = AF_INET;}

   sockAddrIn(unsigned short port,unsigned long addr = 0)

    {

       sin_family = AF_INET;

       sin_port   = port;

       sin_addr.s_addr = addr;

   };

};

THREAD_STATUS_TYPES threadInUse[MAX_CONNECTIONS];

SOCKET clientSockets[MAX_CONNECTIONS];

sockAddrIn* clientSockaddrs[MAX_CONNECTIONS];

/*

 * Server thread function

 */

void netServer(unsigned long port);

/*

 * Network Read thread function

 */

void netRead(unsigned long threadIndex);

/*

 * FPGA Write thread function

 */

void fpgaWrite(unsigned long comHandle);

int readDebug(int fd, int n, char * args[]);            //Custom cli functions

int readDebugHelp(int fd, int n, char * args[]);        //

/*

 * Set this to 1 to run the system POST tests during startup.

 */

const int APP_POST = 0;

/*

 * Set this to 1 to run the manufacturing burn in tests.

 */

int APP_BURN_IN_TEST = 0;

/*

 * Thread size

 */

#define STACK_SIZE      4096

/*

 * Thread control blocks

 */

TX_THREAD               net_server;

TX_THREAD               fpga_write;

TX_THREAD               *net_read[MAX_CONNECTIONS];

/*

 * Message queues

 */

TX_QUEUE                inMsg;

/*

 * Global variables

 */

unsigned int currentReceiverIndex = MAX_CONNECTIONS;

char* currentReceiverData;

int debug[2];

/*

 *

 *  Function: void applicationTcpDown (void)

 *

 *  Description:

 *

 *      This routine will be called by the NET+OS root thread once every

 *      clock tick while it is waiting for the TCP/IP stack to come up.

 *

 *      This routone is called to print the application name and then

 *      to print the '.' every second.

 *

 *      This function will not be called once the stack has started.

 *

 *      This function uses the global C++ object PrintApplicationDown app_down.

 *

 *  Parameters:

 *

 *      none

 *

 *  Return Values:

 *

 *      none

 *

 */

extern "C"

void applicationTcpDown (void)

{

}

/*

 *

 *  Function: void applicationStart (void)

 *

 *  Description:

 *

 *      This routine is responsible for starting the user application.  It should

 *      create any threads or other resources the application needs.

 *

 *      ThreadX, the NET+OS device drivers, and the TCP/IP stack will be running

 *      when this function is called.

 *

 *      This function uses global C++ object:

 *              PrintApplicationDown app_down.

 *

 *  Parameters:

 *

 *      none

 *

 *  Return Values:

 *

 *      none

 *

 */

extern "C"

void applicationStart (void)

{

    void *stack;

    char *app_name;

    int rc,prio;

#ifdef NETOS_GNU_TOOLS

        using namespace std;

#endif

        /* Initialize the system services for the application. */

        initAppServices();

        /*

         * Create queues for messaging between socket threads and fpga communication thread

         */

        if(tx_queue_create(&inMsg, (char*)"Incoming Message Queue", TX_1_ULONG , (void*)0x300000, 4*MAX_CONNECTIONS) != SUCCESS)

        {

                netosFatalError ((char *)"Error creating Incoming Message Queue!", 5, 5);

        }

        int i=0;

        currentReceiverData = new char[PACKETSIZE+2+32];

        while(((int)(&currentReceiverData[i]))%32) i++;         //Buffers used for reading from SPI need to be on a 32 byte boundary

        currentReceiverData = &currentReceiverData[i];

        /*

         * Add CLI debug stuff

         */

        NaCliCmd_t userTable;

        userTable.command_name = "rd";

        userTable.command_func = readDebug;

        userTable.help_func = readDebugHelp;

        naCliAddUserTable(&userTable);

        /*

         * Setup SPI communication

         */

    NAconfigureGPIOpin(APP_SPI_MASTER_GPIO_CS, NA_GPIO_FUNC4_STATE, 0);

    NAconfigureGPIOpin(APP_SPI_MASTER_GPIO_CLK, NA_GPIO_FUNC4_STATE, 0);

    NAconfigureGPIOpin(APP_SPI_MASTER_GPIO_RXD, NA_GPIO_FUNC4_STATE, 0);

    NAconfigureGPIOpin(APP_SPI_MASTER_GPIO_TXD, NA_GPIO_FUNC4_STATE, 0);

        NASpiDeviceConfigType spiDevice0 = {0, NULL, NULL, NA_SPI_MODE2, NA_SPI_MSB, 4000000, 2000, "SPI1"};     //2, 4000000

        NASpiRegisterDevice(&spiDevice0);

        /*

         * Start threads

         */

        prio = 16;

        stack = malloc (STACK_SIZE);

        if (stack == NULL)

        {

                netosFatalError ((char *)"Unable to allocate thread stack.", 5, 5);

        }

        rc = tx_thread_create (&net_server,                                                     /* control block for thread*/

                                (char *)"Network Server thread",        /* thread name*/

                                netServer,                                              /* entry function*/

                                50000,                                          /* parameter - port*/

                                stack,                                          /* start of stack*/

                                STACK_SIZE,                                     /* size of stack*/

                                prio,                                           /* priority*/

                                prio,                                           /* preemption threshold */

                                1,                                              /* time slice threshold*/

                                TX_AUTO_START);                                 /* start immediately*/

        if (rc != TX_SUCCESS)

        {

            netosFatalError ((char *)"Unable to create thread.", 5, 5);

        }

        stack = malloc (STACK_SIZE);

        if (stack == NULL)

        {

                netosFatalError ((char *)"Unable to allocate thread stack.", 5, 5);

        }

        rc = tx_thread_create (&fpga_write,                                             /* control block for thread*/

                                (char *)"Write to FPGA Thread",         /* thread name*/

                                fpgaWrite,                                              /* entry function*/

                                (unsigned long) 0,                                       /* parameter*/

                                stack,                                          /* start of stack*/

                                STACK_SIZE,                                     /* size of stack*/

                                prio,                                                   /* priority*/

                                prio,                                                   /* preemption threshold */

                                1,                                              /* time slice threshold*/

                                TX_AUTO_START);                                 /* start immediately*/

        if (rc != TX_SUCCESS)

        {

            netosFatalError ((char *)"Unable to create thread.", 5, 5);

    }

        /*

         * Necessary threads started, suspend this thread

         */

        tx_thread_suspend(tx_thread_identify());

}

/*

 *

 *  Function: void netServer()

 *

 *  Description:

 *

 *      This is the netServer thread function.

 *              It waits for connections, accepts these, and spawns a new socket

 *              and thread to handle them.

 *              Old threads are automatically cleaned up when the socket is

 *              disconnected.

 *

 */

void netServer(unsigned long port)

{

    void *stack[MAX_CONNECTIONS];

    int rc, prio = 16, currentThreadIndex;

    int bufsize = 65536;

    for(int n=0; n<MAX_CONNECTIONS; n++)

    {

        threadInUse[n] = FREE;

        clientSockaddrs[n] = new sockAddrIn;

    }

        SOCKET serverSocket;

        serverSocket = socket(AF_INET, SOCK_STREAM, 0);

        if(serverSocket == -1)

        {

                printf("Socket Creation Error %d\n", getErrno());

                return;

        }

        int error = 0;

        const int onValue = 1;

        const int offValue = 0;

        error += setsockopt(serverSocket, SOL_SOCKET, SO_SNDBUF, (char*)&bufsize, sizeof(bufsize));

        error += setsockopt(serverSocket, SOL_SOCKET, SO_RCVBUF, (char*)&bufsize, sizeof(bufsize));

        error += setsockopt(serverSocket, SOL_SOCKET, SO_BIO, (char*)&onValue, sizeof(onValue));

        error += setsockopt(serverSocket, SOL_SOCKET, SO_NONBLOCK, (char*)&offValue, sizeof(offValue));

        if(error != 0)

        {

                printf("Error setting Socket options %d\n", getErrno());

                return;

        }

        sockAddrIn sin(50000, INADDR_ANY);

        if(bind(serverSocket, (sockaddr *) &sin, sizeof(sin)) == -1)

        {

                printf("Error binding Socket %d\n", getErrno());

                return;

        }

        if(listen(serverSocket, MAX_CONNECTIONS) == -1)

        {

                printf("Error listening on Socket %d\n", getErrno());

                return;

        }

        int sinClientSize = sizeof(sockAddrIn);

        while(1)

        {

                for(int n=0; n<MAX_CONNECTIONS; n++)

                {

                        if(threadInUse[n] == TERMINATED)

                        {

                                free(stack[n]);

                                tx_thread_delete(net_read[n]);

                                delete net_read[n];

                                threadInUse[n] = FREE;

                        }

                }

                currentThreadIndex = -1;

                for(int n=0; n<MAX_CONNECTIONS; n++)

                {

                        if(threadInUse[n] == FREE)

                        {

                                currentThreadIndex = n;

                                n = MAX_CONNECTIONS;

                        }

                }

                if(currentThreadIndex > -1)

                {

                        if((clientSockets[currentThreadIndex] = accept(serverSocket, (sockaddr*)clientSockaddrs[currentThreadIndex], &sinClientSize)) == -1)

                        {

                                printf("Error accepting client connection %d\n", getErrno());

                                return;

                        }

                        net_read[currentThreadIndex] = new TX_THREAD;

                        stack[currentThreadIndex] = malloc(STACK_SIZE);

                        if (stack[currentThreadIndex] == NULL)

                        {

                                netosFatalError ((char *)"Unable to allocate thread stack.", 5, 5);

                        }

                        rc = tx_thread_create (net_read[currentThreadIndex],            /* control block for thread*/

                                                (char *)"Network Read thread",          /* thread name*/

                                                netRead,                                                /* entry function*/

                                                (unsigned long)currentThreadIndex,      /* parameter - port*/

                                                stack[currentThreadIndex],                      /* start of stack*/

                                                STACK_SIZE,                                     /* size of stack*/

                                                prio,                                           /* priority*/

                                                prio,                                           /* preemption threshold */

                                                1,                                              /* time slice threshold*/

                                                TX_AUTO_START);                                 /* start immediately*/

                        if (rc != TX_SUCCESS)

                        {

                            netosFatalError ((char *)"Unable to create thread.", 5, 5);

                        }

                        else

                        {

                                threadInUse[currentThreadIndex] = RUNNING;

                        }

                }

                tx_thread_relinquish();

        }

}

/*

 *

 *  Function: void fpgaWrite()

 *

 *  Description:

 *

 *      This is the fpgaWrite thread function.

 *              It accepts read/write requests from a message queue, and forwards these

 *              to the FPGA over the SPI interface.

 *

 */

void fpgaWrite(unsigned long comHandle)

{

        char* writeBuffer;

        char* readBuffer;

        char* temp;

        unsigned long currentIndex;

        int i=0;

        readBuffer = new char[PACKETSIZE+2+32];

        while(((int)(&readBuffer[i]))%32) i++;

        readBuffer = &readBuffer[i];

        while(1)

        {

                if(tx_queue_receive(&inMsg, &writeBuffer, TX_NO_WAIT) == TX_SUCCESS)

                {

                        currentIndex = writeBuffer[PACKETSIZE];

                        for(int n=0; n<PACKETSIZE; n++)

                        {

                                readBuffer[n] = 0;

                        }

                        NASpiReadWrite("SPI1", (char*)writeBuffer, (char*)readBuffer, PACKETSIZE);

                        if(((int*)writeBuffer)[0] & DO_COMMIT_READ_PRE)

                        {

                                ((int*)writeBuffer)[0] &= ~(DO_COMMIT_READ_PRE + DO_COMMIT_WRITE_PRE + DO_WRITE + DO_COMMIT_WRITE_POST);

                                do

                                {

                                        tx_thread_relinquish();

                                        NASpiReadWrite("SPI1", (char*)writeBuffer, (char*)readBuffer, PACKETSIZE);

                                        debug[0] = ((int*)readBuffer)[0];

                                        debug[1] = ((int*)readBuffer)[1];

                                }

                                while(((unsigned int*)readBuffer)[0] > 1);

                        }

                        if(((int*)writeBuffer)[0] & DO_READ)

                        {

                                while(currentReceiverIndex != MAX_CONNECTIONS)

                                {

                                        tx_thread_relinquish();

                                }

                                temp = readBuffer;

                                readBuffer = currentReceiverData;

                                currentReceiverData = temp;

                                currentReceiverIndex = currentIndex;

                        }

                }

                tx_thread_relinquish();

        }

}

/*

 *

 *  Function: void netRead(unsigned long threadIndex)

 *

 *  Description:

 *

 *      This is the netRead thread function.

 *              It is spawned for every new connection made to the netServer, and

 *              handles the necessary communication.

 *

 *  Parameters:

 *

 *              threadIndex     -       The global index of the thread. Used for indexing into

 *                                              the global thread status variables.

 *

 */

void netRead(unsigned long threadIndex)

{

        char* buffer;

        int temp;

        char backupTemp;

        buffer = new char[PACKETSIZE + 2];

        buffer[PACKETSIZE] = '\0';

        bool doRead, doWrite;

        while(1)

        {

        if((temp = recv(clientSockets[threadIndex], buffer, PACKETSIZE, 0)) < 1)

        {

                        threadInUse[threadIndex] = TERMINATED;

                delete [] buffer;

                closesocket(clientSockets[threadIndex]);

                tx_thread_terminate(tx_thread_identify());

        }

        else

        {

                for(int n=0; n<(PACKETSIZE/4); n++)

                {

                        backupTemp = buffer[n*4];

                        buffer[n*4] = buffer[n*4+3];

                        buffer[n*4+3] = backupTemp;

                        backupTemp = buffer[n*4+2];

                        buffer[n*4+2] = buffer[n*4+1];

                        buffer[n*4+1] = backupTemp;

                }

                buffer[PACKETSIZE+1] = '\0';

                        buffer[PACKETSIZE] = threadIndex;

                        doRead = ((int*)buffer)[0] & DO_READ;

                        doWrite = ((int*)buffer)[0] & DO_WRITE;

                        if(doWrite && (temp < 8))

                        {

                                ((int*)buffer)[0] &= ~(DO_COMMIT_WRITE_PRE + DO_WRITE + DO_COMMIT_WRITE_POST);

                        }

                        if(!doRead)

                        {

                                ((int*)buffer)[0] &= ~(DO_COMMIT_READ_PRE);

                        }

                        tx_queue_send(&inMsg, &buffer, TX_NO_WAIT);

                        if(doRead)

                        {

                                while(currentReceiverIndex != threadIndex)

                                {

                                        tx_thread_relinquish();

                                }

                        backupTemp = (&(currentReceiverData[4]))[0];

                        (&(currentReceiverData[4]))[0] = (&(currentReceiverData[4]))[3];

                        (&(currentReceiverData[4]))[3] = backupTemp;

                        backupTemp = (&(currentReceiverData[4]))[2];

                        (&(currentReceiverData[4]))[2] = (&(currentReceiverData[4]))[1];

                        (&(currentReceiverData[4]))[1] = backupTemp;

                                send(clientSockets[threadIndex], (&(currentReceiverData[4])), 4, 0);

                                currentReceiverIndex = MAX_CONNECTIONS;

                        }

        }

                tx_thread_relinquish();

        }

}

int readDebug(int fd, int n, char * args[])

{

        naCliPrintf(fd, "Read values: %.8x  |  %.8x\n\r", debug[0], debug[1]);

        return 0;

}

int readDebugHelp(int fd, int n, char * args[])

{

        naCliPrintf(fd, "Prints the six first integers in the read-array from the SPI transfer");

        return 0;

}