File content as of revision 16:77f4f42eb6a7:

/******************************************************************************
 * 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 "USBHostMouse.h"
#include "USBHostKeyboard.h"

#include "DMBoard.h"

#include "AppLauncher.h"
#include "meas.h"

#include "AppNetworkSettings.h"
#include "AppStatus.h"
#include "AppTouchCalibration.h"
#include "AppColorPicker.h"
#include "AppImageViewer.h"
#include "AppSlideShow.h"
#include "image_data.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
 *****************************************************************************/

Mutex usbInitGuard;

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

EthernetInterface eth;
bool ethInitialized = false;
bool ethUsingDHCP = true;
bool haveUSBMSD = false;

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

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/message.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---\n", prefix, num);
        buff[num] = '\0';
        log->printf((const char*)buff);
        log->printf("\n---\n");
      } 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)

typedef enum {
    ColorPickerApp,
    ImageViewerApp,
    SlideshowApp,
    SettingsApp, 
    StatusApp, 
    TouchTestApp,
    CalibrationApp =  AppLauncher::CalibrationApp,
    Placeholder,
} myapps_t;

static App* launchApp(uint32_t id)
{
  App* a = NULL;
  switch ((myapps_t)id) {
      case CalibrationApp:
          a = new AppTouchCalibration();
          break;
      case SettingsApp:
          a = new AppNetworkSettings();
          break;
      case ColorPickerApp:
          a = new AppColorPicker();
          break;
      case ImageViewerApp:
          a = new AppImageViewer();
          break;
      case SlideshowApp:
          a = new AppSlideShow();
          break;
      case StatusApp:
          a = new AppStatus();
          break;
      default:
          break;
  }
  return a;
}

#define SWIM_TASK_PREFIX  "[SWIM] "
void swimTask(void const* args)
{
  RtosLog* log = DMBoard::instance().logger();
    
  log->printf(SWIM_TASK_PREFIX"swimTask started\n");
  
  AppLauncher launcher;
    
    
  if (launcher.setup()) {
    launcher.addImageButton(SettingsApp,  img_preferences_desktop_applications, img_size_preferences_desktop_applications);
    launcher.addImageButton(Placeholder, img_bijiben, img_size_bijiben);
    launcher.addImageButton(SlideshowApp, img_multimedia_photo_manager, img_size_multimedia_photo_manager);
    //launcher.addImageButton(TouchGFXApp,  "TouchGFX");
    //launcher.addImageButton(EmWinApp,     "emWin");
    launcher.addImageButton(ColorPickerApp,  img_preferences_color, img_size_preferences_color);
    launcher.addImageButton(ImageViewerApp,  img_multimedia_photo_manager, img_size_multimedia_photo_manager);
    launcher.addImageButton(StatusApp,  img_help_info, img_size_help_info);
    launcher.addImageButton(Placeholder,  img_unetbootin, img_size_unetbootin);
      
    launcher.setAppCreatorFunc(launchApp);
    log->printf(SWIM_TASK_PREFIX"Starting menu system\n");
    launcher.runToCompletion();
    launcher.teardown();
  } else {
    log->printf(SWIM_TASK_PREFIX"Failed to prepare menu system\n");
  }
  
  // Should never end up here  
  mbed_die();
}

#endif //DM_BOARD_USE_DISPLAY

#define MSD_TASK_PREFIX  "[MSD] "

void msdTask(void const* args)
{    
  usbInitGuard.lock();
  USBHostMSD* msd = new USBHostMSD("usb");
  usbInitGuard.unlock();
  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
        bool connected = false;
        do {
            usbInitGuard.lock();
            connected = msd->connect();
            usbInitGuard.unlock();
            if (!connected) {
                //log->printf(MSD_TASK_PREFIX"Failed to connect, waiting and trying again!\n");
                Thread::wait(500);
                //DMBoard::instance().buzzer(440, 100);
            }
        } while(!connected);
        
        log->printf(MSD_TASK_PREFIX"Connected!\n");
        haveUSBMSD = true;

        // 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;
            }
        }
        haveUSBMSD = false;
        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();
  }
  while (eth.connect() != 0) {
     Thread::wait(1000);
  }
  
  ethInitialized = true;
  ethUsingDHCP = true;
  
  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);
}

