Changeset - 2fa25ca2db21
Parent rev.
Child rev.
[Not reviewed]
default
0 2 0
Ethan Zonca - 9 years ago 2016-10-13 22:08:54
ez@ethanzonca.com
Don't zero out everything in position, because we need some of that data; fix timer clocking
2 files changed with 12 insertions and 12 deletions:
src/gps.c
11
11
src/wspr.c
1
1
0 comments (0 inline, 0 general)
src/gps.c
➞
Show inline comments
 
//
 
// GPS: communicate with ublox GPS module via ubx protocol
 
//
 

			




	
	
	
		
 
#include "stm32f0xx_hal.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include "config.h"

			




	
	
	
		
 
#include "gpio.h"

			




	
	
	
		
 
#include "uart.h"

			




	
	
	
		
 
#include "gps.h"

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
volatile gps_data_t position;

			




	
	
	
		
 
uint8_t gpson = 0;

			




	
	
	
		
 

			




	
	
	
		
 
// Private methods

			




	
	
	
		
 
static void gps_ubx_checksum(uint8_t* data, uint8_t len, uint8_t* cka, uint8_t* ckb);

			




	
	
	
		
 
static uint8_t _gps_verify_checksum(uint8_t* data, uint8_t len);

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// Poll for fix data from the GPS and update the internal structure

			




	
	
	
		
 
void gps_update_data(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
	// Error!

			




	
	
	
		
 
	if(!gpson)

			




	
	
	
		
 
	{

			




	
	
	
		
 
		led_blink(5);

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
    // Construct the request to the GPS

			




	
	
	
		
 
    uint8_t request[8] = {0xB5, 0x62, 0x01, 0x07, 0x00, 0x00, 0xFF, 0xFF};

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    volatile uint8_t check_a = 0;

			




	
	
	
		
 
    volatile uint8_t check_b = 0;

			




	
	
	
		
 
    for(uint8_t i = 2; i<6; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
    	check_a += request[i];

			




	
	
	
		
 
    	check_b += check_a;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    request[6] = check_a;

			




	
	
	
		
 
    request[7] = check_b;

			




	
	
	
		
 

			




	
	
	
		
 
    uint8_t flushed = uart_gethandle()->Instance->RDR;

			




	
	
	
		
 
    HAL_UART_Transmit(uart_gethandle(), request, 8, 100);

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    // Get the message back from the GPS

			




	
	
	
		
 
    uint8_t buf[100];

			




	
	
	
		
 
    for(uint8_t i=0; i<100; i++)

			




	
	
	
		
 
    	buf[i] = 0xaa;

			




	
	
	
		
 
    volatile HAL_StatusTypeDef res = HAL_UART_Receive(uart_gethandle(), buf, 100, 3000);

			




	
	
	
		
 

			




	
	
	
		
 
    // Check 60 bytes minus SYNC and CHECKSUM (4 bytes)

			




	
	
	
		
 
    if( !_gps_verify_checksum(&buf[2], 96) )

			




	
	
	
		
 
        led_blink(2);

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    //volatile uint32_t gpstime_ms = (buf[6+0] << 24) | (buf[6+1] << 16) | buf[6+2] << 8) | (buf[6+3]);

			




	
	
	
		
 

			




	
	
	
		
 
    position.month = buf[6+6];

			




	
	
	
		
 
    position.day = buf[6+7];

			




	
	
	
		
 
    position.hour = buf[6+8];

			




	
	
	
		
 
    position.minute = buf[6+9];

			




	
	
	
		
 
    position.second = buf[6+10];

			




	
	
	
		
 
    position.valid = buf[6+11] & 0b1111;

			




	
	
	
		
 
    position.fixtype = buf[6+20];

			




	
	
	
		
 

			




	
	
	
		
 
    position.sats_in_solution = buf[6+23];

			




	
	
	
		
 

			




	
	
	
		
 
    position.longitude = (buf[6+24] << 0) | (buf[6+25] << 8) | (buf[6+26] << 16) | (buf[6+27] << 24); // degrees

			




	
	
	
		
 
    position.latitude =  (buf[6+28] << 0) | (buf[6+29] << 8) | (buf[6+30] << 16) | (buf[6+31] << 24); // degrees

			




	
	
	
		
 

			




	
	
	
		
 
    position.altitude = (buf[6+36] << 0) | (buf[6+37] << 8) | (buf[6+38] << 16) | (buf[6+39] << 24); // mm above sealevel

			




	
	
	
		
 
    position.altitude /= 1000; // mm => m

			




	
	
	
		
 

			




	
	
	
		
 
    position.speed = (buf[6+60] << 0) | (buf[6+61] << 8) | (buf[6+62] << 16) | (buf[6+63] << 24); // mm/second

			




	
	
	
		
 
    position.speed /= 1000; // mm/s -> m/s

			




	
	
	
		
 
    

			




	
	
	
		
 
    position.pdop = (buf[6+76] << 0) | (buf[6+77] << 8);

			




	
	
	
		
 
    position.pdop /= 100; // scale to dop units

			




	
	
	
		
 

			




	
	
	
		
 
    position.heading = (buf[6+84] << 0) | (buf[6+85] << 8) | (buf[6+86] << 16) | (buf[6+87] << 24); // mm above sealevel

			




	
	
	
		
 
    position.heading /= 100000; // 1e-5

			




	
	
	
		
 

			




	
	
	
		
 
//    // Return the value if GPSfixOK is set in 'flags'

			




	
	
	
		
 
//    if( buf[17] & 0x01 )

			




	
	
	
		
 
//        *lock = buf[16];

			




	
	
	
		
 
//    else

			




	
	
	
		
 
//        *lock = 0;

			




	
	
	
		
 

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// TODO: Add data valid flag: invalidate data when GPS powered off

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// Verify that the uBlox 6 GPS receiver is set to the <1g airborne navigaion mode.

			




	
	
	
		
 
uint8_t gps_check_nav(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    uint8_t request[8] = {0xB5, 0x62, 0x06, 0x24, 0x00, 0x00,

			




	
	
	
		
 
        0x2A, 0x84};

			




	
	
	
		
 
    uint8_t flushed = uart_gethandle()->Instance->RDR;

			




	
	
	
		
 
    HAL_UART_Transmit(uart_gethandle(), request, 8, 100);

			




	
	
	
		
 

			




	
	
	
		
 
    // Get the message back from the GPS

			




	
	
	
		
 
    uint8_t buf[44];

			




	
	
	
		
 
    HAL_UART_Receive(uart_gethandle(), buf, 44, 100);

			




	
	
	
		
 

			




	
	
	
		
 
//    // Verify sync and header bytes

			




	
	
	
		
 
//    if( buf[0] != 0xB5 || buf[1] != 0x62 )

			




	
	
	
		
 
//        led_set(LED_RED, 1);

			




	
	
	
		
 
//    if( buf[2] != 0x06 || buf[3] != 0x24 )

			




	
	
	
		
 
//        led_set(LED_RED, 1);

			




	
	
	
		
 

			




	
	
	
		
 
    // Check 40 bytes of message checksum

			




	
	
	
		
 
//    if( !_gps_verify_checksum(&buf[2], 40) ) led_set(LED_RED, 1);

			




	
	
	
		
 

			




	
	
	
		
 
    // Clock in and verify the ACK/NACK

			




	
	
	
		
 
    uint8_t ack[10];

			




	
	
	
		
 
//    for(uint8_t i = 0; i < 10; i++)

			




	
	
	
		
 
//        ack[i] = _gps_get_byte();

			




	
	
	
		
 

			




	
	
	
		
 
    HAL_UART_Receive(uart_gethandle(), ack, 10, 100);

			




	
	
	
		
 

			




	
	
	
		
 
    // If we got a NACK, then return 0xFF

			




	
	
	
		
 
    if( ack[3] == 0x00 ) return 0xFF;

			




	
	
	
		
 

			




	
	
	
		
 
    // Return the navigation mode and let the caller analyse it

			




	
	
	
		
 
    return buf[8];

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// Verify the checksum for the given data and length.

			




	
	
	
		
 
static uint8_t _gps_verify_checksum(uint8_t* data, uint8_t len)

			




	
	
	
		
 
{

			




	
	
	
		
 
    uint8_t a, b;

			




	
	
	
		
 
    gps_ubx_checksum(data, len, &a, &b);

			




	
	
	
		
 
    if( a != *(data + len) || b != *(data + len + 1))

			




	
	
	
		
 
        return 0;

			




	
	
	
		
 
    else

			




	
	
	
		
 
        return 1;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// Calculate a UBX checksum using 8-bit Fletcher (RFC1145)

			




	
	
	
		
 
static void gps_ubx_checksum(uint8_t* data, uint8_t len, uint8_t* cka, uint8_t* ckb)

			




	
	
	
		
 
{

			




	
	
	
		
 
    *cka = 0;

			




	
	
	
		
 
    *ckb = 0;

			




	
	
	
		
 
    for( uint8_t i = 0; i < len; i++ )

			




	
	
	
		
 
    {

			




	
	
	
		
 
        *cka += *data;

			




	
	
	
		
 
        *ckb += *cka;

			




	
	
	
		
 
        data++;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// Power on GPS module and initialize UART

			




	
	
	
		
 
void gps_poweron(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // NOTE: pchannel

			




	
	
	
		
 
    HAL_GPIO_WritePin(GPS_NOTEN, 0);

			




	
	
	
		
 
    uart_init();

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
	// Disable messages

			




	
	
	
		
 
	uint8_t setGGA[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0XFF, 0X23};

			




	
	
	
		
 
	HAL_UART_Transmit(uart_gethandle(), setGGA, sizeof(setGGA)/sizeof(uint8_t), 100);

			




	
	
	
		
 
	HAL_Delay(100);

			




	
	
	
		
 

			




	
	
	
		
 
	uint8_t ackbuffer[10];

			




	
	
	
		
 
	for(uint8_t i=0; i<10; i++)

			




	
	
	
		
 
		ackbuffer[i] = 0xaa;

			




	
	
	
		
 
	HAL_UART_Receive(uart_gethandle(), ackbuffer, 10, 100);

			




	
	
	
		
 

			




	
	
	
		
 
	uint8_t setZDA[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X07, 0X5B};

			




	
	
	
		
 
	HAL_UART_Transmit(uart_gethandle(), setZDA, sizeof(setZDA)/sizeof(uint8_t), 100);

			




	
	
	
		
 
	HAL_Delay(100);

			




	
	
	
		
 

			




	
	
	
		
 
	uint8_t setGLL[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X01, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X2A};

			




	
	
	
		
 
	HAL_UART_Transmit(uart_gethandle(), setGLL, sizeof(setGLL)/sizeof(uint8_t), 100);

			




	
	
	
		
 
	HAL_Delay(100);

			




	
	
	
		
 

			




	
	
	
		
 
	uint8_t setGSA[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X02, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X01, 0X31};

			




	
	
	
		
 
	HAL_UART_Transmit(uart_gethandle(), setGSA, sizeof(setGSA)/sizeof(uint8_t), 100);

			




	
	
	
		
 
	HAL_Delay(100);

			




	
	
	
		
 

			




	
	
	
		
 
	uint8_t setGSV[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X03, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X02, 0X38};

			




	
	
	
		
 
	HAL_UART_Transmit(uart_gethandle(), setGSV, sizeof(setGSV)/sizeof(uint8_t), 100);

			




	
	
	
		
 
	HAL_Delay(100);

			




	
	
	
		
 

			




	
	
	
		
 
	uint8_t setRMC[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X04, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X03, 0X3F};

			




	
	
	
		
 
	HAL_UART_Transmit(uart_gethandle(), setRMC, sizeof(setRMC)/sizeof(uint8_t), 100);

			




	
	
	
		
 
	HAL_Delay(100);

			




	
	
	
		
 

			




	
	
	
		
 
	uint8_t setVTG[] = {0XB5, 0X62, 0X06, 0X01, 0X08, 0X00, 0XF0, 0X05, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X04, 0X46};

			




	
	
	
		
 
	HAL_UART_Transmit(uart_gethandle(), setVTG, sizeof(setRMC)/sizeof(uint8_t), 100);

			




	
	
	
		
 
	HAL_Delay(100);

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
//    // Disable GLONASS mode

			




	
	
	
		
 
//    uint8_t disable_glonass[20] = {0xB5, 0x62, 0x06, 0x3E, 0x0C, 0x00, 0x00, 0x00, 0x20, 0x01, 0x06, 0x08, 0x0E, 0x00, 0x00, 0x00, 0x01, 0x01, 0x8F, 0xB2};

			




	
	
	
		
 
//

			




	
	
	
		
 
//    //gps_sendubx(disable_glonass, 20);

			




	
	
	
		
 
//    volatile HAL_StatusTypeDef res = HAL_UART_Transmit(uart_gethandle(), disable_glonass, 20, 100);

			




	
	
	
		
 
//

			




	
	
	
		
 
//    // Enable power saving

			




	
	
	
		
 
//    uint8_t enable_powersave[10] = {0xB5, 0x62, 0x06, 0x11, 0x02, 0x00, 0x08, 0x01, 0x22, 0x92};

			




	
	
	
		
 
//    //gps_sendubx(enable_powersave, 10);

			




	
	
	
		
 
//    res = HAL_UART_Transmit(uart_gethandle(), enable_powersave, 10, 100);

			




	
	
	
		
 
//

			




	
	
	
		
 
//

			




	
	
	
		
 
//    // Set dynamic model 6 (<1g airborne platform)

			




	
	
	
		
 
//    uint8_t airborne_model[] = { 0xB5, 0x62, 0x06, 0x24, 0x24, 0x00, 0xFF, 0xFF, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10, 0x27, 0x00, 0x00, 0x05, 0x00, 0xFA, 0x00, 0xFA, 0x00, 0x64, 0x00, 0x2C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0xDC };

			




	
	
	
		
 
//    //gps_sendubx(airborne_model, sizeof(airborne_model)/sizeof(uint8_t));

			




	
	
	
		
 
//    res = HAL_UART_Transmit(uart_gethandle(), airborne_model, sizeof(airborne_model)/sizeof(uint8_t), 100);

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    // Begin DMA reception

			




	
	
	
		
 
    //HAL_UART_Receive_DMA(uart_gethandle(), nmeaBuffer, NMEABUFFER_SIZE);

			




	
	
	
		
 

			




	
	
	
		
 
    gpson = 1;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// Power off GPS module

			




	
	
	
		
 
void gps_poweroff(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // NOTE: pchannel

			




	
	
	
		
 
	position.hour = 0;

			




	
	
	
		
 
	position.minute = 0;

			




	
	
	
		
 
	position.second = 0;

			




	
	
	
		
 
	position.altitude = 0;

			




	
	
	
		
 
	position.latitude = 0;

			




	
	
	
		
 
	position.longitude = 0;

			




	
	
	
		
 
	position.day = 0;

			




	
	
	
		
 
	position.month = 0;

			




	
	
	
		
 
	position.fixtype = 0;

			




	
	
	
		
 
	position.valid = 0;

			




	
	
	
		
 
//	position.hour = 0;

			




	
	
	
		
 
//	position.minute = 0;

			




	
	
	
		
 
//	position.second = 0;

			




	
	
	
		
 
//	position.altitude = 0;

			




	
	
	
		
 
//	position.latitude = 0;

			




	
	
	
		
 
//	position.longitude = 0;

			




	
	
	
		
 
//	position.day = 0;

			




	
	
	
		
 
//	position.month = 0;

			




	
	
	
		
 
//	position.fixtype = 0;

			




	
	
	
		
 
//	position.valid = 0;

			




	
	
	
		
 
	position.pdop = 0;

			




	
	
	
		
 
	position.sats_in_solution = 0;

			




	
	
	
		
 
	position.speed = 0;

			




	
	
	
		
 
//	position.speed = 0;

			




	
	
	
		
 

			




	
	
	
		
 
    uart_deinit();

			




	
	
	
		
 
    HAL_GPIO_WritePin(GPS_NOTEN, 1);

			




	
	
	
		
 
    gpson = 0;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
gps_data_t* gps_getdata(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &position;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
uint8_t gps_ison(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    return gpson;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// vim:softtabstop=4 shiftwidth=4 expandtab 

			




        

    


    
    

    

        

                

                    src/wspr.c
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
#include "stm32f0xx_hal.h"

			




	
	
	
		
 
#include "si5351.h"

			




	
	
	
		
 
#include "jtencode.h"

			




	
	
	
		
 
#include "gpio.h"

			




	
	
	
		
 
#include "wspr.h"

			




	
	
	
		
 
#include "i2c.h"

			




	
	
	
		
 
#include "config.h"

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#define WSPR_DEFAULT_FREQ 10140100UL

			




	
	
	
		
 
#define WSPR_TONE_SPACING 146 // ~1.46 Hz

			




	
	
	
		
 
#define WSPR_CTC 10672 // CTC value for WSPR

			




	
	
	
		
 

			




	
	
	
		
 
// Test stuff

			




	
	
	
		
 
char call[7] = "KD8TDF";

			




	
	
	
		
 
char loc[5] = "EN72";

			




	
	
	
		
 
uint8_t dbm = 10;

			




	
	
	
		
 
uint8_t tx_buffer[255];

			




	
	
	
		
 

			




	
	
	
		
 
// Frequencies and channel info

			




	
	
	
		
 
uint32_t freq = WSPR_DEFAULT_FREQ;

			




	
	
	
		
 
uint8_t symbol_count = WSPR_SYMBOL_COUNT;

			




	
	
	
		
 
uint16_t ctc = WSPR_CTC;

			




	
	
	
		
 
uint16_t tone_spacing = WSPR_TONE_SPACING;

			




	
	
	
		
 
volatile uint8_t proceed = 0;

			




	
	
	
		
 

			




	
	
	
		
 
TIM_HandleTypeDef htim1;

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
void wspr_init(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // Turn off ICs

			




	
	
	
		
 
    HAL_GPIO_WritePin(OSC_NOTEN, 1);

			




	
	
	
		
 
    HAL_GPIO_WritePin(TCXO_EN, 0);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// Do anything needed to prepare for sleep

			




	
	
	
		
 
void wspr_sleep(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    HAL_TIM_Base_Stop_IT(&htim1);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void wspr_wakeup(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
    HAL_TIM_Base_Start_IT(&htim1);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
// Bring up TCXO and oscillator IC

			




	
	
	
		
 
void wspr_transmit(uint8_t* grid_locator)

			




	
	
	
		
 
{

			




	
	
	
		
 
	// Copy 4 digit grid locator to local buffer; null terminate

			




	
	
	
		
 
	for(uint8_t i=0; i<4; i++)

			




	
	
	
		
 
		loc[i] = grid_locator[i];

			




	
	
	
		
 
	loc[4] = '\0';

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    // Start timer for WSPR

			




	
	
	
		
 
    __TIM1_CLK_ENABLE();

			




	
	
	
		
 
    htim1.Instance = TIM1;

			




	
	
	
		
 
    htim1.Init.Prescaler = 512; // gives 64uS ticks from 8MHz ahbclk

			




	
	
	
		
 
    htim1.Init.Prescaler = 512 / 4; // FIXED gives 64us ticks from 2mhz clock // gives 64uS ticks from 8MHz ahbclk

			




	
	
	
		
 
    htim1.Init.CounterMode = TIM_COUNTERMODE_UP;

			




	
	
	
		
 
    htim1.Init.Period = ctc; // Count up to this value (how many 64uS ticks per symbol)

			




	
	
	
		
 
    htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

			




	
	
	
		
 
    htim1.Init.RepetitionCounter = 0;

			




	
	
	
		
 
    HAL_TIM_Base_Init(&htim1);

			




	
	
	
		
 
    HAL_TIM_Base_Start_IT(&htim1);

			




	
	
	
		
 
    HAL_NVIC_SetPriority(TIM1_BRK_UP_TRG_COM_IRQn, 0, 0);

			




	
	
	
		
 
    HAL_NVIC_EnableIRQ(TIM1_BRK_UP_TRG_COM_IRQn);

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    HAL_GPIO_WritePin(OSC_NOTEN, 0);

			




	
	
	
		
 
    HAL_GPIO_WritePin(TCXO_EN, 1);

			




	
	
	
		
 
    HAL_Delay(100);

			




	
	
	
		
 

			




	
	
	
		
 
    // Bring up the chip

			




	
	
	
		
 
    i2c_init();

			




	
	
	
		
 
    si5351_init(i2c_get(), SI5351_CRYSTAL_LOAD_8PF, 0);

			




	
	
	
		
 
    si5351_set_correction(0);

			




	
	
	
		
 
    //si5351_set_pll(SI5351_PLL_FIXED, SI5351_PLLA);

			




	
	
	
		
 
    //si5351_set_ms_source(SI5351_CLK0, SI5351_PLLA);

			




	
	
	
		
 
    si5351_set_freq(WSPR_DEFAULT_FREQ * 100, 0, SI5351_CLK0);

			




	
	
	
		
 
    si5351_drive_strength(SI5351_CLK0, SI5351_DRIVE_8MA); // Set for max power if desired (8ma max)

			




	
	
	
		
 
    si5351_output_enable(SI5351_CLK0, 1);

			




	
	
	
		
 
    //si5351_pll_reset(SI5351_PLLA);

			




	
	
	
		
 

			




	
	
	
		
 
    // Make sure the other outputs of the SI5351 are disabled

			




	
	
	
		
 
    si5351_output_enable(SI5351_CLK1, 0); // Disable the clock initially

			




	
	
	
		
 
    si5351_output_enable(SI5351_CLK2, 0); // Disable the clock initially

			




	
	
	
		
 

			




	
	
	
		
 
    // disable clock powers

			




	
	
	
		
 
    si5351_set_clock_pwr(SI5351_CLK1, 0);

			




	
	
	
		
 
    si5351_set_clock_pwr(SI5351_CLK2, 0);

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
    // Encode message to transmit

			




	
	
	
		
 
    wspr_encode(call, loc, dbm, tx_buffer);

			




	
	
	
		
 

			




	
	
	
		
 
    // Key transmitter

			




	
	
	
		
 
    si5351_output_enable(SI5351_CLK0, 1);

			




	
	
	
		
 

			




	
	
	
		
 
    // Loop through and transmit symbols TODO: Do this from an ISR or ISR-triggered main loop function call (optimal)

			




	
	
	
		
 
    uint8_t i;

			




	
	
	
		
 
    for(i=0; i<symbol_count; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        uint32_t freq2 = (freq * 100) + (tx_buffer[i] * tone_spacing);

			




	
	
	
		
 
        si5351_set_freq(freq2, 0, SI5351_CLK0);

			




	
	
	
		
 
        HAL_GPIO_TogglePin(LED_BLUE);

			




	
	
	
		
 

			




	
	
	
		
 
        proceed = 0;

			




	
	
	
		
 
        while(!proceed);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // Disable transmitter

			




	
	
	
		
 
    si5351_output_enable(SI5351_CLK0, 0);

			




	
	
	
		
 

			




	
	
	
		
 
    HAL_GPIO_WritePin(OSC_NOTEN, 1);

			




	
	
	
		
 
    HAL_GPIO_WritePin(TCXO_EN, 0);

			




	
	
	
		
 

			




	
	
	
		
 
    i2c_deinit();

			




	
	
	
		
 

			




	
	
	
		
 
    // Disable timer

			




	
	
	
		
 
    HAL_NVIC_DisableIRQ(TIM1_BRK_UP_TRG_COM_IRQn);

			




	
	
	
		
 
    HAL_TIM_Base_Stop_IT(&htim1);

			




	
	
	
		
 
    HAL_TIM_Base_DeInit(&htim1);

			




	
	
	
		
 

			




	
	
	
		
 
    __TIM1_CLK_DISABLE();

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
}

			




	
	
	
		
 

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: zserverv-626845
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support