File content as of revision 0:dfad71908d59:

/******************************************************************************
 * Includes
 *****************************************************************************/
 
#include "mbed.h"
#include "mbed_interface.h"
#include "rtos.h"
#include "EthernetInterface.h"
#include "HTTPServer.h"
#include "mbed_rpc.h"
#include "USBHostMSD.h"

#include "DMBoard.h"
#include "Graphics.h"

/******************************************************************************
 * Typedefs and defines
 *****************************************************************************/

/* Number of colors in 565 mode */
#define NUM_COLORS    65536
/* Number of red colors in 565 mode */
#define RED_COLORS    0x20
/* Number of green colors in 565 mode */
#define GREEN_COLORS  0x40
/* Number of blue colors in 565 mode */
#define BLUE_COLORS   0x20
/* Black color, 565 mode */
#define BLACK         0x0000

/******************************************************************************
 * Local variables
 *****************************************************************************/

EthernetInterface eth;

/******************************************************************************
 * Global variables
 *****************************************************************************/

/******************************************************************************
 * Local functions
 *****************************************************************************/

static void verticalLine16(uint16_t* framebuffer, int w, int x, int y0, int y1, uint16_t color)
{
    if (x < w) {
        int h = y1 - y0 + 1;
        uint16_t* fb = framebuffer;
        fb += x;
        fb += y0 * w;
        for (int i = 0; i < h; i++) {
            *fb = color;
            fb += w;
        }
    }
}

/**
 * Draw color bars to the display
 */
static void drawBars565(uint16_t* framebuffer, int w, int h)
{
  uint16_t clr;
  uint16_t xgs, ygs, curx, cury, curym, xidx;
  int idx;

  /* Compute vertical size for bars */
  ygs = h / 3;

  /* Draw Red bars */
  cury = 0;
  curx = 0;
  curym = ygs - 1;
  xgs = w / RED_COLORS;
  clr = BLACK;
  for (xidx = 0; xidx < RED_COLORS; xidx++)
  {
      //swim_set_pen_color(win1, clr);
      for (idx = 0; idx <= xgs; idx++)
      {
          //swim_put_line(win1, curx, cury, curx, curym);
        //g.put_line(curx, cury, curx, curym, clr);
          verticalLine16(framebuffer, w, curx, cury, curym, clr);
        curx++;
      }
      clr = clr + 0x0800;
  }

  /* Draw green bars */
  cury = cury + ygs;
  curx = 0;
  curym = cury + (ygs - 1);
  xgs = w / GREEN_COLORS;
  clr = BLACK;
  for (xidx = 0; xidx < GREEN_COLORS; xidx++)
  {
      //swim_set_pen_color(win1, clr);
      for (idx = 0; idx <= xgs; idx++)
      {
          //swim_put_line(win1, curx, cury, curx, curym);
        //g.put_line(curx, cury, curx, curym, clr);
          verticalLine16(framebuffer, w, curx, cury, curym, clr);
          curx++;
      }
      clr = clr + 0x0020;
  }

  /* Draw blue bars */
  cury = cury + ygs;
  curx = 0;
  curym = h - 1;//cury + (ygs - 1);
  xgs = w / BLUE_COLORS;
  clr = BLACK;
  for (xidx = 0; xidx < BLUE_COLORS; xidx++)
  {
      //swim_set_pen_color(win1, clr);
      for (idx = 0; idx <= xgs; idx++)
      {
          //swim_put_line(win1, curx, cury, curx, curym);
        //g.put_line(curx, cury, curx, curym, clr);
          verticalLine16(framebuffer, w, curx, cury, curym, clr);
          curx++;
      }
      clr = clr + 0x0001;
  }
}



void aliveTask(void const* args)
{
  DMBoard* board = &DMBoard::instance();
    
  while(true)
  {
    board->setLED(DMBoard::Led4, false);
    board->setLED(DMBoard::Led1, true);
    Thread::wait(300);
    board->setLED(DMBoard::Led1, false);
    board->setLED(DMBoard::Led2, true);
    Thread::wait(300);
    board->setLED(DMBoard::Led2, false);
    board->setLED(DMBoard::Led3, true);
    Thread::wait(300);
    board->setLED(DMBoard::Led3, false);
    board->setLED(DMBoard::Led4, true);
    Thread::wait(300);
  }
}

/*
 * Reads the /message.txt file from the file system and prints the content
 */
void readMessageFile(const char* prefix)
{
  RtosLog* log = DMBoard::instance().logger();
  log->printf("%sTesting to read from USB\n", prefix);
    
  FILE * fp = fopen("/usb/test1.txt", "r");
  
  if (fp != NULL) {
    uint8_t* buff = (uint8_t*)malloc(1024+1);
    if (buff == NULL) {
      log->printf("%sFailed to allocate memory for test\n", prefix);
    } else {
      int num = fread(buff, 1, 1024, fp);
      if (num <= 0) {
        log->printf("%sUnable to read file, got %d as result\n", prefix, num);
      } else if (num < 1024) {
        log->printf("%sHave read all %d bytes in the file\n", prefix, num);
        buff[num] = '\0';
        log->printf((const char*)buff);
      } else {
        log->printf("%sHave read %d bytes with more to read\n", prefix, num);
      }
      free(buff);
    }
    fclose(fp);
  } else {
    log->printf("%sFILE == NULL\r\n", prefix);
  }
}


