Changeset 11667 for firmware


Ignore:
Timestamp:
Jul 27, 2011, 6:57:59 PM (8 years ago)
Author:
neise
Message:
 
Location:
firmware/FSC/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • firmware/FSC/src/FSC_eth_with_user_interface.c

    r10911 r11667  
    4646        U16 eth_red_bytes;
    4747
     48        U08 rc;
     49       
    4850        app_init();               // Setup: Watchdog and I/Os
    4951        usart_init();
     
    6264       
    6365for ( U08 i=0; i < (RESISTANCE_CHANNELS/8); ++i ) {
    64         ad7719_enables[i]=0x00;
     66        ad7719_enables[i]=0xFF;
    6567        ad7719_channels_ready[i]=0;
    6668        }
     
    9092
    9193        // checks if socket is okay and resets in case of problem the W5100
    92         if (w5100_caretaker()) 
     94        rc=w5100_caretaker();
     95        if ( rc != 0x17 && rc != 0x14) 
    9396        {
     97                usart_write_str((pU08)"caretaker! error code:");
     98                usart_write_U08_hex(rc);
     99                usart_write_crlf();
    94100        // something is not okay with the ethernet ...
    95101        // will be reset in the next revolution.. but maybe we want to do more...
     
    99105        if ( (milisec % W5100_INPUT_CHECK_TIME == 0) && (w5100_ready) )
    100106        {
    101                 eth_red_bytes = get_S0_RX_RSR();
    102                 if (eth_red_bytes != 0) { // we have something to read
     107                if ( (eth_red_bytes = get_S0_RX_RSR()) != 0) {
     108                        for (U08 rep=0; rep<1; ) {
     109                                if (eth_red_bytes == get_S0_RX_RSR() )
     110                                        rep++;
     111                                else
     112                                        eth_red_bytes =get_S0_RX_RSR();
     113                        }
    103114                        usart_write_str((pU08)"ethgot:");
    104115                        usart_write_U16(eth_red_bytes, 7);
     
    106117                        parse_w5300_incoming( w5100_get_RX(ETH_READ_BUFFER_SIZE, true) );
    107118                }
     119               
    108120        }
    109121       
     
    116128                        usart_write_U32(sec ,8);
    117129                        print_adc_nicely(false,true);
     130                        write_status_via_eth();
    118131                        //print_adc_stupid();
    119132                        reset_voltage_done();
    120133                        reset_voltage_values();
    121                         telegram_start();
    122                         w5100_set_TX((U08*) adc_values, ADC_VALUES_LEN_BYTE);
     134                        //telegram_start();
     135                        //w5100_set_TX((U08*) adc_values, ADC_VALUES_LEN_BYTE);
    123136
    124137                        reset_voltage_done();
     
    127140                        adc_values_printed = true;
    128141                        print_adc_nicely(true,true);
     142                        write_status_via_eth();
    129143                        //print_adc_stupid();
    130144                        //reset_voltage_done();
    131                         telegram_start();
    132                         w5100_set_TX((U08*) adc_values, ADC_VALUES_LEN_BYTE);
     145                        //telegram_start();
     146                        //w5100_set_TX((U08*) adc_values, ADC_VALUES_LEN_BYTE);
    133147
    134148                }
     
    138152
    139153                if(ad7719_print_endless){
    140                         usart_write_str((pU08)"R|");
    141                         usart_write_U32(sec ,8);
    142                         print_ad7719_nicely(false,true);
     154                       
     155                        print_ad7719_nicely();
     156                        write_status_via_eth();
    143157                        reset_resistance_done();
    144                         telegram_start();
    145                         w5100_set_TX((U08*) ad7719_values, AD7719_VALUES_LEN_BYTE);
     158                        reset_voltage_done();
     159                       
     160                        //telegram_start();
     161                        //w5100_set_TX((U08*) ad7719_values, AD7719_VALUES_LEN_BYTE);
    146162
    147163                } else
     
    149165                        ad7719_values_printed = true;
    150166                        print_ad7719_nicely(true,true);
     167                        write_status_via_eth();
    151168                        reset_resistance_done();
    152                         telegram_start();
    153                         w5100_set_TX((U08*) ad7719_values, AD7719_VALUES_LEN_BYTE);
     169                        //telegram_start();
     170                        //w5100_set_TX((U08*) ad7719_values, AD7719_VALUES_LEN_BYTE);
    154171
    155172                }
  • firmware/FSC/src/parser.c

    r10911 r11667  
    44#include "usart.h"
    55#include "w5100_spi_interface.h"
     6#include "timer.h"
    67// this method parses the data,
    78// which came in via USART
     
    350351                case 'm':       // *m*easure active channels commands
    351352                        reset_done();
     353                        ad7719_print_endless = true;
     354                       
    352355                        simple_acknowledge();
    353356                        break;
     
    420423
    421424void write_status_via_eth() {
     425float resistance;
     426
    422427        // take care: ethernet write buffer is just 32 bytes long.
    423428        eth_write_str("status: ");                              eth_writeln_str(nc_U32_to_hex(status));
     
    425430        // otherwise the numbers in time_sec and time_ms might get corrupt during output.
    426431        cli();
    427         eth_write_str("time_s: ");                              eth_writeln_str(nc_U32_to_str(time_sec, 10));
    428         eth_write_str("mili_s: ");                              eth_writeln_str(nc_U16_to_str(time_ms, 6));
     432        eth_write_str("time_s: ");                              eth_write_str(nc_U32_to_str(sec, 1));
     433        eth_write_str(".");eth_writeln_str(nc_U16_to_str(milisec, 1));
     434        //eth_write_str("mili_s: ");                            eth_writeln_str(nc_U16_to_str(milisec, 1));
    429435        sei();
    430436       
    431         eth_write_str("R_ref : ");                              eth_writeln_str(nc_U16_to_str(ref_resistor, 6));
     437        //eth_write_str("R_ref : ");                            eth_writeln_str(nc_U16_to_str(ref_resistor, 6));
    432438       
    433439        eth_writeln_str("VOLTAGES\n");
    434440                eth_write_str("enable:");                               
    435                 for (U08 i=0; i<4 ; i++){
     441                for (U08 i=0; i<VOLTAGE_REGS ; i++){
    436442                        eth_write_str(nc_U08_to_bin(adc_enables[i]));
    437443                        // need to tweak here in order to get some nice spaces...
     
    439445                        eth_write_index++;
    440446                }
    441                 eth_writeln_str(nc_U08_to_bin(adc_enables[4]));
     447                eth_write_buffer[eth_write_index++] = '\n';
    442448               
    443449                eth_write_str("  done:");                               
    444                 for (U08 i=0; i<4 ; i++){
     450                for (U08 i=0; i<VOLTAGE_REGS ; i++){
    445451                        eth_write_str(nc_U08_to_bin(adc_channels_ready[i]));
    446452                        // need to tweak here in order to get some nice spaces...
     
    448454                        eth_write_index++;
    449455                }
    450                 eth_writeln_str(nc_U08_to_bin(adc_channels_ready[4]));
    451 
     456                eth_write_buffer[eth_write_index++] = '\n';
     457               
    452458                eth_write_str("values:");                               
    453                 for (U08 i=0; i<73 ; i++){
    454                         eth_write_str(nc_U16_to_str(adc_values[i], 6) );
     459                for (U08 i=0; i<VOLTAGE_CHANNELS ; i++){
     460                        eth_write_str(nc_U16_to_str(adc_values[i]/10, 1) );
    455461                        // need to tweak here in order to get some nice spaces...
    456462                        eth_write_buffer[eth_write_index] = ' ';
    457463                        eth_write_index++;
    458464                }
    459                 eth_writeln_str(nc_U16_to_str(adc_values[73], 6) );
     465                eth_write_buffer[eth_write_index++] = '\n';
    460466               
    461467        eth_writeln_str("RESISTANCES\n");
    462468                eth_write_str("enable:");                               
    463                 for (U08 i=0; i<7 ; i++){
     469                for (U08 i=0; i<(RESISTANCE_CHANNELS/8) ; i++){
    464470                        eth_write_str(nc_U08_to_bin(ad7719_enables[i]));
    465471                        // need to tweak here in order to get some nice spaces...
     
    467473                        eth_write_index++;
    468474                }
    469                 eth_writeln_str(nc_U08_to_bin(ad7719_enables[7]));
     475                eth_write_buffer[eth_write_index++] = '\n';
    470476               
    471477                eth_write_str("  done:");                               
    472                 for (U08 i=0; i<7 ; i++){
     478                for (U08 i=0; i<(RESISTANCE_CHANNELS/8) ; i++){
    473479                        eth_write_str(nc_U08_to_bin(ad7719_channels_ready[i]));
    474480                        // need to tweak here in order to get some nice spaces...
     
    476482                        eth_write_index++;
    477483                }
    478                 eth_writeln_str(nc_U08_to_bin(ad7719_channels_ready[7]));
    479 
    480                 eth_write_str("values:");                               
    481                 for (U08 i=0; i<63 ; i++){
    482                         eth_write_str(nc_U32_to_str(ad7719_values[i], 10) );
     484                eth_write_buffer[eth_write_index++] = '\n';
     485
     486                eth_write_str("values:\n");                             
     487                for (U08 i=0; i<RESISTANCE_CHANNELS ; i++){
     488                        //eth_write_str(nc_U32_to_str(ad7719_values[i], 10) );
     489                       
     490                        resistance = (6.25 * 1024 * ad7719_values[i]) / ((U32)1 << 25);
     491                        eth_write_str(nc_float_to_str(resistance , 2, 2) );
    483492                        // need to tweak here in order to get some nice spaces...
    484                         eth_write_buffer[eth_write_index] = ' ';
     493                        if (i%8 == 7)
     494                                eth_write_buffer[eth_write_index] = '\n';
     495                        else
     496                                eth_write_buffer[eth_write_index] = ' ';
     497                       
    485498                        eth_write_index++;
    486499                }
    487                 eth_writeln_str(nc_U32_to_str(ad7719_values[63], 10) );
     500                eth_writeln_str("\nend.\n");
    488501               
    489502
     
    491504
    492505void eth_write_stuff(void) {
    493         S08 buf []="Test Ah Alarm!!\n";
    494         for (U08 i =0 ; i<7 ; i++) {
    495                 eth_write_str(buf);                             
    496         }
    497 }
     506        S08 buf []="Test Ah A!!\n";
     507        for (U08 i =0 ; i<255 ; i++) {
     508                eth_write_str(nc_U08_to_str(i,4));
     509                eth_write_str(buf);
     510        }
     511}
  • firmware/FSC/src/parser.h

    r10910 r11667  
    2424// I hope this is convenient.
    2525void write_status_via_eth();
     26void eth_write_stuff(void);
    2627#endif
  • firmware/FSC/src/spi_master.c

    r10697 r11667  
    1616
    1717void spi_setup_w5100() {
    18         spi_clock_index = 4;            // 1Mbps
    19         // this is reasonable for W5100 because of slow level shifters on the FSC.
    20         // in case the slow level shifters, are improved. this value may go up to 6!
    21 
     18        spi_clock_index = 1;            //
    2219        spi_dord = 0;                                   // Data Order MSB first dord = 0  --> good for all devices
    2320        spi_cpol = 0;   spi_cpha = 0;   // SPI mode=0 good for ethernet.
  • firmware/FSC/src/w5100_spi_interface.c

    r10911 r11667  
    1212// INTERFACE CONTROL VARS
    1313
    14 bool w5100_needs_reset = true;
    1514bool w5100_needs_init = true;
    1615bool w5100_ready = false;
    1716
     17U16 last_samurai = 0x0000;
     18
    1819U08 w5100_caretaker() {
    1920U08 socket_status;
    20         if (w5100_needs_reset)
    21                 w5100_reset();
    22                
     21       
    2322        socket_status = w5100_sock_status();
     23        //usart_write_str((pU08)"ss:");
     24        //usart_write_U08_hex(socket_status);
     25        //usart_write_char(' ');
    2426       
    2527        if (socket_status == SR_SOCK_ESTABLISHED) {
    2628                w5100_ready = true;
    27                
    2829                // everything is fine...
    29                 return 0;
    30         }
    31         else if(socket_status < SR_SOCK_ESTABLISHED) {
    32         // it might be LISTENING ... or not even OPEN
    33                 if (socket_status == SR_SOCK_CLOSED) {
     30        }
     31        else if (socket_status == SR_SOCK_LISTEN) {
     32                w5100_ready = false;
     33                // wait for connection
     34        }
     35        else {
     36                socket_status = w5100_sock_status();
     37                //usart_write_str((pU08)"ss2:");
     38                //usart_write_U08_hex(socket_status);
     39                //usart_write_char(' ');
     40                       
     41                if (socket_status == SR_SOCK_ESTABLISHED) {
     42                w5100_ready = true;
     43                // everything is fine...
     44                }
     45                else if (socket_status == SR_SOCK_LISTEN) {
     46                w5100_ready = false;
     47                // wait for connection
     48                }
     49                else
     50                {
     51                // this should never happen
     52                w5100_ready = false;
     53                        w5100_reset();
    3454                        w5100_init();
    3555                }
    36                 if (socket_status == SR_SOCK_INIT) {
    37                         w5100_init();
    38                 }
    39                 if (socket_status == SR_SOCK_LISTEN) {
    40                        
    41                 }
    42         }       
    43         else { // all other socket states need a reset
    44                 w5100_needs_reset = true;
    45         }
    46 w5100_ready = false;
    47 return 1;
     56        }
     57       
     58        //usart_write_crlf();
     59return socket_status;
    4860}
    4961
     
    5466        PORTB |= 1<<PB2; //#reset = HIGH --> W5100 is active
    5567        _delay_ms(5);           // give it 5ms to accomodate.
    56         w5100_needs_reset = false;
    5768}
    5869
     
    165176{
    166177U16 freesize;
    167 freesize=w5100_read(S0_TX_FSR0);
    168 freesize = freesize << 8;
     178freesize=w5100_read(S0_TX_FSR0);                // datasheet: user should read upper byte first, and lower byte later
     179freesize = freesize << 8;                               //                              to get correct value
    169180freesize += w5100_read(S0_TX_FSR1);
    170181return freesize;
     
    195206{
    196207U16 received_size;
    197 received_size=w5100_read(S0_RX_RSR0);
    198 received_size = received_size << 8;
    199 received_size += w5100_read(S0_RX_RSR1);   // S0_RX_RSR1 is the least significant byte ...
    200 return received_size;
     208U08 highbyte, lowbyte;
     209        highbyte = w5100_read(S0_RX_RSR0);
     210        lowbyte = w5100_read(S0_RX_RSR1);
     211        received_size = (highbyte<<8) | lowbyte;
     212       
     213//      usart_write_str((pU08)"hi:");
     214//      usart_write_U08_hex(highbyte);
     215//      usart_write_crlf();
     216//     
     217//      usart_write_str((pU08)"lo:");
     218//      usart_write_U08_hex(lowbyte);
     219//      usart_write_crlf();
     220//     
     221//      usart_write_str((pU08)"total:");
     222//      usart_write_U16_hex(received_size);
     223//      usart_write_crlf();
     224       
     225//      _delay_ms(200);
     226       
     227        return received_size;
    201228}
    202229
     
    205232{
    206233U16 readpointer;
    207 readpointer=w5100_read(S0_RX_RD0);
     234readpointer=w5100_read(S0_RX_RD0);             
    208235readpointer = readpointer << 8;
    209236readpointer += w5100_read(S0_RX_RD1);
     
    217244U08 high_byte = (value>>8);
    218245U08 low_byte = value&0x00FF;
     246w5100_write(S0_TX_WR0, high_byte);
    219247w5100_write(S0_TX_WR1, low_byte);
    220 w5100_write(S0_TX_WR0, high_byte);
    221 
    222248}
    223249
     
    227253U08 high_byte = (value>>8);
    228254U08 low_byte = value&0x00FF;
    229 
    230255w5100_write(S0_RX_RD0, high_byte);
    231256w5100_write(S0_RX_RD1, low_byte);
     
    255280        U16 start_address =  S0_RX_BASE + offset;
    256281
     282        usart_write_str((pU08)"lrp:");
     283        usart_write_U16_hex(last_RX_read_pointer);
     284        usart_write_crlf();
     285        usart_write_str((pU08)"off:");
     286        usart_write_U16_hex(offset);
     287        usart_write_crlf();
     288        usart_write_str((pU08)"sad:");
     289        usart_write_U16_hex(start_address);
     290        usart_write_crlf();
     291       
     292       
    257293        if ((offset + NumBytes) > (S0_RX_MASK + 1) )  // if data is turned over in RX-mem
    258294        {
     
    277313
    278314        // inform W5100 about how much data was read out.
    279         set_S0_RX_RD(last_RX_read_pointer + NumBytes);
     315        U16 new_read_pointer =  last_RX_read_pointer + NumBytes;
     316        usart_write_str((pU08)"nrp:");
     317        usart_write_U16_hex(new_read_pointer);
     318        usart_write_crlf();
     319       
     320        set_S0_RX_RD(new_read_pointer);
    280321        w5100_write ( S0_CR, CR_RECV );
    281322       
     
    305346U16 w5100_set_TX(U08* string, U16 NumBytes) {
    306347
    307         U16 freesize = get_S0_TX_FSR();
     348        U08 repetitions;
     349        U16 freesize;
     350        U16 last_TX_write_pointer;
     351       
     352        //usart_write_str((pU08)"S0_IR:");
     353        //usart_write_U08_hex( w5100_read(S0_IR) );
     354        //usart_write_crlf();
     355       
     356        freesize = get_S0_TX_FSR();
     357        for (repetitions=0 ; repetitions < 3;  ) // increase is *inside the loop*
     358        {
     359                if ( freesize != get_S0_TX_FSR()) {
     360                         freesize = get_S0_TX_FSR();
     361                } else {
     362                        repetitions++;
     363                }
     364        }
     365       
    308366        if (freesize == 0)
    309367        {
     
    311369        }
    312370       
    313         U16 last_TX_write_pointer = get_S0_TX_WR();
     371        last_TX_write_pointer = get_S0_TX_WR();
     372        for (repetitions=0 ; repetitions < 3;  ) // increase is *inside the loop*
     373        {
     374                if ( last_TX_write_pointer != get_S0_TX_WR()) {
     375                         last_TX_write_pointer = get_S0_TX_WR();
     376                } else {
     377                        repetitions++;
     378                }
     379        }
     380       
    314381        U16 offset = last_TX_write_pointer & S0_TX_MASK;
    315382        U16 start_address =  S0_TX_BASE + offset;
    316383
    317         usart_write_crlf();
    318         usart_write_crlf();
    319         usart_write_str((pU08)"lwp :");
    320         usart_write_U16_hex(last_TX_write_pointer);
    321         usart_write_crlf();
    322        
    323         usart_write_str((pU08)"off :");
    324         usart_write_U16_hex(offset);
    325         usart_write_crlf();
    326        
    327         usart_write_str((pU08)"stad:");
    328         usart_write_U16_hex(start_address);
    329         usart_write_crlf();
     384        if (last_samurai != last_TX_write_pointer)
     385                        usart_write_str((pU08)"Hilfeeeeeeeeeeeeeee\n");
     386       
     387        //usart_write_crlf();
     388        //usart_write_char('|');usart_write_U16_hex( last_TX_write_pointer );
     389        //usart_write_char('|');usart_write_U16_hex( offset );
     390        //usart_write_char('|');usart_write_U16_hex( start_address );
     391       
     392       
     393        //usart_write_crlf();
     394        //usart_write_crlf();
     395        //usart_write_str((pU08)"lwp :");
     396        //usart_write_U16_hex(last_TX_write_pointer);
     397        //usart_write_crlf();
     398        //
     399        //usart_write_str((pU08)"off :");
     400        //usart_write_U16_hex(offset);
     401        //usart_write_crlf();
     402        //
     403        //usart_write_str((pU08)"stad:");
     404        //usart_write_U16_hex(start_address);
     405        //usart_write_crlf();
    330406       
    331407
     
    345421                NumBytes = freesize;
    346422        }
    347 
     423        //usart_write_char('|');usart_write_U16_hex( NumBytes );
     424       
    348425        // now calculate the offset address
    349426        // calculated according to W5100 datasheet page: 44
    350 
    351427        if ((offset + NumBytes) > (S0_RX_MASK + 1) )  // if data is turned over in RX-mem
    352428        {
     
    356432                {
    357433                        w5100_write(start_address + i, string[i]);
    358                         usart_write_str((pU08)"wr:");
    359                         usart_write_U16_hex(start_address + i);
    360                         usart_write_char(' ');
    361                         usart_write_char(string[i]);
    362                         usart_write_crlf();
     434                        //usart_write_str((pU08)"wr:");
     435                        //usart_write_U16_hex(start_address + i);
     436                        //usart_write_char(' ');
     437                        //usart_write_char(string[i]);
     438                        //usart_write_crlf();
    363439
    364440                }
     
    366442                {
    367443                        w5100_write(S0_RX_BASE + i, string[upper_size+i]);
    368                         usart_write_str((pU08)"wr:");
    369                         usart_write_U16_hex(S0_RX_BASE + i);
    370                         usart_write_char(' ');
    371                         usart_write_char(string[upper_size+i]);
    372                         usart_write_crlf();
     444                        //usart_write_str((pU08)"wr:");
     445                        //usart_write_U16_hex(S0_RX_BASE + i);
     446                        //usart_write_char(' ');
     447                        //usart_write_char(string[upper_size+i]);
     448                        //usart_write_crlf();
    373449
    374450                }
     
    379455                {
    380456                        w5100_write(start_address + i, string[i]);
    381                         usart_write_str((pU08)"wr:");
    382                         usart_write_U16_hex(start_address + i);
    383                         usart_write_char(' ');
    384                         usart_write_char(string[i]);
    385                         usart_write_crlf();
     457                        //usart_write_str((pU08)"wr:");
     458                        //usart_write_U16_hex(start_address + i);
     459                        //usart_write_char(' ');
     460                        //usart_write_char(string[i]);
     461                        //usart_write_crlf();
    386462
    387463                }
     
    389465
    390466        // inform W5100 about how much data was written.
    391         set_S0_TX_WR(last_TX_write_pointer + NumBytes);
    392                 usart_write_str((pU08)"wrpt:");
    393                 usart_write_U16_hex(last_TX_write_pointer + NumBytes);
    394                 usart_write_crlf();
     467        U16 new_write_pointer = last_TX_write_pointer + NumBytes;
     468        last_samurai = new_write_pointer;
     469       
     470       
     471        set_S0_TX_WR(new_write_pointer);
     472        //usart_write_char('|');usart_write_U16_hex( new_write_pointer );
     473       
     474        //usart_write_char('|');
     475        //usart_write_crlf();
     476       
     477               
     478                //usart_write_str((pU08)"wrpt:");
     479                //usart_write_U16_hex(last_TX_write_pointer + NumBytes);
     480                //usart_write_crlf();
    395481
    396482        // tell it to send now the data away
    397483        w5100_write( S0_CR, CR_SEND);
     484       
     485       
    398486       
    399487        return NumBytes;
     
    427515}
    428516
     517void eth_write_lf(void) {
     518        if (eth_write_index < ETH_WRITE_BUFFER_SIZE) {
     519                eth_write_buffer[eth_write_index++] = '\n';
     520        }
     521        w5100_set_TX(eth_write_buffer, eth_write_index);
     522        eth_write_index = 0;
     523}
  • firmware/FSC/src/w5100_spi_interface.h

    r10910 r11667  
    144144// NETWORK SETTING:
    145145// set GAR to FSC_GATEWAY_ADDRESS
    146 //#define FSC_GATEWAY_ADDRESS0 0xC0             // 192.33.96.1
    147 //#define FSC_GATEWAY_ADDRESS1 0x21
    148 //#define FSC_GATEWAY_ADDRESS2 0x60
    149 //#define FSC_GATEWAY_ADDRESS3 0x01
    150 
    151 #define FSC_GATEWAY_ADDRESS0 0xC0               // 192.168.0.1
    152 #define FSC_GATEWAY_ADDRESS1 0x21
    153 #define FSC_GATEWAY_ADDRESS2 0x60
    154 #define FSC_GATEWAY_ADDRESS3 0x01
     146//#define FSC_GATEWAY_ADDRESS0 192              // 192.33.96.1
     147//#define FSC_GATEWAY_ADDRESS1 33
     148//#define FSC_GATEWAY_ADDRESS2 96
     149//#define FSC_GATEWAY_ADDRESS3 1
     150
     151#define FSC_GATEWAY_ADDRESS0 10
     152#define FSC_GATEWAY_ADDRESS1 0
     153#define FSC_GATEWAY_ADDRESS2 0
     154#define FSC_GATEWAY_ADDRESS3 0
     155
     156
     157//#define FSC_GATEWAY_ADDRESS0 192              // 192.168.0.1
     158//#define FSC_GATEWAY_ADDRESS1 168
     159//#define FSC_GATEWAY_ADDRESS2 0
     160//#define FSC_GATEWAY_ADDRESS3 1
    155161
    156162
     
    162168#define FSC_MAC_ADDRESS4 0x22
    163169#define FSC_MAC_ADDRESS5 0x01
     170
    164171// set SUBR to FSC_SUBNET_MASK
    165 #define FSC_SUBNET_MASK0 255    //255.255.248.0
     172#define FSC_SUBNET_MASK0 255    //255.255.255.0
    166173#define FSC_SUBNET_MASK1 255
    167174#define FSC_SUBNET_MASK2 255
    168175#define FSC_SUBNET_MASK3 0
    169176// set SIPR to FSC_IP_ADDRESS
    170 //#define FSC_IP_ADDRESS0 0xC0  // 192.33.99.247
    171 //#define FSC_IP_ADDRESS1 0x21
    172 //#define FSC_IP_ADDRESS2 0x63
    173 //#define FSC_IP_ADDRESS3 0xF7
    174 #define FSC_IP_ADDRESS0 192     // 192.168.0.2
    175 #define FSC_IP_ADDRESS1 168
    176 #define FSC_IP_ADDRESS2 0
    177 #define FSC_IP_ADDRESS3 2
     177
     178//#define FSC_IP_ADDRESS0 192   // 192.33.99.247
     179//#define FSC_IP_ADDRESS1 33
     180//#define FSC_IP_ADDRESS2 99
     181//#define FSC_IP_ADDRESS3 247
     182
     183#define FSC_IP_ADDRESS0 10     
     184#define FSC_IP_ADDRESS1 0
     185#define FSC_IP_ADDRESS2 128
     186#define FSC_IP_ADDRESS3 127
     187
     188
     189//#define FSC_IP_ADDRESS0 192   // 192.168.0.2
     190//#define FSC_IP_ADDRESS1 168
     191//#define FSC_IP_ADDRESS2 0
     192//#define FSC_IP_ADDRESS3 2
     193
     194
    178195//------------------------------------------------------------------------------
    179196// MEM SETTINGS:
     
    218235U16 w5100_set_TX(U08* string, U16 NumBytes);
    219236
    220 extern bool w5100_needs_reset;
    221237extern bool w5100_needs_init;
    222238extern bool w5100_ready;
     
    230246void eth_write_str( U08* str );
    231247void eth_writeln_str( U08* str );
     248void eth_write_lf(void);
Note: See TracChangeset for help on using the changeset viewer.