Changeset 10910 for firmware


Ignore:
Timestamp:
Jun 5, 2011, 5:40:00 PM (8 years ago)
Author:
neise
Message:
 
Location:
firmware/FSC/src
Files:
12 edited

Legend:

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

    r10705 r10910  
    3434        bool once_told_you = true;
    3535        bool debug_mode = false;
    36        
    37 // ETHERNET VARS
    38 U08 downloaded_bytes;
    39 
     36
     37       
    4038//-----------------------------------------------------------------------------
    4139//   M A I N    ---   M A I N    ---   M A I N    ---   M A I N    ---  M A I N   
     
    4341int main(void)
    4442{
     43        U08 highbyte;
     44        U08 lowbyte;
     45
    4546        app_init();               // Setup: Watchdog and I/Os
    4647        usart_init();
     
    5960       
    6061for ( U08 i=0; i < (RESISTANCE_CHANNELS/8); ++i ) {
    61         ad7719_enables[i]=0xFF;
     62        ad7719_enables[i]=0x00;
    6263        ad7719_channels_ready[i]=0;
    6364        }
    64 for ( U08 i=0; i < (VOLTAGE_CHANNELS/8); ++i ) {
    65         adc_enables[i]=0x00;
     65for ( U08 i=0; i < (VOLTAGE_REGS); ++i ) {
     66        if (i < (VOLTAGE_REGS)-1)
     67                adc_enables[i]=0xFF;
     68        else
     69                adc_enables[i]=0x0F;
    6670        adc_channels_ready[i]=0;
    6771}
    6872
    69         static U08 welcome[]="welcome to:\n FSC command interface 0.1 \n build: ??.05.2010\n";
     73        static U08 welcome[]="FSC 0.2 \n build: 05.06.2010 - 12:57\n";
    7074        usart_write_str(welcome);
    7175        /*
     
    9498        {
    9599                if (get_S0_RX_RSR() != 0) { // we have something to read
    96                         downloaded_bytes = w5100_get_RX(ETH_READ_BUFFER_SIZE, true);
    97                         parse_w5300_incoming( downloaded_bytes );
     100                       
     101                        parse_w5300_incoming( w5100_get_RX(ETH_READ_BUFFER_SIZE, true) );
    98102                }
    99103        }
     
    107111                        usart_write_U32(sec ,8);
    108112                        print_adc_nicely(false,true);
     113                        //print_adc_stupid();
     114                        reset_voltage_done();
     115                        reset_voltage_values();
    109116                        telegram_start();
    110117                        w5100_set_TX((U08*) adc_values, ADC_VALUES_LEN_BYTE);
     
    115122                        adc_values_printed = true;
    116123                        print_adc_nicely(true,true);
     124                        //print_adc_stupid();
     125                        //reset_voltage_done();
    117126                        telegram_start();
    118127                        w5100_set_TX((U08*) adc_values, ADC_VALUES_LEN_BYTE);
     
    135144                        ad7719_values_printed = true;
    136145                        print_ad7719_nicely(true,true);
     146                        reset_resistance_done();
    137147                        telegram_start();
    138148                        w5100_set_TX((U08*) ad7719_values, AD7719_VALUES_LEN_BYTE);
     
    187197        //      -It is not allowed to send more than one command between two '\n'
    188198        if (usart_rx_ready){
    189                 void MSR_parser();
     199                //parse_ascii();
     200                MSR_parser();
    190201        }
    191202//----------------------------------------------------------------------------
     
    193204        //IF ATmega internal ADC did finish a conversion --every 200us
    194205        if ( (ADCSRA & (1<<ADIF)) && !adc_measured_all) {
    195                 *adc_current_reading = (U16)ADCL;
    196                 *adc_current_reading += (U16)ADCH<<8;
     206                lowbyte = ADCL;
     207                highbyte = ADCH;
     208                ADCSRA |= 1<<ADIF;
     209                *adc_current_reading = ((U16)highbyte<<8) | ((U16)lowbyte);
     210                if (debug_mode) {
     211                                usart_write_U16_hex(*adc_current_reading);
     212                                usart_write_crlf();
     213                }
     214               
    197215                if (*adc_readings_since_last_muxing == ADC_READINGS_UNTIL_SETTLED+adc_readings_until_mean-1) {
     216                        adc_values[*adc_current_channel] += *adc_current_reading;
    198217                        adc_channels_ready[*adc_current_channel/8] |= (1<<(*adc_current_channel%8));
    199218                        *adc_current_channel = increase_adc (*adc_current_channel);
     
    201220                        Set_V_Muxer(*adc_current_channel);
    202221                        *adc_readings_since_last_muxing = 0;
    203                         _delay_ms(10);
     222                        _delay_ms(10); // this is a muxer delay                 
    204223                }
    205224                else if (adc_readings_since_last_muxing >= ADC_READINGS_UNTIL_SETTLED-1) {
    206225                        adc_values[*adc_current_channel] += *adc_current_reading;
     226                        if (debug_mode) {
     227                                usart_write_str((pU08)"ch:");
     228                                usart_write_U08(*adc_current_channel,4);
     229                                usart_write_str((pU08)" v:");
     230                                usart_write_U16_hex(*adc_current_reading);
     231                                usart_write_str((pU08)" sum:");
     232                                usart_write_U16(adc_values[*adc_current_channel],8);
     233                                usart_write_crlf();
     234                        }
     235
    207236                        ++(*adc_readings_since_last_muxing);
    208237                }
     
    212241
    213242        }
     243       
    214244//----------------------------------------------------------------------------
    215245
  • firmware/FSC/src/FSC_test.c

    r10677 r10910  
    5555// ATMEGA ADC global variables
    5656        U08 adc_values[VOLTAGE_CHANNELS]; // stores measured voltage in steps of 16mV
    57         U08 adc_enables[VOLTAGE_CHANNELS/8];
    58         U08 adc_channels_ready[VOLTAGE_CHANNELS/8];
     57        U08 adc_enables[VOLTAGE_REGS];
     58        U08 adc_channels_ready[VOLTAGE_REGS];
    5959        U08 adc_readings_since_last_muxing = 0;
    6060        U08 adc_current_channel = 0;
  • firmware/FSC/src/application.c

    r10705 r10910  
    1919
    2020U32 *ad7719_values                                              = (U32*)&FSCregister[68];
    21 U08 *ad7719_enables                                     = &FSCregister[32];
    22 U08 *ad7719_channels_ready                              = &FSCregister[50];
     21U08 *ad7719_enables                                     = &FSCregister[30];
     22U08 *ad7719_channels_ready                              = &FSCregister[49];
    2323U08 *ad7719_readings_since_last_muxing  = &FSCregister[14];
    2424U08 *ad7719_current_channel                     = &FSCregister[15];
     
    2626
    2727U16 *adc_values                                                 = (U16*) &FSCregister[324];
    28 U08 *adc_enables                                                = &FSCregister[40];
    29 U08 *adc_channels_ready                                 = &FSCregister[58];
     28U08 *adc_enables                                                = &FSCregister[38];
     29U08 *adc_channels_ready                                 = &FSCregister[57];
    3030U08 *adc_readings_since_last_muxing     = &FSCregister[20];
    3131U08 *adc_current_channel                                = &FSCregister[21];
     
    178178        {
    179179                effective_channel = (channel + increase) % (VOLTAGE_CHANNELS);
    180                 if (adc_enables[effective_channel/8] & (1<<effective_channel%8))
     180                if (adc_enables[effective_channel/8] & (1<<effective_channel%8)) {
     181                        if (debug_mode)
     182                        {
     183                                usart_write_U08(effective_channel,3);
     184                                usart_write_crlf();
     185                        }
    181186                        return effective_channel;
     187                }
     188        }
     189        if (debug_mode)
     190        {
     191                usart_write_U08(channel,3);
     192                usart_write_crlf();
    182193        }
    183194        return channel;
     
    197208void check_if_measured_all() {
    198209        adc_measured_all = true;
    199         for ( U08 i=0; i<(VOLTAGE_CHANNELS/8); ++i ) {
     210        for ( U08 i=0; i<(VOLTAGE_REGS); ++i ) {
    200211                if ((adc_enables[i] ^ adc_channels_ready[i]) != 0x00) {
    201212                        adc_measured_all = false;
     
    214225}
    215226
    216 
     227// an U08 array containts bitmaps, which encode, which channel is enabled and which is not.
     228// a measurement is done, when all (or more) enabled channels were already measured.
     229// a similar U08 array contains a bitmap, encoding which channels are already done.
     230//  note: "or more" above is important, if we check to strictly,
     231//      we will never finish, in case a disabled channel get measured by any mistake...
     232//
     233//      lets assume:
     234//      enabled = 1110.0011             1110.0011
     235//      done    = 1111.0011             0111.0010
     236//
     237//      and             = 1110.0011             0110.0010
     238//      nand    = 0001.0011             1001.1101
     239//      or              = 1111.0011             1111.0011
     240//      xor             = 0001.0000             1001.0001
     241//     
     242//                                                                                     
     243// (en xor done) and enabled =
     244//      xor             = 0001.0000             1001.0001
     245//      enabled = 1110.0011             1110.0011
     246//                        ---------             ---------
     247//                        0000.0000             1000.0001
     248// if this statement evaluates to zero,
    217249bool check_if_adc_measurement_done(){
    218250        adc_measured_all = true;
    219         for ( U08 i=0; i<VOLTAGE_CHANNELS/8; ++i ) {
    220                 if ((adc_enables[i] ^ adc_channels_ready[i]) != 0x00) {
     251        for ( U08 i=0; i<VOLTAGE_REGS; ++i ) {
     252                if (( (adc_enables[i] ^ adc_channels_ready[i]) & adc_enables[i] ) != 0x00) {
    221253                        adc_measured_all = false;
    222254                        break;
     
    229261        ad7719_measured_all = true;
    230262        for ( U08 i=0; i<RESISTANCE_CHANNELS/8; ++i ) {
    231                 if ((ad7719_enables[i] ^ ad7719_channels_ready[i]) != 0x00) {
     263                if (( (ad7719_enables[i] ^ ad7719_channels_ready[i]) & ad7719_enables[i]) != 0x00) {
    232264                        ad7719_measured_all = false;
    233265                        break;
  • firmware/FSC/src/application.h

    r10705 r10910  
    77// in order to implement the "registers" I work with a quite long
    88//  char-array like this:
    9 # define FSC_REGISTER_LENGTH 254
     9# define FSC_REGISTER_LENGTH 492
    1010extern U08 FSCregister[FSC_REGISTER_LENGTH];
    1111// but this register is not only accessible by
     
    2626
    2727extern U16 *adc_values                                          ;
    28 #define ADC_VALUES_LEN_BYTE 152
     28#define ADC_VALUES_LEN_BYTE 168
    2929extern U08 *adc_enables                                                 ;
    3030extern U08 *adc_channels_ready                          ;
     
    7070       
    7171        #define VOLTAGE_CHANNELS 84
     72        #define VOLTAGE_REGS 11
    7273        #define ADC_READINGS_UNTIL_SETTLED 1
    7374#endif
     
    9091
    9192// ATMEGA ADC global variables
    92         #define adc_readings_until_mean 250
     93        #define adc_readings_until_mean 40
    9394        extern bool adc_measured_all;
    9495        extern bool adc_values_printed;
  • firmware/FSC/src/atmega_adc.c

    r10109 r10910  
    1515        ADMUX &= ~(1<<REFS0);
    1616        ADMUX &= ~(1<<REFS1);   //REFS = 00 --> use external reference voltage.
    17         ADMUX |= 1<<ADLAR;              //ADLAR =1      --> left adjust ac result in ADCH register --> 8bit resolution only.                           
     17        //ADMUX |= 1<<ADLAR;            //ADLAR =1      --> left adjust ac result in ADCH register --> 8bit resolution only.                           
    1818        ADMUX |= (0x1F & 0x06); //MUX = 0x06 --> Pin ADC6 = PA6 is used as ADC input pin.
    1919       
  • firmware/FSC/src/muxer_fsc.c

    r10244 r10910  
    11#include "muxer_fsc.h"
    2 
     2#include "usart.h"
    33// Sets voltage Muxer to current channel
    44// this is a Muxing, and therefor the adc might need some time to settle.
     
    3939                                break;
    4040                        case 2:
    41                                 SB = 0x58; //0101.0010
     41                                SB = 0x52; //0101.0010
    4242                                break;
    4343                        case 3:
    44                                 SB = 0x58; //0101.0011
     44                                SB = 0x53; //0101.0011
    4545                                break;
    4646                } // end of switch-case
  • firmware/FSC/src/output.c

    r10697 r10910  
    77void print_status() {
    88        usart_write_str((pU08)"adc status:\n");
    9         for (U08 i=0; i< VOLTAGE_CHANNELS/8;++i) {
     9        for (U08 i=0; i< VOLTAGE_REGS;++i) {
    1010                usart_write_U08_bin(adc_enables[i]);   
    1111                usart_write_char(' ');
    1212        }
    13         usart_write_char('\n');
    14         for (U08 i=0; i< VOLTAGE_CHANNELS/8;++i){
     13        usart_write_crlf();
     14        for (U08 i=0; i< VOLTAGE_REGS;++i){
    1515                usart_write_U08_bin(adc_channels_ready[i]);
    1616                usart_write_char(' ');
    1717        }
    18         usart_write_char('\n');
     18        usart_write_crlf();
    1919
    2020        usart_write_str((pU08)"ad7719 status:\n");
     
    2323                usart_write_char(' ');
    2424        }
    25         usart_write_char('\n');
     25        usart_write_crlf();
    2626        for (U08 i=0; i< RESISTANCE_CHANNELS/8;++i){
    2727                usart_write_U08_bin(ad7719_channels_ready[i]);
    2828                usart_write_char(' ');
    2929        }
    30         usart_write_char('\n');
     30        usart_write_crlf();
    3131
    3232        usart_write_str((pU08)"time:");
    3333        usart_write_U32(sec,10);
    3434        usart_write_str((pU08)" sec.\n");
    35 
     35/*
    3636        usart_write_str((pU08)"adc measured all: ");
    3737        if (adc_measured_all)
     
    4848        usart_write_str((pU08)"adc current channel:");
    4949        usart_write_U08(*adc_current_channel,2);
    50         usart_write_char('\n');
     50        usart_write_crlf();
    5151
    5252        usart_write_str((pU08)"ad7719 current channel:");
    5353        usart_write_U08(*ad7719_current_channel,2);
    54         usart_write_char('\n');
    55 
     54        usart_write_crlf();
     55       
     56        usart_write_str((pU08)"mux SB:");
     57        usart_write_U08_hex(PORTC);
     58        usart_write_str((pU08)" SA:");
     59        usart_write_U08_hex(PORTA);
     60        usart_write_crlf();
     61*/
    5662}
    5763void print_adc_nicely() {
     
    9298                        usart_write_str((pU08)" ");     
    9399                } else {
    94                         usart_write_str((pU08)"         ");     
     100                        usart_write_str((pU08)"       ");       
    95101                }
    96102                //usart_write_char('\n');
     
    114120}
    115121
    116 void adc_output(U08 channel, U08 data) {
     122void adc_output(U08 channel, U16 data) {
    117123
    118124//      if (channel < 40)
     
    167173        //usart_write_U08(channel,2); // Numbers 1...8
    168174        usart_write_char(':');
    169         usart_write_U16((U16)data*16, 4); //data
     175        usart_write_U16(data/(adc_readings_until_mean/4), 7); //data
    170176}
    171177
     
    182188        w5100_set_TX(eth_write_buffer, 2);
    183189}
     190
     191void print_help(){
     192        usart_write_str((pU08)"printing help: -not yet- \n");
     193}
     194
     195void print_adc_stupid() {
     196        usart_write_str((pU08)"printing voltages in mV - stupid mode:\n");
     197        for (U08 i = 0 ; i < VOLTAGE_CHANNELS ; ++i) {
     198                usart_write_str((pU08)"ch:");
     199                usart_write_U08(i,3);
     200                usart_write_char(' ');
     201                usart_write_U16_hex(adc_values[i]);
     202                usart_write_char(' ');
     203                usart_write_U16(adc_values[i],7);
     204                usart_write_crlf();
     205        }
     206        usart_write_char('\n');
     207}
  • firmware/FSC/src/output.h

    r10697 r10910  
    55
    66void ad7719_output(U08 channel, U32 data);
    7 void adc_output(U08 channel, U08 data);
     7void adc_output(U08 channel, U16 data);
    88void adc_output_all();
    99void print_ad7719_nicely();
    1010void print_adc_nicely();
     11void print_adc_stupid();
    1112void print_status() ;
    1213
    13 
     14void print_help();
    1415void telegram_start();
    1516
  • firmware/FSC/src/parser.c

    r10697 r10910  
    4141                case 'g':                       // GET the voltage/current/humidity channels, which are enabled
    4242                        once_told_you = false;
    43                         for ( U08 i=0; i<VOLTAGE_CHANNELS/8; ++i ) {
     43                        for ( U08 i=0; i<VOLTAGE_REGS; ++i ) {
    4444                                adc_channels_ready[i]=0;
    4545                        }
     
    107107}
    108108*/
    109 /*
     109
    110110
    111111// this is the recent MSR parser
     
    242242                        case 'G':                       // GET the Temperature channels, which are enabled
    243243                                ad7719_values_printed = false;
    244                                 for ( U08 i=0; i<RESISTANCE_CHANNELS/8; ++i ) {
    245                                         ad7719_channels_ready[i]=0;
    246                                 }
    247                                 break;
     244                                reset_resistance_done();
     245                                reset_resistance_values();                             
     246                                break;
     247                               
    248248                        case 'g':                       // GET the voltage/current/humidity channels, which are enabled
    249249                                adc_values_printed = false;
    250                                 for ( U08 i=0; i<VOLTAGE_CHANNELS/8; ++i ) {
    251                                         adc_channels_ready[i]=0;
    252                                 }
     250                                reset_voltage_done();
     251                                reset_voltage_values();
    253252                                break;
    254253
     
    264263                                        ad7719_print_endless = false;
    265264                                break;         
     265                       
     266                        case 's':
     267                                print_status();
     268                                //print_adc_enable_status(true);
     269                                //usart_write_char('\n');
     270
     271                                //print_ad7719_enable_status(true);
     272                                //usart_write_char('\n');
     273                       
     274                                //usart_write_str((pU08)"time:");
     275                                //usart_write_float((float)local_ms/1000 , 1,7);
     276                                //usart_write_str((pU08)" sec.\n");
     277                                break; 
    266278                               
    267 
    268                         case 's':                       
    269                                 print_adc_enable_status(true);
    270                                 usart_write_char('\n');
    271 
    272                                 print_ad7719_enable_status(true);
    273                                 usart_write_char('\n');
    274                        
    275                                 usart_write_str((pU08)"time:");
    276                                 usart_write_float((float)local_ms/1000 , 1,7);
    277                                 usart_write_str((pU08)" sec.\n");
    278                                 break; 
     279                        case 'S':
     280                                write_status_via_eth();
     281                                break;
    279282
    280283                        case '!':
     
    306309}       // END of MSR_parser();
    307310
    308 */
     311
    309312
    310313///////////////////////////////////////////////////////////////////////////////////////
     
    342345                case 's':       // return *s*tatus information
    343346                        // this might take a lot of time... about... 25us per byte .. --> less than 25ms
    344                         w5100_set_TX(FSCregister, FSC_REGISTER_LENGTH);
     347                        write_status_via_eth();
     348                        //w5100_set_TX(FSCregister, FSC_REGISTER_LENGTH);
    345349                        break;
    346350                       
     
    372376        }
    373377}
     378void reset_resistance_values(){
     379        for (U08 i=0; i < RESISTANCE_CHANNELS; i++){
     380                ad7719_values[i] = 0;
     381        }
     382}
     383
     384
    374385void reset_voltage_done(){
    375         for (U08 i=0; i < (VOLTAGE_CHANNELS/8); i++){
     386        for (U08 i=0; i < (VOLTAGE_REGS); i++){
    376387                adc_channels_ready[i] = 0;
    377388        }
    378389}
     390void reset_voltage_values(){
     391        for (U08 i=0; i < VOLTAGE_CHANNELS; i++){
     392                adc_values[i] = 0;
     393        }
     394}
     395
    379396void reset_done(){
    380397        reset_resistance_done();
     
    387404        w5100_set_TX(eth_write_buffer, 2);
    388405}
     406
     407void write_status_via_eth() {
     408        // take care: ethernet write buffer is just 32 bytes long.
     409        eth_write_str("status: ");                              eth_writeln_str(nc_U32_to_hex(status));
     410        // better switch off interrupts here:
     411        // otherwise the numbers in time_sec and time_ms might get corrupt during output.
     412        cli();
     413        eth_write_str("time_s: ");                              eth_writeln_str(nc_U32_to_str(time_sec, 10));
     414        eth_write_str("mili_s: ");                              eth_writeln_str(nc_U16_to_str(time_ms, 6));
     415        sei();
     416       
     417        eth_write_str("R_ref : ");                              eth_writeln_str(nc_U16_to_str(ref_resistor, 6));
     418       
     419        eth_writeln_str("VOLTAGES\n");
     420                eth_write_str("enable:");                               
     421                for (U08 i=0; i<4 ; i++){
     422                        eth_write_str(nc_U08_to_bin(adc_enables[i]));
     423                        // need to tweak here in order to get some nice spaces...
     424                        eth_write_buffer[eth_write_index] = ' ';
     425                        eth_write_index++;
     426                }
     427                eth_writeln_str(nc_U08_to_bin(adc_enables[4]));
     428               
     429                eth_write_str("  done:");                               
     430                for (U08 i=0; i<4 ; i++){
     431                        eth_write_str(nc_U08_to_bin(adc_channels_ready[i]));
     432                        // need to tweak here in order to get some nice spaces...
     433                        eth_write_buffer[eth_write_index] = ' ';
     434                        eth_write_index++;
     435                }
     436                eth_writeln_str(nc_U08_to_bin(adc_channels_ready[4]));
     437
     438                eth_write_str("values:");                               
     439                for (U08 i=0; i<73 ; i++){
     440                        eth_write_str(nc_U16_to_str(adc_values[i], 6) );
     441                        // need to tweak here in order to get some nice spaces...
     442                        eth_write_buffer[eth_write_index] = ' ';
     443                        eth_write_index++;
     444                }
     445                eth_writeln_str(nc_U16_to_str(adc_values[73], 6) );
     446               
     447        eth_writeln_str("RESISTANCES\n");
     448                eth_write_str("enable:");                               
     449                for (U08 i=0; i<7 ; i++){
     450                        eth_write_str(nc_U08_to_bin(ad7719_enables[i]));
     451                        // need to tweak here in order to get some nice spaces...
     452                        eth_write_buffer[eth_write_index] = ' ';
     453                        eth_write_index++;
     454                }
     455                eth_writeln_str(nc_U08_to_bin(ad7719_enables[7]));
     456               
     457                eth_write_str("  done:");                               
     458                for (U08 i=0; i<7 ; i++){
     459                        eth_write_str(nc_U08_to_bin(ad7719_channels_ready[i]));
     460                        // need to tweak here in order to get some nice spaces...
     461                        eth_write_buffer[eth_write_index] = ' ';
     462                        eth_write_index++;
     463                }
     464                eth_writeln_str(nc_U08_to_bin(ad7719_channels_ready[7]));
     465
     466                eth_write_str("values:");                               
     467                for (U08 i=0; i<63 ; i++){
     468                        eth_write_str(nc_U32_to_str(ad7719_values[i], 10) );
     469                        // need to tweak here in order to get some nice spaces...
     470                        eth_write_buffer[eth_write_index] = ' ';
     471                        eth_write_index++;
     472                }
     473                eth_writeln_str(nc_U32_to_str(ad7719_values[63], 10) );
     474               
     475
     476}
  • firmware/FSC/src/parser.h

    r10697 r10910  
    1515void read_FSC_register();
    1616void reset_resistance_done();
     17void reset_resistance_values();
    1718void reset_voltage_done();
     19void reset_voltage_values();
    1820void reset_done();
    1921void simple_acknowledge();
    2022
     23// this function will loop over the entire FSC register and output it in a human readable form.
     24// I hope this is convenient.
     25void write_status_via_eth();
    2126#endif
  • firmware/FSC/src/w5100_spi_interface.c

    r10698 r10910  
    88volatile U08 eth_write_buffer[ETH_WRITE_BUFFER_SIZE];
    99
     10U08 eth_write_index;
    1011//-----------------------------------------------------------------------------
    1112// INTERFACE CONTROL VARS
     
    305306        {
    306307                return 0;
    307         }
    308         usart_write_str((U08*)"sending via eth: with pointer:");
    309         usart_write_U16_hex(string);
    310         usart_write_str((U08*)" #of bytes: ");
    311         usart_write_U16(NumBytes,4 );
    312         usart_write_char(' \n');
    313        
     308        }       
    314309        U16 last_TX_write_pointer = get_S0_TX_WR();
    315310        U16 offset = last_TX_write_pointer & S0_TX_MASK;
     
    340335                upper_size = (S0_RX_MASK + 1) - offset;
    341336                lower_size = NumBytes - upper_size;
    342                 for (U08 i = 0; i < upper_size; ++i)
     337                for (U16 i = 0; i < upper_size; ++i)
    343338                {
    344339                        w5100_write(start_address + i, string[i]);
    345340                }
    346                 for (U08 i = 0; i < lower_size; ++i)
     341                for (U16 i = 0; i < lower_size; ++i)
    347342                {
    348343                        w5100_write(S0_RX_BASE + i, string[upper_size+i]);
     
    351346        else // if not data turn over in RX-mem
    352347        {
    353                 for (U08 i = 0; i < NumBytes; ++i)
     348                for (U16 i = 0; i < NumBytes; ++i)
    354349                {
    355350                        w5100_write(start_address + i, string[i]);
     
    366361}
    367362
     363void eth_write_str( U08* str ){
     364
     365        while (*str) {
     366                if (eth_write_index < ETH_WRITE_BUFFER_SIZE) {
     367                        eth_write_buffer[eth_write_index++] = *str++;
     368                }
     369               
     370        }
     371        w5100_set_TX(eth_write_buffer, eth_write_index);
     372        eth_write_index = 0;
     373}
     374
     375void eth_writeln_str( U08* str ){
     376
     377        while (*str)
     378        {
     379                if (eth_write_index < ETH_WRITE_BUFFER_SIZE) {
     380                        eth_write_buffer[eth_write_index++] = *str++;
     381                }
     382        }
     383        if (eth_write_index < ETH_WRITE_BUFFER_SIZE) {
     384                eth_write_buffer[eth_write_index++] = '\n';
     385        }
     386        w5100_set_TX(eth_write_buffer, eth_write_index);
     387        eth_write_index = 0;
     388}
     389
  • firmware/FSC/src/w5100_spi_interface.h

    r10697 r10910  
    1111
    1212#define ETH_READ_BUFFER_SIZE 4
    13 #define ETH_WRITE_BUFFER_SIZE 4
     13#define ETH_WRITE_BUFFER_SIZE 32
    1414extern volatile U08 eth_read_buffer[ETH_READ_BUFFER_SIZE];
    1515extern volatile U08 eth_write_buffer[ETH_WRITE_BUFFER_SIZE];
     16extern U08 eth_write_index;
    1617//-----------------------------------------------------------------------------
    1718// Port Definitions
     
    227228
    228229
     230void eth_write_str( U08* str );
     231void eth_writeln_str( U08* str );
Note: See TracChangeset for help on using the changeset viewer.