/branches/wireless/code/projects/unit_tests/xbee.c - Diff - Colony - Robotics Club

Revision 1638

Added by David Schultz about 14 years ago

wireless: fixed API mode 1. Can now enter and exit API mode properly. Can also set and read MY address.

     /* API Mode Functions */
     //TODO: does this exist?  static int8_t xbee_handle_packet(uint8_t* packet, uint16_t len);
     static int8_t xbee_handle_at_command_response(uint16_t command, uint8_t result, uint8_t len);
     static int8_t xbee_handle_at_command_response(uint16_t command, uint8_t status, uint8_t len);
     static void xbee_handle_status(uint8_t status);
     static int8_t xbee_verify_checksum(uint8_t* packet, uint16_t len);
     static uint8_t xbee_compute_checksum(uint8_t* packet, uint16_t len);
-...
     static uint8_t xbee_basic_buf[PACKET_BUFFER_SIZE];
     // beginning of first packet in basic buffer
     static uint8_t basic_buf_first = 0;
     static uint8_t basic_buf_first = 0xFF;
     // byte after end of last packet in basic buffer (only access < basic_buf_last)
     // aka, the first free byte in basic buffer
-...
     static uint8_t xbee_other_buf[PACKET_BUFFER_SIZE];
     // beginning of first packet in other buffer
     static uint8_t other_buf_first = 0;
     static uint8_t other_buf_first = 0xFF;
     // byte after end of last packet in other buffer (only access < other_buf_last)
     // aka, the first free byte in other buffer
-...
     uint8_t xbee_status = XBEE_NOT_INITD;
     // xbee command response (for PAN, channel, address, etc)
     static uint8_t xbee_command[4];
     static uint8_t xbee_command[8];
     // external ack handler (wireless_send.c)
     void ackhandle(uint8_t num,uint8_t val) { return; } // disabled
     // message buffer
     uint8_t step=99;
     uint8_t message[100];
-...
      **/
     //#ifndef FIREFLY
     #ifndef FIREFLY
     #define PORT UDR1
     #define FLAG RXC1
     #define FLAG (UCSR1A & (1<<RXC1))
     ISR(USART1_RX_vect) {
     //#else
     //#define PORT UDR0
     //#define FLAG RXC0
     //SIGNAL(SIG_USART0_RECV)
     //#endif
       step=0;
     #else
     #define PORT UDR0
     #define FLAG (UCSR0A & (1<<RXC0))
     SIGNAL(SIG_USART0_RECV)
     #endif
       // start of frame
       uint8_t apitype = PORT; // get frame start byte
       uint16_t i=0;
       uint16_t len=0;
       usb_puts("xbee_interrupt");
       step=0;
       WL_DEBUG_PRINT("in interrupt|status=");
       /*WL_DEBUG_PRINT("in interrupt|status=");
       WL_DEBUG_PRINT_HEX(xbee_status);
       WL_DEBUG_PRINT("|frame_start=");
       WL_DEBUG_PRINT_HEX(apitype);
-...
         WL_DEBUG_PRINT("|API ON");
       } else {
         WL_DEBUG_PRINT("|API ERROR");
+      }
       }*/
       // check that we're in API mode
       if (getStatus(XBEE_API_MASK) == XBEE_API_OFF || apitype != XBEE_FRAME_START) {
         // not in API mode
         WL_DEBUG_PRINT("|api off branch");
         step=1;
         if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_WAIT) {
           // get rest of command and put in basic buf
           xbee_basic_buf[i] = apitype;
-...
                 xbee_basic_buf[i] = PORT;
                 if (xbee_basic_buf[i] == '\r')
                   break;
                 i++;
+              }
               i++;
+            }
+          }
           WL_DEBUG_PRINT("got packet, len=");
           WL_DEBUG_PRINT_INT(i);
           WL_DEBUG_PRINT("str=");
           WL_DEBUG_PRINT(xbee_basic_buf);
           step=2;
           // signal handler that command response is done
           setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_RESPONSE);
+        }
         WL_DEBUG_PRINT("return\r\n");
         step=3;
         return;
