File content as of revision 1:b71f9a293c54:

// Test code used during library development, showing how
// to do various things, and how to call various functions
// ported to mbed by Karl Zweimueller

#include "mbed.h"

#include <RF22.h>
#include "TextLCD.h"
#include "mRotaryEncoder.h"

Serial pc(USBTX, USBRX);

TextLCD lcd(p30, p29, p28, p27, p26, p25, TextLCD::LCD16x2); // rs, e, d4-d7

//mRotaryEncoder(PinName pinA, PinName pinB, PinName pinSW, PinMode pullMode=PullUp, int debounceTime_us=1500)
mRotaryEncoder  wheel(p21, p22, p23, PullUp, 1500);

volatile bool enc_pressed = false;      // Button of rotaryencoder was pressed
volatile bool enc_rotated = false;      // rotary encoder was totaded left or right

// mbed LEDs
//DigitalOut led1(LED1);
//DigitalOut led2(LED2);
//DigitalOut led3(LED3);
//DigitalOut led4(LED4);


// Singleton instance of the radio
//rf22(PinName slaveSelectPin , PinName mosi, PinName miso, PinName sclk, PinName interrupt );
RF22 rf22(p14,p11,p12,p13,p15);

int counter = 1;

float frequence = 869.50;           // frequence for sender
const float f_offset = -0.01;       // frequence-offset for receiver


//interrup-Handler for button on rotary-encoder - no function
void trigger_sw() {
    enc_pressed = true;               // just set the flag, rest is done outside isr
}

//interrup-Handler for rotary-encoder rotation - change frequence
void trigger_rotated() {
    frequence = wheel.Get()/1000.0;
    lcd.locate(0,1);
    lcd.printf("%4.3fMHz   ",frequence);
    if (!rf22.setFrequency(frequence))               // set the new frequence
        pc.printf("setFrequency failed");
}

void setup() {

    if (!rf22.init())
        pc.printf("RF22 init failed\n\r");
}

void
test_read_write() {
    uint8_t val;
    rf22.spiWrite(RF22_REG_42_CHECK_HEADER0, 10);
    val = rf22.spiRead(RF22_REG_42_CHECK_HEADER0);
    pc.printf("%n\r\n",val);

    rf22.spiWrite(RF22_REG_42_CHECK_HEADER0, 5);
    val = rf22.spiRead(RF22_REG_42_CHECK_HEADER0);
    pc.printf("%n\r\n", val);
    pc.printf("-----");
}

void
test_adc() {
    uint8_t val = rf22.adcRead(RF22_ADCSEL_GND);
    pc.printf("%n\r\n", val);
}

void test_temp() {
    float val = rf22.temperatureRead();
    pc.printf("%3.1f\r\n", (val/2)-64);
}

void
test_burst_read() {
    uint8_t buf[127];
    rf22.spiBurstRead(0, buf, sizeof(buf));
    uint8_t i;
    for (i = 0; i < 127; i++) {
        pc.printf("%x : %x\n\r",i,buf[i]);
    }
}

void test_burst_write() {
    uint8_t buf[] = "Hello";
    rf22.spiBurstWrite(RF22_REG_7F_FIFO_ACCESS, buf, sizeof(buf));
}

void
test_wut() {
    pc.printf("WUT Start");
    rf22.setWutPeriod(10000); // 10000, 0, 0 -> 1 secs
    rf22.spiWrite(RF22_REG_07_OPERATING_MODE1, RF22_ENWT);
    // Wait for the interrupt to occur
    while (1) {
        uint8_t val = rf22.spiRead(RF22_REG_04_INTERRUPT_STATUS2);
        if (val & RF22_IWUT)
            break;
    }
    rf22.spiWrite(RF22_REG_07_OPERATING_MODE1, 0);

    pc.printf("WUT Interrupt bit detected OK");
}

void
test_set_frequency() {
    if (!rf22.setFHStepSize(0))
        pc.printf("setFHStepSize 1 Fail");
    if (!rf22.setFHChannel(0))
        pc.printf("setFHChannel 1 Fail");
    if (!rf22.setFrequency(434.0))
        pc.printf("setFrequency 1 Fail");
    if (!rf22.setFrequency(240.0))
        pc.printf("setFrequency 2 Fail");
    if (!rf22.setFrequency(929.9999)) // Higher than this produces FREQERR on my 06 silicon
        pc.printf("setFrequency 3 Fail");
    if (rf22.setFrequency(960.1)) // Should fail
        pc.printf("setFrequency 4 Fail");

    pc.printf("-------------");
}

