コード例 #1
0
ファイル: main.cpp プロジェクト: 1deus/tmk_keyboard
int main() {
    led1 = 0;
    led2 = 0;
    uint32_t initial_handler, final_handler;
    Counter c;

    // Test chaining inside Serial class
    flipper_1.attach(&flip_1, 1.0); // the address of the function to be attached (flip) and the interval (1 second)
    flipper_2.attach(&flip_2, 2.0); // the address of the function to be attached (flip) and the interval (2 seconds)

    // Test global chaining (InterruptManager)
    printf("Handler initially: %08X\n", initial_handler = NVIC_GetVector(TIMER_IRQ));
    InterruptManager *pManager = InterruptManager::get();
    pFunctionPointer_t ptm = pManager->add_handler(testme, TIMER_IRQ);
    pFunctionPointer_t pinc = pManager->add_handler_front(&c, &Counter::inc, TIMER_IRQ);
    printf("Handler after calling InterruptManager: %08X\n", NVIC_GetVector(TIMER_IRQ));

    wait(4.0);

    if (!pManager->remove_handler(ptm, TIMER_IRQ) || !pManager->remove_handler(pinc, TIMER_IRQ)) {
        printf ("remove handler failed.\n");
        notify_completion(false);
    }
    printf("Interrupt handler calls: %d\n", c.get_count());
    printf("Handler after removing previously added functions: %08X\n", final_handler = NVIC_GetVector(TIMER_IRQ));

    if (initial_handler != final_handler) {
        printf( "InteruptManager test failed.\n");
        notify_completion(false);
    }

    while(1);
}
コード例 #2
0
ファイル: main.cpp プロジェクト: ElAbbassi/mbed
int main() {

	initialize_spifi();
	
	// Make sure that cube_image is placed in SPIFI
	if (!IS_ADDR_IN_SPIFI(cube_image)) {
		notify_completion(false);
	}
	
	// Make sure that cube_image_ref is in IFLASH
	if (IS_ADDR_IN_SPIFI(cube_image_ref)) {
		notify_completion(false);
	}
	
	// Compare content
    if (cube_image_sz != cube_image_ref_sz) {
		notify_completion(false);
    } else {
      int i = 0;
      for (; i < cube_image_sz; i++) {
        if (cube_image[i] != cube_image_ref[i]) {
			notify_completion(false);
        }
      }
    }
	
	notify_completion(true);
}
コード例 #3
0
ファイル: main.cpp プロジェクト: CNCBASHER/mbed
int main() {
    SDFileSystem sd(p11, p12, p13, p14, "sd");
    
    FILE *f;
    char* str = TEST_STRING;
    char* buffer = (char*) malloc(sizeof(unsigned char)*strlen(TEST_STRING));
    int str_len = strlen(TEST_STRING);
    
    printf("Write files\n");
    char filename[32];
    for (int i=0; i<10; i++) {
        sprintf(filename, "/sd/test_%d.txt", i);
        printf("Creating file: %s\n", filename);
        f = test_open(filename, "w");
        test_write(f, str);
        test_close(f);
    }
    
    printf("List files:\n");
    DIR *d = opendir("/sd");
    if (d == NULL) {
        printf("Error opening directory\n");
        notify_completion(false);
    }
    
    struct dirent *p;
    while((p = readdir(d)) != NULL) {
        printf("%s\n", p->d_name);
    }
    closedir(d);
    
    notify_completion(true);
}
コード例 #4
0
ファイル: main.cpp プロジェクト: 23chrischen/mbed
int main() {
    out = 0; myled = 0;
    //Test falling edges first
    in.rise(NULL);
    in.fall(in_handler);
    flipper();

    if(checks != 5) {
        printf("falling edges test failed: %d\n",checks);
        notify_completion(false);
    }

    //Now test rising edges
    in.rise(in_handler);
    in.fall(NULL);
    flipper();

    if (checks != 10) {
        printf("raising edges test failed: %d\n",checks);
        notify_completion(false);
    }

    //Finally test both
    in.rise(in_handler);
    in.fall(in_handler);
    flipper();

    if (checks != 20) {
        printf("Simultaneous rising and falling edges failed\n");
        notify_completion(false);
    }

    notify_completion(true);
    return 0;
}
コード例 #5
0
ファイル: main.cpp プロジェクト: 23chrischen/mbed
int main()
{
    EthernetInterface eth;
    NTPClient ntp;
    eth.init(); //Use DHCP
    eth.connect();

    // NTP set time
    {
        bool result = true;
        const char *url_ntp_server = "0.pool.ntp.org";
        printf("NTP_SETTIME: Trying to update time... \r\n");
        const int ret = ntp.setTime(url_ntp_server);
        if (ret == 0) {
          time_t ctTime = time(NULL);
          printf("NTP_SETTIME: UTC Time read successfully ... [OK]\r\n");
          printf("NTP_SETTIME: %s\r\n", ctime(&ctTime));
        }
        else {
          printf("NTP_SETTIME: Error(%d) ... [FAIL]\r\n", ret);
          result = false;
        }

        if (result == false) {
            notify_completion(false);
            exit(ret);
        }
    }
    eth.disconnect();
    notify_completion(true);
    return 0;
}
コード例 #6
0
ファイル: main.cpp プロジェクト: SolarTeamEindhoven/mbed
int main()
{
    char sent = 'T', received;

    master.frequency(FREQ);
    slave.frequency(FREQ);
    slave.address(ADDR);

    // First transfer: master to slave
    master.start();
    master.write(ADDR);
    master.write(sent);
    while(slave.receive() != I2CSlave::WriteAddressed);

    slave.read(&received, 1);
    if(sent != received)
    {
        notify_completion(false);
        return 1;
    }
    master.stop();

    // Second transfer: slave to master
    master.start();
    master.write(ADDR | 1);
    while(slave.receive() != I2CSlave::ReadAddressed);

    slave.write(received);
    received = master.read(0);
    master.stop();
    notify_completion(received == sent);
}
コード例 #7
0
ファイル: main.cpp プロジェクト: ElAbbassi/mbed
int main() {
  const int addr = 0xA0;
  const char mark = 0x66;
  char data[3];
  int fw = 0, fr = 0, fc = 0;
  int i2c_stat;
  
  i2c.frequency(i2c_freq_hz);
  
  // Data write
  data[0] = data[1] = 0;
  data[2] = mark;
  if((i2c_stat = i2c.write(addr, data, 3)) != 0) {
    dprintf("Unable to write data to EEPROM (i2c_stat = 0x%02X), aborting\r\n", i2c_stat);
    notify_completion(false);
    return 1;
  }
  // ACK polling (assumes write will be successful eventually)
  while(i2c.write(addr, data, 0) != 0);

  // Data read (actual test)
  for(int i = 0; i < ntests; i ++)
  {
    data[0] = data[1] = 0;
    if((i2c_stat = i2c.write(addr, data, 2, true)) != 0)
    {
      dprintf("Test %d failed at write, i2c_stat is 0x%02X\r\n", i, i2c_stat);
      fw ++;
      continue;
    }
    if(i2c_delay_us != 0)
      wait_us(i2c_delay_us);
    if((i2c_stat = i2c.read(addr, data, 1)) != 0)
    {
      dprintf("Test %d failed at read, i2c_stat is 0x%02X\r\n", i, i2c_stat);
      fr ++;
      continue; 
    }
    if(data[0] != mark)
    {
      dprintf("Test %d failed at data match\r\n", i);
      fc ++;
    }
  }
  dprintf("Test finished.\r\n");
  if(fw + fr + fc == 0)
    dprintf("No failures in %d tests.\r\n", ntests);
  else
  {
    dprintf("Statistics:\r\n");
    dprintf("  Total tests:     %d\r\n", ntests);
    dprintf("  Failed at write: %d\r\n", fw);
    dprintf("  Failed at read:  %d\r\n", fr);
    dprintf("  Data mismatch:   %d\r\n", fc);
    dprintf("  Total failures:  %d\r\n", fw + fr + fc);
    notify_completion(false);
  }

  notify_completion(true);
}
コード例 #8
0
ファイル: main.cpp プロジェクト: ElAbbassi/mbed
static void initialize_spifi(void)
{
  SPIFIobj* obj = (SPIFIobj*)malloc(sizeof(SPIFIobj));
  if (obj == NULL) {
    // Failed to allocate memory for ROM data
	notify_completion(false);
  }
  
  // Turn on SPIFI block as it is disabled on reset
  LPC_SC->PCONP |= 0x00010000;

  // pinsel for SPIFI
  LPC_IOCON->P2_7 = 5; /* SPIFI_CSN @ P2.7 */
  LPC_IOCON->P0_22 = 5; /* SPIFI_CLK @ P0.22 */
  LPC_IOCON->P0_15 = 5; /* SPIFI_IO2 @ P0.15 */
  LPC_IOCON->P0_16 = 5; /* SPIFI_IO3 @ P0.16 */
  LPC_IOCON->P0_17 = 5; /* SPIFI_IO1 @ P0.17 */
  LPC_IOCON->P0_18 = 5; /* SPIFI_IO0 @ P0.18 */
  
  uint32_t spifi_clk_div = (*((volatile uint32_t*)0x400FC1B4)) & 0x1f;
  uint32_t spifi_clk_mhz = (SystemCoreClock / spifi_clk_div) / 1000000;

  const SPIFI_RTNS* _spifi = ROM_DRIVERS_PTR->pSPIFID;

  /* Typical time tCS is 20 ns min, we give 200 ns to be on safer side */
  int rc = _spifi->spifi_init (obj, spifi_clk_mhz/5, S_FULLCLK+S_RCVCLK, spifi_clk_mhz);
  if (rc) {
	// Failed to initialize SPIFI
	notify_completion(false);
  }
}
コード例 #9
0
int main()
{
#if defined(TARGET_KL25Z)
    SDFileSystem sd(PTD2, PTD3, PTD1, PTD0, "sd");
#elif defined(TARGET_nRF51822)
//SDFileSystem sd(p20, p22, p25, p24, "sd");
    SDFileSystem sd(p12, p13, p15, p14, "sd");
#elif defined(TARGET_NUCLEO_F030R8) || \
      defined(TARGET_NUCLEO_F072RB) || \
      defined(TARGET_NUCLEO_F091RC) || \
      defined(TARGET_NUCLEO_F103RB) || \
      defined(TARGET_NUCLEO_F302R8) || \
      defined(TARGET_NUCLEO_F303RE) || \
      defined(TARGET_NUCLEO_F334R8) || \
      defined(TARGET_NUCLEO_F401RE) || \
      defined(TARGET_NUCLEO_F411RE) || \
      defined(TARGET_NUCLEO_L053R8) || \
      defined(TARGET_NUCLEO_L152RE)
    SDFileSystem sd(D11, D12, D13, D10, "sd");
#elif defined(TARGET_LPC1768_MINI_DK2)
    SDFileSystem sd(SD_SDI, SD_SDO, SD_SCK, SD_CS, "sd");
#else
    SDFileSystem sd(p11, p12, p13, p14, "sd");
#endif
    led2 = 1;
    wait(0.5);
    FILE *f;
    char *str = TEST_STRING;
    char *buffer = (char *)malloc(sizeof(unsigned char) * strlen(TEST_STRING));
    int str_len = strlen(TEST_STRING);

    printf("Write files\n");
    char filename[32];
    for (int i = 0; i < 10; i++) {
        sprintf(filename, "/sd/test_%d.txt", i);
        printf("Creating file: %s\n", filename);
        f = test_open(filename, "w");
        led2 = 0;
        test_write(f, str);
        test_close(f);
    }

    printf("List files:\n");
    DIR *d = opendir("/sd");
    if (d == NULL) {
        printf("Error opening directory\n");
        notify_completion(false);
    }

    struct dirent *p;
    while ((p = readdir(d)) != NULL)
        printf("%s\n", p->d_name);
    closedir(d);

    notify_completion(true);
}
コード例 #10
0
int main() {
#if defined(TARGET_LPC1768) || defined(TARGET_LPC2368) || defined(TARGET_LPC11U24) || defined(TARGET_LPC4088)
    PwmOut pwm_p25(p25);
    PwmOut pwm_p26(p26);

    pwm_p25.write(0.75);
    pwm_p26.write(0.50);

    printf("Initialize PWM on pin 25 with duty cycle: %.2f\n", pwm_p25.read());
    printf("Initialize PWM on pin 26 with duty cycle: %.2f\n", pwm_p26.read());

#elif defined(TARGET_KL25Z)
    PwmOut pwm_d2(D2);

    pwm_d2.period_ms(10);
    pwm_d2.write(0.75);
    printf("%.2f\n", pwm_d2.read());

#elif defined(TARGET_KL05Z)
    PwmOut pwm_d2(D3);

    pwm_d2.period_ms(10);
    pwm_d2.write(0.75);
    printf("%.2f\n", pwm_d2.read());
#endif

    notify_completion(true);
}
コード例 #11
0
ファイル: main.cpp プロジェクト: 23chrischen/mbed
int main (void) {
    Thread thread(send_thread);
    bool result = true;
    int result_counter = 0;

    while (true) {
        osEvent evt = queue.get();
        if (evt.status == osEventMessage) {
            message_t *message = (message_t*)evt.value.p;
            const float expected_voltage = CREATE_VOLTAGE(message->counter);
            const float expected_current = CREATE_CURRENT(message->counter);
            // Check using macros if received values correspond to values sent via queue
            bool expected_values = (expected_voltage == message->voltage) &&
                                   (expected_current == message->current);
            result = result && expected_values;
            const char *result_msg = expected_values ? "OK" : "FAIL";
            printf("%3d %.2fV %.2fA ... [%s]\r\n", message->counter,
                                                   message->voltage,
                                                   message->current,
                                                   result_msg);
            mpool.free(message);
            if (result == false || ++result_counter == QUEUE_SIZE) {
                break;
            }
        }
    }
    notify_completion(result);
    return 0;
}
コード例 #12
0
ファイル: main.cpp プロジェクト: jrv/mbed
int main() {
    bool check = true;

    port1.output();
    port2.input();

    port1 = MASK_1;
    wait(0.1);
    if (port2 != MASK_2) check = false;

    port1 = 0;
    wait(0.1);
    if (port2 != 0) check = false;

    port1.input();
    port2.output();

    port2 = MASK_2;
    wait(0.1);
    if (port1 != MASK_1) check = false;

    port2 = 0;
    wait(0.1);
    if (port1 != 0) check = false;

    notify_completion(check);
}
コード例 #13
0
ファイル: main.cpp プロジェクト: 3eggert/mbed
int main() {
    pc.printf("Test the Stream class\n");
    
    printf("connected: %s\n", (semihost_connected()) ? ("Yes") : ("No"));
    
    char mac[16];
    mbed_mac_address(mac); 
    printf("mac address: %02x,%02x,%02x,%02x,%02x,%02x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); 
    
    LocalFileSystem local("local");
    
    FILE *f;
    char* str = TEST_STRING;
    char* buffer = (char*) malloc(sizeof(unsigned char)*strlen(TEST_STRING));
    int str_len = strlen(TEST_STRING);
    
    // Write
    f = test_open("w");
    test_write(f, str, str_len);
    test_close(f);
    
    // Read
    f = test_open("r");
    test_read(f, buffer, str_len);
    test_close(f);
    
    // Check the two strings are equal
    notify_completion((strncmp(buffer, str, str_len) == 0));
}
コード例 #14
0
ファイル: main.cpp プロジェクト: 3eggert/mbed
void test_read(FILE* f, char* str, int str_len) {
    int n = fread(str, sizeof(unsigned char), str_len, f);
    if (n != str_len) {
        printf("Error reading file"NL);
        notify_completion(false);
    }
}
コード例 #15
0
ファイル: main.cpp プロジェクト: 3eggert/mbed
void test_write(FILE* f, char* str, int str_len) {
    int n = fprintf(f, str);
    if (n != str_len) {
        printf("Error writing file"NL);
        notify_completion(false);
    }
}
コード例 #16
0
ファイル: main.cpp プロジェクト: 3eggert/mbed
void test(void const*)  
{    
    VodafoneUSBModem modem;
    bool test = run(modem);
    if(test)
    {
      printf("Test successful\n");
      notify_completion(true);
    }
    else
    {
      printf("Test failed\n");
      notify_completion(false);
    }
    //notify_completion() blocks indefinitely
}
コード例 #17
0
ファイル: main.cpp プロジェクト: ElAbbassi/mbed
int main() {
    char uid[DEVICE_ID_LENGTH + 1] = {0};
    bool result = true;

    const int ret = mbed_interface_uid(uid);
    if (ret == 0) {
        printf("UID: %s\r\n", uid);
    }
    else {
        result = false;
    }

    char mac[6] = {0};  // @param mac A 6-byte array to write the MAC address
    mbed_mac_address(mac);
    printf("MAC Address: %02X:%02X:%02X:%02X:%02X:%02X\r\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);

    if (mac[0] == MAC_VENDOR_ARM_0 &&
        mac[1] == MAC_VENDOR_ARM_1 &&
        mac[2] == MAC_VENDOR_ARM_2) {
        printf("MAC Address Prefix: 00:02:F7, Vendor: ARM\r\n");
    }

    notify_completion(result);
    return 0;
}
コード例 #18
0
ファイル: main.cpp プロジェクト: ElAbbassi/mbed
int main() {
    out = 0;
    wait(0.1);
    if (in != 0) {
        printf("ERROR: in != 0\n");
        notify_completion(false);
    }
    out = 1;
    wait(0.1);
    if (in != 1) {
        printf("ERROR: in != 1\n");
        notify_completion(false);
    }

    notify_completion(true);
}
コード例 #19
0
ファイル: main.cpp プロジェクト: 23chrischen/mbed
int main() {
    bool success = true;
    char buf[] = {3, 2, 1, 4, 5, 6, 7, 8, 9, 10};
    char res[SIZE];

    i2c.write(ADDR, buf, SIZE);
    i2c.read(ADDR, res, SIZE);

    // here should be buf[all]++
    i2c.write(ADDR, res, SIZE);
    i2c.read(ADDR, res, SIZE);

    // here should be buf[all]+=2
    i2c.write(ADDR, res, SIZE);
    i2c.write(ADDR, res, SIZE);

    // here should be buf[all]+=3
    i2c.read(ADDR, res, SIZE);
    i2c.read(ADDR, res, SIZE);

    for(int i = 0; i < SIZE; i++) {
        if (res[i] != (buf[i] + 3)) {
            success = false;
            break;
        }
    }

    notify_completion(success);
}
コード例 #20
0
ファイル: main.cpp プロジェクト: CNCBASHER/mbed
void test_close(FILE* f) {
    int rc = fclose(f);
    if (rc != 0) {
        printf("Error closing file\n");
        notify_completion(false);
    }
}
コード例 #21
0
ファイル: main.cpp プロジェクト: CNCBASHER/mbed
void test_write(FILE* f, const char* str) {
    int n = fprintf(f, str);
    if (n != strlen(str)) {
        printf("Error writing file\n");
        notify_completion(false);
    }
}
コード例 #22
0
ファイル: main.cpp プロジェクト: 23chrischen/mbed
int main() {
    printf("MBED: re-routing stdout to /null\n");
    freopen("/null", "w", stdout);
    printf("MBED: printf redirected to /null\n");   // This shouldn't appear
    // If failure message can be seen test should fail :)
    notify_completion(false);   // This is 'false' on purpose
    return 0;
}
コード例 #23
0
ファイル: main.cpp プロジェクト: 1deus/tmk_keyboard
FILE *test_open(const char *mode) {
    FILE *f = fopen(FILENAME, mode);
    if (f == NULL) {
        printf("Error opening file"NL);
        notify_completion(false);
    }
    return f;
}
コード例 #24
0
ファイル: main.cpp プロジェクト: Parthasarathy/mbed
int main() {
    int data = 0;
    int res = 0;

    for(int i = 0; i < 30; i++) {

        cs = 0;
        res = spi.write(data++);
        cs = 1;

        wait_ms(0.001);

        if ((i > 1) && ((res + 2) != data))
            notify_completion(false);
    }

    notify_completion(true);
}
コード例 #25
0
ファイル: main.cpp プロジェクト: Illuminux/mbed
int main() {
    port_out = MASK_1;
    wait(0.1);
    int value = port_in.read();
    if (value != MASK_2) {
        printf("[Test high] expected (0x%x) received (0x%x)\n", MASK_2, value);
        notify_completion(false);
    }
    
    port_out = 0;
    wait(0.1);
    value = port_in.read();
    if (value != 0) {
        printf("[Test low] expected (0x%x) received (0x%x)\n", 0, value);
        notify_completion(false);
    }
    
    notify_completion(true);
}
コード例 #26
0
ファイル: main.cpp プロジェクト: GvoOjeda/mbed
int main()
{
    float t = temperature.read();

    printf("TMP102: Temperature: %f\n\r", t);
    // In our test environment (ARM office) we should get a temperature within
    // the range ]15, 30[C
    bool result = (t > 15.0) && (t < 30.0);
    notify_completion(result);
}
コード例 #27
0
ファイル: main.cpp プロジェクト: CNCBASHER/mbed
FILE* test_open(char* path, const char* mode) {
    FILE *f;
    f = fopen(path, mode);
    if (f == NULL) {
        printf("Error opening file\n");
        notify_completion(false);
    }
    
    return f;
}
コード例 #28
0
ファイル: main.cpp プロジェクト: ElAbbassi/mbed
int main (void) {
    char c;
    initial_stack_p = &c;
    
    initial_heap_p = (char*)malloc(1);
    if (initial_heap_p == NULL) {
        printf("Unable to malloc a single byte\n");
        notify_completion(false);
    }
    
    printf("Initial stack/heap geometry:\n");
    printf("   stack pointer:V %p\n", initial_stack_p);
    printf("   heap pointer :^ %p\n", initial_heap_p);
    
    initial_heap_p++;
    stack_test(initial_heap_p);
    
    notify_completion(true);
}
コード例 #29
0
ファイル: main.cpp プロジェクト: barroque/mbed
void sd_thread(void const *argument) {
#if defined(TARGET_KL25Z)
    SDFileSystem sd(PTD2, PTD3, PTD1, PTD0, "sd");
#else
    SDFileSystem sd(p11, p12, p13, p14, "sd");
#endif
    FILE *f = fopen("/sd/out.txt", "w");

    // allocate buffers
    uint8_t data_written[SIZE];
    uint8_t data_read[SIZE];

    // fill data_written buffer with random data
    // write these data into the file
    printf("written: [");
    for (int i = 0; i < SIZE; i++) {
        data_written[i] = rand() % 0xff;
        fprintf(f, "%c", data_written[i]);
        printf("%d ", data_written[i]);
    }
    printf("]\r\nclosing\r\n");
    fclose(f);

    // read back the data from the file and store them in data_read
    f = fopen("/sd/out.txt", "r");
    printf("read: [");
    for (int i=0; i<SIZE; i++) {
        data_read[i] = fgetc(f);
        printf("%d ", data_read[i]);
    }
    printf("]\r\nclosing\r\n");
    fclose(f);

    // check that the data written == data read
    for (int i = 0; i < SIZE; i++) {
        if (data_written[i] != data_read[i]) {
            notify_completion(false);
        }
    }
    notify_completion(true);
}
コード例 #30
0
ファイル: main.cpp プロジェクト: 1deus/tmk_keyboard
int main()
{
    notify_start();
    
    for (i=0; i<=65535; i++) {
        bus1 = i;
        bus2 = i;
        wait(0.0001);
    }
    
    notify_completion(true);
}