+      }
       WL_DEBUG_PRINT("|api on branch");
       step=10;
       //WL_DEBUG_PRINT("|api on branch");
       // get length and type
       apitype = 0;
       while((len==0 && i<100)||i<(len+3)) {
       char buf[100];
       uint8_t buf_pos = 18;
       while(i<3) {
         if (FLAG) {
           if (i==0) {
             len |= PORT<<8;
             //WL_DEBUG_PRINT("|len_hi:0x");
             //WL_DEBUG_PRINT_HEX(PORT);
             buf[0] = 'l';
             buf[1] = 'e';
             buf[2] = 'n';
             buf[3] = '_';
             buf[4] = 'h';
             buf[5] = 'i';
             buf[6] = '|';
             //WL_DEBUG_PRINT("|len_hi");
           } else if (i==1) {
             len |= PORT;
             //WL_DEBUG_PRINT("|len_low:0x");
             //WL_DEBUG_PRINT_HEX(PORT);
             buf[7] = 'l';
             buf[8] = 'e';
             buf[9] = 'n';
             buf[10] = '_';
             buf[11] = 'l';
             buf[12] = 'o';
             buf[13] = '|';
             //WL_DEBUG_PRINT("|len_lo");
           } else if (i==2) {
             //WL_DEBUG_PRINT("|GOT APITYPE:0x");
             //WL_DEBUG_PRINT_HEX(PORT);
             apitype = PORT;
             buf[14] = 'a';
             buf[15] = 'p';
             buf[16] = 'i';
             buf[17] = '|';
             //WL_DEBUG_PRINT("|GOT APITYPE");
           } else {
             WL_DEBUG_PRINT("|GOT NEXT:0x");
             WL_DEBUG_PRINT_HEX(PORT);
             buf[buf_pos++] = PORT;
             //WL_DEBUG_PRINT("|GOT NEXT");
+          }
           i++;
+        }
+      }
       WL_DEBUG_PRINT("|len=");
       WL_DEBUG_PRINT_INT(len);
       WL_DEBUG_PRINT("|apitype=");
       WL_DEBUG_PRINT_HEX(apitype);
       WL_DEBUG_PRINT("\r\n");
       step=11;
       // do something based on the type
       i=1;
-...
       case XBEE_FRAME_AT_COMMAND_RESPONSE: {
         // AT command response
         if (getStatus(XBEE_COMMAND_MASK) == XBEE_COMMAND_RESPONSE)
           return; // we're currently processing a command, so drop the incoming one
           return; // we're currently processing a command, so drop the incoming one  ***** TODO: we need to read the whole length of the frame to do this right ****
         uint16_t atcommand=0;
         uint8_t ptr=basic_buf_last;
         while(i<len) {
-...
+            }
             i++;
+          }
+        }
         // handle AT command
         xbee_handle_at_command_response(atcommand,apitype,i-5); // TODO: rewrite function
+        }
         // handle AT command
         WL_DEBUG_PRINT("i=");
         WL_DEBUG_PRINT_INT(i);
         WL_DEBUG_PRINT("|len=");
         WL_DEBUG_PRINT_INT(len);
         WL_DEBUG_PRINT("|status:");
         WL_DEBUG_PRINT_INT(apitype);
         WL_DEBUG_PRINT("|atcommand:");
         WL_DEBUG_PRINT_CHAR((uint8_t)(atcommand>>8));
         WL_DEBUG_PRINT_CHAR((uint8_t)(atcommand&0xFF));
         WL_DEBUG_PRINT("|buf=");
         uint8_t ptr2 = basic_buf_last;
         for(uint8_t j=0;j<i;j++)
           WL_DEBUG_PRINT_HEX(xbee_basic_buf_get(&ptr2));
         WL_DEBUG_PRINT("|\r\n");
         xbee_handle_at_command_response(atcommand,apitype,len-5); // TODO: rewrite function
         break; }
       case XBEE_FRAME_TX_STATUS: {
         // TX status
-...
           break;
+        }
+      }
       WL_DEBUG_PRINT("return\r\n");
       step=255;
       buf[buf_pos] = '\0';
       WL_DEBUG_PRINT("xbee_interrupt_api_mode|");
       WL_DEBUG_PRINT(buf);
       WL_DEBUG_PRINT("|len=");
       WL_DEBUG_PRINT_INT(len);
       WL_DEBUG_PRINT("|apitype=");
       WL_DEBUG_PRINT_HEX(apitype);
       WL_DEBUG_PRINT("|return\r\n");
     } // end of interrupt