void
test_rssi() {
    rf22.setModeRx();
    pc.printf("Start\n\r");
    float f = 848.0;
    while (f < 888.0) {
        rf22.setFrequency(f);
        wait_ms(200); // Wait for freq to settle
        uint8_t rssi = rf22.rssiRead();

        pc.printf("%f: %i\n\r",f,rssi);
        f += 1.0;
    }
    pc.printf("End\n\r");
    rf22.setModeIdle();
    pc.printf("\n\r-------------\n\r");
}

// Sends 0.5 secs of PN9 modulated with with GFSK at full power
void test_tx_pn9() {
    rf22.setFrequency(434.0);
    rf22.setTxPower(RF22_TXPOW_17DBM);
    rf22.setModeRx();
    // Takes a little while to start
    wait(1);
    pc.printf("%x \n\r",rf22.statusRead());
    rf22.setModemConfig(RF22::FSK_PN9_Rb2Fd5);
//  rf22.setModemConfig(RF22::UnmodulatedCarrier);
    rf22.setModeTx(); // Turns off Rx
    // Takes a little while to start
    wait(1);
    pc.printf("%x \n\r",rf22.statusRead());
    wait_ms(500);
    rf22.setModeIdle();
    // Takes a little while to turn off the transmitter
    wait_ms(10);
    pc.printf("%x \n\r",rf22.statusRead());
    pc.printf("-------------");
    wait_ms(500);
}

// Connect analog test points to GPIO1 and GPIO2
void test_analog_gpio() {
    rf22.setFrequency(434.0);
    rf22.setModeRx();
    // GPIO1 for Test N output
    rf22.spiWrite(RF22_REG_0C_GPIO_CONFIGURATION1, 0x0c);
    // GPIO2 for Test P output
    rf22.spiWrite(RF22_REG_0D_GPIO_CONFIGURATION2, 0x0d);
    rf22.spiWrite(RF22_REG_50_ANALOG_TEST_BUS_SELECT, 15); // Detector?
    while (1);
}

void test_modem_config() {
    if (rf22.setModemConfig((RF22::ModemConfigChoice)255)) // Should fail
        pc.printf("setModemConfig 1 failed");
    if (!rf22.setModemConfig(RF22::FSK_Rb2Fd5))
        pc.printf("setModemConfig 2 failed");
    if (!rf22.setModemConfig(RF22::FSK_Rb2_4Fd36))
        pc.printf("setModemConfig 3 failed");
    if (!rf22.setModemConfig(RF22::GFSK_Rb2_4Fd36))
        pc.printf("setModemConfig 3 failed");
    if (!rf22.setModemConfig(RF22::OOK_Rb40Bw335))
        pc.printf("setModemConfig 4 failed");

    pc.printf("-------------");
}

// This works with test_rx below
void test_tx() {
    pc.printf("Start Send...\n\r");
    if (!rf22.setFrequency(869.50))
        pc.printf("setFrequency failed");
    if (!rf22.setModemConfig(RF22::GFSK_Rb2Fd5))
        pc.printf("setModemConfig failed");
    //uint8_t data[] = "hello";
    // 255 octets:
    //uint8_t data[] = "12345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012345";
    uint8_t data[32] = "";
    sprintf((char*)data,"Message-Nr:     %d",counter);
    rf22.send(data, sizeof(data));
    rf22.waitPacketSent();
    pc.printf("Send OK\n\r");

}

// This works with test_tx above
void test_rx() {
    pc.printf("Start Receive...\n\r");
    //if (!rf22.setFrequency(869.50))
    if (!rf22.setFrequency(869.49))      //          sending frequence doesn't work!!! Offset!   Seems to be a problem if combining RFM22B-S1 with -S2
        pc.printf("setFrequency failed\n\r");
    if (!rf22.setModemConfig(RF22::GFSK_Rb2Fd5))
        pc.printf("setModemConfig failed\n\r");

    //while (1) {
    uint8_t buf[RF22_MAX_MESSAGE_LEN];
    uint8_t len = sizeof(buf);
    if (rf22.recv(buf, &len)) // Should fail, no message available
        pc.printf("recv 1 failed\n\r");

    //rf22.waitAvailable();
    if (rf22.waitAvailableTimeout(6000)) {
        if (rf22.recv(buf, &len)) {
            pc.printf("got one in user: >%s<\n\r",(char*)buf);
            lcd.locate(0,0);
            lcd.printf("%16s",(char*)buf);
        } else
            pc.printf("recv 2 failed\n\r");
    } else
        pc.printf("recv timeout\n\r");

    //}
}

void loop() {
//  test_read_write();
//  test_adc();
//  test_temp();
//  test_burst_read();
//  test_burst_write();
//  test_wut();
//  test_set_frequency();
//  test_rssi();
    test_tx_pn9();
//  test_analog_gpio();
//  test_modem_config();
//  test_tx();
//  test_rx();

//  while (1);
    wait_ms(1000);
}

