WebSVN - NaviCtrl - Diff - Rev 201 and 275

 // +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 // +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 // +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // +  POSSIBILITY OF SUCH DAMAGE.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#include <stdio.h>
 #include <string.h>
 #include "91x_lib.h"
 #include "config.h"
 #include "main.h"
 #include "uart1.h"
-#include "usb.h"
 #include "mkprotocol.h"
 #include "waypoints.h"
 #include "gps.h"
 #include "timer1.h"
 #include "uart0.h"
 #include "uart1.h"
 #include "uart2.h"
 #include "menu.h"
+#include "usb.h"
 #define ABO_TIMEOUT 4000 // disable abo after 4 seconds
+u32 USB_AboTimeOut = 0;
+u16 Echo; // 2 bytes recieved will be sent back as echo
+// the primary rx fifo
+#define USB_RX_FIFO_LEN 512
+u8 USB_rxfifobuffer[USB_RX_FIFO_LEN];
-u32 USB_AboTimeOut = 0;
+fifo_t USB_rx_fifo;
 // the tx buffer
 #define USB_TX_BUFFER_LEN  150
 u8 USB_Request_ErrorMessage     = FALSE;
 u8 USB_Request_NewWaypoint      = FALSE;
 u8 USB_Request_ReadWaypoint     = 255;
 u8 USB_Request_Data3D           = FALSE;
 u8 USB_Request_Echo                 = FALSE;
 u8 USB_DisplayKeys = 0;
+u8 USB_DisplayLine                      = 0;
 u8 USB_ConfirmFrame = 0;
 u32 USB_DebugData_Timer = 0;
 u32 USB_DebugData_Interval = 0; // in ms
         GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
         GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
         GPIO_InitStructure.GPIO_Alternate=GPIO_OutputAlt1;
         GPIO_Init (GPIO0, &GPIO_InitStructure);
+        // initialize the rx fifo, block UART IRQ geting a byte from fifo
+        fifo_init(&USB_rx_fifo, USB_rxfifobuffer, USB_RX_FIFO_LEN, NO_ITLine, USBLP_ITLine);
         // initialize txd buffer
         Buffer_Init(&USB_tx_buffer, USB_tbuffer, USB_TX_BUFFER_LEN);
-        // initialize rxd buffer
-        Buffer_Init(&USB_rx_buffer, USB_rbuffer, USB_RX_BUFFER_LEN);
-        PowerOff();
+        // initialize rxd buffer
-        Virtual_Com_Port_Reset();
+        Buffer_Init(&USB_rx_buffer, USB_rbuffer, USB_RX_BUFFER_LEN);
 /**************************************************************/
 /* Process incomming data from debug uart                     */
 /**************************************************************/
 void USB_ProcessRxData(void)