static int8_t mouse_button, mouse_x, mouse_y, mouse_z;
static uint16_t cursor_x=0, cursor_y=0;
void mouseEvent(uint8_t buttons, int8_t x, int8_t y, int8_t z)
{
    mouse_button = buttons;
    mouse_x = x;
    mouse_y = y;
    mouse_z = z;
    
    if (x < 0) {
        if (cursor_x > -x) {
            cursor_x += x;
        } else {
            cursor_x = 0;
        }
    } else {
        if ((cursor_x + x) >= 480) {
            cursor_x = 479;
        } else {
            cursor_x += x;
        }
    }
    y = y/8;
    if (y < 0) {
        if (cursor_y > -y) {
            cursor_y += y;
        } else {
            cursor_y = 0;
        }
    } else {
        if ((cursor_y + y) >= 272) {
            cursor_y = 271;
        } else {
            cursor_y += y;
        }
    }
    
    //Chip_LCD_Cursor_SetPos(LPC_LCD, cursor_x, cursor_y);
    LPC_LCD->CRSR_XY = (cursor_x & 0x3FF) | ((cursor_y & 0x3FF) << 16);
}

#define LCD_CURSOR_32x32 0
#define LCD_CURSOR_64x64 1
#define CURSOR_SIZE  LCD_CURSOR_32x32
#define CURSOR_H_SIZE 32
#define CURSOR_V_SIZE 32
#define CURSOR_NUM   0    
#define CURSOR_H_OFS (10)
#define CURSOR_V_OFS (6)

const unsigned char __attribute__ ((aligned(4))) Cursor[(CURSOR_H_SIZE / 4) * CURSOR_V_SIZE] =
{
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xFA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFE, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFE, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFE, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFE, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFF, 0xEA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFF, 0xFF, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFF, 0xFF, 0xFA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFF, 0xFF, 0xFE, 0xAA, 0xAA,
	0xAA, 0xAB, 0xFB, 0xFF, 0xFF, 0xFF, 0xAA, 0xAA,
	0xAA, 0xAB, 0xFF, 0xFF, 0xFF, 0xFF, 0xAA, 0xAA,
	0xAA, 0xAB, 0xFF, 0xFF, 0xFF, 0xFF, 0xAA, 0xAA,
	0xAA, 0xAA, 0xFF, 0xFF, 0xFF, 0xFF, 0xAA, 0xAA,
	0xAA, 0xAA, 0xBF, 0xFF, 0xFF, 0xFF, 0xAA, 0xAA,
	0xAA, 0xAA, 0xBF, 0xFF, 0xFF, 0xFF, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAF, 0xFF, 0xFF, 0xFF, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAF, 0xFF, 0xFF, 0xFE, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFF, 0xFF, 0xFE, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAB, 0xFF, 0xFF, 0xFE, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xFF, 0xFF, 0xFA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xFF, 0xFF, 0xFA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xFF, 0xFF, 0xFA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA
};

void prepareCursor(bool enable) {
	//Chip_LCD_Cursor_Disable(LPC_LCD, 0);
    LPC_LCD->CRSR_CTRL = (CURSOR_NUM << 4);
    
    if (enable) {
        //Chip_LCD_Cursor_Config(LPC_LCD, LCD_CURSOR_32x32, true);
        LPC_LCD->CRSR_CFG = ((true ? 1 : 0) << 1) | CURSOR_SIZE;
        
        //Chip_LCD_Cursor_WriteImage(LPC_LCD, 0, (void *) Cursor);
        {
            int i, j;
            uint32_t *fifoptr, *crsr_ptr = (uint32_t *) Cursor;

            /* Check if Cursor Size was configured as 32x32 or 64x64*/
            if (CURSOR_SIZE == LCD_CURSOR_32x32) {
                i = CURSOR_NUM * 64;
                j = i + 64;
            }
            else {
                i = 0;
                j = 256;
            }
            fifoptr = (uint32_t *) &(LPC_LCD->CRSR_IMG[0]);

            /* Copy Cursor Image content to FIFO */
            for (; i < j; i++) {

                *fifoptr = *crsr_ptr;
                crsr_ptr++;
                fifoptr++;
            }
        }
        
        //Chip_LCD_Cursor_SetClip(LPC_LCD, CURSOR_H_OFS, CURSOR_V_OFS);
        LPC_LCD->CRSR_CLIP = (CURSOR_H_OFS & 0x3F) | ((CURSOR_V_OFS & 0x3F) << 8);
        
        //Chip_LCD_Cursor_SetPos(LPC_LCD, cursor_x, cursor_y);
        
        //Chip_LCD_Cursor_Enable(LPC_LCD, 0);
        LPC_LCD->CRSR_CTRL = (CURSOR_NUM << 4) | 1;
    }
}