-...
       // Set startup baud rate of 9600
       // Set frame format: 8data, 1stop bit, asynchronous normal mode
       // Enable receiver and transmitter and the receiving interrupt
     /*#ifdef FIREFLY
       UCSR0A |= (1<<U2X0);
     #ifdef FIREFLY
       UBRR0H = 0x00;
       UBRR0L = 103;
       UCSR0A |= (1<<U2X0);
       UCSR0C |= (1<<UCSZ00) | (1<<UCSZ01);
       UCSR0B |= (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE);
     #else*/
       // Bayboard or robot
     #else
       // Bayboard or robot
       UBRR1H = 0x00; // baud rate
       UBRR1L = 103;  // baud rate
       UCSR1A |= (1<<U2X1); // double transmit speed
-...
       UCSR1B |= (1<<RXEN1)|(1<<TXEN1);
       // Set frame format: 8data, 1stop bit, asynchronous normal mode
       //UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);
       UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);
       //UCSR1C |= (1<<UMSEL1) | (1<<UCSZ10) | (1<<UCSZ11);
       //UCSR1C |= (1 << URSEL) | (1 << UCSZ0) | (1 << UCSZ1);
       UCSR1B |= (1<<RXCIE1);  // enable receive, transmit (1<<RXCIE)
       WL_DEBUG_PRINT("receive interrupt flag=");
       WL_DEBUG_PRINT_HEX(UCSR1B&(1<<RXCIE1));
       WL_DEBUG_PRINT("|\r\n");
     #endif
       sei();
       // enter command mode
-...
       return WL_ERROR_BUAD;
     #endif
     #endif
       // wait one second for the baud change to stabalize
       delay_ms(1000);
       // wait half second for the baud change to stabalize
       delay_ms(500);
       // enter command mode
       WL_DEBUG_PRINT("entering command mode 2\r\n");
-...
       xbee_wait_for_ok();
       WL_DEBUG_PRINT("entered command mode 2\r\n");
       /*if (xbee_enter_api_mode() != 0) {
       if (xbee_enter_api_mode() != 0) {
         WL_DEBUG_PRINT("can't enter api mode\r\n");
         return -1;
       }*/
       xbee_send_string((uint8_t*)"ATAP 1\r");
       xbee_wait_for_ok();
