void Main_Copy (void) { USB_INT32S fdr; USB_INT32S fdw; USB_INT32U bytes_read; fdr = FILE_Open(FILENAME_R, RDONLY); if (fdr > 0) { fdw = FILE_Open(FILENAME_W, RDWR); if (fdw > 0) { PRINT_Log("Copying from %s to %s...\n", FILENAME_R, FILENAME_W); do { bytes_read = FILE_Read(fdr, UserBuffer, MAX_BUFFER_SIZE); FILE_Write(fdw, UserBuffer, bytes_read); } while (bytes_read); FILE_Close(fdw); } else { PRINT_Log("Could not open file %s\n", FILENAME_W); return; } FILE_Close(fdr); PRINT_Log("Copy completed\n"); } else { PRINT_Log("Could not open file %s\n", FILENAME_R); return; } }
void Main_Write (void) { USB_INT32S fdw; USB_INT32S fdr; USB_INT32U tot_bytes_written; USB_INT32U bytes_written; fdr = FILE_Open(FILENAME_R, RDONLY); if (fdr > 0) { FILE_Read(fdr, UserBuffer, MAX_BUFFER_SIZE); fdw = FILE_Open(FILENAME_W, RDWR); if (fdw > 0) { tot_bytes_written = 0; PRINT_Log("Writing to %s...\n", FILENAME_W); do { bytes_written = FILE_Write(fdw, UserBuffer, MAX_BUFFER_SIZE); tot_bytes_written += bytes_written; } while (tot_bytes_written < WRITE_SIZE); FILE_Close(fdw); PRINT_Log("Write completed\n"); } else { PRINT_Log("Could not open file %s\n", FILENAME_W); return; } FILE_Close(fdr); } else { PRINT_Log("Could not open file %s\n", FILENAME_R); return; } }
DSTATUS disk_initialize ( BYTE drv /* Physical drive nmuber (0..) */ ) { DSTATUS stat = STA_NOINIT; int result; PRINT_Log("disk_initialize for disk %x \n\r",drv); switch (drv) { case ATA : //result = ATA_disk_initialize(); // translate the reslut code here return stat; case MMC : result = MMC_disk_initialize(0); // translate the reslut code here stat = RES_OK ; driveAttached = TRUE ; return stat; case USB : result = USB_disk_initialize(); // translate the reslut code here stat = RES_OK ; driveAttached = TRUE ; return stat; } PRINT_Log("disk_initialize return problem"); return STA_NOINIT; }
void USB_IRQHandler (void) { USB_INT32U int_status; USB_INT32U ie_status; int_status = LPC_USB->HcInterruptStatus; /* Read Interrupt Status */ ie_status = LPC_USB->HcInterruptEnable; /* Read Interrupt enable status */ if (!(int_status & ie_status)) { return; } else { int_status = int_status & ie_status; if (int_status & OR_INTR_STATUS_RHSC) { /* Root hub status change interrupt */ if (LPC_USB->HcRhPortStatus1 & OR_RH_PORT_CSC) { if (LPC_USB->HcRhStatus & OR_RH_STATUS_DRWE) { /* * When DRWE is on, Connect Status Change * means a remote wakeup event. */ HOST_RhscIntr = 1;// JUST SOMETHING FOR A BREAKPOINT } else { /* * When DRWE is off, Connect Status Change * is NOT a remote wakeup event */ if (LPC_USB->HcRhPortStatus1 & OR_RH_PORT_CCS) { if (!gUSBConnected) { HOST_TDControlStatus = 0; HOST_WdhIntr = 0; HOST_RhscIntr = 1; gUSBConnected = 1; } else PRINT_Log("Spurious status change (connected)?\n"); } else { if (gUSBConnected) { LPC_USB->HcInterruptEnable = 0; // why do we get multiple disc. rupts??? HOST_RhscIntr = 0; gUSBConnected = 0; } else PRINT_Log("Spurious status change (disconnected)?\n"); } } LPC_USB->HcRhPortStatus1 = OR_RH_PORT_CSC; } if (LPC_USB->HcRhPortStatus1 & OR_RH_PORT_PRSC) { LPC_USB->HcRhPortStatus1 = OR_RH_PORT_PRSC; } } if (int_status & OR_INTR_STATUS_WDH) { /* Writeback Done Head interrupt */ HOST_TDControlStatus = (TDHead->Control >> 28) & 0xf; HOST_WdhIntr = 1; } LPC_USB->HcInterruptStatus = int_status; /* Clear interrupt status register */ }
void Main_Read (void) { USB_INT32S fdr; USB_INT32U bytes_read; fdr = FILE_Open(FILENAME_R, RDONLY); if (fdr > 0) { PRINT_Log("Reading from %s...\n", FILENAME_R); do { bytes_read = FILE_Read(fdr, UserBuffer, MAX_BUFFER_SIZE); } while (bytes_read); FILE_Close(fdr); PRINT_Log("Read Complete\n"); } else { PRINT_Log("Could not open file %s\n", FILENAME_R); return; } }
void vZigbeeTask( void *pvParameters ) { uint8_t output[100] ; uint8_t length = 0 ; PRINT_Log("vZigbeeTask Starting"); //quick check to see if we have communication or not UART_Init_Zigbee(9600); //lets try to read the version number of the Zigbee //wait for one second vTaskDelay(1000); PRINT_Log("vZigbeeTask Sending +++\n"); //UART_Printf_Zigbee("+++"); UART_PrintChar_Zigbee('+'); vTaskDelay(50); UART_PrintChar_Zigbee('+'); vTaskDelay(50); UART_PrintChar_Zigbee('+'); vTaskDelay(2000); length = UARTReceive_Zigbee(LPC_UART3, output, sizeof(output)); PRINT_Log("Zigbee Message with length %d \n",length); if (length == 0) { UART_PrintChar_Zigbee('+'); vTaskDelay(50); UART_PrintChar_Zigbee('+'); vTaskDelay(50); UART_PrintChar_Zigbee('+'); //check the ok length = UARTReceive_Zigbee(LPC_UART3, output, sizeof(output)); } if(length != 0) { output[length] = '\0'; PRINT_Log("Zigbee Message with length %d and content %s\n",length,output); } PRINT_Log("vZigbeeTask Sending ATVR command to check version number\n"); //read response UART_Printf_Zigbee("ATVL\n"); length = 0; vTaskDelay(100); length = UARTReceive_Zigbee(LPC_UART3, output, sizeof(output)); output[length] = '\0'; PRINT_Log("Zigbee Message with length %d and content %s\n",length,output); // while(1) { vTaskDelay(100); } return ; }
/*********************************************************************//** * @brief This function is the main function where the execution begins * @param[in] None * @return None **********************************************************************/ int main() { int32_t rc; uint32_t numBlks, blkSize; uint8_t buffer[30]; UINT nun; uint8_t inquiryResult[INQUIRY_LENGTH]; FATFS fs; FIL fsrc, fdst; const TCHAR a=1; SystemInit(); debug_frmwrk_init(); print_menu(); Host_Init(); /* Initialize the lpc17xx host controller */ PRINT_Log("Host Initialized\r\n"); PRINT_Log("Connect a Mass Storage device\r\n"); rc = Host_EnumDev(); /* Enumerate the device connected */ PRINT_Log("Á¬½ÓÉ豸\r\n"); if ((rc == USB_HOST_FUNC_OK) && (Host_GetDeviceType() == MASS_STORAGE_DEVICE)) { PRINT_Log("Mass Storage device connected\r\n"); rc = f_mount(&fs,"0:",1); if(rc==0) { rc = f_open(&fdst, "0:read.txt", FA_READ); if(rc==0) { PRINT_Log("open ok\r\n"); f_read (&fdst, buffer, 30, &nun ); PRINT_Log(buffer); f_close(&fdst); } } } else { PRINT_Log("Not a Mass Storage device\n"); return (0); } return 0; }
/* ************************************************************************************************************** * INITIALIZE THE HOST CONTROLLER * * Description: This function initializes lpc17xx host controller * * Arguments : None * * Returns : * ************************************************************************************************************** */ void Host_Init (void) { PRINT_Log("In Host_Init\n"); NVIC_DisableIRQ(USB_IRQn); /* Disable the USB interrupt source */ // turn on power for USB LPC_SC->PCONP |= (1UL<<31); // Enable USB host clock, port selection and AHB clock LPC_USB->USBClkCtrl |= CLOCK_MASK; // Wait for clocks to become available while ((LPC_USB->USBClkSt & CLOCK_MASK) != CLOCK_MASK) ; // it seems the bits[0:1] mean the following // 0: U1=device, U2=host // 1: U1=host, U2=host // 2: reserved // 3: U1=host, U2=device // NB: this register is only available if OTG clock (aka "port select") is enabled!! // since we don't care about port 2, set just bit 0 to 1 (U1=host) LPC_USB->OTGStCtrl |= 1; // now that we've configured the ports, we can turn off the portsel clock LPC_USB->USBClkCtrl &= ~PORTSEL_CLK_EN; // power pins are not connected on mbed, so we can skip them /* P1[18] = USB_UP_LED, 01 */ /* P1[19] = /USB_PPWR, 10 */ /* P1[22] = USB_PWRD, 10 */ /* P1[27] = /USB_OVRCR, 10 */ /*LPC_PINCON->PINSEL3 &= ~((3<<4) | (3<<6) | (3<<12) | (3<<22)); LPC_PINCON->PINSEL3 |= ((1<<4)|(2<<6) | (2<<12) | (2<<22)); // 0x00802080 */ // configure USB D+/D- pins /* P0[29] = USB_D+, 01 */ /* P0[30] = USB_D-, 01 */ LPC_PINCON->PINSEL1 &= ~((3<<26) | (3<<28)); LPC_PINCON->PINSEL1 |= ((1<<26)|(1<<28)); // 0x14000000 PRINT_Log("Initializing Host Stack\n"); Hcca = (volatile HCCA *)(HostBuf+0x000); TDHead = (volatile HCTD *)(HostBuf+0x100); TDTail = (volatile HCTD *)(HostBuf+0x110); EDCtrl = (volatile HCED *)(HostBuf+0x120); EDBulkIn = (volatile HCED *)(HostBuf+0x130); EDBulkOut = (volatile HCED *)(HostBuf+0x140); TDBuffer = (volatile USB_INT08U *)(HostBuf+0x150); /* Initialize all the TDs, EDs and HCCA to 0 */ Host_EDInit(EDCtrl); Host_EDInit(EDBulkIn); Host_EDInit(EDBulkOut); Host_TDInit(TDHead); Host_TDInit(TDTail); Host_HCCAInit(Hcca); Host_DelayMS(50); /* Wait 50 ms before apply reset */ LPC_USB->HcControl = 0; /* HARDWARE RESET */ LPC_USB->HcControlHeadED = 0; /* Initialize Control list head to Zero */ LPC_USB->HcBulkHeadED = 0; /* Initialize Bulk list head to Zero */ /* SOFTWARE RESET */ LPC_USB->HcCommandStatus = OR_CMD_STATUS_HCR; LPC_USB->HcFmInterval = DEFAULT_FMINTERVAL; /* Write Fm Interval and Largest Data Packet Counter */ /* Put HC in operational state */ LPC_USB->HcControl = (LPC_USB->HcControl & (~OR_CONTROL_HCFS)) | OR_CONTROL_HC_OPER; LPC_USB->HcRhStatus = OR_RH_STATUS_LPSC; /* Set Global Power */ LPC_USB->HcHCCA = (USB_INT32U)Hcca; LPC_USB->HcInterruptStatus |= LPC_USB->HcInterruptStatus; /* Clear Interrrupt Status */ LPC_USB->HcInterruptEnable = OR_INTR_ENABLE_MIE | OR_INTR_ENABLE_WDH | OR_INTR_ENABLE_RHSC; NVIC_SetPriority(USB_IRQn, 0); /* highest priority */ /* Enable the USB Interrupt */ NVIC_EnableIRQ(USB_IRQn); PRINT_Log("Host Initialized\n"); }
int32_t MS_ParseConfiguration (void) { volatile uint8_t *desc_ptr; uint8_t ms_int_found; desc_ptr = TDBuffer; ms_int_found = 0; if (desc_ptr[1] != USB_DESCRIPTOR_TYPE_CONFIGURATION) { return (ERR_BAD_CONFIGURATION); } desc_ptr += desc_ptr[0]; while (desc_ptr != TDBuffer + ReadLE16U(&TDBuffer[2])) { // while (desc_ptr != TDBuffer + *((uint16_t *) &TDBuffer[2])) { switch (desc_ptr[1]) { case USB_DESCRIPTOR_TYPE_INTERFACE: /* If it is an interface descriptor */ if (desc_ptr[5] == MASS_STORAGE_CLASS && /* check if the class is mass storage */ desc_ptr[6] == MASS_STORAGE_SUBCLASS_SCSI && /* check if the subclass is SCSI */ desc_ptr[7] == MASS_STORAGE_PROTOCOL_BO) { /* check if the protocol is Bulk only */ ms_int_found = 1; desc_ptr += desc_ptr[0]; /* Move to next descriptor start */ } break; case USB_DESCRIPTOR_TYPE_ENDPOINT: /* If it is an endpoint descriptor */ if ((desc_ptr[3] & 0x03) == 0x02) { /* If it is Bulk endpoint */ if (desc_ptr[2] & 0x80) { /* If it is In endpoint */ EDBulkIn->Control = 1 | /* USB address */ ((desc_ptr[2] & 0x7F) << 7) | /* Endpoint address */ (2 << 11) | /* direction */ (ReadLE16U(&desc_ptr[4]) << 16); /* MaxPkt Size */ desc_ptr += desc_ptr[0]; /* Move to next descriptor start */ } else { /* If it is Out endpoint */ EDBulkOut->Control = 1 | /* USB address */ ((desc_ptr[2] & 0x7F) << 7) | /* Endpoint address */ (1 << 11) | /* direction */ (ReadLE16U(&desc_ptr[4]) << 16); /* MaxPkt Size */ desc_ptr += desc_ptr[0]; /* Move to next descriptor start */ } } else { /* If it is not bulk end point */ desc_ptr += desc_ptr[0]; /* Move to next descriptor start */ } break; default: /* If the descriptor is neither interface nor endpoint */ desc_ptr += desc_ptr[0]; /* Move to next descriptor start */ break; } } if (ms_int_found) { PRINT_Log("Mass Storage device connected\r\n"); return (OK); } else { PRINT_Log("Not a Mass Storage device\r\n"); return (ERR_NO_MS_INTERFACE); } }
/* * This function is called whenever an uIP event occurs (e.g. when * a new connection is established, new data arrives, sent data is * acknowledged, data needs to be retransmitted, etc.), from the * uip_tcp_appcall() callback. */ void ftpd_appcall( void ) { u16_t i; //PRINT_Log("\r\nftpd_appcall\r\n"); /* * First we must check that it is the port we are listening on as * this function will be called for all events on all connections. */ if (uip_conn->lport == HTONS(FTPD_CONTROL_PORT)) { ftpd_appstate_t *s = (ftpd_appstate_t *)uip_conn->appdata; /* * If a new connection we need to check for a few possibilities. */ if (uip_connected()) { PRINT_Log("\r\nNew command connection from IP Address %d.%d.%d.%d:%d", uip_ipaddr1(uip_conn->ripaddr), uip_ipaddr2(uip_conn->ripaddr), uip_ipaddr3(uip_conn->ripaddr), uip_ipaddr4(uip_conn->ripaddr), ntohs(uip_conn->rport)); if (!driveAttached) { PRINT_Log("\r\nNo drive attached!"); // Initialise the ProtoSocket for the 421 message PSOCK_INIT(&s->ps, NULL, 0); // Set the flag to cause it to be sent s->resp421_flag = TRUE; } else { // find a new FTP server structure for (i = 0; i < NUM_FTP_DAEMONS; i++) { if (FTP_UNUSED == ftpd_state[i].state) { break; } } // Check if we found a free ftpd_state if (NUM_FTP_DAEMONS == i) { PRINT_Log("\r\nNo daemons available!"); // Initialise the ProtoSocket for the 421 message PSOCK_INIT(&s->ps, NULL, 0); // Set the flag to cause it to be sent s->resp421_flag = TRUE; } else { PRINT_Log("\r\nFound unused deamon %d", i); s->ftpd_state_ptr = &ftpd_state[i]; // Initialise the FTP Daemon state ftpd_state[i].state = LOGGED_OUT; ftpd_state[i].data_conn = NULL; //ftpd_state[i].clientip = uip_conn->ripaddr; memcpy(ftpd_state[i].clientip,uip_conn->ripaddr,sizeof(uip_ipaddr_t)); ftpd_state[i].clientport = FTPC_DATA_PORT; // Clear the command index down ftpd_state[i].cmd_index = CMD_INDEX_IDLE; // Reset the directory pointer //ftpd_state[i].pCurrent_dir = NULL; // Clear the current path strcpy(ftpd_state[i].Current_path, "/"); // Setup the PASV information ftpd_state[i].pasvflag = FALSE; // Initialise the ProtoSockets and ProtoThread used by the command parser PSOCK_INIT(&ftpd_state[i].cmdpsin, ftpd_state[i].cmdinputbuffer, CMD_BUFFER_SIZE); PT_INIT(&ftpd_state[i].cmdpt); // Clear the 421 response flag s->resp421_flag = FALSE; } } } else if (uip_closed() || uip_aborted() || uip_timedout()) { PRINT_Log("\r\nCommand connection closing"); if (s->ftpd_state_ptr) { PRINT_Log(" for daemon %d", s->ftpd_state_ptr->pasvport - PASV_PORT_OFFSET); // Free up the FTP daemon s->ftpd_state_ptr->state = FTP_UNUSED; s->ftpd_state_ptr = NULL; } } if (s->resp421_flag) { send_421_response(s); } else if (s->ftpd_state_ptr) { handle_cmd_input(s->ftpd_state_ptr); handle_cmd_output(s->ftpd_state_ptr); } } else { //PRINT_Log("\r\nSearch though all the FTPD Structures and see if this one of our data connections."); /* * Search though all the FTPD Structures and see if this one of our data connections. */ u16_t i; for (i = 0; i < NUM_FTP_DAEMONS; i++) { if (ftpd_state[i].data_conn == uip_conn) { if (uip_connected()) { PRINT_Log("\r\nNew active data connection for daemon %d to IP Address %d.%d.%d.%d:%d", i, uip_ipaddr1(uip_conn->ripaddr), uip_ipaddr2(uip_conn->ripaddr), uip_ipaddr3(uip_conn->ripaddr), uip_ipaddr4(uip_conn->ripaddr), ntohs(uip_conn->rport)); PSOCK_INIT(&ftpd_state[i].dataps, ftpd_state[i].datainputbuffer, DATA_BUFFER_SIZE); // Move the state on as required if (WAITING_FOR_CONNECT == ftpd_state[i].state) { ftpd_state[i].state = CONNECT_OK; } } else if (uip_closed() || uip_aborted() || uip_timedout()) { PRINT_Log("\r\nData connection closing for daemon %d", i); if (uip_closed() && (TRANSFER_RECV == ftpd_state[i].state)) { // There may be data in this last packet handle_data_connection(&ftpd_state[i]); // Closing of the connection in a RECV state indicates end of file #if 1 CloseFile(&ftpd_state[i]); #endif //close the file in here PRINT_Log("\r\nFinished file receive for daemon %d", i); ftpd_state[i].state = TRANSFER_DONE; } else if((TRANSFER_LIST == ftpd_state[i].state) || (TRANSFER_SEND == ftpd_state[i].state) || (TRANSFER_RECV == ftpd_state[i].state)) { PRINT_Log("\r\nAborting data transfer for daemon %d", i); ftpd_state[i].state = TRANSFER_ABORT; } ftpd_state[i].data_conn = NULL; } if (ftpd_state[i].data_conn) { handle_data_connection(&ftpd_state[i]); } // Leave the loop early break; } else { // Check for a new connection in Passive mode if(ftpd_state[i].pasvflag && uip_connected() && (ntohs(uip_conn->lport) == ftpd_state[i].pasvport)) { PRINT_Log("\r\nNew passive data connection for daemon %d from IP Address %d.%d.%d.%d:%d", i, uip_ipaddr1(uip_conn->ripaddr), uip_ipaddr2(uip_conn->ripaddr), uip_ipaddr3(uip_conn->ripaddr), uip_ipaddr4(uip_conn->ripaddr), ntohs(uip_conn->rport)); ftpd_state[i].data_conn = uip_conn; PSOCK_INIT(&ftpd_state[i].dataps, ftpd_state[i].datainputbuffer, DATA_BUFFER_SIZE); // Move the state on as required if (WAITING_FOR_CONNECT == ftpd_state[i].state) { ftpd_state[i].state = CONNECT_OK; } handle_data_connection(&ftpd_state[i]); // Leave the loop early break; } } } } }