+{
+        u8 c;
         SerialMsg_t SerialMsg;
         Waypoint_t * pWaypoint = NULL;
         // if data in the rxd buffer are not locked immediately return
+        // if rx buffer is not locked
+        if(USB_rx_buffer.Locked == FALSE)
+        {
+                //collect data from primary rx fifo
+                while(fifo_get(&USB_rx_fifo, &c))
+                {
+                        // break if complete frame has been collected
+                        if(MKProtocol_CollectSerialFrame(&USB_rx_buffer, c)) break;
+                }
+        }
-        if((USB_rx_buffer.Locked == FALSE) || (DebugUART != UART1) ) return;
+        if(USB_rx_buffer.Locked == FALSE) return;
         MKProtocol_DecodeSerialFrameHeader(&USB_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
         MKProtocol_DecodeSerialFrameData(&USB_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
     if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250;      // reset SerialTimeout, but not in case of the "ping"
         switch(SerialMsg.Address) // check for Slave Address
+        {
                 case NC_ADDRESS:  // own Slave Address
+                switch(SerialMsg.CmdID)
+                {
+                        case 'z': // connection checker
+                                memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
+                                USB_Request_Echo = TRUE;
-                switch(SerialMsg.CmdID)
+                                break;
                         case 'e': // request for the text of the error status
                                 USB_Request_ErrorMessage = TRUE;
                                         WPList_Clear(); // empty WPList
                                         WPList_Append(pWaypoint);
                                         GPS_pWaypoint = WPList_Begin();
+                                }
                                 break;
-                   /*
-                        case 'u': // redirect debug uart
-                                switch(SerialMsg.pData[0])
-                                {
-                                        case UART_FLIGHTCTRL:
-                                                UART2_Init();                           // initialize UART2 to FC pins
-                                                DebugUART = UART2;
-                                                break;
-                                        case UART_MK3MAG:
-                                                if(FC.Flags & FCFLAG_MOTOR_RUN) break; // not if the motors are running
-                                                UART0_Connect_to_MK3MAG();      // mux UART0 to MK3MAG pins
-                                                GPSData.Status = INVALID;
-                                                DebugUART = UART0;
-                                                break;
-                                        case UART_MKGPS:
-                                                if(FC.Flags & FCFLAG_MOTOR_RUN) break; // not if the motors are running
-                                                UART0_Connect_to_MKGPS();       // connect UART0 to MKGPS pins
-                                                GPSData.Status = INVALID;
-                                                DebugUART = UART0;
-                                                break;
-                                }
-                                break;
-                         */
                         case 'w'://  Append Waypoint to List
+                                {
-                                pWaypoint = (Waypoint_t*)SerialMsg.pData;
+                                        pWaypoint = (Waypoint_t*)SerialMsg.pData;
-                                if(pWaypoint->Position.Status == INVALID)
+                                        if((pWaypoint->Position.Status == INVALID) && (pWaypoint->Index == 0))
-                                {  // clear WP List
+                                        {
-                                        WPList_Clear();
+                                                WPList_Clear();
-                                        GPS_pWaypoint = WPList_Begin();
+                                                GPS_pWaypoint = WPList_Begin();
-                                        //UART1_PutString("\r\nClear WP List\r\n");
+                                                USB_Request_NewWaypoint = TRUE; // return new WP number
+                                        }
-                                else if (pWaypoint->Position.Status == NEWDATA)
+                                        else
-                                {  // app current WP to the list
+                                        {  // app current WP to the list
+                                                if (pWaypoint->Index == (WPList_GetCount() + 1))
+                                                {
-                                        WPList_Append(pWaypoint);
+                                                        WPList_Append(pWaypoint);
-                                        BeepTime = 500;
+                                                        BeepTime = 500;
-                                        //UART1_PutString("\r\nAdd WP to List\r\n");
+                                                        USB_Request_NewWaypoint = TRUE; // return new WP number
+                                                }
+                                        }
+                                }
-                                USB_Request_NewWaypoint = TRUE;
                                 break;
                         case 'x'://  Read Waypoint from List
                                 USB_Request_ReadWaypoint = SerialMsg.pData[0];
                                 USB_ConfirmFrame = ExternControl.Frame;
                                 break;
                         */
                         case 'd': // request for debug data;
                                 USB_DebugData_Interval = (u32) SerialMsg.pData[0] * 10;
-                                USB_AboTimeOut = SetDelay(ABO_TIMEOUT);
                                 if(USB_DebugData_Interval > 0) USB_Request_DebugData = TRUE;
+                                USB_AboTimeOut = SetDelay(ABO_TIMEOUT);
                                 break;
                         case 'c': // request for 3D data;
-                                USB_Data3D_Interval = (u32) SerialMsg.pData[0] * 10;
-                                USB_AboTimeOut = SetDelay(ABO_TIMEOUT);
+                                USB_Data3D_Interval = (u32) SerialMsg.pData[0] * 10;
+                                if(USB_Data3D_Interval > 0) USB_Request_Data3D = TRUE;
-                                if(USB_Data3D_Interval > 0) USB_Request_Data3D = TRUE;
+                                USB_AboTimeOut = SetDelay(ABO_TIMEOUT);
-                                break;
-                        /*
-                        case 'g':// request for external control data
-                                USB_Request_ExternalControl = TRUE;
                                 break;
                         */
+                        case 'h':// reqest for display line
+                                if((SerialMsg.pData[0]& 0x80) == 0x00)// old format
+                                {
+                                        USB_DisplayLine = 2;
+                                        USB_Display_Interval = 0;
+                                }
+                                else
                         case 'h':// reqest for display line
-                                USB_DisplayKeys |= ~SerialMsg.pData[0];
+                                        USB_DisplayKeys |= ~SerialMsg.pData[0];
+                                        USB_Display_Interval = (u32) SerialMsg.pData[1] * 10;
-                                USB_Display_Interval = (u32) SerialMsg.pData[1] * 10;
+                                        USB_DisplayLine = 4;
+                                        USB_AboTimeOut = SetDelay(ABO_TIMEOUT);
                                 USB_AboTimeOut = SetDelay(ABO_TIMEOUT);
                                 USB_Request_Display = TRUE;
                                 break;
                         case 'l':// reqest for display columns
                                 MenuItem = SerialMsg.pData[0];
                                 USB_Request_Display1 = TRUE;
                                 break;
                         case 'o': // request for navigation information
+                        case 'o': // request for navigation information
                                 USB_NaviData_Interval = (u32) SerialMsg.pData[0] * 10;
-                                USB_AboTimeOut = SetDelay(ABO_TIMEOUT);
+                                if(USB_NaviData_Interval > 0) USB_Request_NaviData = TRUE;
-                                if(USB_NaviData_Interval > 0) USB_Request_NaviData = TRUE;
+                                USB_AboTimeOut = SetDelay(ABO_TIMEOUT);
                                 break;
         if (NewState == ENABLE)
         GPIO_WriteBit(GPIO0, GPIO_Pin_1, Bit_RESET);
         else
         GPIO_WriteBit(GPIO0, GPIO_Pin_1, Bit_SET);
+}
+//-----------------------------------------------------------------
+void USB_EnterLowPowerMode(void)
+{
+  /* Set the device state to suspend */
+  bDeviceState = SUSPENDED;
+}
+//-----------------------------------------------------------------
+void USB_LeaveLowPowerMode(void)
+{
+  DEVICE_INFO *pInfo = &Device_Info;
+  /* Set the device state to the correct state */
+  if (pInfo->Current_Configuration != 0)
+  {
+    /* Device configured */
+    bDeviceState = CONFIGURED;
+  }
+  else
+  {
+    bDeviceState = ATTACHED;
+  }
+}
 //-----------------------------------------------------------------
 void USB_PutString(u8 *string)
+{
 /*         Transmit tx buffer via usb                         */
 /**************************************************************/
 void USB_Transmit(void)
 {   // nur blockweises kopieren des sendebuffers, nicht alles mit einem mal
         // if something has to be send and the txd fifo is not full
-        u16 i;
         if(USB_tx_buffer.Locked == TRUE)
+        {
                 if(_GetEPTxStatus(ENDP1) == EP_TX_NAK)
-                //if(_GetEPTxStatus(ENDP1) != EP_TX_VALID) // ready to send
+                {
+                        u16 i;
                         if(USB_tx_buffer.Position < USB_tx_buffer.DataBytes)
+                        {
                                 i = USB_tx_buffer.DataBytes - USB_tx_buffer.Position; // bytes to send
                                 if(i > 64) i = 64; // limit packet size to 64 bytes
                                 UserToPMABufferCopy(&(USB_tx_buffer.pData[USB_tx_buffer.Position]), ENDP1_TXADDR, i);

Subversion Repositories NaviCtrl

(root)/tags/V0.30h/usb.c @ 653 - Rev 201 → 275