+      }
       /*xbee_send_string((uint8_t*)"ATAP 1\r");
       xbee_wait_for_ok();*/
       WL_DEBUG_PRINT("Entered api mode.\r\n");
       /*WL_DEBUG_PRINT("Entered api mode.\r\n");
       if (xbee_exit_command_mode() != 0) {
         WL_DEBUG_PRINT("can't exit command mode\r\n");
-...
       WL_DEBUG_PRINT_HEX(getStatus(0xFF));
       WL_DEBUG_PRINT("\r\n");
       setStatus(XBEE_API_MASK,XBEE_API_ON); // set status
       setStatus(XBEE_API_MASK,XBEE_API_ON); // set status to API_ON (API mode 1)*/
     #ifdef WL_DEBUG
       if (getStatus(XBEE_API_MASK) == XBEE_API_OFF) {
         WL_DEBUG_PRINT("|API OFF|");
       } else if (getStatus(XBEE_API_MASK) == XBEE_API_ON) {
-...
       } else {
         WL_DEBUG_PRINT("|API ERROR|");
+      }
     #endif
       WL_DEBUG_PRINT("after status=");
       WL_DEBUG_PRINT_HEX(getStatus(0xFF));
       WL_DEBUG_PRINT("\r\n");
       // TODO: we should set the MY address to the robot address from eeprom
       if (xbee_send_modify_at_command((uint8_t*)"MY",(uint8_t*)"4",1) != WL_SUCCESS) {
       uint16_t i=0;
       setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
       uint8_t newmy = 4;
       if (xbee_send_modify_at_command((uint8_t*)"MY",&newmy,1) != WL_SUCCESS) {
         WL_DEBUG_PRINT("setting MY address failed\r\n");
+      }
       // wait for up to 30 ms
       while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 10000) {
         delay_us(1); // wait 3us
+      }
       if (i < 1000 && xbee_command[0] == 'M' && xbee_command[1] == 'Y') {
         WL_DEBUG_PRINT("setting MY address successful\r\n");
       } else
         WL_DEBUG_PRINT("setting MY address failed\r\n");
       setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
       if (xbee_get_address() == WL_ERROR_XBEE_COMMAND_16BIT) {
       uint16_t address = xbee_get_address();
       if (address == WL_ERROR_XBEE_COMMAND_16BIT) {
         WL_DEBUG_PRINT("getting MY address failed\r\n");
+      }
       WL_DEBUG_PRINT("MY address successful\r\n");
       WL_DEBUG_PRINT("MY address:");
       WL_DEBUG_PRINT_HEX((uint8_t)(address>>8));
       WL_DEBUG_PRINT_HEX((uint8_t)(address&0xFF));
       WL_DEBUG_PRINT("\r\n");
         // wait one second for the baud change to stabalize
       delay_ms(500);
       // enter command mode
       WL_DEBUG_PRINT("entering command mode 3\r\n");
       xbee_send_string((uint8_t*)"+++");
       xbee_wait_for_ok();
       WL_DEBUG_PRINT("entered command mode 3\r\n");
       xbee_exit_command_mode();
       return WL_SUCCESS;
+    }
-...
       // Wait until buffer is clear for sending
       // Then load buffer with your character
       WL_DEBUG_PRINT("xbee_putc:");
       /*WL_DEBUG_PRINT("xbee_putc:");
       WL_DEBUG_PRINT_HEX(c);
       WL_DEBUG_PRINT("|\r\n");
       WL_DEBUG_PRINT("|\r\n");*/
     /*#ifdef FIREFLY
     #ifdef FIREFLY
       loop_until_bit_is_set(UCSR0A, UDRE0);
       UDR0 = c;
     #else*/
     #else
       loop_until_bit_is_set(UCSR1A, UDRE1);
       //WL_DEBUG_PRINT_HEX(UCSR1A&TXC1);
       UDR1 = c;
     //#endif
     #endif
       return WL_SUCCESS;
+    }
-...
       if (xbee_send_string((uint8_t*)"ATCN\r") != 0) {
         return WL_ERROR_SEND;
+      }
       xbee_wait_for_ok();
       if (xbee_wait_for_ok() != WL_SUCCESS) {
         WL_DEBUG_PRINT("failed to exit command mode\r\n");
         return WL_ERROR_SEND;
+      }
       return WL_SUCCESS;
