/* Software for Zachtek WSPR Transmitter products For Arduino Pro Mini ATMega 328 8MHz, 3.3V boards or ATMega328P-AU chips Hardware connections: -------------------------- pin 2 and 3 is Sofware serial port to GPS module pin 4 is Status LED, except on Mini and Pico models- they use pin A2. This Led is Used as StatusIndicator to display what state the software is currently in, Yellow LED on all models except Pico that has a white LED pin 5,6 and 7 are Relay controll pins on the Desktop and LP1 products pin 8 is Red TX LED next to RF out SMA connector on the Desktop and LP1 products. Used as Indicator to display when there is RF out. pin A1 Hardware Sleep signal of the GPS on the WSPR-TX Pico, The Mini is using Serial command to put GPS to sleep. pin A3 Power-down the Si5351 from this pin on the WSPR-TX Mini Version History: ------------------------------------- 0.51 First Beta for Serial API 0.51 Expanded the Serial API and changed all information messages to {MIN} messages 0.52 [DGF] API updates will change SignalGen output freq if running. 0.54 Added TX status updates when sending CCM status to improve the PC client display. 0.55 Added support for factory data in EEPROM, stores TCXO and hardware info. 0.56 Changed 80 TX freq to new standard of 3.570,100MHz 0.57 Split Firmware in to two separate version for the WSPR-TX_ LP1 and Desktop products and changed the "Product_Model" from Factory EEPROM data to constant 0.58 Fixed Frequency information output calculation errors when Freq=<1MHz 0.59 Fixed dim Red TX LED, (Pin was not set to output by setup routine) 0.60 Fixed wrong TX Freq on 10,12 and 15 Band 0.61 Added routines to Set and Get LP filters with factory data API [FLP] 0.62 Added functionality to automatically use one of the Low Pass filter in WSPR and SignalGen routines (New rutines - PickLP,SetLPFilter) 0.63 Changed Software Version and Revision to constants that can be read by the Serial API [FSV] and [FSR] and merged Firmware for LP1 and Desktop in one version again as they were before v0.57 0.64 Added function BandNumOfHigestLP to find the bandnumber of higest fitted LP filter, expanded on the PickLP filter routine 0.65 Fixed bug that forced Hardware Revision to 4 0.66 Fixed relay driving bug that affected Desktop transmitter with hardware revision higher than 4 0.67 Added support for relay driving the WSPR-TX_LP1 with the Mezzanine LP4 card that contains relays 0.68 Added support for manual override relay control over the Serial API and Relay update messages. ([CSL] command and {LPI} status message, shortened Start LED Blink 0.69 Added support for hardware WSPR-TX Mini 1021, added funtion readVcc() that returs Arduino Voltage, added PowerSave funtions save current on the Mini 0.70 Added power saving for the Mini, GPS turned off if TX pause is longer than a minute. 0.71 Corrected 2m Frequency, not in use but nice to have correct. Enabled PLL power saving for the Mini if TX pause is longer than a minute. Current draw for mini is: 40mA waiting to TX, 60mA TX, 0.72 Sends GPS updates when in Idle and Signal gen mode and when pausing in WSRP Beacon mode. Improved Serial port respons when pausing in WSPR Beacon mode, On the Mini the GPS and the Si5351 is put to power save during long TX Pauses. Current draw is now arround 40 mA regardless if tranmitting or not. 0.73 Sends Satellite positions and their received SNR to the config program, changed to NeoGPS library 0.74 Improvement in GUI responsiveness when in WSPR Beacon. Additional power saving for the Mini, MCU goes to sleep if TX pause is longer than a minute. 0.75 Added MCU VCC Voltage info, added support for Pico model, Sends less GPS info in Idle mode 0.76 Added Support for WSPR-TX Pico, GPS position updates in idle and signal gen mode, status LED now fast blink during WSPR Beacon TX instead of steady lit The Pico will always boot in to WSPR Beacon regardless of Boot configuration, this is a failsafe. Moved check if Call Sign is set from SendWSPRBlock() to DoWSPR() 0.77 Changed around the orders of hardware check in Setup() 0.78 The WSPR Beacon will now stay in Beacon mode even if the user changed something in the PC GUI like changed bands, click Save button etc 0.79 Support the new Desktop V1R10 with new improved LP filters. Fixed TX Pause limit of 32000, it can now go to 99999 seconds (27.7 Hours) 0.80 Added routine FreqToBand () to improve signal generator filtering. The Signal Generator now picks the correct low pass filter instead of always using the highest one Fixed smartdelay routine so it only transmitts status once a second to avoid Configuration GUI lockup du to excessive amount of data 0.81 Added Altitude encoding in the power field option. 0.82 Improved handling of serial data when in WSPR Beacon mode so it is less likely to exit the Beacon mode when serial API queries are sent from PC. Slight improvment of the smartdelay routine 0.83 Only put the MCU to sleep in WSPR Beacon TX Pauses when the PC is not connected. This ensures responsiveness in the PC GUI and avoid the misconseption that the device has hang during TX Pauses To compile : 1 set board to "Arduino Pro or Pro Mini", set processor to ATMega328P(3.3V, 8MHZ) 2 Install library "EtherKit JTEncode by Jason Mildrum" and "NeoGPS by Slash Devin" you will find them in the library manager 3 locate and modify the file NMEAGPS_cfg.h. it is part of the NeoGPS library and on a Windows computer it is usually in ..\Documents\Arduino\libraries\NeoGPS\src 4 in that file add the following lines and save it: #define NMEAGPS_PARSE_GSV #define NMEAGPS_PARSE_SATELLITE_INFO #define NMEAGPS_PARSE_SATELLITES //Harry */ const uint8_t SoftwareVersion = 0; //0 to 255. 0=Beta const uint8_t SoftwareRevision = 83; //0 to 255 // Product model. WSPR-TX_LP1 =1011 // Product model. WSPR-TX Desktop =1012 // Product model. WSPR-TX Mini =1017 // Product model. WSPR-TX_LP1 with Mezzanine LP4 card =1020 // Product model. WSPR-TX Pico =1028 const uint16_t Product_Model =1012; #include #include //JTEncode by NT7S https://github.com/etherkit/JTEncode #include #include //NeoGps by SlashDevin" /* You must Enable these defines in the file NMEAGPS_cfg.h after you have installed the NeoGPS Library. It will usually be found in ..\Documents\Arduino\libraries\NeoGPS\src #define NMEAGPS_PARSE_GSV #define NMEAGPS_PARSE_SATELLITE_INFO #define NMEAGPS_PARSE_SATELLITES */ NMEAGPS gps; // This parses the GPS characters gps_fix fix; // This holds on to the latest values // Data structures enum E_Band { LF2190m = 0, LF630m = 1, HF160m = 2, HF80m = 3, HF40m = 4, HF30m = 5, HF20m = 6, HF17m = 7, HF15m = 8, HF12m = 9, HF10m = 10, HF6m = 11, VHF4m = 12, VHF2m = 13, UHF70cm = 14, UHF23cm = 15 }; enum E_Mode { WSPRBeacon , SignalGen, Idle }; enum E_LocatorOption { Manual, GPS }; enum E_PowerOption { Normal, Altitude }; struct S_WSPRData { char CallSign[7]; //Radio amateur Call Sign, zero terminated string can be four to six char in length + zero termination E_LocatorOption LocatorOption; //If transmitted Maidenhead locator is based of GPS location or if it is using MaidneHead4 variable. char MaidenHead4[5]; //Maidenhead locator, must be 4 chars and a zero termination E_PowerOption PowerOption; //If transmitted Power is based on TXPowerdBm field or is calculated from GPS Altitude. uint8_t TXPowerdBm; //Power data in dBm min=0 max=60 }; struct S_GadgetData { char Name[40]; //Optional Name of the device. E_Mode StartMode; //What mode the Gadget should go to after boot. S_WSPRData WSPRData; //Data needed to transmit a WSPR packet. bool TXOnBand [16]; //Arraycount corresponds to the Enum E_Band, True =Transmitt Enabled, False = Transmitt disabled on this band unsigned long TXPause; //Number of seconds to pause after having transmitted on all enabled bands. uint64_t GeneratorFreq;//Frequency for when in signal Generator mode. Freq in centiHertz. }; struct S_FactoryData { uint8_t HW_Version; // Hardware version uint8_t HW_Revision; // Hardware revision uint32_t RefFreq; //The frequency of the Reference Oscillator in Hz, usually 26000000 uint8_t LP_A_BandNum; //Low Pass filter A Band number (0-15) Ham Band as defined by E_Band Eg. if a 20m LowPass filter is fitted on LP_A then LP_A_BandNum will be set to 6 by factory config software uint8_t LP_B_BandNum; //Low Pass filter B Band number (0-15) uint8_t LP_C_BandNum; //Low Pass filter C Band number (0-15) uint8_t LP_D_BandNum; //Low Pass filter D Band number (0-15) }; //Constants #define I2C_START 0x08 #define I2C_START_RPT 0x10 #define I2C_SLA_W_ACK 0x18 #define I2C_SLA_R_ACK 0x40 #define I2C_DATA_ACK 0x28 #define I2C_WRITE 0b11000000 #define I2C_READ 0b11000001 #define SI5351A_H #define SI_CLK0_CONTROL 16 // Register definitions #define SI_CLK1_CONTROL 17 #define SI_CLK2_CONTROL 18 #define SI_SYNTH_PLL_A 26 #define SI_SYNTH_PLL_B 34 #define SI_SYNTH_MS_0 42 #define SI_SYNTH_MS_1 50 #define SI_SYNTH_MS_2 58 #define SI_PLL_RESET 177 #define SI_R_DIV_1 0b00000000 // R-division ratio definitions #define SI_R_DIV_2 0b00010000 #define SI_R_DIV_4 0b00100000 #define SI_R_DIV_8 0b00110000 #define SI_R_DIV_16 0b01000000 #define SI_R_DIV_32 0b01010000 #define SI_R_DIV_64 0b01100000 #define SI_R_DIV_128 0b01110000 #define SI_CLK_SRC_PLL_A 0b00000000 #define SI_CLK_SRC_PLL_B 0b00100000 #define WSPR_FREQ23cm 129650150000ULL //23cm 1296.501,500MHz (Overtone, not implemented) #define WSPR_FREQ70cm 43230150000ULL //70cm 432.301,500MHz (Overtone, not implemented) #define WSPR_FREQ2m 14449500000ULL //2m 144.490,000MHz //Not working. No decode in bench test with WSJT-X decoding Software #define WSPR_FREQ4m 7009250000ULL //4m 70.092,500MHz //Slightly lower output power #define WSPR_FREQ6m 5029450000ULL //6m 50.294,500MHz //Slightly lower output power #define WSPR_FREQ10m 2812610000ULL //10m 28.126,100MHz #define WSPR_FREQ12m 2492610000ULL //12m 24.926,100MHz #define WSPR_FREQ15m 2109610000ULL //15m 21.096.100MHz #define WSPR_FREQ17m 1810610000ULL //17m 18.106,100MHz #define WSPR_FREQ20m 1409710000ULL //20m 14.097,100MHz #define WSPR_FREQ30m 1014020000ULL //30m 10.140,200MHz #define WSPR_FREQ40m 704010000ULL //40m 7.040,100MHz #define WSPR_FREQ80m 357010000ULL //80m 3.570,100MHz #define WSPR_FREQ160m 183810000ULL //160m 1.838,100MHz #define WSPR_FREQ630m 47570000ULL //630m 475.700kHz #define WSPR_FREQ2190m 13750000ULL //2190m 137.500kHz #define FactorySpace true #define UserSpace false #define UMesCurrentMode 1 #define UMesLocator 2 #define UMesTime 3 #define UMesGPSLock 4 #define UMesNoGPSLock 5 #define UMesFreq 6 #define UMesTXOn 7 #define UMesTXOff 8 #define UMesLPF 9 #define UMesVCC 10 #define UMesWSPRBandCycleComplete 11 const uint8_t LP_A = 0; const uint8_t LP_B = 1; const uint8_t LP_C = 2; const uint8_t LP_D = 3; // Hardware defines int StatusLED; //LED that indicates current status. Yellow on LP1, DEsktop and Mini models, white on Pico #define Relay1 5 #define Relay2 6 #define Relay3 7 #define TransmitLED 8 //Red LED next to RF out SMA that will turn on when Transmitting (Pico model do not have a TX LED) #define GPSPower A1 //Sleep-Wake signal of the GPS on the WSPR-TX Pico #define SiPower A3 //Power the Si5351 from this pin on the WSPR-TX Mini //Global Variables S_GadgetData GadgetData; //Create a datastructure that holds all relevant data for a WSPR Beacon S_FactoryData FactoryData; //Create a datastructure that holds information of the hardware E_Mode CurrentMode; //What mode are we in, WSPR, signal-gen or nothing uint8_t CurrentBand = 0; //Keeps track on what band we are currently tranmitting on uint8_t CurrentLP = 0; //Keep track on what Low Pass filter is currently switched in const uint8_t SerCMDLength = 50; //Max number of char on a command in the SerialAPI void i2cInit(); uint8_t i2cSendRegister(uint8_t reg, uint8_t data); uint8_t i2cReadRegister(uint8_t reg, uint8_t *data); uint8_t tx_buffer[171]; uint64_t freq; //Holds the Output frequency when we are in signal generator mode or in WSPR mode int GPSH; //GPS Hours int GPSM; //GPS Minutes int GPSS; //GPS Seconds int fixstate; //GPS Fix state-machine. 0=Init, 1=wating for fix,2=fix accuired boolean PCConnected ; // Class instantiation JTEncode jtencode; // The serial connection to the GPS device SoftwareSerial GPSSerial(2, 3); //GPS Serial port, RX on pin 2, TX on pin 3 void si5351aOutputOff(uint8_t clk); void si5351aSetFrequency(uint32_t frequency); void setup() { PCConnected=false; fixstate = 0; //GPS fixstate=No location fix //Initialize the serial ports, The hardware port is used for communicating with a PC. //The Soft Serial is for communcating with the GPS Serial.begin (9600); //USB Serial port Serial.setTimeout(2000); GPSSerial.begin(9600); //Init software serial port to communicate with the on-board GPS module bool i2c_found; //Read all the Factory data from EEPROM at position 400 if (LoadFromEPROM(FactorySpace)) //Read all Factory data from EEPROM { } else //No factory data was found in EEPROM, set some defaults { FactoryData.HW_Version = 1; // Hardware version FactoryData.HW_Revision = 12; // Hardware revision FactoryData.RefFreq = 25000000;//Reference Oscillator frequency FactoryData.LP_A_BandNum = 99; //Low Pass filter A is Nothing FactoryData.LP_B_BandNum = 99; //Low Pass filter B is Nothing FactoryData.LP_C_BandNum = 99; //Low Pass filter C is Nothing FactoryData.LP_D_BandNum = 99; //Low Pass filter D is Nothing if (Product_Model == 1012) //Desktop Model, set default LP as a MidPlus version { FactoryData.LP_A_BandNum = 7; //Low Pass filter A is 160m FactoryData.LP_B_BandNum = 10; //Low Pass filter B is 80m FactoryData.LP_C_BandNum = 11; //Low Pass filter C is 40m FactoryData.LP_D_BandNum = 99; //Low Pass filter D is 20m } Serial.println(F("{MIN} No factory data found !")); Serial.println(F("{MIN} You need to run factory setup to complete configuration, guessing on calibration values for now")); } if (LoadFromEPROM(UserSpace)) //Read all UserSpace data from EEPROM at position 0 { CurrentMode = GadgetData.StartMode; GadgetData.WSPRData.CallSign[6] = 0;//make sure Call sign is null terminated in case of incomplete data saved GadgetData.WSPRData.MaidenHead4[4] = 0; //make sure Maidenhead locator is null terminated in case of incomplete data saved } else //No user data was found in EEPROM, set some defaults { CurrentMode = SignalGen ; GadgetData.Name[0] = 'W'; GadgetData.Name[1] = 'S'; GadgetData.Name[2] = 'P'; GadgetData.Name[3] = 'R'; GadgetData.Name[4] = ' '; GadgetData.Name[5] = 'T'; GadgetData.Name[6] = 'X'; GadgetData.Name[7] = 0; GadgetData.StartMode = Idle; GadgetData.WSPRData.CallSign[0] = 'A'; GadgetData.WSPRData.CallSign[1] = 'A'; GadgetData.WSPRData.CallSign[2] = '0'; GadgetData.WSPRData.CallSign[3] = 'A'; GadgetData.WSPRData.CallSign[4] = 'A'; GadgetData.WSPRData.CallSign[5] = 'A'; GadgetData.WSPRData.CallSign[6] = 0; GadgetData.WSPRData.LocatorOption = GPS; GadgetData.WSPRData.MaidenHead4[0] = 'A'; GadgetData.WSPRData.MaidenHead4[1] = 'A'; GadgetData.WSPRData.MaidenHead4[2] = '0'; GadgetData.WSPRData.MaidenHead4[3] = '0'; GadgetData.WSPRData.MaidenHead4[4] = 0;//Null termination GadgetData.WSPRData.PowerOption = Normal; //Use the Power encoding for normal power reporting GadgetData.WSPRData.TXPowerdBm = 23; //Set deafult power to 0.2W if (Product_Model == 1017) //The WSPR mini { GadgetData.WSPRData.TXPowerdBm = 13; // WSPR Mini has 20mW output power } if (Product_Model == 1028) //The WSPR Pico { GadgetData.WSPRData.TXPowerdBm = 13; // WSPR Pico has 20mW output power } for (int i = 0; i <= 16; i++) { GadgetData.TXOnBand [i] = false; //Disable TX on all bands. } GadgetData.TXOnBand [6] = true; //enable TX on 20m GadgetData.TXPause = 120; //Number of minutes to pause after transmisson GadgetData.GeneratorFreq = 2000000000; Serial.println(F("{MIN} No user data was found, setting default values")); } //Set staus LEd to pin 4. This is the case for most hardware versions but some model use a different pinout and vill owerride this value below StatusLED = 4; switch (Product_Model) { case 1011: Serial.println(F("{MIN} ZachTek WSPR-TX_LP1 transmitter")); break; case 1012: Serial.println(F("{MIN} ZachTek WSPR Desktop transmitter")); if ((FactoryData.HW_Version == 1) & (FactoryData.HW_Revision == 4)) // Early WSPR Desktop hardware had different Relay driving electronics { //De-energize all relays pinMode(Relay1, INPUT); pinMode(Relay2, INPUT); pinMode(Relay3, INPUT); } else { //De-energize all relays pinMode(Relay1, OUTPUT); pinMode(Relay2, OUTPUT); pinMode(Relay3, OUTPUT); digitalWrite(Relay1, LOW); digitalWrite(Relay2, LOW); digitalWrite(Relay3, LOW); } break; case 1017: Serial.println(F("{MIN} ZachTek WSPR Mini transmitter")); StatusLED = A2; //Status LED uses a different output on the Mini pinMode(SiPower, OUTPUT); digitalWrite(SiPower, LOW); //Turn on power to the Si5351 break; case 1020: Serial.println(F("{MIN} ZachTek WSPR-TX_LP1 transmitter with Mezzanine LP4 board")); //De-energize all relays pinMode(Relay1, OUTPUT); pinMode(Relay2, OUTPUT); pinMode(Relay3, OUTPUT); digitalWrite(Relay1, LOW); digitalWrite(Relay2, LOW); digitalWrite(Relay3, LOW); break; case 1028: Serial.println(F("{MIN} ZachTek WSPR Pico transmitter")); StatusLED = A2; //Status LED uses a different output on the Pico //The Pico is assumed to never be used as a stationary transmitter, //it will most likely fly in a ballon beacon so set some settings to avoid a user releasing a ballon with a missconfigured beacon GadgetData.WSPRData.LocatorOption = GPS; // Always set the Locator option to GPS calculated as a failsafe GadgetData.WSPRData.PowerOption = Altitude; // Always encode Altitude in the power field as a failsafe CurrentMode = WSPRBeacon ; // Always boot the WSPR Pico in to beacon mode as a failsafe break; } // Use the Red LED as a Transmitt indicator and the Yellow LED as Status indicator pinMode(StatusLED, OUTPUT); pinMode(TransmitLED, OUTPUT); Serial.print(F("{MIN} Firmware version ")); if (SoftwareVersion == 0) { Serial.print(F("Beta ")); } Serial.print(SoftwareVersion); Serial.print((".")); Serial.println(SoftwareRevision); //Blink StatusLED to indicate Reboot LEDBlink(16); random(RandomSeed()); PowerSaveOFF(); switch (CurrentMode) { case SignalGen : DoSignalGen(); break; case WSPRBeacon: CurrentBand = 0; DoWSPR(); break; case Idle: DoIdle(); break; } } void loop() { if (Serial.available()) { //Handle Serial API request from the PC DoSerialHandling(); } while (gps.available( GPSSerial )) { //Handle Serial data from the GPS as they arrive fix = gps.read(); SendAPIUpdate(UMesTime); if ((GPSS % 4) == 0) //Send some nice-to-have info every 4 seconds, this is a lot of data so we dont want to send it to often to risk choke the Serial output buffer on the PC configuration software { SendSatData(); //Send Satellite position and SNR information to the PC GUI SendAPIUpdate(UMesVCC); //Send power supply voltage at the MCU to the PC GUI SendAPIUpdate (UMesCurrentMode);// Send info of what routine is running to the PC GUI if (fix.valid.location && fix.valid.time) { SendAPIUpdate(UMesGPSLock); if (GadgetData.WSPRData.LocatorOption == GPS) { //If GPS should update the Maidenhead locator calcLocator (fix.latitude(), fix.longitude()); } SendAPIUpdate(UMesLocator); if (CurrentMode == WSPRBeacon) DoWSPR(); //If in WSPR beacon mode but it broke out of beacon loop to handle a Serial data from the PC then go back now to the WSPR routine } else { SendAPIUpdate(UMesNoGPSLock); } } smartdelay(200); } } //Parts from NickGammon Serial Input example //http://www.gammon.com.au/serial void DoSerialHandling() { static char SerialLine[SerCMDLength]; //A single line of incoming serial command and data static uint8_t input_pos = 0; char InChar; PCConnected=true; while (Serial.available () > 0) { InChar = Serial.read (); switch (InChar) { case '\n': // end of text SerialLine [input_pos] = 0; // terminating null byte // terminator reached, process Command DecodeSerialCMD (SerialLine); // reset buffer for next time input_pos = 0; break; case '\r': // discard carriage return break; default: // keep adding if not full ... allow for terminating null byte if (input_pos < (SerCMDLength - 1)) SerialLine [input_pos++] = InChar; break; } // end of switch } // end of processIncomingByte } //Serial API commands and data decoding void DecodeSerialCMD(const char * InputCMD) { char CharInt[13]; bool EnabDisab; if ((InputCMD[0] == '[') && (InputCMD[4] == ']')) { //A Command,Option or Data input if (InputCMD[1] == 'C') { //Commmand //Current Mode if ((InputCMD[2] == 'C') && (InputCMD[3] == 'M')) { if (InputCMD[6] == 'S') { //Set option if (InputCMD[8] == 'S') { DoSignalGen(); } if (InputCMD[8] == 'W') { CurrentBand = 0; DoWSPR(); } if (InputCMD[8] == 'N') { DoIdle (); } }//Set Current Mode else //Get { SendAPIUpdate (UMesCurrentMode); }//Get Current Mode }//CurrentMode //Store Current configuration data to EEPROM if ((InputCMD[2] == 'S') && (InputCMD[3] == 'E')) { if (InputCMD[6] == 'S') { //Set option SaveToEEPROM(UserSpace); Serial.println(F("{MIN} Configuration saved")); } } //Set Low Pass filter (LP filters are automatically set by the WSPR Beacon and Signal Gen. routines but can be temporarily overrided by this command for testing purposes) if ((InputCMD[2] == 'S') && (InputCMD[3] == 'L')) { if (InputCMD[6] == 'S') { //Set option if (InputCMD[8] == 'A') { CurrentLP = 0; } if (InputCMD[8] == 'B') { CurrentLP = 1; } if (InputCMD[8] == 'C') { CurrentLP = 2; } if (InputCMD[8] == 'D') { CurrentLP = 3; } DriveLPFilters (); } } exit; } if (InputCMD[1] == 'O') {//Option //TX Pause if ((InputCMD[2] == 'T') && (InputCMD[3] == 'P')) { if (InputCMD[6] == 'S') { //Set option CharInt[0] = InputCMD[8]; CharInt[1] = InputCMD[9]; CharInt[2] = InputCMD[10]; CharInt[3] = InputCMD[11]; CharInt[4] = InputCMD[12]; CharInt[5] = 0; //GadgetData.TXPause = atoi(CharInt); GadgetData.TXPause = StrTouint64_t(CharInt); } else //Get Option { Serial.print (F("{OTP} ")); if (GadgetData.TXPause < 10000) Serial.print (("0")); if (GadgetData.TXPause < 1000) Serial.print (("0")); if (GadgetData.TXPause < 100) Serial.print (("0")); if (GadgetData.TXPause < 10) Serial.print (("0")); Serial.println (GadgetData.TXPause); } }//TX Pause //StartMode if ((InputCMD[2] == 'S') && (InputCMD[3] == 'M')) { if (InputCMD[6] == 'S') { //Set option if (InputCMD[8] == 'S') { GadgetData.StartMode = SignalGen; } if (InputCMD[8] == 'W') { GadgetData.StartMode = WSPRBeacon; } if (InputCMD[8] == 'N') { GadgetData.StartMode = Idle; } }//Set Start Mode else //Get { Serial.print (F("{OSM} ")); switch (GadgetData.StartMode) { case Idle: Serial.println (("N")); break; case WSPRBeacon: Serial.println (("W")); break; case SignalGen: Serial.println (("S")); break; } }//Get Start Mode }//StartMode //Band TX enable if ((InputCMD[2] == 'B') && (InputCMD[3] == 'D')) { if (InputCMD[6] == 'S') { //Set option CharInt[0] = InputCMD[8]; CharInt[1] = InputCMD[9]; CharInt[2] = 0; CharInt[3] = 0; EnabDisab = false; if (InputCMD[11] == 'E') EnabDisab = true; GadgetData.TXOnBand [atoi(CharInt)] = EnabDisab ; //Enable or disable on this band }//Set Band TX enable else //Get { //Send out 16 lines, one for each band for (int i = 0; i <= 15; i++) { Serial.print (F("{OBD} ")); if (i < 10) Serial.print (("0")); Serial.print (i); if (GadgetData.TXOnBand[i]) { Serial.println ((" E")); } else { Serial.println ((" D")); } }//for }//Get Band TX enable }//Band TX enable //Location Option if ((InputCMD[2] == 'L') && (InputCMD[3] == 'C')) { if (InputCMD[6] == 'S') { //Set Location Option if (InputCMD[8] == 'G') { GadgetData.WSPRData.LocatorOption = GPS; } if (InputCMD[8] == 'M') { GadgetData.WSPRData.LocatorOption = Manual; } }//Set Location Option else //Get Location Option { Serial.print (F("{OLC} ")); if (GadgetData.WSPRData.LocatorOption == GPS) { Serial.println (("G")); } else { Serial.println (("M")); } }//Get Location Option }//Location Option //Power encoding Option if ((InputCMD[2] == 'P') && (InputCMD[3] == 'W')) { if (InputCMD[6] == 'S') { //Set Location Option if (InputCMD[8] == 'N') { GadgetData.WSPRData.PowerOption = Normal; } if (InputCMD[8] == 'A') { GadgetData.WSPRData.PowerOption = Altitude; } }//Set Power Encoding Option else //Get Location Option { Serial.print (F("{OPW} ")); if (GadgetData.WSPRData.PowerOption == Normal) { Serial.println (("N")); } else { Serial.println (("A")); } }//Get Power Encoding Option }//Power encoding Option exit; }//All Options //Data if (InputCMD[1] == 'D') { //Callsign if ((InputCMD[2] == 'C') && (InputCMD[3] == 'S')) { if (InputCMD[6] == 'S') { //Set option for (int i = 0; i <= 5; i++) { GadgetData.WSPRData.CallSign[i] = InputCMD[i + 8]; } GadgetData.WSPRData.CallSign[6] = 0; } else //Get { Serial.print (F("{DCS} ")); Serial.println (GadgetData.WSPRData.CallSign); } }//Callsign //Locator if ((InputCMD[2] == 'L') && (InputCMD[3] == '4')) { if (InputCMD[6] == 'S') { //Set option for (int i = 0; i <= 3; i++) { GadgetData.WSPRData.MaidenHead4[i] = InputCMD[i + 8]; } GadgetData.WSPRData.MaidenHead4[4] = 0; } else //Get { Serial.print (F("{DL4} ")); Serial.println (GadgetData.WSPRData.MaidenHead4); } }//Locator //Name if ((InputCMD[2] == 'N') && (InputCMD[3] == 'M')) { if (InputCMD[6] == 'S') { //Set option for (int i = 0; i <= 38; i++) { GadgetData.Name[i] = InputCMD[i + 8]; } GadgetData.Name[39] = 0; } else //Get { Serial.print (F("{DNM} ")); Serial.println (GadgetData.Name); } }//Name //Power data if ((InputCMD[2] == 'P') && (InputCMD[3] == 'D')) { if (InputCMD[6] == 'S') { //Set option CharInt[0] = InputCMD[8]; CharInt[1] = InputCMD[9]; CharInt[2] = 0; CharInt[3] = 0; GadgetData.WSPRData.TXPowerdBm = atoi(CharInt); } else //Get { Serial.print (F("{DPD} ")); if (GadgetData.WSPRData.TXPowerdBm < 10) Serial.print (("0")); Serial.println (GadgetData.WSPRData.TXPowerdBm); } }//Power Data //Generator Frequency if ((InputCMD[2] == 'G') && (InputCMD[3] == 'F')) { if (InputCMD[6] == 'S') { //Set option for (int i = 0; i <= 11; i++) { CharInt[i] = InputCMD[i + 8]; } CharInt[12] = 0; GadgetData.GeneratorFreq = StrTouint64_t(CharInt); if (CurrentMode == SignalGen) DoSignalGen(); } else //Get { Serial.print (F("{DGF} ")); Serial.println (uint64ToStr(GadgetData.GeneratorFreq, true)); } }//Generator Frequency exit; }//Data //Factory data if (InputCMD[1] == 'F') { //Product model Number if ((InputCMD[2] == 'P') && (InputCMD[3] == 'N')) { if (InputCMD[6] == 'G') { //Get option Serial.print (F("{FPN} ")); if (Product_Model < 10000) Serial.print (("0")); Serial.println (Product_Model); } }//Product model Number //Hardware Version if ((InputCMD[2] == 'H') && (InputCMD[3] == 'V')) { if (InputCMD[6] == 'S') { //Set option CharInt[0] = InputCMD[8]; CharInt[1] = InputCMD[9]; CharInt[2] = InputCMD[10]; CharInt[3] = 0; FactoryData.HW_Version = atoi(CharInt); }//Set else //Get Option { Serial.print (F("{FHV} ")); if (FactoryData.HW_Version < 100) Serial.print (("0")); if (FactoryData.HW_Version < 10) Serial.print (("0")); Serial.println (FactoryData.HW_Version); } }//Hardware Version //Hardware Revision if ((InputCMD[2] == 'H') && (InputCMD[3] == 'R')) { if (InputCMD[6] == 'S') { //Set option CharInt[0] = InputCMD[8]; CharInt[1] = InputCMD[9]; CharInt[2] = InputCMD[10]; CharInt[3] = 0; FactoryData.HW_Revision = atoi(CharInt); }//Set else //Get Option { Serial.print (F("{FHR} ")); if (FactoryData.HW_Revision < 100) Serial.print (("0")); if (FactoryData.HW_Revision < 10) Serial.print (("0")); Serial.println (FactoryData.HW_Revision); } }//Hardware Revision //Software Version if ((InputCMD[2] == 'S') && (InputCMD[3] == 'V')) { if (InputCMD[6] == 'G') { //Get option Serial.print (F("{FSV} ")); Serial.println (SoftwareVersion); } }//Software Version //Software Revision if ((InputCMD[2] == 'S') && (InputCMD[3] == 'R')) { if (InputCMD[6] == 'G') { //Get option Serial.print (F("{FSR} ")); Serial.println (SoftwareRevision); } }//Software Revision //Low pass filter config if ((InputCMD[2] == 'L') && (InputCMD[3] == 'P')) { if (InputCMD[6] == 'S') { //Set option CharInt[0] = InputCMD[10]; CharInt[1] = InputCMD[11]; CharInt[2] = 0; switch (InputCMD[8]) { case 'A': FactoryData.LP_A_BandNum = atoi(CharInt); break; case 'B': FactoryData.LP_B_BandNum = atoi(CharInt); break; case 'C': FactoryData.LP_C_BandNum = atoi(CharInt); break; case 'D': FactoryData.LP_D_BandNum = atoi(CharInt); break; } }//Set else //Get Option { //If Hardvare is V1 R10 and higher it has a few filters that can do more than one band, indicate by sending out these extra bands so the PC config software //will indicate these bands with the little green square in the GUI if ((FactoryData.HW_Version == 1) & (FactoryData.HW_Revision > 9)) { //If 10m LP filter is fitted then indicate it can do 15m and 12m as well if ((FactoryData.LP_A_BandNum == 10) || (FactoryData.LP_B_BandNum == 10) ||(FactoryData.LP_C_BandNum == 10) ||(FactoryData.LP_D_BandNum == 10)) { Serial.println (F("{FLP} A 08")); //Indicate 15m band Serial.println (F("{FLP} A 09")); //Indicate 12m band } //If 20m LP filter is fitted then indicate it can do 30m as well if ((FactoryData.LP_A_BandNum == 6) || (FactoryData.LP_B_BandNum == 6) ||(FactoryData.LP_C_BandNum == 6) ||(FactoryData.LP_D_BandNum == 6)) { Serial.println (F("{FLP} A 05")); //Indicate 30m band } } Serial.print (F("{FLP} A ")); if (FactoryData.LP_A_BandNum < 10) Serial.print (("0")); Serial.println (FactoryData.LP_A_BandNum); Serial.print (F("{FLP} B ")); if (FactoryData.LP_B_BandNum < 10) Serial.print (("0")); Serial.println (FactoryData.LP_B_BandNum); Serial.print (F("{FLP} C ")); if (FactoryData.LP_C_BandNum < 10) Serial.print (("0")); Serial.println (FactoryData.LP_C_BandNum); Serial.print (F("{FLP} D ")); if (FactoryData.LP_D_BandNum < 10) Serial.print (("0")); Serial.println (FactoryData.LP_D_BandNum); } }//Low pass filter config //Reference Oscillator Frequency if ((InputCMD[2] == 'R') && (InputCMD[3] == 'F')) { if (InputCMD[6] == 'S') { //Set option for (int i = 0; i <= 8; i++) { CharInt[i] = InputCMD[i + 8]; } CharInt[9] = 0; FactoryData.RefFreq = StrTouint64_t(CharInt); } else //Get { Serial.print (F("{FRF} ")); Serial.println (uint64ToStr(FactoryData.RefFreq, true)); } }//Reference Oscillator Frequency //Store Current Factory configuration data to EEPROM if ((InputCMD[2] == 'S') && (InputCMD[3] == 'E')) { if (InputCMD[6] == 'S') { //Set option SaveToEEPROM(FactorySpace); Serial.println(F("{MIN} Factory data saved")); } } exit; }//Factory } } uint64_t StrTouint64_t (String InString) { uint64_t y = 0; for (int i = 0; i < InString.length(); i++) { char c = InString.charAt(i); if (c < '0' || c > '9') break; y *= 10; y += (c - '0'); } return y; } String uint64ToStr (uint64_t p_InNumber, boolean p_LeadingZeros) { char l_HighBuffer[7]; //6 digits + null terminator char char l_LowBuffer[7]; //6 digits + null terminator char char l_ResultBuffer [13]; //12 digits + null terminator char String l_ResultString = ""; uint8_t l_Digit; sprintf(l_HighBuffer, "%06lu", p_InNumber / 1000000L); //Convert high part of 64bit unsigned integer to char array sprintf(l_LowBuffer, "%06lu", p_InNumber % 1000000L); //Convert low part of 64bit unsigned integer to char array l_ResultString = l_HighBuffer; l_ResultString = l_ResultString + l_LowBuffer; //Copy the 2 part result to a string if (!p_LeadingZeros) //If leading zeros should be removed { l_ResultString.toCharArray(l_ResultBuffer, 13); for (l_Digit = 0; l_Digit < 12; l_Digit++ ) { if (l_ResultBuffer[l_Digit] == '0') { l_ResultBuffer[l_Digit] = ' '; // replace zero with a space character } else { break; //We have found all the leading Zeros, exit loop } } l_ResultString = l_ResultBuffer; l_ResultString.trim();//Remove all leading spaces } return l_ResultString; } void DoSignalGen () { CurrentMode = SignalGen; freq = GadgetData.GeneratorFreq; PickLP(FreqToBand()); //USe the correct low pass filter si5351aSetFrequency(freq); digitalWrite(StatusLED, HIGH); SendAPIUpdate (UMesCurrentMode); SendAPIUpdate (UMesFreq); } void DoIdle () { PowerSaveOFF(); CurrentMode = Idle; digitalWrite(StatusLED, LOW); si5351aOutputOff(SI_CLK0_CONTROL); SendAPIUpdate (UMesCurrentMode); } void DoWSPR () { boolean ConfigError; PowerSaveOFF(); //Make sure GPS is not in sleep mode CurrentMode = WSPRBeacon; ConfigError=false; //Make sure at least one band is enabled for tranmission if (NoBandEnabled ()) { Serial.println (F("{MIN}Tranmission is not enebled on any band")); ConfigError=true; } //Make sure call sign is set if ((GadgetData.WSPRData.CallSign[0] == 'A') && (GadgetData.WSPRData.CallSign[1] == 'A') && (GadgetData.WSPRData.CallSign[2] == '0') && (GadgetData.WSPRData.CallSign[3] == 'A') && (GadgetData.WSPRData.CallSign[4] == 'A') && (GadgetData.WSPRData.CallSign[5] == 'A')) //Do not actually key the transmitter if the callsign has not been changed from the default one AA0AAA { Serial.println(F("{MIN}Call Sign not set")); ConfigError=true; } if (ConfigError) { Serial.println (F("{MIN}Can not start WSPR Beacon")); DoIdle();// Go back to ideling } else { NextFreq(); //Cycle to next enabled band to transmitt on freq = freq + (100ULL * random (-100, 100)); //modify TX frequency with a random value beween -100 and +100 Hz si5351aOutputOff(SI_CLK0_CONTROL); SendAPIUpdate (UMesCurrentMode); //LOOP HERE FOREVER OR UNTIL INTERRUPTED BY A SERIAL COMMAND while (!Serial.available()) { //Do until incoming serial command while (gps.available( GPSSerial )) { //If GPS data available - process it fix = gps.read(); if (Serial.available()) {// If serialdata was received on control port then handle command return; } if (fix.valid.location && fix.valid.time) { GPSH = fix.dateTime.hours; GPSM = fix.dateTime.minutes; GPSS = fix.dateTime.seconds; if (GadgetData.WSPRData.LocatorOption == GPS) { //If GPS should update the Maidenhead locator //calcLocator (Lat, Lon); calcLocator (fix.latitude(), fix.longitude()); } if ((GPSS == 0) && ((GPSM % 2) == 0))//If second is zero at even minute then start WSPR transmission { // -------------------- Altitude coding to Power ------------------------------------ if (GadgetData.WSPRData.PowerOption == Altitude)// If Power field should be used for Altitude coding { GadgetData.WSPRData.TXPowerdBm = fix.altitude() / 300; //Max 18km altitude if (GadgetData.WSPRData.TXPowerdBm > 60 ) GadgetData.WSPRData.TXPowerdBm =60; if (GadgetData.WSPRData.TXPowerdBm < 0 ) GadgetData.WSPRData.TXPowerdBm =0; } set_tx_buffer();// Encode the message in the transmit buffer GPSGoToSleep();//Put GPS to sleep to save power if (SendWSPRBlock () != 0) //Send a WSPR "Packet" for 1 minute and 50 seconds { // there was an serial command that interrupted the WSPR Block so go and handle it return; } if (LastFreq ()) //If all bands have been transmitted on then pause for user defined time and after that start over on the first band again { if ((GadgetData.TXPause > 60) && (Product_Model == 1017 ) && (!PCConnected)) //If the PC is not connected and the TXdelay is longer than a 60 sec then put the MCU to sleep to save current during this long pause (Mini model only) { delay (600); //Let the serial port send data from its buffer before we go to sleep Si5351PowerOff ();//Turn off the PLL to save power MCUGoToSleep (GadgetData.TXPause - 30); //Set MCU in sleep mode until there is 30 seconds left of delay PowerSaveOFF();// Turn on GPS and PLL again smartdelay(2000); // let the smartdelay routine read a few GPS lines so we can get the new GPS time after our sleep } else { //Not a long pause or not a Mini so do a regular pause after the tranmission for the legth of time the user has specified in the GUI smartdelay(GadgetData.TXPause * 1000UL); //Pause for the time set by the user } SendAPIUpdate(UMesWSPRBandCycleComplete);//Inform PC that we have transmitted on the last enabled WSPR band and will start over } GPSWakeUp(); NextFreq();// get the frequency for the next HAM band that we will transmit on freq = freq + (100ULL * random (-100, 100)); //modify the TX frequency with a random value beween -100 and +100 Hz to avoid lengthy colisions with other users on the band smartdelay(3000); } else //We have GPS fix but it is not top of even minute so dubble-blink to indicate waiting for top of minute { SendAPIUpdate(UMesTime); if (GPSS < 57) //Send some nice-to-have info only if the WSPR start is at least 3 seconds away { SendAPIUpdate(UMesGPSLock); SendAPIUpdate(UMesLocator); SendSatData(); //Send Satellite postion and SNR information to the PC GUI } LEDBlink(2); smartdelay(200); } } else { //Waitng for GPS location fix SendSatData(); //Send Satellite postion and SNR information to the PC GUI, while we wait for the GPS location fix LEDBlink(1); //singelblink to indicate waiting for GPS Lock SendAPIUpdate(UMesNoGPSLock); //Send No lock status SendAPIUpdate(UMesTime); //Send GPS time smartdelay(400); } } //GPS serial data loop } //Incoming serial command } } // Transmitt a Type 1 message for 1 minute 50 seconds on frequency freq int SendWSPRBlock() { uint8_t i; unsigned long startmillis; unsigned long endmillis; boolean TXEnabled = true; int errcode; errcode = 0; boolean blinked; // Send WSPR for two minutes digitalWrite(StatusLED, HIGH); startmillis = millis(); for (i = 0; i < 162; i++) //162 WSPR symbols to transmit { blinked = false; endmillis = startmillis + ((i + 1) * (unsigned long) 683) ; // intersymbol delay in WSPR is 683 milliseconds uint64_t tonefreq; tonefreq = freq + ((tx_buffer[i] * 146)); //~1.46 Hz Tone spacing = 146 centiHz if (TXEnabled) si5351aSetFrequency(tonefreq); //wait untill tone is transmitted for the correct amount of time while ((millis() < endmillis) && (!Serial.available())) ;//Until time is up or there is serial data received on the control Serial port { if (!blinked) { //do pulsing blinks on Status LED to indicate WSPR Beacon transmission but only do it once per WSPR symbol Serial.print (F("{TWS} ")); if (CurrentBand < 10) Serial.print ("0"); Serial.print (CurrentBand); Serial.print (" "); if (i < 10) Serial.print ("0"); if (i < 100) Serial.print ("0"); Serial.println (i); for (int i = 0; i < 5; i++) { digitalWrite(StatusLED, HIGH); delay (10); digitalWrite(StatusLED, LOW); delay (50); } blinked = true; } } if (Serial.available()) // If serialdata was received on Control port then abort and handle command { errcode = 1; break; } } // Switches off Si5351a output si5351aOutputOff(SI_CLK0_CONTROL); digitalWrite(StatusLED, LOW); return errcode; } void set_tx_buffer() { // Clear out the transmit buffer memset(tx_buffer, 0, sizeof(tx_buffer)); jtencode.wspr_encode(GadgetData.WSPRData.CallSign, GadgetData.WSPRData.MaidenHead4, GadgetData.WSPRData.TXPowerdBm, tx_buffer); } //Maidenhead code from Ossi Väänänen https://ham.stackexchange.com/questions/221/how-can-one-convert-from-lat-long-to-grid-square void calcLocator(double lat, double lon) { int o1, o2, o3; int a1, a2, a3; double remainder; // longitude remainder = lon + 180.0; o1 = (int)(remainder / 20.0); remainder = remainder - (double)o1 * 20.0; o2 = (int)(remainder / 2.0); //remainder = remainder - 2.0 * (double)o2; //o3 = (int)(12.0 * remainder); // latitude remainder = lat + 90.0; a1 = (int)(remainder / 10.0); remainder = remainder - (double)a1 * 10.0; a2 = (int)(remainder); //remainder = remainder - (double)a2; //a3 = (int)(24.0 * remainder); GadgetData.WSPRData.MaidenHead4[0] = (char)o1 + 'A'; GadgetData.WSPRData.MaidenHead4[1] = (char)a1 + 'A'; GadgetData.WSPRData.MaidenHead4[2] = (char)o2 + '0'; GadgetData.WSPRData.MaidenHead4[3] = (char)a2 + '0'; GadgetData.WSPRData.MaidenHead4[4] = 0; } //Delay loop that checks if the GPS serial port is sending data and in that case passes it of to the the GPS object static void smartdelay(unsigned long delay_ms) { // This custom version of delay() ensures that the gps object // is being "fed". Original code from the TinyGPS example but here used for the NeoGPS long TimeLeft; unsigned long EndTime = delay_ms + millis(); do { while (gps.available( GPSSerial )) fix = gps.read(); //If GPS data available - process it TimeLeft = EndTime - millis(); if ((TimeLeft > 4000)) { //Send API update Serial.print (F("{MPS} ")); Serial.println (TimeLeft / 1000); delay (1000); } } while ((TimeLeft > 0) && (!Serial.available())) ; //Until time is up or there is serial data received if (delay_ms > 4000) Serial.println (F("{MPS} 0"));//When pause is complete send Pause 0 to the GUI so it looks neater. But only if it was at least a four second delay } uint8_t i2cStart() { TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN); while (!(TWCR & (1 << TWINT))) ; return (TWSR & 0xF8); } void i2cStop() { TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO); while ((TWCR & (1 << TWSTO))) ; } uint8_t i2cByteSend(uint8_t data) { TWDR = data; TWCR = (1 << TWINT) | (1 << TWEN); while (!(TWCR & (1 << TWINT))) ; return (TWSR & 0xF8); } uint8_t i2cByteRead() { TWCR = (1 << TWINT) | (1 << TWEN); while (!(TWCR & (1 << TWINT))) ; return (TWDR); } uint8_t i2cSendRegister(uint8_t reg, uint8_t data) { uint8_t stts; stts = i2cStart(); if (stts != I2C_START) return 1; stts = i2cByteSend(I2C_WRITE); if (stts != I2C_SLA_W_ACK) return 2; stts = i2cByteSend(reg); if (stts != I2C_DATA_ACK) return 3; stts = i2cByteSend(data); if (stts != I2C_DATA_ACK) return 4; i2cStop(); return 0; } uint8_t i2cReadRegister(uint8_t reg, uint8_t *data) { uint8_t stts; stts = i2cStart(); if (stts != I2C_START) return 1; stts = i2cByteSend(I2C_WRITE); if (stts != I2C_SLA_W_ACK) return 2; stts = i2cByteSend(reg); if (stts != I2C_DATA_ACK) return 3; stts = i2cStart(); if (stts != I2C_START_RPT) return 4; stts = i2cByteSend(I2C_READ); if (stts != I2C_SLA_R_ACK) return 5; *data = i2cByteRead(); i2cStop(); return 0; } // Init TWI (I2C) // void i2cInit() { TWBR = 92; TWSR = 0; TWDR = 0xFF; PRR = 0; } // // Set up specified PLL with mult, num and denom // mult is 15..90 // num is 0..1,048,575 (0xFFFFF) // denom is 0..1,048,575 (0xFFFFF) // void setupPLL(uint8_t pll, uint8_t mult, uint32_t num, uint32_t denom) { uint32_t P1; // PLL config register P1 uint32_t P2; // PLL config register P2 uint32_t P3; // PLL config register P3 P1 = (uint32_t)(128 * ((float)num / (float)denom)); P1 = (uint32_t)(128 * (uint32_t)(mult) + P1 - 512); P2 = (uint32_t)(128 * ((float)num / (float)denom)); P2 = (uint32_t)(128 * num - denom * P2); P3 = denom; i2cSendRegister(pll + 0, (P3 & 0x0000FF00) >> 8); i2cSendRegister(pll + 1, (P3 & 0x000000FF)); i2cSendRegister(pll + 2, (P1 & 0x00030000) >> 16); i2cSendRegister(pll + 3, (P1 & 0x0000FF00) >> 8); i2cSendRegister(pll + 4, (P1 & 0x000000FF)); i2cSendRegister(pll + 5, ((P3 & 0x000F0000) >> 12) | ((P2 & 0x000F0000) >> 16)); i2cSendRegister(pll + 6, (P2 & 0x0000FF00) >> 8); i2cSendRegister(pll + 7, (P2 & 0x000000FF)); } // // Set up MultiSynth with integer Divider and R Divider // R Divider is the bit value which is OR'ed onto the appropriate // register, it is a #define in si5351a.h // void setupMultisynth(uint8_t synth, uint32_t Divider, uint8_t rDiv) { uint32_t P1; // Synth config register P1 uint32_t P2; // Synth config register P2 uint32_t P3; // Synth config register P3 P1 = 128 * Divider - 512; P2 = 0; // P2 = 0, P3 = 1 forces an integer value for the Divider P3 = 1; i2cSendRegister(synth + 0, (P3 & 0x0000FF00) >> 8); i2cSendRegister(synth + 1, (P3 & 0x000000FF)); i2cSendRegister(synth + 2, ((P1 & 0x00030000) >> 16) | rDiv); i2cSendRegister(synth + 3, (P1 & 0x0000FF00) >> 8); i2cSendRegister(synth + 4, (P1 & 0x000000FF)); i2cSendRegister(synth + 5, ((P3 & 0x000F0000) >> 12) | ((P2 & 0x000F0000) >> 16)); i2cSendRegister(synth + 6, (P2 & 0x0000FF00) >> 8); i2cSendRegister(synth + 7, (P2 & 0x000000FF)); } // Switches off Si5351a output void si5351aOutputOff(uint8_t clk) { i2cSendRegister(clk, 0x80); // Refer to SiLabs AN619 to see //bit values - 0x80 turns off the output stage digitalWrite(TransmitLED, LOW); SendAPIUpdate(UMesTXOff); } // Set CLK0 output ON and to the specified frequency // Frequency is in the range 10kHz to 150MHz and given in centiHertz (hundreds of Hertz) // Example: si5351aSetFrequency(1000000200); // will set output CLK0 to 10.000,002MHz // // This example sets up PLL A // and MultiSynth 0 // and produces the output on CLK0 // void si5351aSetFrequency(uint64_t frequency) //Frequency is in centiHz { static uint64_t oldFreq; int32_t FreqChange; uint64_t pllFreq; //uint32_t xtalFreq = XTAL_FREQ; uint32_t l; float f; uint8_t mult; uint32_t num; uint32_t denom; uint32_t Divider; uint8_t rDiv; if (frequency > 100000000) { //If higher than 1MHz then set output divider to 1 rDiv = SI_R_DIV_1; Divider = 90000000000ULL / frequency;// Calculate the division ratio. 900MHz is the maximum internal (expressed as deciHz) pllFreq = Divider * frequency; // Calculate the pllFrequency: mult = pllFreq / (FactoryData.RefFreq * 100UL); // Determine the multiplier to l = pllFreq % (FactoryData.RefFreq * 100UL); // It has three parts: f = l; // mult is an integer that must be in the range 15..90 f *= 1048575; // num and denom are the fractional parts, the numerator and denominator f /= FactoryData.RefFreq; // each is 20 bits (range 0..1048575) num = f; // the actual multiplier is mult + num / denom denom = 1048575; // For simplicity we set the denominator to the maximum 1048575 num = num / 100; } else // lower freq than 1MHz - use output Divider set to 128 { rDiv = SI_R_DIV_128; //frequency = frequency * 128ULL; //Set base freq 128 times higher as we are dividing with 128 in the last output stage Divider = 90000000000ULL / (frequency * 128ULL);// Calculate the division ratio. 900,000,000 is the maximum internal freq pllFreq = Divider * frequency * 128ULL; // Calculate the pllFrequency: //the Divider * desired output frequency mult = pllFreq / (FactoryData.RefFreq * 100UL); // Determine the multiplier to //get to the required pllFrequency l = pllFreq % (FactoryData.RefFreq * 100UL); // It has three parts: f = l; // mult is an integer that must be in the range 15..90 f *= 1048575; // num and denom are the fractional parts, the numerator and denominator f /= FactoryData.RefFreq; // each is 20 bits (range 0..1048575) num = f; // the actual multiplier is mult + num / denom denom = 1048575; // For simplicity we set the denominator to the maximum 1048575 num = num / 100; } // Set up PLL A with the calculated multiplication ratio setupPLL(SI_SYNTH_PLL_A, mult, num, denom); // Set up MultiSynth Divider 0, with the calculated Divider. // The final R division stage can divide by a power of two, from 1..128. // reprented by constants SI_R_DIV1 to SI_R_DIV128 (see si5351a.h header file) // If you want to output frequencies below 1MHz, you have to use the // final R division stage setupMultisynth(SI_SYNTH_MS_0, Divider, rDiv); // Reset the PLL. This causes a glitch in the output. For small changes to // the parameters, you don't need to reset the PLL, and there is no glitch FreqChange = frequency - oldFreq; if ( abs(FreqChange) > 100000) //If changed more than 1kHz then reset PLL (completely arbitrary choosen) { i2cSendRegister(SI_PLL_RESET, 0xA0); } // Finally switch on the CLK0 output (0x4F) // and set the MultiSynth0 input to be PLL A i2cSendRegister(SI_CLK0_CONTROL, 0x4F | SI_CLK_SRC_PLL_A); oldFreq = frequency; digitalWrite(TransmitLED, HIGH); Serial.print (F("{TFQ} ")); Serial.println (uint64ToStr(frequency, false)); SendAPIUpdate(UMesTXOn); } //Create a random seed by doing CRC32 on 100 analog values from port A0 unsigned long RandomSeed(void) { const unsigned long crc_table[16] = { 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c }; uint8_t ByteVal; unsigned long crc = ~0L; for (int index = 0 ; index < 100 ; ++index) { ByteVal = analogRead(A0); crc = crc_table[(crc ^ ByteVal) & 0x0f] ^ (crc >> 4); crc = crc_table[(crc ^ (ByteVal >> 4)) & 0x0f] ^ (crc >> 4); crc = ~crc; } return crc; } //Returns true if the user has not enabled any bands for TX boolean NoBandEnabled(void) { boolean NoOne = true; for (int FreqLoop = 0; FreqLoop < 13; FreqLoop++) { if (GadgetData.TXOnBand [FreqLoop]) NoOne = false; } return NoOne; } //Determine what band to transmitt on, cycles upward in the TX enabled bands, e.g if band 2,5,6 and 11 is enbled for TX then the cycle will be 2-5-6-11-2-5-6-11-... void NextFreq (void) { if (NoBandEnabled()) { freq = 0; } else { do { CurrentBand++; if (CurrentBand > 12) CurrentBand = 0; } while (!GadgetData.TXOnBand [CurrentBand]); switch (CurrentBand) { case 0: freq = WSPR_FREQ2190m; break; case 1: freq = WSPR_FREQ630m; break; case 2: freq = WSPR_FREQ160m ; break; case 3: freq = WSPR_FREQ80m ; break; case 4: freq = WSPR_FREQ40m ; break; case 5: freq = WSPR_FREQ30m ; break; case 6: freq = WSPR_FREQ20m ; break; case 7: freq = WSPR_FREQ17m ; break; case 8: freq = WSPR_FREQ15m ; break; case 9: freq = WSPR_FREQ12m ; break; case 10: freq = WSPR_FREQ10m ; break; case 11: freq = WSPR_FREQ6m ; break; case 12: freq = WSPR_FREQ4m ; } Serial.print("{TBN} ");//Send API update to inform what band we are using at the moment if (CurrentBand < 10) Serial.print ("0"); Serial.println(CurrentBand); //We have found what band to use, now pick the right low pass filter for this band PickLP (CurrentBand); } } //Function returns True if the band we just transmitted on was the highest band the user want to transmitt on. boolean LastFreq (void) { boolean Last = true; int TestBand; TestBand = CurrentBand; if (TestBand == 12) { Last = true; } else { do { TestBand++; if (GadgetData.TXOnBand [TestBand]) Last = false; } while (TestBand < 12); } return Last; } //Calculate CRC on either Factory data or Userspace data unsigned long GetEEPROM_CRC(boolean EEPROMSpace) { const unsigned long crc_table[16] = { 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c }; unsigned long crc = ~0L; int Start; int Length; if (EEPROMSpace == FactorySpace) { Start = 400; Length = sizeof(FactoryData); } else { Start = 0; Length = sizeof(GadgetData); } for (int index = Start; index < (Start + Length) ; ++index) { crc = crc_table[(crc ^ EEPROM[index]) & 0x0f] ^ (crc >> 4); crc = crc_table[(crc ^ (EEPROM[index] >> 4)) & 0x0f] ^ (crc >> 4); crc = ~crc; } return crc; } //Load FactoryData or UserSpace Data from Arduino EEPROM bool LoadFromEPROM (boolean EEPROMSpace) { int Start; int Length; unsigned long CRCFromEEPROM, CalculatedCRC; if (EEPROMSpace == FactorySpace) //Factory data { Start = 400; Length = sizeof(FactoryData); EEPROM.get(Start, FactoryData); //Load all the data from EEPROM CalculatedCRC = GetEEPROM_CRC(FactorySpace); //Calculate the CRC of the data } else //User data { Start = 0; Length = sizeof(GadgetData); EEPROM.get(Start, GadgetData); //Load all the data from EEPROM CalculatedCRC = GetEEPROM_CRC(UserSpace); //Calculate the CRC of the data } EEPROM.get(Start + Length, CRCFromEEPROM); //Load the saved CRC at the end of the data return (CRCFromEEPROM == CalculatedCRC); //If Stored and Calculated CRC are the same return true } //Save FactoryData or UserSpace Data to Arduino EEPROM void SaveToEEPROM (boolean EEPROMSpace) { int Start; int Length; unsigned long CRCFromEEPROM; if (EEPROMSpace == FactorySpace) { Start = 400; Length = sizeof(FactoryData); EEPROM.put(Start, FactoryData); //Save all the Factory data to EEPROM at adress400 } else //UserSpace { Start = 0; Length = sizeof(GadgetData); EEPROM.put(Start, GadgetData); //Save all the User data to EEPROM at adress0 } CRCFromEEPROM = GetEEPROM_CRC (EEPROMSpace); //Calculate CRC on the saved data EEPROM.put(Start + Length, CRCFromEEPROM); //Save the CRC after the data } void SendAPIUpdate (uint8_t UpdateType) { switch (UpdateType) { case UMesCurrentMode : Serial.print (F("{CCM} ")); switch (CurrentMode) { case Idle: Serial.println (("N")); Serial.println (F("{TON} F")); //Send TX Off info break; case WSPRBeacon: Serial.println (("W")); Serial.println (F("{TON} F")); //Send TX Off info, only true if WSPR is in pause mode between transmission, if not it will be changed quickly by WSPR routine break; case SignalGen: Serial.println (("S")); Serial.println (F("{TON} T")); //Send TX ON info break; } break; case UMesLocator: Serial.print (F("{GL4} ")); Serial.println (GadgetData.WSPRData.MaidenHead4);; break; case UMesTime: GPSH = fix.dateTime.hours; GPSM = fix.dateTime.minutes; GPSS = fix.dateTime.seconds; Serial.print (F("{GTM} ")); if (GPSH < 10) Serial.print ("0"); Serial.print (GPSH); Serial.print (F(":")); if (GPSM < 10) Serial.print ("0"); Serial.print (GPSM); Serial.print (F(":")); if (GPSS < 10) Serial.print ("0"); Serial.println (GPSS); break; case UMesGPSLock: Serial.println (F("{GLC} T")); break; case UMesNoGPSLock: Serial.println (F("{GLC} F")); break; case UMesFreq: Serial.print (F("{TFQ} ")); Serial.println (uint64ToStr(freq, false)); break; case UMesTXOn: Serial.println (F("{TON} T")); break; case UMesTXOff: Serial.println (F("{TON} F")); break; case UMesWSPRBandCycleComplete: Serial.println (F("{TCC}")); break; case UMesVCC: Serial.print (F("{MVC} ")); Serial.println (GetVCC()); break; case UMesLPF: Serial.print (F("{LPI} ")); if (CurrentLP == LP_A) Serial.println ("A"); if (CurrentLP == LP_B) Serial.println ("B"); if (CurrentLP == LP_C) Serial.println ("C"); if (CurrentLP == LP_D) Serial.println ("D"); } } //Brief flash on the Status LED void LEDBlink(int Blinks) { for (int i = 0; i < Blinks; i++) { digitalWrite(StatusLED, HIGH); smartdelay (50); digitalWrite(StatusLED, LOW); smartdelay (50); } } //Pulls the correct relays to choose LP filter A,B,C or D void DriveLPFilters () { if (Product_Model == 1017) { //If its the WSPR-TX Mini then do nothing as it dont have any relays } else { SendAPIUpdate (UMesLPF); //Product model 1011 E.g WSPR-TX LP1, this will drive the relays on the optional Mezzanine LP4 card if ((Product_Model == 1011) || (Product_Model == 1020)) { switch (CurrentLP) { case LP_A: //all relays are at rest digitalWrite(Relay2, LOW); digitalWrite(Relay3, LOW); break; case LP_B: digitalWrite(Relay2, HIGH); digitalWrite(Relay3, LOW); break; case LP_C: digitalWrite(Relay2, LOW); digitalWrite(Relay3, HIGH); break; case LP_D: digitalWrite(Relay2, HIGH); digitalWrite(Relay3, HIGH); break; }//Case }//If Product_Model == 1011 else { //is not Product Model 1011 and is Hardware version 1.4 E.g en early model of the Desktop transmitter if ((FactoryData.HW_Version == 1) && (FactoryData.HW_Revision == 4)) // Early Hardware has different relay driving { switch (CurrentLP) { case LP_A: //all relays are at rest pinMode(Relay1, INPUT);//Set Relay1 as Input to deactivate the relay pinMode(Relay2, INPUT);//Set Relay2 as Input to deactivate the relay pinMode(Relay3, INPUT);//Set Relay3 as Input to deactivate the relay break; case LP_B: pinMode(Relay1, OUTPUT);//Set Relay1 as Output so it can be pulled low digitalWrite(Relay1, LOW); pinMode(Relay2, INPUT);//Set Relay2 as Input to deactivate the relay pinMode(Relay3, INPUT);//Set Relay3 as Input to deactivate the relay break; case LP_C: pinMode(Relay1, INPUT);//Set Relay1 as Input to deactivate the relay pinMode(Relay2, INPUT);//Set Relay2 as Input to deactivate the relay pinMode(Relay3, OUTPUT);//Set Relay3 as Output so it can be pulled low digitalWrite(Relay3, LOW); break; case LP_D: pinMode(Relay1, INPUT);//Set Relay1 as Input to deactivate the relay pinMode(Relay2, OUTPUT);//Set Relay2 as Output so it can be pulled low digitalWrite(Relay2, LOW); pinMode(Relay3, OUTPUT);//Set Relay3 as Output so it can be pulled low digitalWrite(Relay3, LOW); break; } } else { //Not Product Model 1011 and not Hardvare version 1.4 E.g later model of the Desktop transmitter switch (CurrentLP) { case LP_A: //all relays are at rest digitalWrite(Relay1, LOW); digitalWrite(Relay2, LOW); digitalWrite(Relay3, LOW); break; case LP_B: digitalWrite(Relay1, HIGH); digitalWrite(Relay2, LOW); digitalWrite(Relay3, LOW); break; case LP_C: digitalWrite(Relay1, LOW); digitalWrite(Relay2, LOW); digitalWrite(Relay3, HIGH); break; case LP_D: digitalWrite(Relay1, LOW); digitalWrite(Relay2, HIGH); digitalWrite(Relay3, HIGH); break; } } } } } // Convert a frequency to a Ham band. Frequency is stored in global variable freq uint8_t FreqToBand () { uint8_t BandReturn=15 ; if (freq<(WSPR_FREQ70cm*1.1)) BandReturn=14; if (freq<(WSPR_FREQ2m*1.1)) BandReturn=13; if (freq<(WSPR_FREQ4m*1.1)) BandReturn=12; if (freq<(WSPR_FREQ6m*1.1)) BandReturn=11; if (freq<(WSPR_FREQ10m*1.1)) BandReturn=10; if (freq<(WSPR_FREQ12m*1.1)) BandReturn=9; if (freq<(WSPR_FREQ15m*1.1)) BandReturn=8; if (freq<(WSPR_FREQ17m*1.1)) BandReturn=7; if (freq<(WSPR_FREQ20m*1.1)) BandReturn=6; if (freq<(WSPR_FREQ30m*1.1)) BandReturn=5; if (freq<(WSPR_FREQ40m*1.1)) BandReturn=4; if (freq<(WSPR_FREQ80m*1.1)) BandReturn=3; if (freq<(WSPR_FREQ160m*1.1)) BandReturn=2; if (freq<(WSPR_FREQ630m*1.1)) BandReturn=1; if (freq<(WSPR_FREQ2190m*1.1)) BandReturn=0; return BandReturn; } //Out of the four possible LP filters fitted - find the one that is best for Transmission on TXBand void PickLP (uint8_t TXBand) { boolean ExactMatch = false; uint8_t BandLoop; //Check if some of the four low pass filters is an exact match for the TXBand if (FactoryData.LP_A_BandNum == TXBand) { ExactMatch = true; CurrentLP = LP_A; } if (FactoryData.LP_B_BandNum == TXBand) { ExactMatch = true; CurrentLP = LP_B; } if (FactoryData.LP_C_BandNum == TXBand) { ExactMatch = true; CurrentLP = LP_C; } if (FactoryData.LP_D_BandNum == TXBand) { ExactMatch = true; CurrentLP = LP_D; } //If we did not find a perfect match then use a low pass filter that is higher in frequency. if (!ExactMatch) { for (BandLoop = TXBand; BandLoop < 99; BandLoop ++) //Test all higher bands to find a a possible LP filter in one of the four LP banks { if (FactoryData.LP_A_BandNum == BandLoop) //The LP filter in Bank A is a match for this band { CurrentLP = LP_A; break; } if (FactoryData.LP_B_BandNum == BandLoop) //The LP filter in Bank B is a match for this band { CurrentLP = LP_B; break; } if (FactoryData.LP_C_BandNum == BandLoop) //The LP filter in Bank C is a match for this band { CurrentLP = LP_C; break; } if (FactoryData.LP_D_BandNum == BandLoop) //The LP filter in Bank D is a match for this band { CurrentLP = LP_D; break; } } //If there is no LP that is higher than TXBand then use the highest one, (not ideal as output will be attenuated but best we can do) if (BandLoop == 99) { TXBand = BandNumOfHigestLP(); if (FactoryData.LP_A_BandNum == TXBand) { CurrentLP = LP_A; } if (FactoryData.LP_B_BandNum == TXBand) { CurrentLP = LP_B; } if (FactoryData.LP_C_BandNum == TXBand) { CurrentLP = LP_C; } if (FactoryData.LP_D_BandNum == TXBand) { CurrentLP = LP_D; } } } DriveLPFilters (); } //Returns a band that is the highest band that has a LP filter fitted onboard. //Low pass filter numbering corresponds to Bands or two special cases //The special cases are: 98=just a link between input and output, 99=Nothing fitted (open circut) the firmware will never use this //These numbers are set by the factory Configuration program and stored in EEPROM uint8_t BandNumOfHigestLP () { uint8_t BandLoop, Result; Result = FactoryData.LP_A_BandNum ; //Use this filter if nothing else is a match. //Find the highest band that has a Low Pass filter fitted in one of the four LP banks for (BandLoop = 98; BandLoop > 0; BandLoop--) { if (FactoryData.LP_A_BandNum == BandLoop) //The LP filter in Bank A is a match for this band { Result = FactoryData.LP_A_BandNum ; break; } if (FactoryData.LP_B_BandNum == BandLoop) //The LP filter in Bank B is a match for this band { Result = FactoryData.LP_B_BandNum ; break; } if (FactoryData.LP_C_BandNum == BandLoop) //The LP filter in Bank C is a match for this band { Result = FactoryData.LP_C_BandNum ; break; } if (FactoryData.LP_D_BandNum == BandLoop) //The LP filter in Bank D is a match for this band { Result = FactoryData.LP_D_BandNum ; break; } } return Result; } //Retun VCC voltage measured in milliVolt //So 5000 is 5V, 3300 is 3.3V. int GetVCC() { // Read 1.1V reference against AVcc // set the reference to Vcc and the measurement to the internal 1.1V reference #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); #elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) ADMUX = _BV(MUX5) | _BV(MUX0); #elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__) ADMUX = _BV(MUX3) | _BV(MUX2); #else ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); #endif delay(2); // Wait for Vref to settle ADCSRA |= _BV(ADSC); // Start conversion while (bit_is_set(ADCSRA, ADSC)); // measuring uint8_t low = ADCL; // must read ADCL first - it then locks ADCH uint8_t high = ADCH; // unlocks both long result = (high << 8) | low; result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000 return result; // Vcc in millivolts } void PowerSaveOFF() { GPSWakeUp (); Si5351PowerOn (); } void PowerSaveON() { GPSGoToSleep(); Si5351PowerOff (); } void GPSGoToSleep() { switch (Product_Model) { case 1017: //Mini //If its the WSPR-TX Mini, send the Sleep string to it GPSSerial.println(F("$PMTK161,0*28")); //GPSSleep = true; break; case 1028: //Pico //If it is the WSPR-TX Pico it has a hardware line for sleep/wake pinMode(GPSPower, OUTPUT); digitalWrite(GPSPower, LOW); break; } } void GPSWakeUp () { switch (Product_Model) { case 1017: //Mini //Send anything on the GPS serial line to wake it up GPSSerial.println(" "); //GPSSleep = false; delay(100); //Give the GPS some time to wake up and send its serial data back to us break; case 1028: //Pico //If it is the WSPR-TX Pico it has a hardware line for sleep/wake pinMode(GPSPower, INPUT); //digitalWrite(GPSPower, HIGH); delay(100); //Give the GPS some time to wake up break; } } void Si5351PowerOff () { if (Product_Model == 1017 || Product_Model == 1028 )//If its the WSPR-TX Mini it has a control line that can cut power to the Si5351 { //Power off the Si5351 digitalWrite(SiPower, HIGH); } } void Si5351PowerOn () { if (Product_Model == 1017 || Product_Model == 1028 )//If its the WSPR-TX Mini or Pico it has a control line that can cut power to the Si5351 { //Power on the Si5351 digitalWrite(SiPower, LOW); //Give it some time to stabilize voltage before init delay (100); //re-initialize the Si5351 i2cInit(); si5351aOutputOff(SI_CLK0_CONTROL); } } //Sleep code from Kevin Darrah https://www.youtube.com/watch?v=urLSDi7SD8M void MCUGoToSleep( int SleepTime)//Sleep time in seconds, accurate to the nearest 8 seconds { int SleepLoop; SleepLoop = SleepTime / 8 ; // every sleep period is 8 seconds GPSSerial.end();//Must turn off software serialport or sleep will not work //Serial.end(); //Turn off Hardware serial port as well as we will temporary change all ports to outputs AllIOtoLow (); //Set all IO pins to outputs to save power DisableADC (); //Turn off ADC to save power //SETUP WATCHDOG TIMER WDTCSR = (24);//change enable and WDE - also resets WDTCSR = (33);//prescalers only - get rid of the WDE and WDCE bit WDTCSR |= (1 << 6); //enable interrupt mode //ENABLE SLEEP - this enables the sleep mode SMCR |= (1 << 2); //power down mode SMCR |= 1;//enable sleep for (int i = 0; i < SleepLoop; i++)//sleep for eight second intervals untill SleepTime is reached { //BOD DISABLE - this must be called right before the __asm__ sleep instruction MCUCR |= (3 << 5); //set both BODS and BODSE at the same time MCUCR = (MCUCR & ~(1 << 5)) | (1 << 6); //then set the BODS bit and clear the BODSE bit at the same time __asm__ __volatile__("sleep");//in line assembler to go to sleep //Just woke upp after 8 seconds of sleep, do a short blink to indicate that I'm still running digitalWrite(StatusLED, HIGH); delay (30); digitalWrite(StatusLED, LOW); } //Restore everything EnableADC (); GPSSerial.begin(9600); //Init software serial port to communicate with the on-board GPS module } void AllIOtoLow () { // Save Power by setting all IO pins to outputs and setting them either low or high // (for some odd reason the ATMEga328 takes less power when this is done instead of having IO pins as inputs during sleep, see more in Kevin Darrahs YouTube Videos) pinMode(A0, OUTPUT); digitalWrite(A0, LOW); pinMode(A6, OUTPUT); digitalWrite(A6, LOW); pinMode(A7, OUTPUT); digitalWrite(A7, LOW); pinMode(10, OUTPUT); digitalWrite(10, LOW); pinMode(11, OUTPUT); digitalWrite(11, LOW); pinMode(12, OUTPUT); digitalWrite(12, LOW); pinMode(13, OUTPUT); digitalWrite(13, LOW); pinMode(4, OUTPUT); digitalWrite(4, LOW); pinMode(5, OUTPUT); digitalWrite(5, LOW); pinMode(6, OUTPUT); digitalWrite(6, LOW); pinMode(7, OUTPUT); digitalWrite(7, LOW); pinMode(8, OUTPUT); digitalWrite(8, LOW); pinMode(9, OUTPUT); digitalWrite(9, LOW); } void DisableADC () { //Disable ADC - don't forget to flip back after waking up if using ADC in your application ADCSRA |= (1 << 7); ADCSRA &= ~(1 << 7); } void EnableADC () { //Enable ADC again ADCSRA |= (1 << 7); } void SerialPrintZero() { Serial.print("0"); } //Sends the Sattelite data like Elevation, Azimuth SNR and ID using the Serial API {GSI} format void SendSatData() { uint8_t SNR; for (uint8_t i = 0; i < gps.sat_count; i++) { Serial.print (F("{GSI} ")); if (gps.satellites[i].id < 10) SerialPrintZero(); Serial.print( gps.satellites[i].id); Serial.print(" "); if (gps.satellites[i].azimuth < 100) SerialPrintZero(); if (gps.satellites[i].azimuth < 10) SerialPrintZero(); Serial.print( gps.satellites[i].azimuth ); Serial.print(" "); if (gps.satellites[i].elevation < 10) SerialPrintZero(); Serial.print( gps.satellites[i].elevation ); Serial.print((" ")); SNR = 0; if (gps.satellites[i].tracked) { SNR = gps.satellites[i].snr ; } else { SNR = 0; } if (SNR < 10) SerialPrintZero(); Serial.println(SNR); } Serial.println(); } // displaySatellitesInView ISR(WDT_vect) { //DON'T FORGET THIS! Needed for the watch dog timer. This is called after a watch dog timer timeout - this is the interrupt function called after waking up }// watchdog interrupt