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);
}