+    }
-...
       if (xbee_send_string((uint8_t*)"ATAP 1\r") != 0) {
         return WL_ERROR_SEND;
+      }
       if (xbee_wait_for_ok() != 0) {
       if (xbee_wait_for_ok() != WL_SUCCESS) {
         WL_DEBUG_PRINT("failed to enter API mode\r\n");
         return WL_ERROR_SEND;
+      }
       if (xbee_exit_command_mode() != WL_SUCCESS) {
         WL_DEBUG_PRINT("failed to enter API mode\r\n");
         return WL_ERROR_SEND;
+      }
       WL_DEBUG_PRINT("got OK after entering API mode\r\n");
       setStatus(XBEE_API_MASK,XBEE_API_ON); // set status
       return WL_SUCCESS;
+    }
-...
       if (xbee_send_string((uint8_t*)"ATAP 2\r") != 0) {
         return WL_ERROR_SEND;
+      }
       if (xbee_wait_for_ok() != 0) {
       if (xbee_wait_for_ok() != WL_SUCCESS) {
         WL_DEBUG_PRINT("failed to enter API mode2\r\n");
         return WL_ERROR_SEND;
+      }
       if (xbee_exit_command_mode() != WL_SUCCESS) {
         WL_DEBUG_PRINT("failed to enter API mode2\r\n");
         return WL_ERROR_SEND;
+      }
       WL_DEBUG_PRINT("got OK after entering API mode2\r\n");
       setStatus(XBEE_API_MASK,XBEE_API_ESCAPE); // set status
-...
       int16_t i=0;
       // change status to command wait
       setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
       xbee_send_modify_at_command((uint8_t*)"AP",(uint8_t*)"0",1); // send command
       if (xbee_send_modify_at_command((uint8_t*)"AP",(uint8_t*)(&i),1) != WL_SUCCESS) { // send command
         WL_DEBUG_PRINT("error sending AP 0 command\r\n");
         setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
         return WL_ERROR_XBEE_COMMAND;
+      }
       // wait for up to 30 ms
       while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 10000) {
         delay_us(1); // wait 3us
-...
         WL_DEBUG_PRINT("failed to exit API mode\r\n");
         i = WL_ERROR_XBEE_COMMAND; // set error code
+      }
       setStatus(XBEE_API_MASK,XBEE_API_OFF); // reset status
       setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
       setStatus(XBEE_API_MASK,XBEE_API_OFF);
       return (int8_t)i; // return
+    }
-...
      **/
     static int8_t xbee_wait_for_ok()
+    {
       return xbee_wait_for_string((uint8_t*)"OK\r", 3);
       //delay_ms(1000);
       //return WL_SUCCESS;
       return xbee_wait_for_string((uint8_t*)"OK", 2);
+    }
     /**
-...
         setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // clear status
+      }
       WL_DEBUG_PRINT("|\r\ndone waiting for string. interrupt status=");
       WL_DEBUG_PRINT_INT(step);
       WL_DEBUG_PRINT("\r\n");
       WL_DEBUG_PRINT("done waiting for string.\r\n");
       return 0;
+    }
     /**
      * Delay until we receive a command response.
      * (either OK\r or some actual value)
      * Then copy the response to S and set the len
+     *
      * Only works when not in API mode
+     *
-...
           i=strcspn((char*)xbee_basic_buf,"\r");
           if (i<PACKET_BUFFER_SIZE) {
             memcpy(s,xbee_basic_buf,i);
             len = i;
             setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // clear response
             return 0;
+          }
-...
       //packet prefix
       if (xbee_putc(XBEE_FRAME_START) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc((uint8_t)((len & 0xFF00) >> 8)) != WL_SUCCESS)
       if (xbee_putc((uint8_t)(len>>8)) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_putc((uint8_t)(len & 0x00FF)) != WL_SUCCESS)
       if (xbee_putc((uint8_t)(len&0xFF)) != WL_SUCCESS)
         return WL_ERROR_SEND;
       if (xbee_send(buf, len) != WL_SUCCESS)
-...
      * @param result 0 for success, 1 for an error
      * @param len the length in bytes of extra
      **/
     static int8_t xbee_handle_at_command_response(uint16_t command, uint8_t result, uint8_t len)
     static int8_t xbee_handle_at_command_response(uint16_t command, uint8_t status, uint8_t len)
