Index: firmware/FSC/usb_src/FSC.c =================================================================== --- firmware/FSC/usb_src/FSC.c (revision 10754) +++ firmware/FSC/usb_src/FSC.c (revision 10754) @@ -0,0 +1,1090 @@ +//----------------------------------------------------------------------------- +#include "typedefs.h" +#include "application.h" +#include "spi_master.h" +#include "ad7719_adc.h" +#include "atmega_adc.h" +#include "usart.h" +#include "macros.h" +#include "interpol.h" +//#include "w5100_spi_interface.h" +#include +#include +#include +//----------------------------------------------------------------------------- +// definition of some functions: +// these function are implemented in this file, this is not doog coding style. +// sooner or later, they will be moved into more apropriate files. +U08 increase_adc (U08 channel); +U08 increase_ad7719 (U08 channel); +void Set_V_Muxer (U08 channel); +void Set_T_Muxer(U08 channel); +void talk(void);// never used up to now. +void ad7719_output(U08 channel, U32 data); +void adc_output(U08 channel, U08 data); +void adc_output_all(); +void parse(); //doesn't do anything at the moment +void check_if_measured_all() ; +void print_ad7719_nicely(); +void print_adc_nicely(); +void print_temp_nicely(); +// end of function definition: +//----------------------------------------------------------------------------- + +// MAIN WORKFLOW GLOBAL VARIABLES + bool verbose; + bool heartbeat_enable; + +// USART global variables + U08 usart_rx_buffer[USART_RX_BUFFER_SIZE]; + U08 usart_tx_buffer[USART_TX_BUFFER_SIZE]; + U08 usart_received_chars; + U08 usart_rx_buffer_index = 0; + U08 usart_tx_buffer_index = 0; + U08 usart_last_char; // last received char + +// USART FLAGS + bool usart_tx_buffer_overflow = false; // true if usart_tx_buffer was full. + bool usart_rx_ready = false; // EOL was received, parser needs to be called + +// TIMER global variable + volatile U32 local_ms = 0; + +// AD7719 global variables + #define TEMP_CHANNELS 64 + #define CHANNEL_BITMAP 8 + #define AD7719_READINGS_UNTIL_SETTLED 3 // bei3:480ms + U32 ad7719_values[TEMP_CHANNELS]; + U08 ad7719_enables[CHANNEL_BITMAP]; + U08 ad7719_channels_ready[CHANNEL_BITMAP]; + U08 ad7719_readings_since_last_muxing = 0; + U08 ad7719_current_channel = 0; + U32 ad7719_current_reading = 0; + bool ad7719_measured_all = false; + +// ATMEGA ADC global variables + #define V_CHANNELS 40 + #define I_CHANNELS 40 + #define H_CHANNELS 4 + #define V_BITMAP 5 + #define I_BITMAP 5 + #define H_BITMAP 1 + #define ADC_READINGS_UNTIL_SETTLED 1 + U08 adc_values[V_CHANNELS + I_CHANNELS + H_CHANNELS]; // stores measured voltage in steps of 16mV + U08 adc_enables[V_BITMAP + I_BITMAP + H_BITMAP]; + U08 adc_channels_ready[V_BITMAP + I_BITMAP + H_BITMAP]; + U08 adc_readings_since_last_muxing = 0; + U08 adc_current_channel = 0; + U08 adc_current_reading = 0; + bool adc_measured_all = false; + + bool once_told_you = true; + bool debug_mode = false; + +//----------------------------------------------------------------------------- +// M A I N --- M A I N --- M A I N --- M A I N --- M A I N +//----------------------------------------------------------------------------- +int main(void) +{ + app_init(); // Setup: Watchdog and I/Os + usart_init(); // Initialize serial interface + spi_init(); // Initialize SPI interface as master + ad7719_init(); // Initialize AD7719 ADC as SPI slave + atmega_adc_init(); + +// TIMER2 is used as local clock: +// configure timer 2 + TCCR2 = (1< counts up every 8us + OCR2 = 125-1; // --> output compare interrupt occurs every 125 x 8us = 1ms + // Compare Interrupt erlauben + TIMSK |= (1< heartbeat +//---------------------------------------------------------------------------- + //IF we need to send away one byte, and ready to send + + if ( (usart_tx_buffer_index > 0) && (UCSRA & (1< looking at the voltage channels +// channel 40..79 --> looking at the current channels +// channel 80..83 --> looking at the humidities +void Set_V_Muxer (U08 channel){ +U08 SB = 0; + // voltages + if (channel < 40) { + if (channel < 36) + SB = channel*2; + else + SB = (channel+1)*2; + } + // currents + else if (channel < 80) { + channel -= 40; + if (channel < 36) + SB = channel*2+1; + else + SB = (channel+1)*2+1; + } + // humidities + else if (channel < 84) { + channel -= 80; + switch (channel) { + case 0: + SB = 0x48; //0100.1000 + break; + case 1: + SB = 0x49; //0100.1001 + break; + case 2: + SB = 0x58; //0101.0010 + break; + case 3: + SB = 0x58; //0101.0011 + break; + } // end of switch-case + } // end of if (channel < some_number) + + PORTC = (PORTC & 0x80) | (0x7F & SB); // Here the muxer is switched. +} + +void Set_T_Muxer(U08 channel) { +U08 SA = 0x00; + + switch (channel/16) { + case 0: + SA |= 1<<4; // 0001.0000 + break; + case 1: + break; // 0000.0000 + case 2: + SA |= (1<<4)|(1<<5); // 0011.0000 + break; + case 3: + SA |= 1<<5; // 0010.0000 + break; + } + + SA = SA | (channel%16); + + PORTA = (PORTA & 0xC0) | (0x3F & SA); // Here the muxer is switched. +} + +void talk(void){ + +/* +// makes no sense to declare the 'new_measurement' vars here +// but maybe the whole function will be deleted, anyway ... +// I'm thinking about it. +bool ad7719_new_measurement; +bool atmega_adc_new_measurement; + if (verbose == true) { + // somebody wants to read every new measured value, even if it is trash! + // do not actually send away data ! + // just prepare the data to be send away. + if ( ad7719_new_measurement == true ) { + add_str_to_output_stream("ad7719: reading:"); + add_dec_to_output_stream(reading_since_last_muxer_switch,1); + add_str_to_output_stream(" temperature channel:"); + add_dec_to_output_stream(current_temperature_channel,2); + add_str_to_output_stream(" = "); + add_float_to_output_stream(current_ad7719_value,4,3); + add_str_to_output_stream("\n"); + } + if (atmega_adc_new_measurement == true) { + add_str_to_output_stream("atmega_adc: reading:"); + add_dec_to_output_stream(reading_since_last_muxer_switch,1); + add_str_to_output_stream(" voltage channel:"); + add_dec_to_output_stream(current_voltage_channel,2); + add_str_to_output_stream(" = "); + add_float_to_output_stream(current_atmega_adc_value,4,3); + add_str_to_output_stream("\n"); + } + } // end of: if verbose +*/ +} // end of talk() + +// this function generates some output. +void ad7719_output(U08 channel, U32 data) { +float value = 0; + usart_write_str((pU08)"R:"); //R for resistance + usart_write_char('A'+channel/8); // Letters A,B,C,D,E,F,G,H + //usart_write_char(' '); + usart_write_U08(channel%8+1,1); // Numbers 1...8 + usart_write_char(':'); + + + value = (6.25 * data) / ((U32)1 << 25); + usart_write_float(value, 3,6); + //usart_write_U32_hex(data); //data + + +} + +void adc_output(U08 channel, U08 data) { + +// if (channel < 40) +// usart_write_str((pU08)"V:"); +// else if (channel < 80) +// usart_write_str((pU08)"I:"); +// else if (channel < 84) +// usart_write_str((pU08)"H:"); + + if (channel <80) + { + switch ((channel%40)/4) { + case 0: + case 1: + usart_write_char('A'); + break; + case 2: + case 3: + usart_write_char('B'); + break; + case 4: + case 5: + usart_write_char('C'); + break; + case 6: + case 7: + usart_write_char('D'); + break; + case 8: + usart_write_char('E'); + break; + case 9: + usart_write_char('F'); + break; + default: + usart_write_char('?'); + break; + } + } + else // channel 80..83 + { + usart_write_char('H'); + } + //usart_write_char(' '); + + if ( (channel%40)/4 == 9) + usart_write_U08((channel)%4+1,1); // Numbers 1...4 + else + usart_write_U08((channel)%8+1,1); // Numbers 1...8 + + + //usart_write_U08(channel,2); // Numbers 1...8 + usart_write_char(':'); + usart_write_U16((U16)data*16, 4); //data +} + + +void adc_output_all() { + print_adc_nicely(); + print_ad7719_nicely(); +} + + +// this method parses the data, +// which came in via USART +// later it might as well parse the data from ethernet. +void parse() { +U08 command = usart_rx_buffer[0]; +// look at first byte +// I hope, I can manage to use one byte commands + usart_rx_buffer[USART_RX_BUFFER_SIZE-1] = 0; + usart_write_str((pU08)"got:"); + usart_write_str(usart_rx_buffer); + + + + switch (command) { + case 'E': // AD7719 enable bitmaps may be set + usart_write_str((pU08)"\n set enable bits of AD7719 Port "); + if ((usart_rx_buffer_index>=5) && + (usart_rx_buffer[2] >= 'A' && usart_rx_buffer[2] <= 'H')) + { + usart_write_char(usart_rx_buffer[2]); + usart_write_str((pU08)" to "); + usart_write_U08_hex(usart_rx_buffer[4]); + usart_write_char('\n'); + ad7719_enables[usart_rx_buffer[2]-'A']=usart_rx_buffer[4]; + ad7719_channels_ready[usart_rx_buffer[2]-'A']=0x00; + } + else if ((usart_rx_buffer_index=3) && + (usart_rx_buffer[1] >= 'A' && usart_rx_buffer[1] <= 'H')) + { + usart_write_char(usart_rx_buffer[1]); + if (usart_rx_buffer[2]!='0') { + usart_write_str((pU08)" to 0xFF\n"); + ad7719_enables[usart_rx_buffer[1]-'A']=0xFF; + } else + { + usart_write_str((pU08)" to 0x00\n"); + ad7719_enables[usart_rx_buffer[1]-'A']=0x00; + } + ad7719_channels_ready[usart_rx_buffer[1]-'A']=0x00; + } + else + { + usart_write_str((pU08)"\n something wrong\n"); + usart_write_str((pU08)"usart_rx_buffer_index: "); + usart_write_U08(usart_rx_buffer_index, 3); + usart_write_str((pU08)"\n usart_rx_buffer[2]: "); + usart_write_char(usart_rx_buffer[2]); + usart_write_str((pU08)"\n usart_rx_buffer[4]: "); + usart_write_U08_hex(usart_rx_buffer[4]); + usart_write_char('\n'); + } + break; + case 'e': // ATmega internal ADC enable bitmaps may be set + usart_write_str((pU08)"\n setting ADC enable registers all"); + if (usart_rx_buffer[1] == '0'){ + usart_write_str((pU08)"OFF \n"); + for ( U08 i=0; i AUX ADc is used for Temp measurement. + // ACH = 011 --> Tempsensor + // U/#B = 0 --> bipolar, but i'm not entirely sure if this is correct. + // ARN = 1 --> input range is REFIN2 , but when tempsensor is chosen, internal ref is used ... + +#define AD0CON_INIT 0x8E // 1000.1110 + // AD0EN is set + // WL is cleared --> 24bit + // CH = 00 --> AIN1 , AIN2 used + // U/#B = 1 --> unipolar + // RN=110 --> input range = +-1.28V --> whatever this means in ratiometric measurements. + + +#define MODE_IDLE 0x01 +#define MODE_SINGLE 0x02 +#define MODE_CONT 0x03 +#define MODE_INTERNAL_ZERO_CAL 0x04 // not tested +#define MODE_INTERNAL_FULL_CAL 0x05 // not tested + +// since the ADC is chopped, one should wait 3 conversions +// after the muxer was switched, until the reading is okay. +#define READINGS_UNTIL_AD7719_SETTLED 3 + +void ad7719_init(void); +void startconv(U08 continuous); +void stopconv(void); +U32 read_adc(void); +//----------------------------------------------------------------------------- +#endif Index: firmware/FSC/usb_src/application.c =================================================================== --- firmware/FSC/usb_src/application.c (revision 10754) +++ firmware/FSC/usb_src/application.c (revision 10754) @@ -0,0 +1,92 @@ +//----------------------------------------------------------------------------- + +#include "application.h" +#include + + +//----------------------------------------------------------------------------- + +volatile U08 app_reset_source; +//----------------------------------------------------------------------------- + +void app_init(void) +{ + app_reset_source = MCUSR; // Save last reset source + MCUSR = 0x00; // Clear reset source for next reset cycle + + + // Dangerous here: I still do not know much about the watchdog. + // This code is still from Udo Juerss. + + // The watchdog timer is disabled by default ("startup.asm") + #ifdef USE_WATCHDOG + WDTCSR = WDTOE | (1 << WDE); // Enable watchdog reset (~16ms) + #endif + + // define PORTS + // USART + DDRD &= ~(1< output + DDRC |= 0x7F; // SB-pins -> output + + // SPI + // set all CS's: output + DDRB |= (1 << SPI_E_CS); + DDRD |= (1 << SPI_AD_CS) |(1 << SPI_M_CS) |(1 << SPI_A_CS); + + // set all Chips selects HIGH + PORTB |= (1 << SPI_E_CS); + PORTD |= (1 << SPI_AD_CS) |(1 << SPI_M_CS) |(1 << SPI_A_CS); + + // set MOSI and SCK: output & // set MISO: input + SPI_DDR |= (1 << SPI_MOSI); + SPI_DDR |= (1 << SPI_SCLK); + SPI_DDR &= ~(1 << SPI_MISO); + + // set MOSI, SCK: HIGH. MISO leave alone. + SPI_PRT |= (1 << SPI_MOSI); + SPI_PRT |= (1 << SPI_SCLK); + //SPI_PRT |= (1 << SPI_MISO); + + // ADC + DDRD &= ~(1< free running mode + ADCSRA |= (1< use external reference voltage. + ADMUX |= 1< left adjust ac result in ADCH register --> 8bit resolution only. + ADMUX |= (0x1F & 0x06); //MUX = 0x06 --> Pin ADC6 = PA6 is used as ADC input pin. + + ADCSRA |= (1<= (min + 8*s)) + { + if (adcword >= (min + 12*s)) + { + if (adcword >= (min + 14*s)) + { + if (adcword >= (min + 15*s)) + { + if (adcword < max) + { + temprange = 16; + } + } + else + { + temprange = 15; + } + } + else + { + if (adcword >= (min + 13*s)) + { + temprange = 14; + } + else + { + temprange = 13; + } + } + } + else + { + if (adcword >= (min + 10*s)) + { + if (adcword >= (min + 11*s)) + { + temprange = 12; + } + else + { + temprange = 11; + } + } + else + { + if (adcword >= (min + 9*s)) + { + temprange = 10; + } + else + { + temprange = 9; + } + } + } + } + else + { + if (adcword >= (min + 4*s)) + { + if (adcword >= (min + 6*s)) + { + if (adcword >= (min + 7*s)) + { + temprange = 8; + } + else + { + temprange = 7; + } + } + else + { + if (adcword >= (min + 5*s)) + { + temprange = 6; + } + else + { + temprange = 5; + } + } + } + else + { + if (adcword >= (min + 2*s)) + { + if (adcword >= (min + 3*s)) + { + temprange = 4; + } + else + { + temprange = 3; + } + } + else + { + if (adcword >= (min + s)) + { + temprange = 2; + } + else + { + if (adcword > min) + { + temprange = 1; + } + } + } + } + } + + + switch (temprange) + { + case 1:{ // Temp. Range [-50°C , -34.375°C[ + temp = ((float)adcword / 20764.727846 - 252.7721); //20764.727846 - 252.7721 + } + break; + + case 2:{ // Temp. Range [-34.375°C , -18.75°C[ + temp = ((float)adcword / 20658.049789 - 253.8995); //20658.049789 - 253.8995 + } + break; + + case 3:{ // Temp. Range [-18.75°C , -3.125°C[ + temp = ((float)adcword / 20557.997603 - 255.0436); //20557.997603 - 255.0436 + } + break; + + case 4:{ // Temp. Range [-3.125°C , 12.5°C] + temp = ((float)adcword / 20462.362624 - 256.2209); //20462.362624 - 256.2209 + } + break; + + case 5:{ // Temp. Range [12.5°C , 28.125°C] + temp = ((float)adcword / 20367.745024 - 257.4692); //20367.745024 - 257.4692 + } + break; + + case 6:{ // Temp. Range [28.125°C , 43.75°C] + temp = ((float)adcword / 20273.127424 - 258.8021); //20273.127424 - 258.8021 + } + break; + + case 7:{ // Temp. Range [43.75°C , 59.375°C] + temp = ((float)adcword / 20178.509824 - 260.2208); //20178.509824 - 260.2208 + } + break; + + case 8:{ // Temp. Range [59.375°C , 75°C] + temp = ((float)adcword / 20083.892224 - 261.7265); //20083.892224 - 261.7265 + } + break; + + case 9:{ // Temp. Range [75°C , 90.625°C] + temp = ((float)adcword / 19989.274624 - 263.3203); //19989.274624 - 263.3203 + } + break; + + case 10:{ // Temp. Range [90.625°C , 106.25°C] + temp = ((float)adcword / 19894.657024 - 265.0037); //19894.657024 - 265.0037 + } + break; + + case 11:{ // Temp. Range [106.25°C , 121.875°C] + temp = ((float)adcword / 19800.039424 - 266.7778); //19800.039424 - 266.7778 + } + break; + + case 12:{ // Temp. Range [121.875°C , 137.5°C] + temp = ((float)adcword / 19705.421824 - 268.6439); //19705.421824 - 268.6439 + } + break; + + case 13:{ // Temp. Range [137.5°C , 153.125°C] + temp = ((float)adcword / 19610.804224 - 270.6035); //19610.804224 - 270.6035 + } + break; + + case 14:{ // Temp. Range [153.125°C , 168.75°C] + temp = ((float)adcword / 19516.186624 - 272.6578); //19516.186624 - 272.6578 + } + break; + + case 15:{ // Temp. Range [168.75°C , 184.375°C] + temp = ((float)adcword / 19421.569024 - 274.8082); //19421.569024 - 274.8082 + } + break; + + case 16:{ // Temp. Range [184.375°C , 200°C] + temp = ((float)adcword / 19326.951424 - 277.0562); //19326.951424 - 277.0562 + } + break; + default:{ // Temp. Range beyond [-50C , 200C] + PORTC = (PORTC | 0x04); + } + }// end of switch case statement + return temp; + + } + + void readandsendpress(void) + { + U32 adcword=0; + float press; + + adcword = read_adc(); + + if ( (adcword > 0x253332) && (adcword < 0xF80000) ) // Press. Range is [0Bar , 250Bar] + { + press = ((float)adcword / (62 * 836.658790402)) - 63.0091; // 62 Ohm + usart_write_float(press,2,5); + usart_write_flash_str(space_STR); + } + else + { + usart_write_flash_str(OoR_STR); // Press. is beyond [0Bar , 250Bar] + PORTC = (PORTC | 0x04); + } + + } + + +/* +Temperatur Sensoren von IST nach DIN60751, Kl.B +Messfehler +/- 0.30+0.005*|t| + +R(t) = R0(1 + At + Bt^2 + C(t-100)t^3) t = [-200, 0]°C +R(t) = R0(1 + At + Bt^2) t = [0, 850]°C + +A = 3.9083*10^-3[°C^-1] +B = -5.775*10^-7[°C^-2] +C = -4.183*10^-12[°C^-4] + +Strom durch R ist konstant 400uA +Messung ist ratiometrisch bezogen auf Referenzwiderstand an ADC Pin5 (REFIN-) und Pin6 (REFIN+) +Referenzwiderstand ist ca. 6.28kOhm. +ADC hat internes gain von 2. + +*/ + +float getresistance(void) +{ + + U32 adcword=0; + float resistance; + const float R_REF=6.25; // kilo-ohms + adcword = read_adc(); + U32 fullscale = 16777215L; //2^24 -1 + + resistance = ((float)adcword / (float)fullscale) /2.0 * R_REF; // divide through 2.0 because of PGA in ADC. + + return resistance; // in kilo-ohms +} + +U32 getadc(void) +{ +return read_adc(); +} + + + float calc_temp(U32 adcword) + { + U8 temprange = 17; + + float temp=NAN; + const U32 min = 0x404054; + const U32 max = 0x8CAF50; + const U32 s = 0x4C6F0; //(max-min)/16 = s(lice) + + if (adcword >= (min + 8*s)) + { + if (adcword >= (min + 12*s)) + { + if (adcword >= (min + 14*s)) + { + if (adcword >= (min + 15*s)) + { + if (adcword < max) + { + temprange = 16; + } + } + else + { + temprange = 15; + } + } + else + { + if (adcword >= (min + 13*s)) + { + temprange = 14; + } + else + { + temprange = 13; + } + } + } + else + { + if (adcword >= (min + 10*s)) + { + if (adcword >= (min + 11*s)) + { + temprange = 12; + } + else + { + temprange = 11; + } + } + else + { + if (adcword >= (min + 9*s)) + { + temprange = 10; + } + else + { + temprange = 9; + } + } + } + } + else + { + if (adcword >= (min + 4*s)) + { + if (adcword >= (min + 6*s)) + { + if (adcword >= (min + 7*s)) + { + temprange = 8; + } + else + { + temprange = 7; + } + } + else + { + if (adcword >= (min + 5*s)) + { + temprange = 6; + } + else + { + temprange = 5; + } + } + } + else + { + if (adcword >= (min + 2*s)) + { + if (adcword >= (min + 3*s)) + { + temprange = 4; + } + else + { + temprange = 3; + } + } + else + { + if (adcword >= (min + s)) + { + temprange = 2; + } + else + { + if (adcword > min) + { + temprange = 1; + } + } + } + } + } + + + switch (temprange) + { + case 1:{ // Temp. Range [-50°C , -34.375°C[ + temp = ((float)adcword / 20764.727846 - 252.7721); //20764.727846 - 252.7721 + } + break; + + case 2:{ // Temp. Range [-34.375°C , -18.75°C[ + temp = ((float)adcword / 20658.049789 - 253.8995); //20658.049789 - 253.8995 + } + break; + + case 3:{ // Temp. Range [-18.75°C , -3.125°C[ + temp = ((float)adcword / 20557.997603 - 255.0436); //20557.997603 - 255.0436 + } + break; + + case 4:{ // Temp. Range [-3.125°C , 12.5°C] + temp = ((float)adcword / 20462.362624 - 256.2209); //20462.362624 - 256.2209 + } + break; + + case 5:{ // Temp. Range [12.5°C , 28.125°C] + temp = ((float)adcword / 20367.745024 - 257.4692); //20367.745024 - 257.4692 + } + break; + + case 6:{ // Temp. Range [28.125°C , 43.75°C] + temp = ((float)adcword / 20273.127424 - 258.8021); //20273.127424 - 258.8021 + } + break; + + case 7:{ // Temp. Range [43.75°C , 59.375°C] + temp = ((float)adcword / 20178.509824 - 260.2208); //20178.509824 - 260.2208 + } + break; + + case 8:{ // Temp. Range [59.375°C , 75°C] + temp = ((float)adcword / 20083.892224 - 261.7265); //20083.892224 - 261.7265 + } + break; + + case 9:{ // Temp. Range [75°C , 90.625°C] + temp = ((float)adcword / 19989.274624 - 263.3203); //19989.274624 - 263.3203 + } + break; + + case 10:{ // Temp. Range [90.625°C , 106.25°C] + temp = ((float)adcword / 19894.657024 - 265.0037); //19894.657024 - 265.0037 + } + break; + + case 11:{ // Temp. Range [106.25°C , 121.875°C] + temp = ((float)adcword / 19800.039424 - 266.7778); //19800.039424 - 266.7778 + } + break; + + case 12:{ // Temp. Range [121.875°C , 137.5°C] + temp = ((float)adcword / 19705.421824 - 268.6439); //19705.421824 - 268.6439 + } + break; + + case 13:{ // Temp. Range [137.5°C , 153.125°C] + temp = ((float)adcword / 19610.804224 - 270.6035); //19610.804224 - 270.6035 + } + break; + + case 14:{ // Temp. Range [153.125°C , 168.75°C] + temp = ((float)adcword / 19516.186624 - 272.6578); //19516.186624 - 272.6578 + } + break; + + case 15:{ // Temp. Range [168.75°C , 184.375°C] + temp = ((float)adcword / 19421.569024 - 274.8082); //19421.569024 - 274.8082 + } + break; + + case 16:{ // Temp. Range [184.375°C , 200°C] + temp = ((float)adcword / 19326.951424 - 277.0562); //19326.951424 - 277.0562 + } + break; + default: + break; + }// end of switch case statement + return temp; + + } + + Index: firmware/FSC/usb_src/interpol.h =================================================================== --- firmware/FSC/usb_src/interpol.h (revision 10754) +++ firmware/FSC/usb_src/interpol.h (revision 10754) @@ -0,0 +1,19 @@ +#ifndef __INTERPOL_H +#define __INTERPOL_H +//----------------------------------------------------------------------------- + +#include "typedefs.h" +#include "application.h" +#include "num_conversion.h" +//----------------------------------------------------------------------------- + +// function prototype + + + float gettemp(void); + void readandsendpress(void); + float getresistance(void); + U32 getadc(void); + float calc_temp(U32 adcword); +//----------------------------------------------------------------------------- +#endif Index: firmware/FSC/usb_src/macros.h =================================================================== --- firmware/FSC/usb_src/macros.h (revision 10754) +++ firmware/FSC/usb_src/macros.h (revision 10754) @@ -0,0 +1,21 @@ +#ifndef __MACROS_H +#define __MACROS_H +//----------------------------------------------------------------------------- + +#define SET_BIT(byte,bit) (byte |= (1 << bit)) // Set bit in byte +#define CLR_BIT(byte,bit) (byte &= ~(1 << bit)) // Clear bit in byte +#define TGL_BIT(byte,bit) (byte ^= (1 << bit)) // Toggle bit in byte + +#define IS_SET(reg,bit) (reg & bit) // TRUE if bit = 1 +#define IS_CLR(reg,bit) !(reg & bit) // TRUE if bit = 0 + +#define BIT(x) (1 << (x)) // Define bit value +#define HI(x) ((x) >> 8) // Highbyte of 16-bit value + +#define ABS(x) ((x >= 0) ? x : -x) // Absolute value of x + +#define HI_HEX(x) ("0123456789ABCDEF" [x >> 4]) // Create hex of high nibble +#define LO_HEX(x) ("0123456789ABCDEF" [x & 0x0F]) // Create hex of low nibble +//----------------------------------------------------------------------------- + +#endif Index: firmware/FSC/usb_src/muxer_fsc.c =================================================================== --- firmware/FSC/usb_src/muxer_fsc.c (revision 10754) +++ firmware/FSC/usb_src/muxer_fsc.c (revision 10754) @@ -0,0 +1,74 @@ +#include "muxer_fsc.h" + +// Sets voltage Muxer to current channel +// this is a Muxing, and therefor the adc might need some time to settle. +// Since there are: +// - 40 voltage monitor channels +// - 40 current monitor channels +// - 4 humidity monitor channels +// the muxer is set as follows. +// channel 00..39 --> looking at the voltage channels +// channel 40..79 --> looking at the current channels +// channel 80..83 --> looking at the humidities +void Set_V_Muxer (U08 channel){ +U08 SB = 0; + // voltages + if (channel < 40) { + if (channel < 36) + SB = channel*2; + else + SB = (channel+1)*2; + } + // currents + else if (channel < 80) { + channel -= 40; + if (channel < 36) + SB = channel*2+1; + else + SB = (channel+1)*2+1; + } + // humidities + else if (channel < 84) { + channel -= 80; + switch (channel) { + case 0: + SB = 0x48; //0100.1000 + break; + case 1: + SB = 0x49; //0100.1001 + break; + case 2: + SB = 0x58; //0101.0010 + break; + case 3: + SB = 0x58; //0101.0011 + break; + } // end of switch-case + } // end of if (channel < some_number) + + PORTC = (PORTC & 0x80) | (0x7F & SB); // Here the muxer is switched. +} + +void Set_T_Muxer(U08 channel) { +U08 SA = 0x00; + + switch (channel/16) { + case 0: + SA |= 1<<4; // 0001.0000 + break; + case 1: + break; // 0000.0000 + case 2: + SA |= (1<<4)|(1<<5); // 0011.0000 + break; + case 3: + SA |= 1<<5; // 0010.0000 + break; + } + + SA = SA | (channel%16); + + PORTA = (PORTA & 0xC0) | (0x3F & SA); // Here the muxer is switched. +} + + Index: firmware/FSC/usb_src/muxer_fsc.h =================================================================== --- firmware/FSC/usb_src/muxer_fsc.h (revision 10754) +++ firmware/FSC/usb_src/muxer_fsc.h (revision 10754) @@ -0,0 +1,19 @@ +// include either muxer_fsc.h or muxer_msr.h +#ifndef __MUXER_FSC_H +#define __MUXER_FSC_H + +#include "typedefs.h" + + #ifndef __MUXER_XXX_H_ + # define __MUXER_XXX_H "muxer_fsc.h" + #else + # error "Attempt to include more than one file." + #endif + + void Set_V_Muxer(U08 channel); + void Set_T_Muxer(U08 channel); + + + + +#endif Index: firmware/FSC/usb_src/num_conversion.c =================================================================== --- firmware/FSC/usb_src/num_conversion.c (revision 10754) +++ firmware/FSC/usb_src/num_conversion.c (revision 10754) @@ -0,0 +1,378 @@ +//----------------------------------------------------------------------------- + +#include "num_conversion.h" +#include "math.h" +//----------------------------------------------------------------------------- + +//__flash U08 NC_HEX_ARRAY[] = "0123456789ABCDEF"; +U08 NC_HEX_ARRAY[] = "0123456789ABCDEF"; +//----------------------------------------------------------------------------- + +U08 nc_buffer[NC_BUFFER_LENGTH]; // Conversion buffer +U08 nc_format_buffer[NC_BUFFER_LENGTH]; // Format buffer + +static U08 nc_int_digits[8]; +static U08 nc_dec_digits[6]; +//----------------------------------------------------------------------------- + +pU08 nc_format(pU08 source_ptr,U08 digits) +{ + U08 len = strlen((const char *)source_ptr); + pU08 dest_ptr = (pU08)&nc_format_buffer; + + // Fillup loop + while (digits-- > len) + { + *dest_ptr++ = NC_FILL_CHAR; + } + + // Copy loop + while (len--) + { + *dest_ptr++ = *source_ptr++; + } + + *dest_ptr = 0; // Terminate format string + + return (pU08)&nc_format_buffer; +} +//----------------------------------------------------------------------------- + +pU08 nc_U08_to_str(U08 value,U08 digits) +{ + pU08 pstr = nc_buffer; + + if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100)); + if (value >= 10) *pstr++ = ('0' + (value % 100 / 10)); + *pstr++ = ('0' + (value % 10)); + *pstr = 0; + + if (!digits) // If digits = 0, then return buffer start + { + return nc_buffer; + } + else // Do formatted output + { + return nc_format(nc_buffer,digits); + } +} +//----------------------------------------------------------------------------- + +pU08 nc_S08_to_str(S08 signed_value,U08 digits) +{ + pU08 pstr = nc_buffer; + U08 value; + + if (signed_value < 0) + { + *pstr++ = '-'; + value = -signed_value; + } + else + { + value = signed_value; + } + + if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100)); + if (value >= 10) *pstr++ = ('0' + (value % 100 / 10)); + *pstr++ = ('0' + (value % 10)); + *pstr = 0; + + if (!digits) // If digits = 0, then return buffer start + { + return nc_buffer; + } + else // Do formatted output + { + return nc_format(nc_buffer,digits); + } +} +//----------------------------------------------------------------------------- + +pU08 nc_U08_to_hex(U08 value) +{ + pU08 pstr = nc_buffer; + + *pstr++ = NC_HEX_ARRAY[value >> 4]; + *pstr++ = NC_HEX_ARRAY[value & 0x0F]; + *pstr = 0; + + return (nc_buffer); +} +//----------------------------------------------------------------------------- + +pU08 nc_U08_to_bin(U08 value) +{ + pU08 pstr = nc_buffer; + U08 n; + + for (n = 7; n < 8; n--) + { + if (value & (1 << n)) + { + *pstr++ = '1'; + } + else + { + *pstr++ = '0'; + } + } + + *pstr = 0; + + return (nc_buffer); +} +//----------------------------------------------------------------------------- + +pU08 nc_U16_to_str(U16 value,U08 digits) +{ + pU08 pstr = nc_buffer; + + if (value >= 10000) *pstr++ = ('0' + (value / 10000)); + if (value >= 1000) *pstr++ = ('0' + (value % 10000 / 1000)); + if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100)); + if (value >= 10)*pstr++ = ('0' + (value % 100 / 10)); + *pstr++ = ('0' + (value % 10)); + *pstr = 0; + + if (!digits) // If digits = 0, then return buffer start + { + return nc_buffer; + } + else // Do formatted output + { + return nc_format(nc_buffer,digits); + } +} +//----------------------------------------------------------------------------- + +pU08 nc_S16_to_str(S16 signed_value,U08 digits) +{ + pU08 pstr = nc_buffer; + U16 value; + + if (signed_value < 0) + { + *pstr++ = '-'; + value = -signed_value; + } + else + { + value = signed_value; + } + + if (value >= 10000) *pstr++ = ('0' + (value / 10000)); + if (value >= 1000) *pstr++ = ('0' + (value % 10000 / 1000)); + if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100)); + if (value >= 10) *pstr++ = ('0' + (value % 100 / 10)); + *pstr++ = ('0' + (value % 10)); + *pstr = 0; + + if (!digits) // If digits = 0, then return buffer start + { + return nc_buffer; + } + else // Do formatted output + { + return nc_format(nc_buffer,digits); + } +} +//----------------------------------------------------------------------------- + +pU08 nc_U16_to_hex(U16 value) +{ + pU08 pstr = nc_buffer; + tMEM16 data; + + data.word = value; + + *pstr++ = NC_HEX_ARRAY[(data.byte[1]) >> 4]; + *pstr++ = NC_HEX_ARRAY[(data.byte[1]) & 0x0F]; + + *pstr++ = NC_HEX_ARRAY[(data.byte[0]) >> 4]; + *pstr++ = NC_HEX_ARRAY[(data.byte[0]) & 0x0F]; + + *pstr = 0; + + return (nc_buffer); +} +//----------------------------------------------------------------------------- + +pU08 nc_U32_to_str(U32 value,U08 digits) +{ + pU08 pstr = nc_buffer; + + if (value >= 1000000000) *pstr++ = ('0' + (value / 1000000000)); + if (value >= 100000000) *pstr++ = ('0' + (value % 1000000000 / 100000000)); + if (value >= 10000000) *pstr++ = ('0' + (value % 100000000 / 10000000)); + if (value >= 1000000) *pstr++ = ('0' + (value % 10000000 / 1000000)); + if (value >= 100000) *pstr++ = ('0' + (value % 1000000 / 100000)); + if (value >= 10000) *pstr++ = ('0' + (value % 100000 / 10000)); + if (value >= 1000) *pstr++ = ('0' + (value % 10000 / 1000)); + if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100)); + if (value >= 10) *pstr++ = ('0' + (value % 100 / 10)); + + *pstr++ = ('0' + (value % 10)); + *pstr = 0; + + if (!digits) // If digits = 0, then return buffer start + { + return nc_buffer; + } + else // Do formatted output + { + return nc_format(nc_buffer,digits); + } +} +//----------------------------------------------------------------------------- + +pU08 nc_S32_to_str(S32 signed_value,U08 digits) +{ + pU08 pstr = nc_buffer; + U32 value; + + if (signed_value < 0) + { + *pstr++ = '-'; + value = -signed_value; + } + else + { + value = signed_value; + } + + if (value >= 1000000000) *pstr++ = ('0' + (value / 1000000000)); + if (value >= 100000000) *pstr++ = ('0' + (value % 1000000000 / 100000000)); + if (value >= 10000000) *pstr++ = ('0' + (value % 100000000 / 10000000)); + if (value >= 1000000) *pstr++ = ('0' + (value % 10000000 / 1000000)); + if (value >= 100000) *pstr++ = ('0' + (value % 1000000 / 100000)); + if (value >= 10000) *pstr++ = ('0' + (value % 100000 / 10000)); + if (value >= 1000) *pstr++ = ('0' + (value % 10000 / 1000)); + if (value >= 100) *pstr++ = ('0' + (value % 1000 / 100)); + if (value >= 10) *pstr++ = ('0' + (value % 100 / 10)); + + *pstr++ = ('0' + (value % 10)); + *pstr = 0; + + if (!digits) // If digits = 0, then return buffer start + { + return nc_buffer; + } + else // Do formatted output + { + return nc_format(nc_buffer,digits); + } +} +//----------------------------------------------------------------------------- + +pU08 nc_U32_to_hex(U32 value) +{ + pU08 pstr = nc_buffer; + tMEM32 data; + + data.dword = value; + + *pstr++ = NC_HEX_ARRAY[(data.byte[3]) >> 4]; + *pstr++ = NC_HEX_ARRAY[(data.byte[3]) & 0x0F]; + + *pstr++ = NC_HEX_ARRAY[(data.byte[2]) >> 4]; + *pstr++ = NC_HEX_ARRAY[(data.byte[2]) & 0x0F]; + + *pstr++ = NC_HEX_ARRAY[(data.byte[1]) >> 4]; + *pstr++ = NC_HEX_ARRAY[(data.byte[1]) & 0x0F]; + + *pstr++ = NC_HEX_ARRAY[(data.byte[0]) >> 4]; + *pstr++ = NC_HEX_ARRAY[(data.byte[0]) & 0x0F]; + + *pstr = 0; + + return (nc_buffer); +} +//----------------------------------------------------------------------------- + +pU08 nc_float_to_str(float value,U08 decimals,U08 digits) +{ + S08 n; + U08 int_count; + U08 dec_count; + float dec_part; + U32 int_part; + pU08 pstr = nc_buffer; + + if (decimals > 5) + { + decimals = 5; + } + + if (isnan(value)){ + pstr[0]=pstr[2]='n'; + pstr[1]='a'; + pstr[3]=0; + return nc_buffer; + } + if (value < 0.0) + { + *pstr++ = '-'; + value = -value; + } + + int_part = value; + dec_part = value - int_part; + int_count = 0; + dec_count = 0; + + if (int_part == 0) + { + *pstr++ = '0'; + } + + while (int_part > 0) + { + nc_int_digits[int_count] = int_part % 10; + int_part = int_part - nc_int_digits[int_count]; + + if (int_part > 0) + { + int_part = int_part / 10; + } + + int_count++; // go to the next digit + } + + while (dec_count < decimals) + { + dec_part = dec_part * 10.0; + nc_dec_digits[dec_count] = dec_part; + + if (nc_dec_digits[dec_count] > 0) + { + dec_part = dec_part - nc_dec_digits[dec_count]; + } + + dec_count++; + } + + for (n = int_count - 1; n > -1; n--) + { + *pstr++ = 48 + nc_int_digits[n]; + } + + *pstr++ = '.'; + + for (n = 0; n < dec_count; n++) + { + *pstr++ = 48 + nc_dec_digits[n]; + } + + // Terminate string + *pstr = 0; + + if (!digits) // If digits = 0, then return buffer start + { + return nc_buffer; + } + else // Do formatted output + { + return nc_format(nc_buffer,digits); + } +} Index: firmware/FSC/usb_src/num_conversion.h =================================================================== --- firmware/FSC/usb_src/num_conversion.h (revision 10754) +++ firmware/FSC/usb_src/num_conversion.h (revision 10754) @@ -0,0 +1,29 @@ +#ifndef __NUM_CONVERSION_H +#define __NUM_CONVERSION_H +//----------------------------------------------------------------------------- + +#include "typedefs.h" +//----------------------------------------------------------------------------- + +#define NC_BUFFER_LENGTH 16 // Conversion buffer size +#define NC_FILL_CHAR 32 // Character for post digits +//----------------------------------------------------------------------------- + +extern U08 nc_buffer[]; +//----------------------------------------------------------------------------- + +pU08 nc_format(pU08 source_ptr,U08 digits); +pU08 nc_U08_to_str(U8 value,U08 digits); +pU08 nc_S08_to_str(S08 signed_value,U08 digits); +pU08 nc_U08_to_hex(U08 value); +pU08 nc_U08_to_bin(U08 value); +pU08 nc_U16_to_str(U16 value,U08 digits); +pU08 nc_S16_to_str(S16 signed_value,U08 digits); +pU08 nc_U16_to_hex(U16 value); +pU08 nc_U32_to_str(U32 value,U08 digits); +pU08 nc_S32_to_str(S32 signed_value,U08 digits); +pU08 nc_U32_to_hex(U32 value); +pU08 nc_float_to_str(float value,U08 decimals,U08 digits); +//----------------------------------------------------------------------------- + +#endif Index: firmware/FSC/usb_src/output.c =================================================================== --- firmware/FSC/usb_src/output.c (revision 10754) +++ firmware/FSC/usb_src/output.c (revision 10754) @@ -0,0 +1,173 @@ +#include "output.h" +#include "usart.h" + +void print_status() { + usart_write_str((pU08)"adc status:\n"); + for (U08 i=0; i< V_BITMAP + I_BITMAP + H_BITMAP;++i) { + usart_write_U08_bin(adc_enables[i]); + usart_write_char(' '); + } + usart_write_char('\n'); + for (U08 i=0; i< V_BITMAP + I_BITMAP + H_BITMAP;++i){ + usart_write_U08_bin(adc_channels_ready[i]); + usart_write_char(' '); + } + usart_write_char('\n'); + + usart_write_str((pU08)"ad7719 status:\n"); + for (U08 i=0; i< CHANNEL_BITMAP;++i) { + usart_write_U08_bin(ad7719_enables[i]); + usart_write_char(' '); + } + usart_write_char('\n'); + for (U08 i=0; i< CHANNEL_BITMAP;++i){ + usart_write_U08_bin(ad7719_channels_ready[i]); + usart_write_char(' '); + } + usart_write_char('\n'); + + usart_write_str((pU08)"time:"); + usart_write_float((float)local_ms/1000 , 1,7); + usart_write_str((pU08)" sec.\n"); + + usart_write_str((pU08)"adc measured all: "); + if (adc_measured_all) + usart_write_str((pU08)" true\n"); + else + usart_write_str((pU08)"false\n"); + + usart_write_str((pU08)"ad7719 measured all: "); + if (ad7719_measured_all) + usart_write_str((pU08)" true\n"); + else + usart_write_str((pU08)"false\n"); + + usart_write_str((pU08)"adc current channel:"); + usart_write_U08(adc_current_channel,2); + usart_write_char('\n'); + + usart_write_str((pU08)"ad7719 current channel:"); + usart_write_U08(ad7719_current_channel,2); + usart_write_char('\n'); + +} +void print_adc_nicely() { + usart_write_str((pU08)"\n printing voltages in mV:\n"); + // output: U08 adc_values[V_CHANNELS + I_CHANNELS + H_CHANNELS]; + for (U08 i=0; i< V_CHANNELS + I_CHANNELS + H_CHANNELS;++i) { + if (i%8 == 0) usart_write_char('\n'); + adc_output(i, adc_values[i]); + usart_write_str((pU08)" "); + } + usart_write_char('\n'); +} + + +void print_ad7719_nicely() +{ + float value; + + usart_write_str((pU08)"\n printing measured resistance in kohms:\n"); + + for (U08 i=0; i< TEMP_CHANNELS;++i) { + if (i%8 == 0) usart_write_char('\n'); + + // print channel name: + usart_write_str((pU08)"R:"); //R for resistance + usart_write_char('A'+i/8); // Letters A,B,C,D,E,F,G,H + //usart_write_char(' '); + usart_write_U08(i%8+1,1); // Numbers 1...8 + usart_write_char(':'); + + // check if this channel is enabled in the bitmap + if (ad7719_enables[i/8] & (1< eighther cpol=cpha=0 or cpol=cpha=1 + // THAT IS NOT TRUE!!!! + // only mode 0 !!!!!!!!!!!!!!!!!!!!!!!!!!!1 + // MSB first + // SCLK time 70ns minimum --> 14.2MHz maximum + // + // 2.) AD7719 + // supports mode=3 --> cpol=cpha=1 + // MSB first + // SCLK time 200ns minimum --> 5MHz maximum + // + // 3.) LIS3LV + // SPI CLK idles high --> cpol=1 + // data valid at rising edge. --> cpha=1 as well + // ==> mode 3 is supported only. + // MSB first, but take take at multi byte transfers. LSbyte first + // SCLK time - is not mentioned in the datasheet + // + // 4.) MAX6662 Tempsensor + // since it is not assembled, this information is not necessary. + + // fastes SPI CLK frequency can be --> F_CPU/2 = 4MHz + // slowest can be --> F_CPU/128 = 62.5KHz + + // Lets try with the fastest! + spi_clock_index = 0; // Set Clockindex for lowest clock speed (F_CPU / 128) + + spi_dord = 0; // Data Order MSB first dord = 0 --> good for all devices + spi_cpol = 1; spi_cpha = 1; // SPI mode=3 --> good for all devices + spi_setup(); // Setup SPI bits and clock speed + +} +//----------------------------------------------------------------------------- +void spi_setup(void) +{ + // Disable SPI, clear all flags + SPCR = 0; + + // Set/Clear bits DORD, CPOL and CPHA in SPI Control Register + spi_dord & 0x01 ? (SPCR |= (1 << DORD)) : (SPCR &= ~(1 << DORD)); + spi_cpol & 0x01 ? (SPCR |= (1 << CPOL)) : (SPCR &= ~(1 << CPOL)); + spi_cpha & 0x01 ? (SPCR |= (1 << CPHA)) : (SPCR &= ~(1 << CPHA)); + + switch (spi_clock_index) + { + case 0:{ // F_CPU / 128 + SPCR |= (1 << SPR1) | (1 << SPR0); + SPSR &= ~(1 < SPI_MAX_CLOCK_INDEX) + { + clock_index = SPI_MAX_CLOCK_INDEX; + } + + spi_clock_index = clock_index; + + spi_setup(); // Setup SPI bits and clock speed +} +//----------------------------------------------------------------------------- + +void spi_set_dord(U08 dord) +{ + if (dord > 1) + { + dord = 1; + } + + spi_dord = dord; + + spi_setup(); // Setup SPI bits and clock speed +} +//----------------------------------------------------------------------------- + +void spi_set_cpol(U08 cpol) +{ + if (cpol > 1) + { + cpol = 1; + } + + spi_cpol = cpol; + + spi_setup(); // Setup SPI bits and clock speed +} +//----------------------------------------------------------------------------- + +void spi_set_cpha(U08 cpha) +{ + if (cpha > 1) + { + cpha = 1; + } + + spi_cpha = cpha; + + spi_setup(); // Setup SPI bits and clock speed +} + +//----------------------------------------------------------------------------- + +void spi_transfer(U08 bytes, U08 device) +{ +/* +#define SPI_E_CS PB4 //device 0 +#define SPI_AD_CS PD3 //device 1 +#define SPI_M_CS PD4 //device 2 +#define SPI_A_CS PD5 //device 3 +*/ + U08 n; + // Transfer requested bytes + for (n = 0; n < bytes; n++) + { + // Check for active slave select level + if (SPI_DEVICE_ACTIVE_HIGH[device]) + { + if (device == 0) { + PORTB |= (1 << SPI_DEVICE_SS[device]); // Set Slave Select high + } else { + PORTD |= (1 << SPI_DEVICE_SS[device]); // Set Slave Select high + } + } + else + { + if (device == 0) { + PORTB &= ~(1 << SPI_DEVICE_SS[device]); // Set Slave Select low + } else { + PORTD &= ~(1 << SPI_DEVICE_SS[device]); // Set Slave Select low + } + } + + + spi_read_buffer[n] = spi_transfer_byte(spi_write_buffer[n]); + + + // Check for inactive slave select level + if (SPI_DEVICE_ACTIVE_HIGH[device]) + { + if (device == 0) { + PORTB &= ~(1 << SPI_DEVICE_SS[device]); // Set Slave Select low + } else { + PORTD &= ~(1 << SPI_DEVICE_SS[device]); // Set Slave Select low + } + } + else + { + if (device == 0) { + PORTB |= (1 << SPI_DEVICE_SS[device]); // Set Slave Select high + } else { + PORTD |= (1 << SPI_DEVICE_SS[device]); // Set Slave Select high + } + } + + } +} +//----------------------------------------------------------------------------- + +U08 spi_transfer_byte(U08 data) +{ + // Start SPI Transfer + if (!(SPCR & (1< +#include +#include +#include +#include +#include +#include +#include +#include "macros.h" +#include + +//----------------------------------------------------------------------------- + +#define true 1 +#define TRUE 1 +#define ON 1 +#define on 1 +#define SET 1 +#define set 1 + +#define false 0 +#define FALSE 0 +#define OFF 0 +#define off 0 +#define CLEAR 0 +#define clear 0 + +#define BIT0 0x01 +#define BIT1 0x02 +#define BIT2 0x04 +#define BIT3 0x08 +#define BIT4 0x10 +#define BIT5 0x20 +#define BIT6 0x40 +#define BIT7 0x80 +#define BIT8 0x0100 +#define BIT9 0x0200 +#define BIT10 0x0400 +#define BIT11 0x0800 +#define BIT12 0x1000 +#define BIT13 0x2000 +#define BIT14 0x4000 +#define BIT15 0x8000 +#define BIT16 0x010000 +#define BIT17 0x020000 +#define BIT18 0x040000 +#define BIT19 0x080000 +#define BIT20 0x100000 +#define BIT21 0x200000 +#define BIT22 0x400000 +#define BIT23 0x800000 +#define BIT24 0x01000000 +#define BIT25 0x02000000 +#define BIT26 0x04000000 +#define BIT27 0x08000000 +#define BIT28 0x10000000 +#define BIT29 0x20000000 +#define BIT30 0x40000000 +#define BIT31 0x80000000 +//----------------------------------------------------------------------------- + +// Typendeklarationen +typedef signed char S8; +typedef signed char S08; +typedef signed char tS08; +typedef unsigned char U8; +typedef unsigned char U08; +typedef unsigned char tU08; + +typedef signed int S16; +typedef signed int tS16; +typedef unsigned int U16; +typedef unsigned int tU16; +typedef signed long S32; +typedef signed long tS32; +typedef unsigned long U32; +typedef unsigned long tU32; + +typedef S08 *pS8; +typedef S08 *pS08; +typedef U08 *pU8; +typedef U08 *pU08; +typedef S16 *pS16; +typedef U16 *pU16; +typedef S32 *pS32; +typedef U32 *pU32; +typedef float *pfloat; + +typedef U08 BOOL; +typedef BOOL *pBOOL; +typedef U08 bool; + +//typedef U08 __flash *fpU08; //geht nicht mit gcc +//typedef U08 PROGMEM prog_U08; +//typedef prog_U08 *fpU08; +typedef U08 *fpU08; + +typedef union uMEM16 // Word and Byte access to 16-Bit data +{ + U16 word; // Word + pU16 pword; // Pointer to Word + U08 byte[2]; // Byte + pU08 pbyte; // Pointer to Byte +} tMEM16; + +typedef union uMEM32 // DWord, Word and Byte access to 32-Bit data +{ + U32 dword; // DWORD + pU32 pdword[2]; // Pointer to U32 + + float fp; // Float + pfloat pfp[2]; // Pointer to float + + U16 word[2]; // Word + pU16 pword[2]; // Pointer to U16 + + U08 byte[4]; // Byte + pU08 pbyte[2]; // Pointer to U08 + +} tMEM32; + +typedef enum // Enumeration of watchdog prescale values +{ + WDT_PS_2K, // 2048 cycles (16ms) + WDT_PS_4K, // 40968 cycles (32ms) + WDT_PS_8K, // 8192 cycles (64ms) + WDT_PS_16K, // 16384 cycles (0.125s) + WDT_PS_32K, // 32768 cycles (0.25s) + WDT_PS_64K, // 65536 cycles (0.5s) + WDT_PS_128K, // 131072 cycles (1.0s) + WDT_PS_256K, // 262144 cycles (2.0s) + WDT_PS_512K, // 524288 cycles (4.0s) + WDT_PS_1024K // 1048576 cycles (8.0s) +} tWDT_PRESCALE; +//----------------------------------------------------------------------------- + +#endif Index: firmware/FSC/usb_src/usart.c =================================================================== --- firmware/FSC/usb_src/usart.c (revision 10754) +++ firmware/FSC/usb_src/usart.c (revision 10754) @@ -0,0 +1,269 @@ +//----------------------------------------------------------------------------- + +#include "usart.h" +#include +//----------------------------------------------------------------------------- + +#ifdef USART_USE_RX_IRQ + U08 usart_rx_buffer[USART_RX_BUFFER_SIZE]; + //U08 *usart_rx_buffer_ptr = &usart_rx_buffer[0]; + U08 usart_received_chars; + volatile BOOL usart_rx_ready = false; + static U08 usart_rx_buffer_index = 0; + static U08 usart_receive_char; + static BOOL usart_receive_suspended = false; + volatile BOOL ISR_toggle_out = false; +#endif +//----------------------------------------------------------------------------- + +void usart_init(void) +{ + USART_SET_BAUDRATE(USART_BAUDRATE); + + UCSRA = 0x00; + + UCSRB = 0x00; // Disable receiver and transmitter and interrupts + +#ifdef USART_USE_RX + UCSRB |= (1 << RXEN); // Turn on receiver + DDRD &= ~(1<= 'a' && usart_receive_char <= 'z') + { + usart_receive_char -= 32; + } +#endif + + if (usart_rx_buffer_index < USART_RX_BUFFER_SIZE - 1) // Store character + { + usart_rx_buffer[usart_rx_buffer_index++] = usart_receive_char; + usart_writeln_str(usart_rx_buffer); + } + + //usart_write_char(usart_rx_buffer[usart_rx_buffer_index]); + //usart_writeln_str(usart_rx_buffer); + //usart_write_char(usart_rx_buffer[1,2]); + //usart_write_char(usart_rx_buffer[usart_rx_buffer_index]); + //usart_writeln_flash_str(*usart_rx_buffer); + //usart_write_char(usart_rx_buffer); +} +#endif +/* +#define uart_maxstrlen 64 + +volatile U8 uart_str_complete=0; +volatile U8 uart_str_count=0; +volatile U8 uart_string[uart_maxstrlen+1]=""; + +ISR(USART_RXC_vect) +{ + unsigned char buffer = 64; + // Daten aus dem Puffer lesen + buffer = UDR; + UDR = buffer; + if ( uart_str_complete==0 ){ // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen + // Daten werden erst in string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird + if (buffer!='\n' && buffer!='\r' && uart_str_count> 8),\ + UBRRL = (U08)(((U32)F_CPU) /\ + ((U32)br * 16) - 1)) +//----------------------------------------------------------------------------- +/* +extern U08 usart_rx_buffer[]; +extern volatile BOOL usart_rx_ready; +extern volatile BOOL ISR_toggle_out; +extern U08 usart_received_chars; +*/ +extern bool usart_tx_buffer_overflow; +extern U08 usart_tx_buffer_index; +extern U08 usart_tx_buffer[USART_TX_BUFFER_SIZE]; +extern U08 usart_received_chars; +//----------------------------------------------------------------------------- + +void usart_init(void); +void usart_write_char(U08 data); +void usart_write_crlf(void); +void usart_write_str(pU08 str); +void usart_writeln_str(pU08 str); +void usart_write_flash_str(fpU08 str); +void usart_writeln_flash_str(fpU08 str); +void usart_write_U08(U08 value,U08 digits); +void usart_write_S08(S08 value,U08 digits); +void usart_write_U08_hex(U08 value); +void usart_write_U08_bin(U08 value); +void usart_write_U16(U16 value,U08 digits); +void usart_write_S16(S16 value,U08 digits); +void usart_write_U16_hex(U16 value); +void usart_write_U32(U32 value,U08 digits); +void usart_write_S32(S32 value,U08 digits); +void usart_write_U32_hex(U32 value); +void usart_write_float(float value,U08 decimals,U08 digits); +//----------------------------------------------------------------------------- + +#endif Index: firmware/FSC/usb_src/w5100_spi_interface.c =================================================================== --- firmware/FSC/usb_src/w5100_spi_interface.c (revision 10754) +++ firmware/FSC/usb_src/w5100_spi_interface.c (revision 10754) @@ -0,0 +1,302 @@ +//----------------------------------------------------------------------------- + +#include "w5100_spi_interface.h" +#include "spi_master.h" +volatile BOOL sock0_connection_established = false; +volatile U08 eth_read_buffer[ETH_READ_BUFFER_SIZE]; +volatile U08 eth_write_buffer[ETH_WRITE_BUFFER_SIZE]; + +//----------------------------------------------------------------------------- + +void w5100_write( U16 addr, U08 data) +{ +spi_write_buffer[0]=0xF0; +spi_write_buffer[1]=(U08)(addr>>8); +spi_write_buffer[2]=(U08)(addr); +spi_write_buffer[3]=data; + +spi_transfer(4, 0); +// spi_read_buffer should contain 0x00 0x01 0x02 and 0x03 ... nice check! +} + +U08 w5100_read( U16 addr) +{ +spi_write_buffer[0]=0x0F; +spi_write_buffer[1]=(U08)(addr>>8); +spi_write_buffer[2]=(U08)(addr); +spi_write_buffer[3]=0x00; + +spi_transfer(4, 0); +return spi_read_buffer[3]; +// spi_read_buffer should contain 0x00 0x01 0x02 and data ... nice check! +} + +U08 w5100_init (void) +{ +U08 sock0_status; + + // set FSCs MAC Address to value defined in w5100_spi_interface.h + w5100_write( CM_SHAR0, FSC_MAC_ADDRESS0 ); + w5100_write( CM_SHAR1, FSC_MAC_ADDRESS1 ); + w5100_write( CM_SHAR2, FSC_MAC_ADDRESS2 ); + w5100_write( CM_SHAR3, FSC_MAC_ADDRESS3 ); + w5100_write( CM_SHAR4, FSC_MAC_ADDRESS4 ); + w5100_write( CM_SHAR5, FSC_MAC_ADDRESS5 ); + + //set IP + w5100_write( CM_SIPR0, FSC_IP_ADDRESS0 ); + w5100_write( CM_SIPR1, FSC_IP_ADDRESS1 ); + w5100_write( CM_SIPR2, FSC_IP_ADDRESS2 ); + w5100_write( CM_SIPR3, FSC_IP_ADDRESS3 ); + + // set subnet mask + w5100_write( CM_SUBR0, FSC_SUBNET_MASK0 ); + w5100_write( CM_SUBR1, FSC_SUBNET_MASK1 ); + w5100_write( CM_SUBR2, FSC_SUBNET_MASK2 ); + w5100_write( CM_SUBR3, FSC_SUBNET_MASK3 ); + + // set IP of Gateway used by FSC + w5100_write( CM_GAR0, FSC_GATEWAY_ADDRESS0 ); + w5100_write( CM_GAR1, FSC_GATEWAY_ADDRESS1 ); + w5100_write( CM_GAR2, FSC_GATEWAY_ADDRESS2 ); + w5100_write( CM_GAR3, FSC_GATEWAY_ADDRESS3 ); + + //set socket read and write fifo sizes + w5100_write( CM_RMSR, 0x0A); // --> 4k for socket 0 and 1 + w5100_write( CM_TMSR, 0x0A); // --> 4k for socket 0 and 1 + + + w5100_write ( S0_MR, 0x01); // set Socket 0 as TCP + w5100_write ( S0_PORT0, 0x13 ); // Port 5000 -> 0x1388 + w5100_write ( S0_PORT1, 0x88 ); + w5100_write ( S0_CR, CR_OPEN ); // issue Socket open command + sock0_status = w5100_read(S0_SR); // request socket 0 status + if ( sock0_status != SR_SOCK_INIT) + { + return sock0_status; + } + + w5100_write ( S0_CR, CR_LISTEN ); // issue Socket listen command + sock0_status = w5100_read(S0_SR); // request socket 0 status + if ( sock0_status != SR_SOCK_LISTEN) + { + return sock0_status; + } + + return sock0_status; +} + + +BOOL w5100_is_established() +{ + if ( w5100_read(S0_SR) == SR_SOCK_ESTABLISHED ) + { + sock0_connection_established = true; + } + else + { + sock0_connection_established = false; + } + return sock0_connection_established; + +} + +U08 w5100_sock_status() +{ + return w5100_read(S0_SR); +} + + +// getters of TX and RX registers +// S0_TX_FSR +U16 get_S0_TX_FSR() +{ +U16 freesize; +freesize=w5100_read(S0_TX_FSR1); +freesize = freesize << 8; +freesize += w5100_read(S0_TX_FSR0); +return freesize; +} + +// S0_TX_RD +U16 get_S0_TX_RD() +{ +U16 readpointer; +readpointer=w5100_read(S0_TX_RD1); +readpointer = readpointer << 8; +readpointer += w5100_read(S0_TX_RD0); +return readpointer; +} + +// S0_TX_WR +U16 get_S0_TX_WR() +{ +U16 writepointer; +writepointer=w5100_read(S0_TX_WR1); +writepointer = writepointer << 8; +writepointer += w5100_read(S0_TX_WR0); +return writepointer; +} + +// S0_RX_RSR +U16 get_S0_RX_RSR() +{ +U16 received_size; +received_size=w5100_read(S0_RX_RSR1); +received_size = received_size << 8; +received_size += w5100_read(S0_RX_RSR0); +return received_size; +} + +// S0_RX_RD +U16 get_S0_RX_RD() +{ +U16 readpointer; +readpointer=w5100_read(S0_RX_RD1); +readpointer = readpointer << 8; +readpointer += w5100_read(S0_RX_RD0); +return readpointer; +} + +// setters for some RX and TX registers +// S0_TX_WR +void set_S0_TX_WR(U16 value) +{ +U08 high_byte = (value>>8); +U08 low_byte = (value<<8)>>8; +w5100_write(S0_TX_WR1, high_byte); +w5100_write(S0_TX_WR0, low_byte); +} + +// S0_TX_RD +void set_S0_RX_RD(U16 value) +{ +U08 high_byte = (value>>8); +U08 low_byte = (value<<8)>>8; +w5100_write(S0_TX_RD1, high_byte); +w5100_write(S0_TX_RD0, low_byte); +} + +U08 w5100_get_RX(U08 NumBytes, BOOL send_ACK) +{ + U16 size = get_S0_RX_RSR(); + U16 upper_size, lower_size; + if (NumBytes > ETH_READ_BUFFER_SIZE) + { + NumBytes = ETH_READ_BUFFER_SIZE; + } + if (size == 0) + { + return 0; + } + else if ( size < NumBytes ) + { + NumBytes = size; + } + + // now calculate the offset address + // calculated according to W5100 datasheet page: 43 + U16 last_RX_read_pointer = get_S0_RX_RD(); + U16 offset = last_RX_read_pointer & S0_RX_MASK; + U16 start_address = S0_RX_BASE + offset; + + if ((offset + NumBytes) > (S0_RX_MASK + 1) ) // if data is turned over in RX-mem + { + upper_size = (S0_RX_MASK + 1) - offset; + lower_size = NumBytes - upper_size; + for (U08 i = 0; i < upper_size; ++i) + { + eth_read_buffer[i] = w5100_read(start_address + i); + } + for (U08 i = 0; i < lower_size; ++i) + { + eth_read_buffer[upper_size + i] = w5100_read(S0_RX_BASE + i); + } + } + else // if not data turn over in RX-mem + { + for (U08 i = 0; i < NumBytes; ++i) + { + eth_read_buffer[i] = w5100_read(start_address + i); + } + } + + // inform W5100 about how much data was read out. + set_S0_RX_RD(last_RX_read_pointer + NumBytes); + + // if user wishes, W5100 may inform peer about receiption. + // this should be done quickly, otherwise timeout may occur on + // peer side, and peer retransmitts or so ... + // + // maybe it is necessary to acknowledge receiption very early. + // I think there is an option in Socket mode register for this. + if (send_ACK) + { + w5100_write ( S0_CR, CR_RECV ); + } + + return NumBytes; +} + +// returns number of words, transmitted into TX - buffer. +U08 w5100_set_TX(U08 NumBytes) +{ + U16 freesize = get_S0_TX_FSR(); + if (freesize == 0) + { + return 0; + } + if (freesize < NumBytes) + { + NumBytes = freesize; + } + + U16 last_TX_write_pointer = get_S0_TX_WR(); + U16 offset = last_TX_write_pointer & S0_TX_MASK; + U16 start_address = S0_TX_BASE + offset; + + + U16 upper_size, lower_size; + if (NumBytes > ETH_READ_BUFFER_SIZE) + { + NumBytes = ETH_READ_BUFFER_SIZE; + } + if (freesize == 0) + { + return 0; + } + else if ( freesize < NumBytes ) + { + NumBytes = freesize; + } + + // now calculate the offset address + // calculated according to W5100 datasheet page: 43 + + if ((offset + NumBytes) > (S0_RX_MASK + 1) ) // if data is turned over in RX-mem + { + upper_size = (S0_RX_MASK + 1) - offset; + lower_size = NumBytes - upper_size; + for (U08 i = 0; i < upper_size; ++i) + { + eth_read_buffer[i] = w5100_read(start_address + i); + } + for (U08 i = 0; i < lower_size; ++i) + { + eth_read_buffer[upper_size + i] = w5100_read(S0_RX_BASE + i); + } + } + else // if not data turn over in RX-mem + { + for (U08 i = 0; i < NumBytes; ++i) + { + eth_read_buffer[i] = w5100_read(start_address + i); + } + } + + // inform W5100 about how much data was read out. + set_S0_RX_RD(last_TX_write_pointer + NumBytes); + + + return NumBytes; +} Index: firmware/FSC/usb_src/w5100_spi_interface.h =================================================================== --- firmware/FSC/usb_src/w5100_spi_interface.h (revision 10754) +++ firmware/FSC/usb_src/w5100_spi_interface.h (revision 10754) @@ -0,0 +1,197 @@ +#ifndef __W5100_SPI_INTERFACE_H +#define __W5100_SPI_INTERFACE_H +//----------------------------------------------------------------------------- + +#include "typedefs.h" +#include "application.h" +#include "num_conversion.h" + +extern volatile BOOL sock0_connection_established; + + +#define ETH_READ_BUFFER_SIZE 16 +#define ETH_WRITE_BUFFER_SIZE 16 +extern volatile U08 eth_read_buffer[ETH_READ_BUFFER_SIZE]; +extern volatile U08 eth_write_buffer[ETH_WRITE_BUFFER_SIZE]; +//----------------------------------------------------------------------------- +// Port Definitions +// Pin Definitions +// W5100 is SPI device 0 +// -- so there is no need to define special pins. +// -- refer to the device by using the global buffers: +// volatile U08 spi_read_buffer[SPI_READ_BUFFER_SIZE]; +// volatile U08 spi_write_buffer[SPI_WRITE_BUFFER_SIZE]; +// +// and the spi function: +// void spi_transfer(U08 bytes, U08 device) +// +// when only sending one byte, you can do: +// U08 returnvalue; +// CLR_BIT(SPI_DEVICE_SS_PRT[0], SPI_DEVICE_SS[0]); // Set CS low +// returnvalue = spi_transfer_byte(0xFF); +// SET_BIT(SPI_DEVICE_SS_PRT[0], SPI_DEVICE_SS[0]); // Set CS high +// +// W5100 supports SPI modes 0 and 3 --> cpol/cpha= 0/0 or 1/1 + +// we only use socket 0 in this application. So only a few of W5100 adresses are mentioned here +// W5100 MEM Addresses +// Common registers: +#define CM_MR 0x0000 // mode register +#define CM_GAR0 0x0001 // Gateway adress +#define CM_GAR1 0x0002 // Gateway adress +#define CM_GAR2 0x0003 // Gateway adress +#define CM_GAR3 0x0004 // Gateway adress +#define CM_SUBR0 0x0005 // Subnetmask adress +#define CM_SUBR1 0x0006 // Subnetmask adress +#define CM_SUBR2 0x0007 // Subnetmask adress +#define CM_SUBR3 0x0008 // Subnetmask adress +#define CM_SHAR0 0x0009 // Source Hardware adress: MAC +#define CM_SHAR1 0x000A // Source Hardware adress: MAC +#define CM_SHAR2 0x000B // Source Hardware adress: MAC +#define CM_SHAR3 0x000C // Source Hardware adress: MAC +#define CM_SHAR4 0x000D // Source Hardware adress: MAC +#define CM_SHAR5 0x000E // Source Hardware adress: MAC +#define CM_SIPR0 0x000F // Source IP adress +#define CM_SIPR1 0x0010 // Source IP adress +#define CM_SIPR2 0x0011 // Source IP adress +#define CM_SIPR3 0x0012 // Source IP adress +#define CM_IR 0x0015 // Interrupt +#define CM_IMR 0x0016 // Source IP adress +#define CM_RTR0 0x0017 // retry time register +#define CM_RTR1 0x0018 // retry time register +#define CM_RCR 0x0019 // Retry count +#define CM_RMSR 0x001A // RX mem size -- full mem size for sock0 --> value=0x03 +#define CM_TMSR 0x001B // TX mem size -- full mem size for sock0 --> value=0x03 + +// Socket 0 registers +#define S0_MR 0x0400 // Socket 0 mode -- for TCP value = 0x01 (set bit 5 for no delay ACK) +#define S0_CR 0x0401 // socket 0 command -- for commands see below +#define S0_IR 0x0402 // socket 0 interrupt -- see bit description below +#define S0_SR 0x0403 // socket 0 status -- see below +#define S0_PORT0 0x0404 // socket 0 Port -- FSC might get port number 0x1F5C = 8028, since we have only one FSC in cam +#define S0_PORT1 0x0405 // socket 0 Port -- 0xF5C1= 62913 is okay as well ... +#define S0_MSSR0 0x0412 // max segment size -- +#define S0_MSSR1 0x0413 // max segment size -- reset value is 0xFFFF; is set to other party value, if in TCP passive mode +#define S0_TX_FSR0 0x0420 // socket 0 TX free size +#define S0_TX_FSR1 0x0421 // socket 0 TX free size +#define S0_TX_RD0 0x0422 // socket 0 TX read pointer -- read only: +#define S0_TX_RD1 0x0423 // socket 0 TX read pointer +#define S0_TX_WR0 0x0424 // socket 0 TX write pointer +#define S0_TX_WR1 0x0425 // socket 0 TX write pointer +#define S0_RX_RSR0 0x0426 // socket 0 RX received size +#define S0_RX_RSR1 0x0427 // socket 0 RX received size +#define S0_RX_RD0 0x0428 // socket 0 RX read pointer +#define S0_RX_RD1 0x0429 // socket 0 RX read pointer + + + +// some register values: +#define MR_TCP 0 +#define MR_NOACKDELAY 5 + +#define CR_OPEN 0x01 +#define CR_LISTEN 0x02 +#define CR_CONECT 0x04 +#define CR_DISCON 0x08 +#define CR_CLOSE 0x10 +#define CR_SEND 0x20 +#define CR_RECV 0x40 +#define CR_SEND_MAC 0x21 +#define CR_SEND_KEEP 0x22 + +#define IR_SEND_OK 4 +#define IR_TIMEOUT 3 +#define IR_RECV 2 +#define IR_DISCON 1 +#define IR_CON 0 + +#define SR_SOCK_CLOSED 0x00 +#define SR_SOCK_INIT 0x13 +#define SR_SOCK_LISTEN 0x14 +#define SR_SOCK_ESTABLISHED 0x17 +#define SR_SOCK_CLOSE_WAIT 0x1C +#define SR_SOCK_UDP 0x22 +#define SR_SOCK_IPRAW 0x32 +#define SR_SOCK_MACRAW 0x42 +#define SR_SOCK_PPPOE 0x5F +//changing +#define SR_SOCK_SYNSENT 0x15 +#define SR_SOCK_SYNRECV 0x16 +#define SR_SOCK_FIN_WAIT 0x18 +#define SR_SOCK_CLOSING 0x1A +#define SR_SOCK_TIME_WAIT 0x1B +#define SR_SOCK_LAST_ACK 0x1D +#define SR_SOCK_ARP0 0x11 +#define SR_SOCK_ARP1 0x21 +#define SR_SOCK_ARP2 0x31 + +// low level functions +void w5100_write( U16 addr, U08 data); +U08 w5100_read( U16 addr); + +//------------------------------------------------------------------------------ +// Description of w5100_init() function: +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ +// BASIC SETTINGS: +//------------------------------------------------------------------------------ +// leave common MR in default state: 0x00 +// leave IMR in default state: 0x00 no interrupt will occur, since #INT line is not routed +// leave RTR in default state: 0x07D0 --> 200ms +// leave RCR in default state: 0x08, after 8 re-transmissionsm, the TIMEOUT bit in Sn_IR is set '1' +//------------------------------------------------------------------------------ +// NETWORK SETTING: +// set GAR to FSC_GATEWAY_ADDRESS +#define FSC_GATEWAY_ADDRESS0 0xC0 // 192.33.96.1 +#define FSC_GATEWAY_ADDRESS1 0x21 +#define FSC_GATEWAY_ADDRESS2 0x60 +#define FSC_GATEWAY_ADDRESS3 0x01 +// set SHAR to FSC_MAC_ADDRESS +#define FSC_MAC_ADDRESS0 0xFA //FA:C7:0F:AD:22:01 +#define FSC_MAC_ADDRESS1 0xC7 +#define FSC_MAC_ADDRESS2 0x0F +#define FSC_MAC_ADDRESS3 0xAD +#define FSC_MAC_ADDRESS4 0x22 +#define FSC_MAC_ADDRESS5 0x01 +// set SUBR to FSC_SUBNET_MASK +#define FSC_SUBNET_MASK0 0xFF //255.255.248.0 +#define FSC_SUBNET_MASK1 0xFF +#define FSC_SUBNET_MASK2 0xF8 +#define FSC_SUBNET_MASK3 0x00 +// set SIPR to FSC_IP_ADDRESS +#define FSC_IP_ADDRESS0 0xC0 // 192.33.99.247 +#define FSC_IP_ADDRESS1 0x21 +#define FSC_IP_ADDRESS2 0x63 +#define FSC_IP_ADDRESS3 0xF7 +//------------------------------------------------------------------------------ +// MEM SETTINGS: +// we plan the possible use of 2 Sockets: +// Socket 0 for command input and requested data output +// Socket 1 as a Webserver +// +// set RMSR=0x0A --> 4k memory for Socket 0 and 1 +#define RX_MEM_BASE 0x6000 +#define S0_RX_BASE 0x6000 // since it is the first socket its base adress is just the RX MEM SPACE BASE +#define S0_RX_MASK 0x0FFF // this is 4k - 1 +#define S1_RX_BASE 0x7000 // 2nd socket start, right after first socket +#define S1_RX_MASK 0x0FFF // again: 4k - 1 +// set TMSR=0x0A --> 4k mem for each socket +#define TX_MEM_BASE 0x4000 +#define S0_TX_BASE 0x4000 // since it is the first socket its base adress is just the RX MEM SPACE BASE +#define S0_TX_MASK 0x0FFF // this is 4k - 1 +#define S1_TX_BASE 0x5000 // 2nd socket start, right after first socket +#define S1_TX_MASK 0x0FFF // again: 4k - 1 +//------------------------------------------------------------------------------ +U08 w5100_init(); + + +// -- returns: TRUE if socket status is == SR_SOCK_ESTABLISHED +BOOL w5100_is_established(); +// request socket status info: +U08 w5100_sock_status(); + + +U16 w5100_get_received_size(); +U16 w5100_get_start_address(); +//----------------------------------------------------------------------------- +#endif //__W5100_SPI_INTERFACE_H