#define MOUSE_TASK_PREFIX  "[MOUSE] "

void mouseTask(void const* args)
{
    usbInitGuard.lock();
    USBHostMouse* mouse = new USBHostMouse();
    usbInitGuard.unlock();
    RtosLog* log = DMBoard::instance().logger();
        
    log->printf(MOUSE_TASK_PREFIX"mouseTask started\n");
  
    while(1) {
        
        prepareCursor(false);
        log->printf(MOUSE_TASK_PREFIX"Attempting to connect...\n");
      
        // try to connect a mouse
        bool connected = false;
        do {
            usbInitGuard.lock();
            connected = mouse->connect();
            usbInitGuard.unlock();
            if (!connected) {
                //log->printf(MOUSE_TASK_PREFIX"Failed to connect, waiting and trying again!\n");
                Thread::wait(500);
            }
        } while(!connected);
        
        log->printf(MOUSE_TASK_PREFIX"Connected!\n");
        mouse->attachEvent(mouseEvent);
        prepareCursor(true);

        while(mouse->connected()) {
            log->printf(MOUSE_TASK_PREFIX"Buttons: 0x%02x, X %3d, Y %3d, Z %3d\n", mouse_button, mouse_x, mouse_y, mouse_z);
            Thread::wait(500);
        }

        log->printf(MOUSE_TASK_PREFIX"Disconnected\n");
    }
}

#define CIRCBUFF_SIZE 256
static uint8_t circbuff[CIRCBUFF_SIZE];
static uint32_t circbuff_read = 0;
static uint32_t circbuff_write = 0;
void keyEvent(uint8_t key)
{
    circbuff[circbuff_write%CIRCBUFF_SIZE] = key;
    circbuff_write++;
}

#define KEY_TASK_PREFIX  "[KEY] "

void keyTask(void const* args)
{
    usbInitGuard.lock();
    USBHostKeyboard* keyboard = new USBHostKeyboard();
    usbInitGuard.unlock();
 
    RtosLog* log = DMBoard::instance().logger();
    uint8_t buff[10+1] = {0};
    int pos;
    
    log->printf(KEY_TASK_PREFIX"keyTask started\n");
  
    while(1) {
        
        log->printf(KEY_TASK_PREFIX"Attempting to connect...\n");
      
        // try to connect a keyboard
        bool connected = false;
        do {
            usbInitGuard.lock();
            connected = keyboard->connect();
            usbInitGuard.unlock();
            if (!connected) {
                //log->printf(KEY_TASK_PREFIX"Failed to connect, waiting and trying again!\n");
                Thread::wait(1000);
            }
        } while(!connected);
        
        log->printf(KEY_TASK_PREFIX"Connected!\n");
        keyboard->attach(keyEvent);

        while(keyboard->connected()) {            
            for (pos = 0; pos < 10; pos++) {
                if (circbuff_read < circbuff_write) {
                    buff[pos++] = circbuff[circbuff_read%CIRCBUFF_SIZE];
                    circbuff_read++;
                } else {
                    break;
                }
            }
            if (pos > 0) {
                log->printf(KEY_TASK_PREFIX"%s\n", buff);
            }
            Thread::wait(20);
        }

        log->printf(KEY_TASK_PREFIX"Disconnected\n");
    }
}