/*float start = 868.0;
  float end = 868.8;
*/
//869,40 - 869,65     Allgemein
float start = 869.4;
float end = 869.65;
float step = 0.02;



void spec() {
    rf22.setModeRx();
    float freq;
    pc.printf("\033[H"); // Home
    pc.printf("\033[2J"); // Clear Screen
    for (freq = start; freq < end; freq += step) {
        rf22.setFrequency(freq);
        wait_ms(10); // Let the freq settle
        uint8_t rssi = rf22.rssiRead();
        uint8_t stars = rssi / 8;

        pc.printf("%f: ",freq);

//    Serial.print(rssi, DEC);
        uint8_t i;
        for (i = 0; i < stars; i++)
            pc.putc('*');
        pc.printf("\033[K\n\r"); // DElete to EOL

    }
    pc.printf("------------------\n\r");
}

void send_loop() {
    uint8_t data[32] = "";

    while (1) {
        //uint8_t data[] = "hello";
        // 255 octets:
        //uint8_t data[] = "12345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012312345678901234567890123456789012345678901234567890123456789012345";

        sprintf((char*)data,"Message-Nr:     %d",counter++);
        rf22.send(data, sizeof(data));
        rf22.waitPacketSent();
        pc.printf("Send OK: %s\n\r",(char*)data);

        wait(2);  // Wait 2 Seconds
    }
}

void receive_loop() {
    while (1) {
        uint8_t buf[RF22_MAX_MESSAGE_LEN];
        uint8_t len = sizeof(buf);

        rf22.waitAvailable();
        if (rf22.recv(buf, &len)) {
            pc.printf("got one in user: >%s<\n\r",(char*)buf);
            lcd.cls();
            lcd.locate(0,0);
            lcd.printf("%16s",(char*)buf);
        } else {
            lcd.printf("recv  failed");
            pc.printf("recv  failed\n\r");
        }
    }
}

int main() {

//#define sender;                         // are we sender?

    pc.baud(115200);

    pc.printf("\n\rConnected to mbed\n\r");

    lcd.locate(0,0);                    // 2nd cls needed, as otherwise it doesn't init correctly!!???
    lcd.printf("RF22-Test-V1.0");

    pc.printf("Pre-setup|");
    setup();
    pc.printf("Post-setup\n\r");


    //pc.printf("Pre-test_temp|");
    //test_temp();
    //pc.printf("Post-test_temp\n\r");

    //pc.printf("Pre-test_set_frequency|");
    //test_set_frequency();
    //pc.printf("Post-test_set_frequency\n\r");

    /*    while (1){
        pc.printf("Pre-test_rssi|");
        test_rssi();
        pc.printf("Post-test_rssi\n\r");
        }

    while (1) {
        spec();
    }
    */
    /*
    while (1) {
        lcd.cls();
        test_tx();
        rf22.setModeRx();
        wait(0.5);
        test_rx();
        wait(2);
        spec();
    }
    */

    if (!rf22.setModemConfig(RF22::GFSK_Rb19_2Fd9_6))
        pc.printf("setModemConfig failed");


// Test  activation of AFC: not enough for combination -S1/-S2 Modules!

//  RF22_REG_1D_AFC_LOOP_GEARSHIFT_OVERRIDE     0x1d
// RF22_AFC_EN                             0x40
    rf22.spiWrite(RF22_REG_1D_AFC_LOOP_GEARSHIFT_OVERRIDE, RF22_AFC_EN);


// Reg  RF22_REG_1E_AFC_TIMING_CONTROL          0x1e
// RF22_AFC_TC                             0x0a
    rf22.spiWrite(RF22_REG_1E_AFC_TIMING_CONTROL, RF22_AFC_TC );

// Reg RF22_REG_2A_AFC_LIMITER                  0x2a
// RF22_AFC_LIMIT                          0x50
    rf22.spiWrite(RF22_REG_2A_AFC_LIMITER, RF22_AFC_LIMIT);

#ifndef sender
    frequence+=f_offset;
#endif

    wheel.Set(frequence*1000);   // 3 digits after period

    // call trigger_rot() when the shaft is rotaded left or right - change frequence
    wheel.attachROT(&trigger_rotated);

    lcd.locate(0,1);
    lcd.printf("%fMHz",frequence);
    wait(10);
    lcd.cls();

    if (!rf22.setFrequency(frequence))
        pc.printf("setFrequency failed");


#ifdef sender
    // Code for sending


    send_loop();                // start sending
#endif

#ifndef sender
    // Code for receiving

    receive_loop();             // start receiving

#endif

    //pc.printf("Ready.\n\r");
}