示例#1
0
文件: usbdbg.c 项目: RayPhon/openmv
void usbdbg_data_in(void *buffer, int length)
{
    switch (cmd) {
        case USBDBG_FW_VERSION: {
            uint32_t *ver_buf = buffer;
            ver_buf[0] = FIRMWARE_VERSION_MAJOR;
            ver_buf[1] = FIRMWARE_VERSION_MINOR;
            ver_buf[2] = FIRMWARE_VERSION_PATCH;
            cmd = USBDBG_NONE;
            break;
        }

        case USBDBG_TX_BUF_LEN: {
            uint32_t tx_buf_len = usbd_cdc_tx_buf_len();
            memcpy(buffer, &tx_buf_len, length);
            cmd = USBDBG_NONE;
            break;
        }

        case USBDBG_TX_BUF: {
            uint8_t *tx_buf = usbd_cdc_tx_buf(length);
            memcpy(buffer, tx_buf, length);
            if (xfer_bytes == xfer_length) {
                cmd = USBDBG_NONE;
            }
            break;
        }

        case USBDBG_FRAME_SIZE:
            memcpy(buffer, fb, length);
            cmd = USBDBG_NONE;
            break;

        case USBDBG_FRAME_LOCK:
            // try to lock FB, return fb hdr if locked
            if (fb->ready && mutex_try_lock(&fb->lock)) {
                fb->lock_tried = 0;
                memcpy(buffer, fb, length);
            } else {
                // no valid frame or failed to lock, return 0
                fb->lock_tried = 1;
                ((uint32_t*)buffer)[0] = 0;
            }
            cmd = USBDBG_NONE;
            break;

        case USBDBG_FRAME_DUMP:
            if (xfer_bytes < xfer_length) {
                memcpy(buffer, fb->pixels+xfer_bytes, length);
                xfer_bytes += length;
                if (xfer_bytes == xfer_length) {
                    mutex_unlock(&fb->lock);
                    cmd = USBDBG_NONE;
                }
            }
            break;

        default: /* error */
            break;
    }
}
示例#2
0
void usbdbg_data_in(void *buffer, int length)
{
    switch (cmd) {
        case USBDBG_FW_VERSION: {
            uint32_t *ver_buf = buffer;
            ver_buf[0] = FIRMWARE_VERSION_MAJOR;
            ver_buf[1] = FIRMWARE_VERSION_MINOR;
            ver_buf[2] = FIRMWARE_VERSION_PATCH;
            cmd = USBDBG_NONE;
            break;
        }

        case USBDBG_TX_BUF_LEN: {
            uint32_t tx_buf_len = usbd_cdc_tx_buf_len();
            memcpy(buffer, &tx_buf_len, sizeof(tx_buf_len));
            cmd = USBDBG_NONE;
            break;
        }

        case USBDBG_TX_BUF: {
            uint8_t *tx_buf = usbd_cdc_tx_buf(length);
            memcpy(buffer, tx_buf, length);
            if (xfer_bytes == xfer_length) {
                cmd = USBDBG_NONE;
            }
            break;
        }

        case USBDBG_FRAME_SIZE:
            // Return 0 if FB is locked or not ready.
            ((uint32_t*)buffer)[0] = 0;
            // Try to lock FB. If header size == 0 frame is not ready
            if (mutex_try_lock(&JPEG_FB()->lock, MUTEX_TID_IDE)) {
                // If header size == 0 frame is not ready
                if (JPEG_FB()->size == 0) {
                    // unlock FB
                    mutex_unlock(&JPEG_FB()->lock, MUTEX_TID_IDE);
                } else {
                    // Return header w, h and size/bpp
                    ((uint32_t*)buffer)[0] = JPEG_FB()->w;
                    ((uint32_t*)buffer)[1] = JPEG_FB()->h;
                    ((uint32_t*)buffer)[2] = JPEG_FB()->size;
                }
            }
            cmd = USBDBG_NONE;
            break;

        case USBDBG_FRAME_DUMP:
            if (xfer_bytes < xfer_length) {
                memcpy(buffer, JPEG_FB()->pixels+xfer_bytes, length);
                xfer_bytes += length;
                if (xfer_bytes == xfer_length) {
                    cmd = USBDBG_NONE;
                    JPEG_FB()->w = 0; JPEG_FB()->h = 0; JPEG_FB()->size = 0;
                    mutex_unlock(&JPEG_FB()->lock, MUTEX_TID_IDE);
                }
            }
            break;

        case USBDBG_ARCH_STR: {
            snprintf((char *) buffer, 64, "%s [%s:%08X%08X%08X]",
                    OMV_ARCH_STR, OMV_BOARD_TYPE,
                    *((unsigned int *) (OMV_UNIQUE_ID_ADDR + 8)),
                    *((unsigned int *) (OMV_UNIQUE_ID_ADDR + 4)),
                    *((unsigned int *) (OMV_UNIQUE_ID_ADDR + 0)));
            cmd = USBDBG_NONE;
            break;
        }

        case USBDBG_SCRIPT_RUNNING: {
            uint32_t *buf = buffer;
            buf[0] = (uint32_t) script_running;
            cmd = USBDBG_NONE;
            break;
        }
        default: /* error */
            break;
    }
}
示例#3
0
void usbdbg_data_in(void *buffer, int length)
{
    switch (cmd) {
        case USBDBG_FW_VERSION: {
            uint32_t *ver_buf = buffer;
            ver_buf[0] = FIRMWARE_VERSION_MAJOR;
            ver_buf[1] = FIRMWARE_VERSION_MINOR;
            ver_buf[2] = FIRMWARE_VERSION_PATCH;
            cmd = USBDBG_NONE;
            break;
        }

        case USBDBG_TX_BUF_LEN: {
            uint32_t tx_buf_len = usbd_cdc_tx_buf_len();
            memcpy(buffer, &tx_buf_len, sizeof(tx_buf_len));
            cmd = USBDBG_NONE;
            break;
        }

        case USBDBG_TX_BUF: {
            uint8_t *tx_buf = usbd_cdc_tx_buf(length);
            memcpy(buffer, tx_buf, length);
            if (xfer_bytes == xfer_length) {
                cmd = USBDBG_NONE;
            }
            break;
        }

        case USBDBG_FRAME_SIZE:
            if (!fb->ready) {
                // Frame not ready return 0
                ((uint32_t*)buffer)[0] = 0;
            } else {
                // Frame ready return header
                ((uint32_t*)buffer)[0] = fb->w;
                ((uint32_t*)buffer)[1] = fb->h;
                ((uint32_t*)buffer)[2] = fb->bpp;
            }
            fb->request = 1;
            cmd = USBDBG_NONE;
            break;

        case USBDBG_FRAME_DUMP:
            if (xfer_bytes < xfer_length) {
                memcpy(buffer, fb->pixels+xfer_bytes, length);
                xfer_bytes += length;
                if (xfer_bytes == xfer_length) {
                    fb->request = 0;
                    cmd = USBDBG_NONE;
                }
            }
            break;

        case USBDBG_SCRIPT_RUNNING: {
            uint32_t *buf = buffer;
            buf[0] = (uint32_t) script_running;
            cmd = USBDBG_NONE;
            break;
        }
        default: /* error */
            break;
    }
}