自学教程：C++ FSTR函数代码示例

    void MTD_FLASHMEM HTTPGPIOResponseHTML::flush()    {        setStatus(STR_200_OK);        addHeader(STR_Content_Type, STR_TEXTHTML);        char const* cmd = getRequest().query[FSTR("cmd")];        if (cmd && f_strcmp(cmd, FSTR("set")) == 0)        {            // set gpio            HTTPHelperConfiguration::GPIOSetValue(this);        }        else if (cmd && f_strcmp(cmd, FSTR("conf")) == 0)        {            // conf gpio            HTTPHelperConfiguration::GPIOConf(this);        }                char const* gpio = getRequest().query[STR_gpio];        if (gpio)        {            uint8_t gpion = strtol(gpio, NULL, 10);            addContent(GPIO(gpion).read()? STR_1 : STR_0);        }                HTTPResponse::flush();    }

static int enumerate(struct usb_host_device_t *device_p){    struct usb_descriptor_interface_t *int_desc_p;    std_printf(FSTR("Enumerating a MASS_STORAGE device./r/n"));    int_desc_p = usb_desc_get_interface(device_p->descriptors.buf,                                        device_p->descriptors.size,                                        1,                                        0);    if (int_desc_p == NULL) {        return (-1);    }    if (usb_host_device_set_configuration(device_p, 1) != 0) {        return (-1);    }    get_max_lun(device_p);    scsi_get_inquiry(device_p);    if (scsi_test_unit_ready(device_p) != 0) {        std_printf(FSTR("device is not ready/r/n"));    }    return (0);}

static int get_max_lun(struct usb_host_device_t *device_p){    struct usb_setup_t setup;    uint8_t buf[1];    std_printf(FSTR("get number of LUN:s (logical units) from mass storage device/r/n"));    /* Initiate the setup datastructure. */    setup.request_type = (REQUEST_TYPE_DATA_DIRECTION_DEVICE_TO_HOST                          | REQUEST_TYPE_TYPE_CLASS                          | REQUEST_TYPE_RECIPIENT_INTERFACE);    setup.request = REQUEST_GET_MAX_LUN;    setup.u.base.value = 0;    setup.u.base.index = 0;    setup.length = 1;    if (usb_host_device_control_transfer(device_p,                                         &setup,                                         buf,                                         sizeof(buf)) != sizeof(buf))    {        return (-1);    }    std_printf(FSTR("LUN max = %d/r/n"), buf[0]);    /* Save the max LUN number. */    //device_p->max_lun = 0;    return (0);}

static int cmd_set_bits_per_sample_cb(int argc,                                      const char *argv[],                                      void *out_p,                                      void *in_p,                                      void *arg_p,                                      void *call_arg_p){    long bits_per_sample;    if (argc != 2) {        std_fprintf(out_p, FSTR("Usage: %s <number of bits>/r/n"),                    argv[0]);        return (-EINVAL);    }    if (std_strtol(argv[1], &bits_per_sample) != 0) {        std_fprintf(out_p, FSTR("Usage: %s <number of bits>/r/n"),                    argv[0]);        return (-EINVAL);    }    if ((bits_per_sample < 0) || (bits_per_sample > 12)) {        std_printf(FSTR("The number of bits per sample bust be "                        "an interger from 0 to 12./r/n"));        return (-EINVAL);    }    return (music_player_set_bits_per_sample(&music_player,                                             bits_per_sample));}

int main(){    int address;    int number_of_slaves;        sys_start();    i2c_module_init();    i2c_init(&i2c, &i2c_0_dev, I2C_BAUDRATE_100KBPS, -1);    i2c_start(&i2c);        std_printf(FSTR("Scanning the i2c bus for slaves.../r/n"                    "/r/n"));    number_of_slaves = 0;        for (address = 0; address < 128; address++) {        if (i2c_scan(&i2c, address) == 1) {            std_printf(FSTR("Found slave with address 0x%x./r/n"), address);            number_of_slaves++;        }    }    std_printf(FSTR("/r/n"                    "Scan complete. Found %d slaves./r/n"), number_of_slaves);        return (0);}

static int cmd_list_cb(int argc,                       const char *argv[],                       void *out_p,                       void *in_p,                       void *arg_p,                       void *call_arg_p){    struct song_t *song_p;    int number;    if (argc != 1) {        std_fprintf(out_p, FSTR("Usage: %s/r/n"), argv[0]);        return (1);    }    /* Write the header. */    std_fprintf(out_p,                FSTR("NUMBER            NAME  LENGTH/r/n"));    /* Iterate over all songs in the ordered hash map. */    for (number = FIRST_SONG_NUMBER;         ((song_p = hash_map_get(&song_map, number)) != NULL);         number++) {        std_fprintf(out_p,                    FSTR("%6d %15s %4d:%02d/r/n"),                    song_p->number,                    song_p->name,                    song_p->minutes,                    song_p->seconds);    }    return (0);}

 void MTD_FLASHMEM HTTPHelperConfiguration::setDateTime(HTTPTemplateResponse* response) {     // set current date and time     char const* dateStr = response->getRequest().form[STR_date];     char const* timeStr = response->getRequest().form[STR_time];     if (dateStr && timeStr)     {         DateTime dt;         dt.decode(dateStr, FSTR("%d/%m/%Y"));         dt.decode(timeStr, FSTR("%H:%M:%S"));         DateTime::setCurrentDateTime(dt);     }          // set timezone and NTP server     char const* tzh = response->getRequest().form[STR_tzh];     char const* tzm = response->getRequest().form[STR_tzm];     char const* ntpsrv = response->getRequest().form[STR_ntpsrv];     if (tzh && tzm)     {         ConfigurationManager::setDateTimeParams(strtol(tzh, NULL, 10),                                                 strtol(tzm, NULL, 10),                                                 ntpsrv? ntpsrv : STR_);                                                                     ConfigurationManager::applyDateTime();     } }

static int storage_init(fat16_read_t *read_p,                        fat16_write_t *write_p,                        void **arg_pp){    std_printf(FSTR("SD storage./r/n"));    std_printf(FSTR("spi bitrate = %lu kbps/r/n"),               2 * 16 * SAMPLES_PER_SOCOND / 1024);    /* Initialize SPI for the SD card. */    spi_init(&spi,             &spi_device[0],             &pin_d53_dev,             SPI_MODE_MASTER,             SPI_SPEED_2MBPS,             0,             1);    sd_init(&sd, &spi);    if (sd_start(&sd) != 0) {        return (-1);    }    std_printf(FSTR("sd card started/r/n"));    *read_p = (fat16_read_t)sd_read_block;    *write_p = (fat16_write_t)sd_write_block;    *arg_pp = &sd;    return (0);}

static int cmd_read_cb(int argc,                       const char *argv[],                       void *out_p,                       void *in_p,                       void *arg_p,                       void *call_arg_p){    int pin;    int value;    if (argc != 2) {        std_fprintf(out_p, FSTR("Usage: %s <pin>/r/n"), argv[0]);        return (-EINVAL);    }    /* Get pin. */    pin = board_pin_string_to_device_index(argv[1]);    if (pin == -1) {        std_fprintf(out_p, FSTR("%s: bad pin/r/n"), argv[1]);                return (-EINVAL);    }    value = pin_device_read(&pin_device[pin]);    if (value == 1) {        std_fprintf(out_p, FSTR("high/r/n"));    } else {        std_fprintf(out_p, FSTR("low/r/n"));    }    return (0);}

    // should be called only after setStatus, addHeader and addContent    void MTD_FLASHMEM HTTPResponse::flush()    {        // status line        m_httpHandler->getSocket()->writeFmt(FSTR("HTTP/1.1 %s/r/n"), m_status);        // HTTPResponse headers        addHeader(FSTR("Connection"), FSTR("close"));			        // user headers        for (uint32_t i = 0; i != m_headers.getItemsCount(); ++i)        {            Fields::Item* item = m_headers[i];            m_httpHandler->getSocket()->writeFmt(FSTR("%s: %s/r/n"), APtr<char>(t_strdup(item->key)).get(), APtr<char>(t_strdup(item->value)).get());        }        // content length header        m_httpHandler->getSocket()->writeFmt(FSTR("%s: %d/r/n/r/n"), STR_Content_Length, m_content.getItemsCount());        // actual content        if (m_content.getItemsCount() > 0)        {			            CharChunksIterator iter = m_content.getIterator();            CharChunkBase* chunk = iter.getCurrentChunk();            while (chunk)            {                m_httpHandler->getSocket()->write((uint8_t const*)chunk->data, chunk->getItems());                chunk = iter.moveToNextChunk();            }            m_content.clear();        }    }

 void MTD_FLASHMEM HTTPHelperConfiguration::getClientModeWiFiParams(HTTPTemplateResponse* response) {     char const* SSID;     char const* securityKey;     ConfigurationManager::getClientParams(&SSID, &securityKey);     response->addParamStr(FSTR("CLPSW"), securityKey);     response->addParamStr(FSTR("CLSSID"), SSID); }

static int scsi_get_inquiry(struct usb_host_device_t *device_p){    struct cbw_t cbw;    struct csw_t csw;    struct scsi_cdb_inquiry_t *cdb_p;    struct scsi_cdb_inquiry_data_t inquiry_data;    std_printf(FSTR("get inquiry/r/n"));    device_p->max_packet_size = 512;    /* Initiate the Command Block Wrapper. */    memset(&cbw, 0, sizeof(cbw));    cbw.signature = CBW_SIGNATURE;    cbw.tag = (uint32_t)device_p;    cbw.data_transfer_length = sizeof(inquiry_data);    cbw.flags = 0x80;    cbw.lun = 0;    cbw.command_block_length = sizeof(*cdb_p);    cdb_p = (struct scsi_cdb_inquiry_t *)cbw.command_block;    cdb_p->operation_code = SCSI_CDB_OPERATION_CODE_INQUIRY;    cdb_p->allocation_length = sizeof(inquiry_data);    /* Write the Command Block Wrapper to the device. */    if (usb_host_device_write(device_p, 2, &cbw, sizeof(cbw))        != sizeof(cbw)) {        std_printf(FSTR("failed to write the command block wrapper./r/n"));        return (-1);    }    /* Read the data from the device. */    if (usb_host_device_read(device_p, 1, &inquiry_data, sizeof(inquiry_data))        != sizeof(inquiry_data)) {        std_printf(FSTR("Failed to read data./r/n"));        return (-1);    }    /* Read the Comand Status Wrapper from the device. */    if (usb_host_device_read(device_p, 1, &csw, sizeof(csw))        != sizeof(csw)) {        return (-1);    }    if (csw.status != CSW_STATUS_PASSED) {        std_printf(FSTR("status = %d/r/n"), csw.status);        return (-1);    }    std_printf(FSTR("version = %d/r/n"), inquiry_data.version);    return (csw.data_residue);}

/** * Print a message after a script has been executed. */static void print_exit_message(int res, const char *prefix_p){    if (res == 1) {        std_printf(FSTR("%s exited normally./r/n/r/n"), prefix_p);    } else if (res & PYEXEC_FORCED_EXIT) {        std_printf(FSTR("%s forced exit./r/n/r/n"), prefix_p);    } else {        std_printf(FSTR("%s exited abnormally./r/n/r/n"), prefix_p);    }}

ssize_t usb_host_class_mass_storage_device_read(    struct usb_host_device_t *device_p,    void *buf_p,    size_t address,    size_t size){    struct cbw_t cbw;    struct csw_t csw;    struct scsi_cdb_read_t *cdb_p;    device_p->max_packet_size = 512;    /* Initiate the Command Block Wrapper. */    memset(&cbw, 0, sizeof(cbw));    cbw.signature = CBW_SIGNATURE;    cbw.tag = (uint32_t)device_p;    cbw.data_transfer_length = size;    cbw.flags = 0x80;    cbw.lun = 0;    cbw.command_block_length = sizeof(*cdb_p);    cdb_p = (struct scsi_cdb_read_t *)cbw.command_block;    cdb_p->operation_code = SCSI_CDB_OPERATION_CODE_READ_10;    cdb_p->logical_block_address = htonl(address / 512);    cdb_p->transfer_length = htons(size / 512);    /* Write the Command Block Wrapper to the device. */    if (usb_host_device_write(device_p, 2, &cbw, sizeof(cbw))        != sizeof(cbw)) {        std_printf(FSTR("failed to write the command block wrapper./r/n"));        return (-1);    }    /* Read the dat from the device. */    if (usb_host_device_read(device_p, 1, buf_p, size) != size) {        std_printf(FSTR("Failed to read data./r/n"));        return (-1);    }    /* Read the Comand Status Wrapper from the device. */    if (usb_host_device_read(device_p, 1, &csw, sizeof(csw))        != sizeof(csw)) {        return (-1);    }    if (csw.status != CSW_STATUS_PASSED) {        std_printf(FSTR("status = %d/r/n"), csw.status);        return (-1);    }    return (size - csw.data_residue);}

/** * The listener thread main function. The listener listens for * connections from clients. */static void *listener_main(void *arg_p){    struct http_server_t *self_p = arg_p;    struct http_server_listener_t *listener_p;    struct http_server_connection_t *connection_p;    struct inet_addr_t addr;    thrd_set_name(self_p->listener_p->thrd.name_p);    listener_p = self_p->listener_p;    if (socket_open_tcp(&listener_p->socket) != 0) {        log_object_print(NULL,                         LOG_ERROR,                         FSTR("Failed to open socket."));        return (NULL);    }    if (inet_aton(listener_p->address_p, &addr.ip) != 0) {        return (NULL);    }    addr.port = listener_p->port;    if (socket_bind(&listener_p->socket, &addr) != 0) {        log_object_print(NULL,                         LOG_ERROR,                         FSTR("Failed to bind socket."));        return (NULL);    }    if (socket_listen(&listener_p->socket, 3) != 0) {        log_object_print(NULL,                         LOG_ERROR,                         FSTR("Failed to listen on socket."));        return (NULL);    }    /* Wait for clients to connect. */    while (1) {        /* Allocate a connection. */        connection_p = allocate_connection(self_p);        /* Wait for a client to connect. */        socket_accept(&listener_p->socket,                      &connection_p->socket,                      &addr);        handle_accept(self_p, connection_p);    }    return (NULL);}

 void MTD_FLASHMEM HTTPHelperConfiguration::setAPWiFiParams(HTTPTemplateResponse* response) {     char const* APCH    = response->getRequest().form[FSTR("APCH")];     char const* APSEC   = response->getRequest().form[FSTR("APSEC")];     if (APCH && APSEC)         ConfigurationManager::setAccessPointParams(response->getRequest().form[FSTR("APSSID")],                                                     response->getRequest().form[FSTR("APPSW")],                                                     strtol(APCH, NULL, 10),                                                    (WiFi::SecurityProtocol)strtol(APSEC, NULL, 10),                                                    response->getRequest().form[FSTR("APHSSID")] != NULL);      }

void MTD_FLASHMEM MultipartFormDataProcessor::handle_DecodingHeaders(char c) {  static char const EOH[4] = {0x0D, 0x0A, 0x0D, 0x0A};  if (c == EOH[substate]) {    ++substate;    if (substate == 2) {      // useful if this is not an EOH to separate headers      headers->append(0x0D, 1);    } else if (substate == 4) {      // end of headers      headers->append(0, 1); // add string terminating zero      // look for "name" parameter      CharChunksIterator keyBegin;      extractParameter(FSTR(" name="), headers->getIterator(), &keyBegin, &nameBegin, &nameEnd);      // look for "filename" parameter      CharChunksIterator filenameBegin, filenameEnd;      if (extractParameter(FSTR(" filename="), headers->getIterator(), &keyBegin, &filenameBegin, &filenameEnd)) {        //// this is a file        // add "filename" to form fields        filenameBegin = getFilename(filenameBegin,                                    filenameEnd); // some browsers send a full path instead of a simple file name (IE)        formfields->add(keyBegin + 1, keyBegin + 9, filenameBegin, filenameEnd);        // extract Content-Type parameter        CharChunksIterator contentTypeBegin, contentTypeEnd;        if (extractParameter(FSTR("Content-Type:"), filenameEnd, &keyBegin, &contentTypeBegin, &contentTypeEnd)) {          // add "Content-Type" to form fields          formfields->add(keyBegin, keyBegin + 12, contentTypeBegin, contentTypeEnd);          // create file          file.create(APtr<char>(t_strdup(filenameBegin, filenameEnd)).get(),                      APtr<char>(t_strdup(contentTypeBegin, contentTypeEnd)).get());          state = GettingFile;        } else {          // missing content-type, cannot get as file!          state = GettingValue;        }      } else {        //// this is a normal field        valueStorage = chunksFactory.add();        state = GettingValue;      }      substate = 0;    }  } else {    // add to headers buffer    headers->append(c, HEADERS_CHUNK_SIZE);    substate = 0;  }}

static int test_sine_440_hz(struct harness_t *harness_p){#if !defined(SKIP_TEST_SINE_440_HZ)        int i;    float sample;    int samples_per_second = (membersof(dac_gen_sine) * 440);    struct dac_driver_t dac;    int total_number_of_samples;    BTASSERT(dac_init(&dac,                      &dac_0_dev,                      &pin_0_dev,                      NULL,                      samples_per_second) == 0);    /* Samples are in the range -1.0 to 1.0. Convert them to the range       0 to AMPLITUDE_MAX. */    for (i = 0; i < membersof(samples); i++) {        sample = dac_gen_sine[i % membersof(dac_gen_sine)];        samples[i] =  AMPLITUDE_MAX * ((sample + 1.0) / 2.0);    }    std_printf(FSTR("Converting %d samples./r/n"), (int)membersof(samples));    BTASSERT(dac_convert(&dac, (uint32_t *)samples, membersof(samples) / 2) == 0);    /* Converting the signal on the DAC0-pin for 5 seconds. */    total_number_of_samples = (5 * samples_per_second);    std_printf(FSTR("Converting %d samples./r/n"),               total_number_of_samples);    for (i = 0; i < total_number_of_samples; i += membersof(samples)) {        BTASSERT(dac_async_convert(&dac,                                   (uint32_t *)samples,                                   membersof(samples) / 2) == 0);        std_printf(FSTR("Samples left = %d/r/n"), total_number_of_samples - i);    }    std_printf(FSTR("Waiting for last samples to be converted/r/n"));    BTASSERT(dac_async_wait(&dac) == 0);        return (0);#else    (void)dac_gen_sine;        return (1);    #endif}

int settings_module_init(void){    /* Return immediately if the module is already initialized. */    if (module.initialized == 1) {        return (0);    }    module.initialized = 1;#if CONFIG_FS_CMD_SETTINGS_LIST == 1    fs_command_init(&module.cmd_list,                    FSTR("/oam/settings/list"),                    cmd_list_cb,                    NULL);    fs_command_register(&module.cmd_list);#endif#if CONFIG_FS_CMD_SETTINGS_RESET == 1    fs_command_init(&module.cmd_reset,                    FSTR("/oam/settings/reset"),                    cmd_reset_cb,                    NULL);    fs_command_register(&module.cmd_reset);#endif#if CONFIG_FS_CMD_SETTINGS_READ == 1    fs_command_init(&module.cmd_read,                    FSTR("/oam/settings/read"),                    cmd_read_cb,                    NULL);    fs_command_register(&module.cmd_read);#endif#if CONFIG_FS_CMD_SETTINGS_WRITE == 1    fs_command_init(&module.cmd_write,                    FSTR("/oam/settings/write"),                    cmd_write_cb,                    NULL);    fs_command_register(&module.cmd_write);#endif    return (settings_port_module_init());}

static int test_create_multiple_files(struct harness_t *harness_p){    struct fat16_file_t file;    char filename[32];    int i;    for (i = 0; i < 32; i++) {        std_sprintf(filename, FSTR("FILE%d.TXT"), i);        std_printf(FSTR("Creating file with name '%s'./r/n"), filename);        BTASSERT(fat16_file_open(&fs, &file, filename, O_CREAT | O_WRITE) == 0);        BTASSERT(fat16_file_close(&file) == 0);    }    return (0);}

	char const* MTD_FLASHMEM ParameterReplacer::replaceTag(char const* curc)	{		char const* tagEnd;		char const* tagStart = extractTagStr(curc, &tagEnd);		if (getChar(tagStart) == '#')		{			// replace multiple parameters ('0param', '1param', ...)			++tagStart;						uint32_t tagLen = tagEnd - tagStart;			char tag[tagLen];			f_memcpy(tag, tagStart, tagLen);			tag[tagLen] = 0;			for (uint32_t index = 0; ; ++index)			{				char const* fulltagname = f_printf(FSTR("%d%s"), index, tag);				Params::Item* item = m_params->getItem(fulltagname);				if (item)					m_result.addChunks(&item->value); // push parameter content				else					break;			}		}		else		{			// replace one parameter			Params::Item* item = m_params->getItem(tagStart, tagEnd);			if (item)								m_result.addChunks(&item->value); // push parameter content		}		return tagEnd + 2;	// bypass "}}"	}

static int test_duty_cycles(struct harness_t *harness_p){    int percentage;    long duty_cycle;    BTASSERT(pwm_soft_start(&pwm_soft[0]) == 0);    BTASSERT(pwm_soft_start(&pwm_soft[1]) == 0);    thrd_sleep_ms(100);    /* Test various duty cycles. */    for (percentage = 0; percentage <= 100; percentage += 10) {        duty_cycle = pwm_soft_duty_cycle(percentage);        BTASSERT(pwm_soft_set_duty_cycle(&pwm_soft[0], duty_cycle) == 0);        BTASSERT(pwm_soft_set_duty_cycle(&pwm_soft[1], duty_cycle) == 0);                std_printf(FSTR("Duty cycle: %ld/r/n"), duty_cycle);        thrd_sleep_ms(100);    }        BTASSERT(pwm_soft_stop(&pwm_soft[0]) == 0);    BTASSERT(pwm_soft_stop(&pwm_soft[1]) == 0);    return (0);}

static int read_initial_request_line(struct socket_t *socket_p,                                     char *buf_p,                                     struct http_server_request_t *request_p){    char *action_p = NULL;    char *path_p = NULL;    char *proto_p = NULL;    *buf_p++ = '/0';    action_p = buf_p;    while (1) {        if (socket_read(socket_p,                        buf_p,                        sizeof(*buf_p)) != sizeof(*buf_p)) {            return (-EIO);        }        buf_p++;        /* The line ending is "/r/n". */        if ((buf_p[-2] == '/r') && (buf_p[-1] == '/n')) {            buf_p[-2] = '/0';            break;        }        /* Action and path has ' ' as terminator. */        if (buf_p[-1] == ' ') {            buf_p[-1] = '/0';            if (path_p == NULL) {                path_p = buf_p;            } else if (proto_p == NULL) {                proto_p = buf_p;            }        }    }    /* A path is required. */    if (path_p == NULL) {        return (-1);    }    log_object_print(NULL,                     LOG_DEBUG,                     FSTR("%s %s %s/r/n"), action_p, path_p, proto_p);    /* Save the action and path in the request struct. */    strcpy(request_p->path, path_p);    if (strcmp(action_p, "GET") == 0) {        request_p->action = http_server_request_action_get_t;    } else if (strcmp(action_p, "POST") == 0) {        request_p->action = http_server_request_action_post_t;    } else {        return (-1);    }    return (0);}

int main(){    sys_start();    uart_soft_init(&uart,                   &pin_d4_dev,                   &pin_d3_dev,                   &exti_d3_dev,                   9600,                   qinbuf,                   sizeof(qinbuf));    fs_command_init(&cmd_at,                    CSTR("/at"),                    cmd_at_cb,                    NULL);    fs_command_register(&cmd_at);    std_printf(FSTR("Welcome to HC-0X configuration tool!/r/n"                    "/r/n"                    "SETUP: Connect pin34 to VCC so the device enters AT mode./r/n"                    "/r/n"                    "Type 'at' to start communicating with the device./r/n"));    shell_init(&shell,               sys_get_stdin(),               sys_get_stdout(),               NULL,               NULL,               NULL,               NULL);    shell_main(&shell);    return (0);}

int test_get_temp(struct harness_t *harness_p){    struct owi_driver_t owi;    struct ds18b20_driver_t ds;    struct owi_device_t devices[4];    char buf[24];    int number_of_sensors;    BTASSERT(owi_init(&owi, &pin_d7_dev, devices, membersof(devices)) == 0);    BTASSERT(ds18b20_init(&ds, &owi) == 0);    time_busy_wait_us(50000);    number_of_sensors = owi_search(&owi);    std_printf(FSTR("number_of_sensors = %d/r/n"), number_of_sensors);    BTASSERT(number_of_sensors == 2);    strcpy(buf, "drivers/ds18b20/list");    BTASSERT(fs_call(buf, NULL, sys_get_stdout(), NULL) == 0);    time_busy_wait_us(50000);    return (0);}

static int test_read_cid(struct harness_t *harness_p){    struct sd_cid_t cid;    static const char *mdt_month[16] = {        "0",        "Jan", "Feb", "Mar", "Apr",        "May", "June", "July", "Aug",        "Sep", "Oct", "Nov", "Dec",        "13", "14", "15"    };    /* Read CID and print it to stdout. */    BTASSERT(sd_read_cid(&sd, &cid) == sizeof(cid));    std_printf(FSTR("cid {/r/n"                    "    manufacturer id = 0x%02x/r/n"                    "    application id = '%c%c'/r/n"                    "    product name = '%c%c%c%c%c'/r/n"                    "    product revision = %02x/r/n"                    "    product serial number = %lu/r/n"                    "    manufacturing date = %s %u/r/n"                    "    crc checksum = 0x%02x/r/n"                    "}/r/n"),               (unsigned int)cid.mid,               cid.oid[0], cid.oid[1],               cid.pnm[0], cid.pnm[1], cid.pnm[2], cid.pnm[3], cid.pnm[4],               cid.prv,               cid.psn,               mdt_month[ntohs(cid.mdt) & 0xf],               2000 + ((ntohs(cid.mdt) >> 4) & 0xff),               cid.crc);    return (0);}

static int test_read_performance(struct harness_t *harness_p){    int i, block, res;    struct time_t start, stop, diff;    float seconds;    unsigned long bytes_per_seconds;    int number_of_blocks = 32;    /* Write reference data to given block and verify that it was       written. */    for (i = 0; i < membersof(buf); i++) {        buf[i] = (i & 0xff);    }    time_get(&start);    /* Write to and read from the first five blocks. */    for (block = 0; block < number_of_blocks; block++) {        BTASSERT((res = sd_read_block(&sd, buf, block)) == SD_BLOCK_SIZE,                 ", res = %d/r/n", res);    }    time_get(&stop);    time_diff(&diff, &stop, &start);    seconds = (diff.seconds + diff.nanoseconds / 1000000000.0f);    bytes_per_seconds = ((SD_BLOCK_SIZE * number_of_blocks) / seconds);    std_printf(FSTR("Read 32 blocks of %d bytes in %f s (%lu bytes/s)./r/n"),               SD_BLOCK_SIZE,               seconds,               bytes_per_seconds);    return (0);}

int test_exti(struct harness_t *harness_p){    int i;    struct exti_driver_t exti;    struct pin_driver_t pin;    pin_init(&pin, &pin_d4_dev, PIN_OUTPUT);    pin_write(&pin, 1);        BTASSERT(exti_init(&exti,                       &exti_d3_dev,                       EXTI_TRIGGER_FALLING_EDGE,                       isr,                       NULL) == 0);    BTASSERT(exti_start(&exti) == 0);    for (i = 0; i < 10; i++) {        pin_write(&pin, 0);        time_busy_wait_us(10000);        pin_write(&pin, 1);        time_busy_wait_us(10000);    }    std_printf(FSTR("flag = %d/r/n"), (int)flag);    BTASSERT(flag == 10);    return (0);}

void MTD_FLASHMEM HTTPHandler::processMultipartFormData(CharChunksIterator headerEnd, int32_t contentLength,                                                        char const *contentType) {  char const *boundary = f_strstr(contentType, FSTR("boundary="));  if (boundary) {    // go to begin of boundary string    boundary += 9;    MultipartFormDataProcessor proc(boundary, &m_request.form);    // consume already received data    CharChunksIterator contentStart = headerEnd;    while (contentStart != CharChunksIterator())      proc.push(*contentStart++);    // consume new data    while (getSocket()->isConnected() && proc.state != MultipartFormDataProcessor::EndOfContent) {      char c;      int32_t bytesRecv = getSocket()->read(&c, 1);      if (bytesRecv <= 0)        break;      proc.push(c);    }    // dispatch must be inside this block, to have MultipartFormDataProcessor content available    dispatch();  } else    dispatch();}

void MTD_FLASHMEM HTTPTemplateResponse::processFileRequest() {  FlashFileSystem::Item file;  if (m_filename && FlashFileSystem::find(m_filename, &file)) {    // found    setStatus(STR_200_OK);    addHeader(STR_Content_Type, FSTR("text/html; charset=UTF-8"));    // replace parameters    m_replacer.start((char const *)file.data, (char const *)file.data + file.datalength, &m_params, NULL);    // is this a specialized file (contains {%..%} blocks)?    if (m_replacer.getBlocks()->getItemsCount() > 0 && m_replacer.getTemplateFilename() != NULL) {      // this is a specialized file      // load template file      file.reset();      if (FlashFileSystem::find(m_replacer.getTemplateFilename(), &file)) {        // replace parameters and blocks of template file        m_templateReplacer.start((char const *)file.data, (char const *)file.data + file.datalength, &m_params,                                 m_replacer.getBlocks());        // flush resulting content        addContent(m_templateReplacer.getResult());        return;      }    } else {      // just flush this file (contains only {{...}} blocks)      addContent(m_replacer.getResult());      return;    }  }  // not found  setStatus(STR_404_Not_Found);}