#if defined(DM_BOARD_USE_DISPLAY)
#define DISPLAY_TASK_PREFIX  "[LCD] "
void displayTask(void const* args)
{
  // Start display in default mode (16-bit)
  RtosLog* log = DMBoard::instance().logger();
  Display* disp = DMBoard::instance().display();
  Display::DisplayError disperr;
  uint16_t* fb = (uint16_t*)disp->allocateFramebuffer();
  if (fb == NULL) {
    log->printf(DISPLAY_TASK_PREFIX"Failed to allocate memory for framebuffer\r\n");
    mbed_die();
  }
  drawBars565(fb, disp->width(), disp->height());
  disperr = disp->powerUp(fb);
  if (disperr != Display::Ok) {
    log->printf(DISPLAY_TASK_PREFIX"Failed to initialize the display, got error %d\r\n", disperr);
    mbed_die();
  }
  
  int h = disp->height();
  int w = disp->width();
  uint16_t COLORS[] = { 0xFFF0, 0xF800, 0x07E0, 0x001F, 0x07FF, 0xF81F };
  int i = 0;
  while(true) {
    uint16_t color = COLORS[i++ % (sizeof(COLORS)/sizeof(COLORS[0]))];
    for (int y = 0; y < h; y++) {
      for (int x = 0; x < w; x++) {
        fb[y*w+x] = color;
      }
      Thread::wait(30);
    }
    
    // test to read the message file
    //readMessageFile(DISPLAY_TASK_PREFIX);
  }
}
#endif //DM_BOARD_USE_DISPLAY

#define MSD_TASK_PREFIX  "[MSD] "

void msdTask(void const* args)
{
  USBHostMSD msd("usb");
  USBHost* host = USBHost::getHostInst();
  RtosLog* log = DMBoard::instance().logger();
    
  log->printf(MSD_TASK_PREFIX"msdTask started\n");
  
    while(1) {
        
        log->printf(MSD_TASK_PREFIX"Attempting to connect...\n");
      
        // try to connect a MSD device
        while(!msd.connect()) {
//            log->printf(MSD_TASK_PREFIX"Failed to connect, waiting 5s and trying again!\n");
//            Thread::wait(5000);
            log->printf(MSD_TASK_PREFIX"Failed to connect, press button to try again!\n");
            while(!DMBoard::instance().buttonPressed()) {
                Thread::wait(20);
            }
            Thread::wait(40);
            while(DMBoard::instance().buttonPressed()) {
                Thread::wait(20);
            }
            log->printf(MSD_TASK_PREFIX"Attempting to connect...\n");
        }
        
        log->printf(MSD_TASK_PREFIX"Connected!\n");

        // read a file
        readMessageFile(MSD_TASK_PREFIX);
        
        // if/when the device is disconnected, we try to connect it again
        while(1) {
            
            Thread::wait(500);
        
            // if device disconnected, try to connect again
            if (!msd.connected())
                break;
        }
        log->printf(MSD_TASK_PREFIX"Disconnected\n");
    }
}

#define NET_TASK_PREFIX  "[NET] "

void netTask(void const* args)
{
  RtosLog* log = DMBoard::instance().logger();
  log->printf(NET_TASK_PREFIX"EthernetInterface Setting up...\r\n");
  if(eth.init()!=0) {                             //for DHCP Server
     //if(eth.init(IPAddress,NetMasks,Gateway)!=0) { //for Static IP Address
     log->printf(NET_TASK_PREFIX"EthernetInterface Initialize Error \r\n");
     mbed_die();
  }
  if(eth.connect()!=0) {
     log->printf(NET_TASK_PREFIX"EthernetInterface Connect Error \r\n");
     mbed_die();
  }
  
  log->printf(NET_TASK_PREFIX"IP Address is %s\r\n", eth.getIPAddress());
  log->printf(NET_TASK_PREFIX"NetMask is %s\r\n", eth.getNetworkMask());
  log->printf(NET_TASK_PREFIX"Gateway Address is %s\r\n", eth.getGateway());
  log->printf(NET_TASK_PREFIX"Ethernet Setup OK\r\n");

  HTTPServerAddHandler<SimpleHandler>("/hello"); //Default handler
  FSHandler::mount("/usb", "/");
  HTTPServerAddHandler<FSHandler>("/");
  //HTTPServerAddHandler<RPCHandler>("/rpc");
  //lcd.locate(0,0);
  //lcd.printf("%s",eth.getIPAddress());
  HTTPServerStart(80);
}

/******************************************************************************
 * Main function
 *****************************************************************************/
int main()
{
  DMBoard::BoardError err;
  DMBoard* board = &DMBoard::instance();
  RtosLog* log = board->logger();
  err = board->init();
  if (err != DMBoard::Ok) {
    log->printf("Failed to initialize the board, got error %d\r\n", err);
    mbed_die();
  }
  
  log->printf("\n\n---\nMulti-threaded demo\nBuilt: " __DATE__ " at " __TIME__ "\n\n");
  
  log->printf("Press button to start...\r\n");
  while(!board->buttonPressed());
  while(board->buttonPressed());
  
  Thread tAlive(aliveTask);
#if defined(DM_BOARD_USE_DISPLAY)
  Thread tDisplay(displayTask, NULL, osPriorityNormal, 8192);
#endif  
  Thread tMemstick(msdTask, NULL, osPriorityNormal, 8192);
  Thread tNetwork(netTask, NULL, osPriorityNormal, 8192);
  
  while(1) { wait(5); }
}