+    {
       WL_DEBUG_PRINT("HANDLE AT COMMAND\r\ninterrupt status=");
       WL_DEBUG_PRINT_INT(step);
       WL_DEBUG_PRINT("\r\n");
       if (result == 1)
       WL_DEBUG_PRINT("HANDLE AT COMMAND\r\n");
       if (status != 0)
+      {
         WL_DEBUG_PRINT("Error with AT");
         WL_DEBUG_PRINT(command);
         WL_DEBUG_PRINT(" packet. Result = ");
         switch(result) {
         switch(status) {
         case 1:
           WL_DEBUG_PRINT("ERROR\r\n");
           break;
-...
         return WL_SUCCESS;
+      }
       WL_DEBUG_PRINT("AT");
       WL_DEBUG_PRINT(command);
       WL_DEBUG_PRINT(" command was successful.\r\n");
       WL_DEBUG_PRINT_CHAR((uint8_t)(command>>8));
       WL_DEBUG_PRINT_CHAR((uint8_t)(command));
       WL_DEBUG_PRINT(" command is being handled\r\n");
       // TODO: program more command responses here (ND, etc)
       switch(command) {
       case ('I'<<8)+'D': // PAN
       case ('C'<<8)+'H': // channel
       case ('M'<<8)+'Y': // address
       case ('A'<<8)+'P': // api mode
         // copy command to handler
         xbee_command[0] = (command&0xFF00)>>8;
         xbee_command[1] = command&0x00FF;
         result = basic_buf_last;
         for(command=2;command<len+2;command++)
           xbee_command[command] = xbee_basic_buf_get(&result);
         uint8_t ptr = basic_buf_last;
         for(command=2;command<len+2;command++) {
           xbee_command[command] = xbee_basic_buf_get(&ptr);
           if (xbee_command[command] == '\r')
             break; // done with command
           WL_DEBUG_PRINT_HEX(xbee_command[command]);
+        }
         xbee_command[command] = '\0';
         WL_DEBUG_PRINT("len=");
         WL_DEBUG_PRINT_INT(len);
         WL_DEBUG_PRINT("ID,CH,or MY command result:");
         WL_DEBUG_PRINT(xbee_command);
         WL_DEBUG_PRINT("\r\n");
         break;
       default:
         WL_DEBUG_PRINT("unknown AT command");
+      }
       // signal handler that command response is done
       setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE);
       setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_RESPONSE);
       return WL_SUCCESS;
+    }
-...
       uint16_t i=0;
       // change status to command wait
       WL_DEBUG_PRINT("\r\nbefore status=");
       /*WL_DEBUG_PRINT("\r\nbefore status=");
       WL_DEBUG_PRINT_HEX(getStatus(0xFF));
       WL_DEBUG_PRINT("\r\n");
       WL_DEBUG_PRINT("\r\n");*/
       setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_WAIT);
       if (getStatus(XBEE_API_MASK) == XBEE_API_OFF) {
       /*if (getStatus(XBEE_API_MASK) == XBEE_API_OFF) {
         WL_DEBUG_PRINT("|API OFF|");
       } else if (getStatus(XBEE_API_MASK) == XBEE_API_ON) {
         WL_DEBUG_PRINT("|API ON|");
-...
+      }
       WL_DEBUG_PRINT("after status=");
       WL_DEBUG_PRINT_HEX(getStatus(0xFF));
       WL_DEBUG_PRINT("\r\n");
       WL_DEBUG_PRINT("\r\n");*/
       xbee_send_read_at_command((uint8_t*)"MY"); // send command to get the address
       // wait for up to 30 ms
       while(getStatus(XBEE_COMMAND_MASK) != XBEE_COMMAND_RESPONSE && i++ < 10000) {
         delay_us(1); // wait 3us
+      }
       if (i < 1000 && xbee_command[0] == 'M' && xbee_command[1] == 'Y')
         i = (xbee_command[2]<<8)+xbee_command[3]; // get address
       else
       if (i < 1000 && xbee_command[0] == 'M' && xbee_command[1] == 'Y') {
         i = (xbee_command[2]<<8) | (xbee_command[3]);
       } else
         i = WL_ERROR_XBEE_COMMAND_16BIT; // set error code
       setStatus(XBEE_COMMAND_MASK,XBEE_COMMAND_NONE); // reset status
       WL_DEBUG_PRINT("get MY address, interrupt status=");
       WL_DEBUG_PRINT_INT(step);
       WL_DEBUG_PRINT("\r\n");
       WL_DEBUG_PRINT("get MY address\r\n");
       return i; // return
+    }

Also available in: Unified diff

Project

General

Profile

Colony

Revision 1638