#define REGTEST "[REG] "
static void testRegistry()
{
  Registry* reg = DMBoard::instance().registry();
  RtosLog* log = DMBoard::instance().logger();
  char* key;
  char* val;
  Registry::RegistryError err;
    
  log->printf(REGTEST"Before:\n");
  for (int i = 0; i < reg->numEntries(); i++) {
    err = reg->entryAt(i, &key, &val);
    if (err == Registry::Ok) {
      log->printf(REGTEST"   [%2d] '%s' = '%s'\n", i, key, val);
      free(key);
      free(val);
    } else {
      log->printf(REGTEST"   [%2d] got error %d\n", i, err);
    }
  }
  
  log->printf(REGTEST"Getting existing value:\n");
  err = reg->getValue("IP Address", &val);
  if (err == Registry::Ok) {
    log->printf(REGTEST"   Existing 'IP Address' = '%s'\n", val);
    free(val);
  } else {
    log->printf(REGTEST"   Existing 'IP Address' got error %d\n", err);
  }
  
  log->printf(REGTEST"Getting missing value:\n");
  err = reg->getValue("X78g4dfwx", &val);
  if (err == Registry::Ok) {
    log->printf(REGTEST"   Missing 'X78g4dfwx' = '%s'\n", val);
    free(val);
  } else if (err == Registry::NoSuchKeyError) {
    log->printf(REGTEST"   Missing 'X78g4dfwx' was missing.\n", err);
  } else {
    log->printf(REGTEST"   Existing 'X78g4dfwx' got error %d\n", err);
  }

  log->printf(REGTEST"Updating value:\n");
  err = reg->getValue("EATest", &val);
  if (err == Registry::Ok) {
    log->printf(REGTEST"   Old value for 'EATest' = '%s'\n", val);
    char buf[32];
    sprintf(buf, "%d", atoi(val)+1);
    free(val);
    err = reg->setValue("EATest", buf);
    if (err == Registry::Ok) {
      log->printf(REGTEST"   Updated 'EATest' to '%s'\n", buf);
    } else {
      log->printf(REGTEST"   Failed to update 'EATest', got error %d\n", err);
    }
  } else if (err == Registry::NoSuchKeyError) {
    log->printf(REGTEST"   No value for 'EATest', adding one\n", err);
    err = reg->setValue("EATest", "-3");
    if (err == Registry::Ok) {
      log->printf(REGTEST"   Set 'EATest' to '0'\n");
    } else {
      log->printf(REGTEST"   Failed to set 'EATest', got error %d\n", err);
    }
  } else {
    log->printf(REGTEST"   Failed to read 'EATest' got error %d\n", err);
  }
  
  log->printf(REGTEST"Storing values persistently\n");
  err = reg->store();
  if (err != Registry::Ok) {
    log->printf(REGTEST"   Failed to store values, got error %d\n", err);
  }

  log->printf(REGTEST"After:\n");
  for (int i = 0; i < reg->numEntries(); i++) {
    err = reg->entryAt(i, &key, &val);
    if (err == Registry::Ok) {
      log->printf(REGTEST"   [%2d] '%s' = '%s'\n", i, key, val);
      free(key);
      free(val);
    } else {
      log->printf(REGTEST"   [%2d] got error %d\n", i, err);
    }
  }  
}

/******************************************************************************
 * 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);
    log->printf("\nTERMINATING\n");
    wait_ms(2000); // allow RtosLog to flush messages
    mbed_die();
  }
  
  board->buzzer(440,50);
  wait_ms(30);
  board->buzzer(660,50);
  wait_ms(30);
  board->buzzer(440,50);
  
  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());
  
  //testRegistry();
  
  
  Thread tAlive(aliveTask);
#if defined(DM_BOARD_USE_DISPLAY)
  Thread tSwim(swimTask, NULL, osPriorityNormal, 8192);
#endif  
  Thread tMemstick(msdTask, NULL, osPriorityNormal, 8192);
  Thread tNetwork(netTask, NULL, osPriorityNormal, 8192);
  Thread tMouse(mouseTask);
  Thread tKeyboard(keyTask);
  
  while(1) { wait(5); }
}