Jump to content

Arch_ETS

Members
  • Content Count

    15
  • Joined

  • Last visited


Reputation Activity

  1. Like
    Arch_ETS reacted to calinp in Tachometer. Resolution vs speed issues.   
    Hi,
    I think that in rpm_fun you should get timestamps to compute the time between sparks instead of counting pulses.
    Anither ideea would be to use pulseIn to get the duration ( measure both high and low pulses). This method will do measurements on differen pulses, but as the engine is a slow system compared to the microcontroller, this should not be a problem.
     
    Calin
  2. Like
    Arch_ETS reacted to Maldrax in Tachometer. Resolution vs speed issues.   
    Try using int instead of float. 
     
    Ex.: float RPM = RPMtemp - RPMtemp/100.0*3.84;
    Try:
     
    int RPM = (RPMtemp - RPMtemp/100.0*3.84)*1000;
     
    And returns to float only on display values if necessary.
     
    float RPM_float;
    RPM_float = RPM/1000;
     
    lcd.print(" RPM=");
        lcd.print(RPM_float);
     
  3. Like
    Arch_ETS reacted to oPossum in Volt/Amp/Watt meter   
    This is a simple voltage and current meter that uses the TI INA219 chip. Voltage measurement range is 0 to 26 volts with 4 mV resolution and current measurement range is -4 to +4 amps with 1 mV resolution (when using a 0.01 ohm shunt). The specs are inferior to a pair of quality multimeters, but it is a fraction of the price and shows wattage in addition to voltage and current. The Nokia 5110 display is used so the firmware could be enhanced to do simple graphing. Sending the measurements to a computer could also be done.
     
    Using the INA219 makes for a very simple circuit.

     
    The normal display is three lines with voltage, amperage and wattage.

     
    Pressing the P1.3 switch will show the 6 registers in the INA219 in hex and signed decimal.

     
    The code is written in C++ and uses templates for the LCD, IIC and INA219. Software SPI and IIC is used for maximum portability.
    vam.zip
  4. Like
    Arch_ETS reacted to MSP430Andy in Poor Man's Command Line Shell   
    Here is my updated Command Line Interface with parameters. (Beta)
    :ugeek:
     

    /*********************************************************************************/ /*! THIS SOFTWARE IS PROVIDED BY THE THE HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 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. THERE ARE BUGS IN ANY SOFTWARE. THERE COULD EVEN BE BUGS IN THIS SOFTWARE??? IF THERE WAS A TIME TO CALL THE BUG EXTERMINATOR, NOW WOULD BE THE TIME TO CALL 1-800-ORKIN. COLONIES OF BUGS ARE HARD TO EXTERMINATE IF YOU LET THEM BREED. IF YOU CAN'T CALL ORKIN JUST FIRE UP THE CCS DEBUGGER AND EXTERMINATE THEM YOURSELF! IF YOU USE THIS SOFTWARE AND YOUR HOUSE BURNS DOWN AND YOUR WIFE AND CHILDREN BECOMES HOMELESS AND WORST OF ALL YOUR DOG DIES, DON'T HOLD ME RESPONSIBLE! YOU CAN USE THIS CODE BUT PLEASE GIVE CREDIT TO THOSE WHO CONTRIBUTED TO IT. PLEASE INCLUDE ALL COPYWRITES HEADERS/FOOTERS IN YOUR SOFTWARE! */ /*********************************************************************************/ /*********************************************************************************/ /*! Author: MSP430Andy Description: LP_2553_Cmd_Line - command line interface or shell or interpreter. Program Revision: 1.0b (beta) Date: 1/30/12 PC Platform: Windows PC/SP3 Development platform: LaunchPad revision 2 firmware. PC compiler used: Eclipse with CCS 4.1 & 5 Configuration setup I/O generated by: GRACE Device used: MSP430G2553 Pin DIP Software Module: USCI_A0 at 9600, 8 N 1 Bugs: 1. Syntax warnings in function printf()? - routine works but there were no errors in CCS 4.1? Code size: 2553 Device: 16K flash, 512 bytes RAM Flash used: xxx k RAM used: xxx bytes (without printf_Test() Program status OK */ /*********************************************************************************/ /*********************************************************************************/ /*! [includes] */ /*********************************************************************************/ #include // GRACE Include #include // Support Include #include // for printF #include /*********************************************************************************/ /*! [Defines] */ /*********************************************************************************/ #ifdef MSP430 static void __inline__ __delay_cycles(register uint16_t n) { // 2553 @ 1 Mhz = 1 usec __delay_cycles(1000); = 1 msec __asm__ __volatile__ ( "1: \n" " dec %[n] \n" " jne 1b \n" : [n] "+r"(n)); } #else #endif // Red LED - on board on LaunchPad #define RED_LED_OFF() P1OUT &= ~BIT0 #define RED_LED_ON() P1OUT |= BIT0 #define RED_LED_FLIP() P1OUT ^= BIT0 // Green LED - on board on LaunchPad #define GRN_LED_OFF() P1OUT &= ~BIT6 #define GRN_LED_ON() P1OUT |= BIT6 #define GRN_LED_FLIP() P1OUT ^= BIT6 #define TX_RX_DIAG 0 // [1 = Toggles LP LEDs rx = grn & tx = red] [0 = all off] - careful for testing only #define SYNC_BYTE 0x7E // 127 dec #define ESCAPE_BYTE 0x7D // 128 dec // Command Line Interface #define PARSE_BUFFER_MAX 16 #define COMMAND_LINE_STYLE 1 // <---<<<< 0 = CLI NO PARAMETERS 1 = CLI with PARAMETERS static char value; static char stack[PARSE_BUFFER_MAX]; static char top; /*********************************************************************************/ /*! [Rx Ring Buffer] */ /*********************************************************************************/ //Ring Buffer #define RING_BUFFER_SIZE 32 char ring_buffer[RING_BUFFER_SIZE]; // usci_A0 rx ring buffer /* Size of RX ring buffer */ #define RING_BUFFER_MASK ( RING_BUFFER_SIZE - 1) #if ( RING_BUFFER_SIZE & RING_BUFFER_MASK ) #error RX ring buffer size is not a power of 2 #endif // Ring Buffer Global Variables int ring_buffer_data_size = 0; // number of chars in buffer int ring_buffer_read_pointer = 0; // indice number of last read char int ring_buffer_write_pointer = 0; // indice number of last written char /*********************************************************************************/ /*! [Printf] */ /*********************************************************************************/ //Printf Functions void printf_putc (unsigned char c); void printf_puts(char *s); void printf(char *, ...); void printf_Test(void); /*********************************************************************************/ /*! [Rx Receive Callback] */ /*********************************************************************************/ // Callbacks static uint8_t dummy_callback( uint8_t ); // default ring buffer callback // Holds pointers to all callback functions for USCI_AO rx buffer static uint8_t (*uart_rx_callback)( uint8_t ) = dummy_callback; /*********************************************************************************/ /*! [Flash Structure] The MSP430G2553 the flash memory is organized as follow: 4 * 64 BYTE BLOCKS = 256 BYTES Flash_ptrA = (char *) 0x10C0; // 10C0-10FF Initialize Flash segment A pointer but never touch this! (calibration constants) Flash_ptrB = (char *) 0x1080; // 1080-10BF Initialize Flash segment B pointer Flash_ptrC = (char *) 0x1040; // 1040-107F Initialize Flash segment C pointer Flash_ptrD = (char *) 0x1000; // 1000-103F Initialize Flash segment D pointer */ /*********************************************************************************/ // We store all the MSPNode RFM12B RF node config data in a structure so that // we can save it in the flash memory. (MSPNode is JeeNode protocol compatible) struct MSPNode { // MSPNode Group ID (1-254) unsigned char grp; // MSPNode Node ID (1-30) unsigned char id; // RFM12B ISM Freq. Band <--- Marked On RFM12B chip! //RF12_433MHZ 1 //RF12_868MHZ 2 //RF12_915MHZ 3 unsigned char band; // RFM12B Central Node ID unsigned char dest; } mspnode = {1,8,3,20}; // <---- init values to write to protected flash segment D (64 bytes total) // ref. only //mspnode.grp //mspnode.id //mspnode.band //mspnode.dest /*********************************************************************************/ /*! [Function Prototypes] */ /*********************************************************************************/ // rx ring buffer prototypes int ring_buffer_full(void); int ring_buffer_empty(void); void ring_buffer_push_char(char c); // to ring buffer unsigned char ring_buffer_pull_char(void); // from ring buffer <------<<<< for rx void flush_ring_buffer(void); // clear ring buffer with spaces 0x20 // usci_a0 uart prototypes void uart_put_char( uint8_t ); // <-------<<<<< for tx void uart_write_buffer( uint8_t*, uint16_t ); void uart_write_buffer_escaped( uint8_t*, uint16_t ); uint8_t hex_to_string( uint8_t* , uint8_t*, uint8_t ); // cmd line with parameters prototypes void cmd_show_help(void); void poll_cmd(void); // cmd line with parameters prototypes void poll_cmd_1(void); void cmd_show_help_1(void); static void parse_Input(char c); // protected flash prototypes // *******DO NOT LOOP THE WRITE FUNCTION - WILL CAUSE FLASH WEAR FAILURES!!!!! ******* void write_P_D_Flash(void); // uses MSPNode data structure (above) void read_P_D_Flash(void); // uses MSPNode data structure (above) void FF_SegD (void); // put FF in all of segment D /*********************************************************************************/ /*! [Main] */ /*********************************************************************************/ void main(void) { CSL_init(); // Activate Grace-generated configuration __enable_interrupt(); // Set global interrupt enable flush_ring_buffer(); // clear receive ring buffer with spaces 0x20 //_________________________________________________________________________________ RED_LED_OFF(); GRN_LED_OFF(); if (COMMAND_LINE_STYLE == 0){ { } cmd_show_help(); // CLI test no parameters } else { cmd_show_help_1(); // CLI test with parameters printf("Cmd >> "); } while(1){ if (COMMAND_LINE_STYLE == 0){ poll_cmd(); // CLI test no parameters } else { poll_cmd_1(); // CLI test with parameters } } } // end of main /*********************************************************************************/ /*! [uART_USCI_A0_RX_ISR] */ /*********************************************************************************/ void UART_USCI_A0_RX_ISR(void){ // Process incoming byte from USART if( IFG2 & UCA0RXIFG ) { // Call rx callback function (default - dummy) or // ring_buffer_callback if selected if( uart_rx_callback( UCA0RXBUF ) ) { // If function returns something nonzero, wakeup the processor //__bic_SR_register_on_exit(LPM1_bits); _nop(); } } } /*********************************************************************************/ /*! [user Application Functions] */ /*********************************************************************************/ /*********************************************************************************/ /*! [uART Functions] */ /*********************************************************************************/ /*********************************************************************************/ /*! @fn uart_put_char( uint8_t character ) @brief transmit single character */ /*********************************************************************************/ void uart_put_char( uint8_t character ) { while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready? UCA0TXBUF = character; if (TX_RX_DIAG){ RED_LED_FLIP(); } } /*********************************************************************************/ /*! @fn uart_write_buffer( uint8_t character ) @brief transmit whole buffer */ /*********************************************************************************/ void uart_write_buffer( uint8_t* buffer, uint16_t length ) { uint16_t buffer_index; for( buffer_index = 0; buffer_index < length; buffer_index++ ) { while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready? UCA0TXBUF = buffer[buffer_index]; } } /*********************************************************************************/ /*! @fn uart_write_buffer_escaped( uint8_t character ) @brief transmit whole buffer while escaping characters The uart_write_buffer_escaped() is more for sending whole packets through the serial peripheral to the computer. Normally you just send a stream of bytes. Unfortunately, there is no way for the computer to know when a stream of data begins or ends. This function uses the 0x7E byte as a start and end of packets. This way, the receiver knows when to begin and end capturing data. If your data contains a 0x7E, that might confuse the receiver, so you must escape it by preceding it with a 0x7D and modifying it. The receiver must be aware of this to process it accordingly. */ /*********************************************************************************/ void uart_write_buffer_escaped( uint8_t* buffer, uint16_t length ) { uint16_t buffer_index; while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready? UCA0TXBUF = SYNC_BYTE; for( buffer_index = 0; buffer_index < length; buffer_index++ ) { if( (buffer[buffer_index] == SYNC_BYTE) | (buffer[buffer_index] == ESCAPE_BYTE) ) { while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready? UCA0TXBUF = ESCAPE_BYTE; while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready? UCA0TXBUF = buffer[buffer_index] ^ 0x20; } else { while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready? UCA0TXBUF = buffer[buffer_index]; } } while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready? UCA0TXBUF = SYNC_BYTE; } /*********************************************************************************/ /*! @fn void dummy_callback( uint8_t rx_char ) @brief empty function works as default callback */ /*********************************************************************************/ static uint8_t dummy_callback( uint8_t rx_char ) { if (TX_RX_DIAG){ GRN_LED_FLIP(); } //uart_put_char(rx_char); // turnaround echo to tx <----- for test only ring_buffer_push_char(rx_char); // Put/push char into ring buffer return 0; } /*********************************************************************************/ /*! @fn uint8_t hex_to_string( uint8_t* buffer_out, uint8_t* buffer_in, uint8_t buffer_in_size ) @brief DEBUG function used to convert hex values to [hex]string format The hex_to_string function was just for debugging. When you want to display a value, you usually use printf(). Unfortunately, printf takes a lot of cycles to format the data, and if you're doing time-sensitive stuff, you can't afford the delay. In cases where you don't have full debugging capability, you might want to print out the values of some registers or variables. the hex_to_string() function converts a value to a hexadecimal string. */ /*********************************************************************************/ uint8_t hex_to_string( uint8_t* buffer_out, uint8_t* buffer_in, uint8_t buffer_in_size ) { static const uint8_t hex_char[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; uint8_t counter = 0; while( counter < buffer_in_size * 2 ) { buffer_out[counter] = hex_char[((buffer_in[(counter>>1)]>>4) & 0xF)]; counter++; buffer_out[counter] = hex_char[(buffer_in[(counter>>1)] & 0xF)]; counter++; } // Terminate string with null character buffer_out[counter++] = 0; return counter; } /*********************************************************************************/ /*! [Printf Functions] */ /*********************************************************************************/ /*********************************************************************************/ /*! @fn void printf_putc (unsigned char c) @brief put char into tx buffer */ /*********************************************************************************/ void printf_putc (unsigned char c) { _nop(); while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready? UCA0TXBUF = c; // TX <-- c } /*********************************************************************************/ /*! @fn void printf_puts(char *s) { while(*s) printf_putc(*s++); @brief put string chars into into tx buffer */ /*********************************************************************************/ void printf_puts(char *s) { while(*s) printf_putc(*s++); } /*********************************************************************************/ /*! @fn @brief */ /*********************************************************************************/ static const unsigned long dv[] = { // 4294967296 // 32 bit unsigned max 1000000000, // +0 100000000, // +1 10000000, // +2 1000000, // +3 100000, // +4 // 65535 // 16 bit unsigned max 10000, // +5 1000, // +6 100, // +7 10, // +8 1, // +9 }; /*********************************************************************************/ /*! @fn @brief */ /*********************************************************************************/ static void xtoa(unsigned long x, const unsigned long *dp) { char c; unsigned long d; if(x) { while(x < *dp) ++dp; do { d = *dp++; c = '0'; while(x >= d) ++c, x -= d; printf_putc(c); } while(!(d & 1)); } else printf_putc('0'); } /*********************************************************************************/ /*! @fn @brief */ /*********************************************************************************/ static void puth(unsigned n) { static const char hex[16] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; printf_putc(hex[n & 15]); } /***********************************************************************************/ /*! @fn @brief */ /***********************************************************************************/ void printf(char *format, ...) { char c; int i; long n; va_list a; va_start(a, format); while(c = *format++) { if(c == '%') { switch(c = *format++) { case 's': // String printf_puts(va_arg(a, char*)); break; case 'c': // Char printf_putc(va_arg(a, char)); break; case 'i': // 16 bit Integer case 'u': // 16 bit Unsigned i = va_arg(a, int); if(c == 'i' && i < 0) i = -i, printf_putc('-'); xtoa((unsigned)i, dv + 5); break; case 'l': // 32 bit Long case 'n': // 32 bit uNsigned loNg n = va_arg(a, long); if(c == 'l' && n < 0) n = -n, printf_putc('-'); xtoa((unsigned long)n, dv); break; case 'x': // 16 bit heXadecimal i = va_arg(a, int); puth(i >> 12); puth(i >> 8); puth(i >> 4); puth(i); break; case 0: return; default: goto bad_fmt; } } else bad_fmt: printf_putc(c); } va_end(a); } /***********************************************************************************/ /*! @fn @brief */ /***********************************************************************************/ void printf_Test(void){ /* ================= Printf() for 2553 ================= There are 7 format specifiers: %c - Character %s - String %i - signed Integer (16 bit) %u - Unsigned integer (16 bit) %l - signed Long (32 bit) %n - uNsigned loNg (32 bit) %x - heXadecimal (16 bit) Field width, floating point and other standard printf() features are not supported. */ const char *s = "test"; const char c = 'X'; const int i = -12345; const unsigned u = 12345; const long int l = -1234567890; const long unsigned n = 1234567890; const unsigned x = 0xABCD ; //hex printf("%s", "\r\n*** printf() test ***\r\n"); printf("String %s\r\n", s); printf("Char %c\r\n", c); printf("Integer %i\r\n", i); printf("Unsigned %u\r\n", u); printf("Long %l\r\n", l); printf("uNsigned loNg %n\r\n", n); printf("heX %x\r\n", x); printf("multiple args %s %c %i %u %l %n %x\r\n", s, c, i, u, l, n, x); printf("\r\n*** Done ***\r\n"); // printf_Test result .... /* *** printf() test *** String test Char X Integer -12345 Unsigned 12345 Long -1234567890 uNsigned loNg 1234567890 heX ABCD multiple args test X -12345 12345 -1234567890 1234567890 ABCD *** Done *** */ } /*********************************************************************************/ /*! [Ring Buffer Functions] */ /*********************************************************************************/ /*********************************************************************************/ /*! @fn void ring_buffer_push_char(char c) @brief adds a char */ /*********************************************************************************/ void ring_buffer_push_char(char c) { // increase ring_buffer_write_pointer, check if at end of array if (++ring_buffer_write_pointer >= RING_BUFFER_SIZE) ring_buffer_write_pointer = 0; ring_buffer[ring_buffer_write_pointer] = c; ring_buffer_data_size++; } /*********************************************************************************/ /*! @fn int ring_buffer_full(void) @brief returns 1 if buffer is full, 0 if buffer is not full */ /*********************************************************************************/ int ring_buffer_full(void) { return ring_buffer_read_pointer == ring_buffer_write_pointer && ring_buffer_data_size == RING_BUFFER_SIZE; } /*********************************************************************************/ /*! @fn int ring_buffer_empty(void) @brief returns 1 if buffer is empty, 0 if buffer is not empty */ /*********************************************************************************/ int ring_buffer_empty(void) { return ring_buffer_read_pointer == ring_buffer_write_pointer && ring_buffer_data_size == 0; } /*********************************************************************************/ /*! @fn void ring_buffer_pull_char(void) @brief pull char from queue */ /*********************************************************************************/ unsigned char ring_buffer_pull_char(void) { char rx; // added - also above unsigned char if (++ring_buffer_read_pointer >= RING_BUFFER_SIZE) ring_buffer_read_pointer = 0; rx = ring_buffer[ring_buffer_read_pointer]; // added // enter space on place of read char so we can see it is removed ring_buffer[ring_buffer_read_pointer] = 0x20; ring_buffer_data_size--; return rx; // added } /*********************************************************************************/ /*! @fn void flush_ring_buffer(void) @brief flushes ring buffer */ /*********************************************************************************/ void flush_ring_buffer(void){ // make sure there are no random chars in array, all spaces int i; for (i = 0; i < RING_BUFFER_SIZE; i++) ring_buffer[i] = 0x20; // spaces } /*********************************************************************************/ /*! [Command Line Functions] */ /*********************************************************************************/ /*********************************************************************************/ /*! @fn void cmd_show_help(void) @brief show cmd line help menu */ /*********************************************************************************/ void cmd_show_help(void) { const char *m0 = "<<--COMMAND LINE MENU-->>"; const char *m1 = "[A] LP Red LED ON"; const char *m2 = "[b] LP Red LED OFF"; const char *m3 = "[C] LP Green LED ON"; const char *m4 = "[D] LP Green LED OFF"; const char *m5 = "[E] Wr Data --> Prot. Flash Seg. D "; const char *m6 = "[F] Rd Data <-- Prot. Flash Seg. D "; const char *m7 = "[G] Wr / CLR Prot. Flash Seg. D with 0xFF"; const char *m8 = "[H] Show Help"; const char *prompt = "Cmd >> "; printf("\r\n"); printf("\r\n"); printf("%s\r\n",m0); printf("\r\n"); printf("%s\r\n",m1); printf("%s\r\n",m2); printf("%s\r\n",m3); printf("%s\r\n",m4); printf("%s\r\n",m5); printf("%s\r\n",m6); printf("%s\r\n",m7); printf("%s\r\n",m8); printf("\r\n"); printf("%s",prompt); } /*********************************************************************************/ /*! @fn void cmd_show_help_1(void) @brief show cmd line help menu */ /*********************************************************************************/ void cmd_show_help_1(void) { const char *m0 = "<<--COMMAND LINE MENU-->>"; const char *m1 = "[A] LP Red LED ON"; const char *m2 = "[b] LP Red LED OFF"; const char *m3 = "[C] Toggle Red & Grn LEDs"; const char *m4 = "[C] P1=1 Red LED ON"; const char *m5 = "[C] P2=2 Grn LED ON"; const char *m6 = "[C] P2=3 Red & Grn LEDs OFF"; const char *m7 = "[H] Show Help"; printf("\r\n"); printf("\r\n"); printf("%s\r\n",m0); printf("\r\n"); printf("%s\r\n",m1); printf("%s\r\n",m2); printf("%s\r\n",m3); printf("%s\r\n",m4); printf("%s\r\n",m5); printf("%s\r\n",m6); printf("%s\r\n",m7); } /*********************************************************************************/ /*! @fn poll_cmd(void) @brief Polls case/switch for keypress */ /*********************************************************************************/ void poll_cmd(void) { const char *FW = " Wr --> prot. flash seg. D ..."; const char *FR = " Rd <-- prot. flash seg. D ..."; const char *FC = " Wr --> prot. flash seg. D with 0xFF ..."; while(1){ char x; if (ring_buffer_data_size > 0){ x = ring_buffer_pull_char(); uart_put_char(x); // return/echo cmd char to uart screen } switch (x){ case 'A': case 'a': _nop(); RED_LED_ON(); _nop(); cmd_show_help(); break; case 'B': case 'b': _nop(); RED_LED_OFF(); _nop(); cmd_show_help(); break; case 'C': case 'c': GRN_LED_ON(); cmd_show_help(); break; case 'D': case 'd': GRN_LED_OFF(); cmd_show_help(); break; case 'E': case 'e': //MSPNode structure ref. only // write flash with MSPNode data mspnode.grp = 1; mspnode.id = 8; mspnode.band = 3; mspnode.dest = 20; write_P_D_Flash(); // uses flash MSPNode data structure (above) printf("%s\r\n", FW ); cmd_show_help(); break; case 'F': case 'f': read_P_D_Flash(); // uses flash MSPNode data structure (above) //MSPNode structure ref. only //mspnode.grp //mspnode.id //mspnode.band //mspnode.dest printf("%s\r\n", FR); printf(" Group ID = %x\r\n", mspnode.grp); printf(" Node ID = %x\r\n", mspnode.id); printf(" Band = %x\r\n", mspnode.band); printf(" Dest ID = %x\r\n", mspnode.dest); printf(" 10 Second Delay ... Please wait ... \r\n"); __delay_cycles(10000000); // 10 secs cmd_show_help(); break; case 'G': case 'g': FF_SegD (); // write 0xFF in all of seg D printf("%s\r\n", FC ); cmd_show_help(); break; case 'H': case 'h': cmd_show_help(); break; //default: } // end of case x = 0x20; // clear case char _nop(); } // end of while } /*********************************************************************************/ /*! @fn parse_Input(char c) @brief parses the user input char(s) and executes the case/switch command Cmd Format: p1,p2,p3,...cCR p1,p2,p3 = 0-255 Max, c is the cmd, chars 'a/A' - 'z/Z' & CR = enter/carriage return Examples: Cmd >> cCR --> will toggle both LEDs (stack[0]) with no other commands Cmd >> 1,0,0,cCR --> will turn on the red LED (stack[0]) Cmd >> 0,2,0,cCR --> will turn on the green LED (stack[1]) Cmd >> 0,0,3,cCR --> will turn off both red / green LEDs (stack[2]) */ /*********************************************************************************/ static void parse_Input(char c){ const char *status0 = "Toggle Red & Green LEDs "; const char *status1 = "Red LED ON "; const char *status2 = "Green LED ON "; const char *status3 = "Red & Green LEDs OFF "; char cr = NULL; uart_put_char(c); // return/echo char to uart screen if ('0' <= c && c <= '9') value = 10 * value + c - '0'; else if (c == ',') { if (top < sizeof stack) stack[top++] = value; value = 0; _nop(); } else if (('a' <= c && c <='z') || ('A' <= c && c <='Z')) { stack[top++] = c; // store command on stack while (!(cr == 0x0D)){ // wait for CR 0x0D if (ring_buffer_data_size > 0) // data available cr = ring_buffer_pull_char(); __delay_cycles(1000); // 1 ms } stack[top++] = cr; // store CR on stack stack[top--] = c; // get and process command from stack switch (c) { default: printf(" Cmd >> "); break; case 'A': case 'a': _nop(); RED_LED_ON(); printf( "\r\nRed LED ON\r\n"); _nop(); break; case 'B': case 'b': _nop(); RED_LED_OFF(); printf( "\r\nRed LED OFF\r\n"); break; case 'C': // command line parameter test case 'c': _nop(); // Process command only _nop(); if ((stack[0] == 'c') || (stack[0] == 'C')){ // stack buffer begins stack[0] // toggle both red and green LEDs RED_LED_FLIP(); GRN_LED_FLIP(); printf("\r\n%s\r\n",status0); break; // No parameters were entered - just the command was entered } // Process parameters // Parameter input values of 0-255 _nop(); if (stack[0] == 0x01){ // first parameter // Turn Red LED ON RED_LED_ON(); _nop(); printf("%\r\n%s\r\n",status1); _nop(); } if (stack[1] == 0x02){ // second parameter // Turn Green LED ON GRN_LED_ON(); _nop(); printf("%\r\n%s\r\n",status2); _nop(); } if (stack[2] == 0x03){ // third parameter // Turn both LEDs off RED_LED_OFF(); GRN_LED_OFF(); printf("\r\n%s\r\n",status3); _nop(); } break; case 'H': case 'h': _nop(); cmd_show_help_1(); //status = "Show Help"; break; } // end of case _nop(); printf("\r\nCmd >> "); value = top = 0; memset(stack, 0, sizeof stack); } else if (c > ' '){ // greater than 'space' value = top = 0; } if (c == 0x0D){ // exit on CR value = top = 0; memset(stack, 0, sizeof stack); printf("\r\nCmd >> "); } } // eof /*********************************************************************************/ /*! @fn poll_cmd_1(void) @brief */ /*********************************************************************************/ void poll_cmd_1(void) { if (ring_buffer_data_size > 0) // data available parse_Input(ring_buffer_pull_char()); } /*********************************************************************************/ /*! PROTECTED FLASH FUNCTIONS WARNING ...DO NOT LOOP THE WRITE FUNCTION - WILL CAUSE FLASH WEAR FAILURES!!!! */ /*********************************************************************************/ /*********************************************************************************/ /*! @fn write_P_D_Flash() @brief Writes flash structure to protected flash segment D - 2553 only WARNING ...DO NOT LOOP THE WRITE FUNCTION - WILL CAUSE FLASH WEAR FAILURES!!!! */ /*********************************************************************************/ void write_P_D_Flash(void) { char *Flash_ptr; char *p = (char *)&mspnode; unsigned int i; //WARNING ...DO NOT LOOP THE WRITE FUNCTION - WILL CAUSE FLASH WEAR FAILURES!!!! // uses flash MSPNode data structure (above) Flash_ptr = (char *) 0x1000; // was 0x103F; Flash pointer, to segment D FCTL1 = FWKEY + ERASE; // Set Erase bit FCTL3 = FWKEY; // Clear Lock bit *Flash_ptr = 0; // Dummy write to erase Flash segment FCTL1 = FWKEY + WRT; // Set WRT bit for write operation for (i=0; i { *Flash_ptr++ = *p++; // Write value to flash } FCTL1 = FWKEY; // Clear WRT bit FCTL3 = FWKEY + LOCK; // Set LOCK bit } /*********************************************************************************/ /*! @fn read_P_D_Flash() @brief Reads flash structure to protected flash segment D - 2553 only WARNING ...DO NOT LOOP THE WRITE FUNCTION - WILL CAUSE FLASH WEAR FAILURES!!!! */ /*********************************************************************************/ void read_P_D_Flash(void) { char *Flash_ptr; char *p = (char *)&mspnode; unsigned int i; // uses flash MSPNode data structure (above) Flash_ptr = (char *)0x1000; // was 0x103F; Flash pointer to segment D for (i=0; i { *p++ = *Flash_ptr++; } } /*********************************************************************************/ /*! @fn FF_SegD (void) @brief Writes 0xFF to all of segment D. WARNING ...DO NOT LOOP THE WRITE FUNCTION - WILL CAUSE FLASH WEAR FAILURES!!!! */ /*********************************************************************************/ void FF_SegD (void) { char *Flash_ptr; // Flash pointer unsigned int i; Flash_ptr = (char *) 0x1000; // Initialize Flash pointer FCTL1 = FWKEY + ERASE; // Set Erase bit FCTL3 = FWKEY; // Clear Lock bit *Flash_ptr = 0; // Dummy write to erase Flash segment FCTL1 = FWKEY + WRT; // Set WRT bit for write operation for (i=0; i<64; i++) { *Flash_ptr++ = 0xFF; // Write value to flash } FCTL1 = FWKEY; // Clear WRT bit FCTL3 = FWKEY + LOCK; // Set LOCK bit } //================================================================================= //================================================================================= // The End
     
     
    LP_2553_Cmd_Line_Test_R6.zip (Beta)
    :ugeek:
  5. Like
    Arch_ETS reacted to username in MSP430 PC GUI Eval Tool   
    Hey all,
     
    I was working on a GUI that would be able to control any and all functions on a particular MSP430 processor from a PC GUI. Only limitations a course would be P1.1 and P1.2 which are required for GUI communication. This is very very very much so a work in progress. Currently i'm writing it using WX Widgets libraries to simplify the GUI aspect of it. However, currently i'm not using a "form builder" so it is going to take a handy amount of time to write. Good c++ experience though....
     
    This GUI would be very handy to have from a hardware/software test debug standpoint. For example, say I wanted to test out some SPI sensor I purchased, I could use a GUI such as this to send custom SPI packets to the device i'm testing and read/observe results live. That as opposed to having to write a micro.c file to do the communication and re write it every time something doesn't work.
     
    Many thanks to rick and suggaraddict for assistance on c++ coding help
     
    GUI Download Rev 0.5 : https://github.com/NateZimmer/MSP430-Ev ... I_EVAL.exe (windows.exe, click "view raw" to download)
    (feedback on whether or not it works for you would be great. Gaurenteed to work with a FTDI RS232 -> USB. However, launchpad drivers suppperr flakey and crapey )
     
    Remember to flash https://github.com/NateZimmer/MSP430-Ev ... er/GUI.cpp to your MSP430G2553
     
    Source Code is now at https://github.com/NateZimmer/MSP430-Eval-Tool
     
    (your going to need to download and BUILD the wx libraries to get this to work)
     
    Main Connect tab: Implemented
     

     
    Digital Output tab: Implemented
     

     
    Digital Input tab: Implemented
     

     
    SPI Tab: Implemented but not fully tested
     

     
    Analog Input tab: In Progress
     
    Connection Issue Debug
    1. Make sure you got a Rev1.5 launchpad with a G2553 micro flashed with the proper code provided. Also, makesure your jumpers are set to hardware uart.
     
    2. If that doesn't work... sadly, the TI RS232 <-> USB sucks hardcore compared to FTDI that always works. Once a connection is established, it works fine. However, getting that first connection can be a super pain. If your having connection issues, open up a terminal program(such as putty), connect to the com port of your msp430, and press the "1" key and ONLY the 1 key. If your msp430 is working properly you should receive "PING" back. At that point, close the terminal program and open up my .exe program. At that point, it should connect fine.
×
×
  • Create New...