first commit

RS41ng/legacy-code/f_rtty.c

@@ -0,0 +1,37 @@
+#include "f_rtty.h"
+
+uint8_t start_bits;
+rttyStates send_rtty(char *buffer) {
+  static uint8_t nr_bit = 0;
+  nr_bit++;
+  if (start_bits){
+    start_bits--;
+    return rttyOne;
+  }
+
+  if (nr_bit == 1) {
+    return rttyZero;
+  }
+  if (nr_bit > 1 && nr_bit < (RTTY_7BIT ? 9 : 10)) {
+    if ((*(buffer) >> (nr_bit - 2)) & 0x01) {
+      return rttyOne;
+    } else {
+      return rttyZero;
+    }
+  }
+
+  #ifdef RTTY_7BIT
+  nr_bit++;
+  #endif
+
+  if (nr_bit == 10) {
+    return rttyOne;
+  }
+  #ifdef RTTY_USE_2_STOP_BITS
+  if (nr_bit == 11) {
+    return rttyOne;
+  }
+  #endif
+  nr_bit = 0;
+  return rttyEnd;
+}

RS41ng/legacy-code/f_rtty.h

@@ -0,0 +1,12 @@
+#include <stdint.h>
+#include "config.h"
+
+typedef enum {
+  rttyZero = 0,
+  rttyOne = 1,
+  rttyEnd = 2
+} rttyStates;
+static const uint8_t RTTY_PRE_START_BITS = 40;
+
+rttyStates send_rtty(char *);
+extern uint8_t start_bits;

RS41ng/legacy-code/main_old.txt

@@ -0,0 +1,539 @@
+// STM32F100 and SI4032 RTTY transmitter
+// released under GPL v.2 by anonymous developer
+// enjoy and have a nice day
+// ver 1.5a
+#include <stm32f10x_gpio.h>
+#include <stm32f10x_usart.h>
+#include "f_rtty.h"
+#include "config.h"
+#include "locator.h"
+
+#define GREEN  GPIO_Pin_7
+#define RED  GPIO_Pin_8
+
+/*
+int main(void) {
+    system_init();
+    delay_init();
+
+    init_timer(1000);
+
+    printf("I2C Init\n");
+
+    i2c_init();
+
+    si5351_test();
+}
+ */
+/*
+int main_bmp280(void)
+{
+    //initialise_monitor_handles();
+    system_init();
+    delay_init();
+
+    //printf("I2C Init\n");
+
+    i2c_init();
+
+    bmp280 bmp280_dev;
+    bmp280_dev.port = &DEFAULT_I2C_PORT;
+    bmp280_dev.addr = BMP280_I2C_ADDRESS_1;
+
+    bmp280_params_t bmp280_params = {
+            .mode = BMP280_MODE_NORMAL,
+            .filter = BMP280_FILTER_16,
+            .oversampling_pressure = BMP280_ULTRA_HIGH_RES,
+            .oversampling_temperature = BMP280_ULTRA_HIGH_RES,
+            .oversampling_humidity = BMP280_ULTRA_HIGH_RES,
+            .standby = BMP280_STANDBY_250,
+    };
+
+    //printf("BMP280 Init\n");
+    char *test = "gg11";
+    //printf("test1: %s\n", test);
+    int test2 = 1234;
+    //printf("test2: %d\n", test2);
+
+    bool bmp280_init_success = bmp280_init(&bmp280_dev, &bmp280_params);
+    if (bmp280_init_success) {
+        //printf("BMP280 Init success\n");
+    } else {
+        //printf("BMP280 Init failure\n");
+    }
+
+    int32_t temperature;
+    uint32_t pressure, humidity;
+
+    while (true) {
+        GPIO_ResetBits(GPIOB, RED);
+        //printf("Measuring...\n");
+        bmp280_read_fixed(&bmp280_dev, &temperature, &pressure, &humidity);
+        //printf("----\n");
+        //printf("Temp: %d\n", temperature);
+        //printf("Pressure: %d\n", pressure);
+        //printf("Humidity: %d\n", humidity);
+        _delay_ms(1000);
+        GPIO_SetBits(GPIOB, RED);
+        _delay_ms(1000);
+    }
+}
+*/
+/*
+const unsigned char test = 0; // 0 - normal, 1 - short frame only cunter, height, flag
+char callsign[15] = {RTTY_CALLSIGN};
+char rtty_comment[25] = {RTTY_COMMENT};
+
+unsigned int send_cun;        //frame counter
+char status[2] = {'N'};
+
+//GPSEntry gpsData;
+int8_t si4032_temperature;
+uint16_t voltage;
+volatile int adc_bottom = 2000;
+
+unsigned int led_timeout = 600 * RTTY_SPEED; // Approx. 10 minutes
+volatile uint8_t led_enabled = 1; // Flag to disable LEDs after a timeout
+
+volatile char flaga = 0;
+uint16_t CRC_rtty = 0x12ab;  //checksum
+char buffer[200];
+char locator[13];
+
+volatile unsigned char pun = 0;
+volatile unsigned int cun = 10;
+volatile unsigned char tx_on = 0;
+volatile unsigned int tx_on_delay;
+volatile unsigned char tx_enable = 0;
+rttyStates send_rtty_status = rttyZero;
+volatile char *rtty_buf;
+volatile uint16_t button_pressed = 0;
+volatile uint8_t disable_armed = 0;
+
+void collect_telemetry_data(void);
+
+void send_rtty_packet(void);
+
+uint16_t gps_CRC16_checksum(char *string);
+
+void send_aprs_packet(void);
+
+void send_morse_message(void);
+*/
+
+/**
+ * GPS data processing
+ */
+ /*
+void USART1_IRQHandler(void)
+{
+    if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {
+        //ubxg6010_handle_incoming_byte((uint8_t) USART_ReceiveData(USART1));
+    } else if (USART_GetITStatus(USART1, USART_IT_ORE) != RESET) {
+        USART_ReceiveData(USART1);
+    } else {
+        USART_ReceiveData(USART1);
+    }
+}
+
+volatile int ready = 0;
+volatile int gen = 1;
+volatile int counter = 0;
+volatile int tone = 0;
+volatile uint16_t freq = 100;
+volatile int ledstate = 0;
+*/
+/*
+void TIM2_IRQHandler(void)
+{
+    if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) {
+        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
+
+
+        if (ready) {
+            if (gen) {
+                GPIO_ResetBits(GPIOB, radioSDIpin); // Low will TX at carrier + deviation
+            } else {
+                GPIO_SetBits(GPIOB, radioSDIpin); // High will TX at carrier - deviation
+            }
+            gen = !gen;
+
+            uint16_t speed = (tone + 1) * 600 * 2;
+            counter = (counter + 1) % speed;
+            if (counter == 0) {
+                tone = (tone + 1) % 4;
+                init_timer(speed);
+            }
+        }
+
+        if (counter == 0) {
+            freq += 100;
+
+            //mod_timer_set_freq(freq);
+            //radio_set_tx_frequency(434.250 + ((float) freq) / 1000000);
+
+            if (freq >= 5000) {
+                freq = 100;
+            }
+
+            if (ledstate) {
+                GPIO_SetBits(GPIOB, GREEN);
+            } else {
+                GPIO_ResetBits(GPIOB, GREEN);
+            }
+            ledstate = !ledstate;
+        }
+
+        counter = (counter + 1) % 1000;
+*/
+        /*    if (aprs_is_active()){
+        aprs_timer_handler();
+      } else {
+        if (ALLOW_DISABLE_BY_BUTTON){
+          if (ADCVal[1] > adc_bottom){
+            button_pressed++;
+            if (button_pressed > (RTTY_SPEED / 3)){
+              disable_armed = 1;
+              GPIO_SetBits(GPIOB, RED);
+              GPIO_SetBits(GPIOB, GREEN);
+            }
+          } else {
+            if (disable_armed){
+              GPIO_SetBits(GPIOA, GPIO_Pin_12);
+            }
+            button_pressed = 0;
+          }
+          if (button_pressed == 0) {
+           adc_bottom = ADCVal[1] * 1.1;	// dynamical reference for power down level
+          }
+        }
+        if (tx_on) {
+          send_rtty_status = send_rtty((char *) rtty_buf);
+          if (!disable_armed){
+            if (send_rtty_status == rttyEnd) {
+              if (led_enabled) GPIO_SetBits(GPIOB, RED);
+              if (*(++rtty_buf) == 0) {
+                tx_on = 0;
+                tx_on_delay = TX_DELAY / (1000/RTTY_SPEED);
+                tx_enable = 0;
+                radio_disable_tx();
+              }
+            } else if (send_rtty_status == rttyOne) {
+              radio_rw_register(0x73, RTTY_DEVIATION, 1);
+              if (led_enabled) GPIO_SetBits(GPIOB, RED);
+            } else if (send_rtty_status == rttyZero) {
+              radio_rw_register(0x73, 0x00, 1);
+              if (led_enabled) GPIO_ResetBits(GPIOB, RED);
+            }
+          }
+        }
+        if (!tx_on && --tx_on_delay == 0) {
+          tx_enable = 1;
+          tx_on_delay--;
+        }
+        if (--cun == 0) {
+          if (pun) {
+            if (led_enabled) GPIO_ResetBits(GPIOB, GREEN);
+            pun = 0;
+          } else {
+            if (flaga & 0x80) {
+              if (led_enabled) GPIO_SetBits(GPIOB, GREEN);
+            }
+            pun = 1;
+          }
+          cun = 200;
+        }
+      }
+
+      if (!LED_ENABLED && led_enabled && !--led_timeout) led_enabled = 0;
+
+    }
+
+}
+*/
+
+        /*
+void TIM1_BRK_TIM15_IRQHandler(void)
+{
+    if (TIM_GetITStatus(TIM15, TIM_IT_CC2) != RESET) {
+        TIM_ClearITPendingBit(TIM15, TIM_IT_CC2);
+
+        if (ledstate) {
+            GPIO_SetBits(GPIOB, GREEN);
+        } else {
+            GPIO_ResetBits(GPIOB, GREEN);
+        }
+        ledstate = !ledstate;
+
+    }
+}
+*/
+
+        /*
+int old_main(void)
+{
+//    initialise_monitor_handles();
+#ifdef DEBUG
+    debug();
+#endif
+    system_init();
+
+    init_port();
+
+    init_timer(1000);
+    delay_init();
+            ubxg6010_init();
+
+    if (led_enabled) GPIO_SetBits(GPIOB, RED);
+    // USART_SendData(USART3, 0xc);
+
+    printf("main!\n");
+
+    deinit_usart_debug();
+    i2c_init();
+
+    radio_soft_reset();
+    // setting RTTY TX frequency
+    //radio_set_tx_frequency(434.250);
+
+    // setting TX power
+    radio_rw_register(0x6D, 00 | (TX_POWER & 0x0007), 1);
+
+    // initial RTTY modulation
+    radio_rw_register(0x71, 0x00, 1);
+
+    // Temperature Value Offset
+    radio_rw_register(0x13, 0xF0, 1);
+
+    // Temperature Sensor Calibration
+    radio_rw_register(0x12, 0x00, 1);
+
+    // ADC configuration
+    radio_rw_register(0x0f, 0x80, 1);
+    rtty_buf = buffer;
+    tx_on = 0;
+    tx_enable = 1;
+
+    uint8_t rtty_before_aprs_left = RTTY_TO_APRS_RATIO;
+    uint8_t morse_countdown = RTTY_TO_MORSE_RATIO;
+
+    radio_set_tx_frequency(434.250);
+
+    //_delay_ms(2);
+    //_delay_ms(2);
+
+    // The frequency deviation can be calculated: Fd = 625 Hz x fd[8:0].
+    // Zero disables deviation between 0/1 bits
+    radio_rw_register(0x72, 1, 1);
+    // The frequency offset can be calculated as Offset = 156.25 Hz x (hbsel + 1) x fo[7:0]. fo[9:0] is a twos complement value. fo[9] is the sign bit.
+    // For 70cm band hbsel is 1, so offset step is 312.5 Hz
+    radio_rw_register(0x73, 0, 1);
+    radio_rw_register(0x74, 0, 1);
+    // Direct Async Mode with OOK modulation
+    //radio_rw_register(0x71, 0b00010001, 1);
+    // Direct Async Mode with FSK modulation
+    radio_rw_register(0x71, 0b00010010, 1);
+
+    //radio_enable_tx();
+
+    spi_deinit();
+
+    // USART interrupts interfere with direct mode transmission
+    USART_Cmd(USART1, DISABLE);
+
+    uint16_t mark = 1000000 / 1200 / 2;
+    uint16_t space = 1000000 / 2200 / 2;
+
+    uint16_t iter = 0;
+
+    //GPIO_SetBits(GPIOC, radioNSELpin);
+
+    //init_mod_timer(freq);
+
+    // ready = 1;
+
+    // FSK example
+    while (1) {
+        // NVIC_SystemLPConfig(NVIC_LP_SEVONPEND, DISABLE);
+        //__WFI();
+        GPIO_SetBits(GPIOB, RED);
+        _delay_ms(500);
+        GPIO_ResetBits(GPIOB, RED);
+        _delay_ms(500);
+        //printf("freq: %d\n", freq);
+    }
+
+    // FSK example with frequency offset
+    while (1) {
+        for (int i = 0; i < 1000; i++) {
+            spi_init();
+            radio_rw_register(0x73, 0, 1);
+            spi_deinit();
+            GPIO_SetBits(GPIOB, RED);
+            GPIO_SetBits(GPIOB, radioSDIpin); // High will TX at carrier - deviation
+            _delay_ms(500);
+            GPIO_ResetBits(GPIOB, RED);
+            GPIO_ResetBits(GPIOB, radioSDIpin); // Low will TX at carrier + deviation
+            _delay_ms(500);
+
+            spi_init();
+            radio_rw_register(0x73, 1, 1);
+            spi_deinit();
+            GPIO_SetBits(GPIOB, RED);
+            GPIO_SetBits(GPIOB, radioSDIpin); // High will TX at carrier - deviation
+            _delay_ms(500);
+            GPIO_ResetBits(GPIOB, RED);
+            GPIO_ResetBits(GPIOB, radioSDIpin); // High will TX at carrier + deviation
+            _delay_ms(500);
+        }
+
+        for (int i = 0; i < 1000; i++) {
+            //GPIO_SetBits(GPIOB, RED);
+            GPIO_SetBits(GPIOB, radioSDIpin);
+            _delay_us(250, 0);
+            //GPIO_ResetBits(GPIOB, RED);
+            GPIO_ResetBits(GPIOB, radioSDIpin);
+            _delay_us(250, 0);
+        }
+    }
+
+    // OOK example
+    while (1) {
+        GPIO_SetBits(GPIOB, RED);
+        GPIO_SetBits(GPIOB, radioSDIpin);
+        _delay_ms(500);
+        GPIO_ResetBits(GPIOB, RED);
+        GPIO_ResetBits(GPIOB, radioSDIpin); // OOK carrier TX is on when SDI is low
+        _delay_ms(500);
+    }
+/*    if (tx_on == 0 && tx_enable) {
+      if (rtty_before_aprs_left){
+        if (SEND_MORSE && !--morse_countdown) {
+          send_morse_message();
+          morse_countdown = RTTY_TO_MORSE_RATIO;
+        }
+        if (SEND_RTTY) send_rtty_packet();
+        else _delay_ms(TX_DELAY);
+        rtty_before_aprs_left--;
+      } else {
+        rtty_before_aprs_left = RTTY_TO_APRS_RATIO;
+        if (SEND_APRS) send_aprs_packet();
+      }
+
+    } else {
+        NVIC_SystemLPConfig(NVIC_LP_SEVONPEND, DISABLE);
+      __WFI();
+    }
+  }
+}
+         */
+/*
+void collect_telemetry_data(void)
+{
+    si4032_temperature = radio_read_temperature();
+    voltage = ADCVal[0] * 600 / 4096;
+    ublox_get_last_data(&gpsData);
+    if (gpsData.fix >= 3) flaga |= 0x80;
+    else flaga &= ~0x80;
+    if (RTTY_WWL || SEND_MORSE_WWL)
+        longlat2locator(gpsData.lon_raw, gpsData.lat_raw, locator);
+}
+
+void send_rtty_packet(void)
+{
+    start_bits = RTTY_PRE_START_BITS;
+    collect_telemetry_data();
+    uint8_t lat_d = (uint8_t) abs(gpsData.lat_raw / 10000000);
+    uint32_t lat_fl = (uint32_t) abs(abs(gpsData.lat_raw) - lat_d * 10000000) / 1000;
+    uint8_t lon_d = (uint8_t) abs(gpsData.lon_raw / 10000000);
+    uint32_t lon_fl = (uint32_t) abs(abs(gpsData.lon_raw) - lon_d * 10000000) / 1000;
+
+    int packetLength = sprintf(buffer, "$$$$%s,%d", callsign, send_cun);
+    if (SEND_RTTY_TIME)
+        packetLength += sprintf(buffer + packetLength, ",%02u:%02u:%02u", gpsData.hours, gpsData.minutes,
+                gpsData.seconds);
+    if (SEND_RTTY_LATLON)
+        packetLength += sprintf(buffer + packetLength, ",%s%u.%04lu,%s%u.%04lu",
+                gpsData.lat_raw < 0 ? "-" : "", lat_d, lat_fl,
+                gpsData.lon_raw < 0 ? "-" : "", lon_d, lon_fl);
+    if (SEND_RTTY_HEIGHT)
+        packetLength += sprintf(buffer + packetLength, ",%ld", (gpsData.alt_raw / 1000));
+    if (SEND_RTTY_SPEED)
+        packetLength += sprintf(buffer + packetLength, ",%ld", gpsData.speed_raw);
+    if (SEND_RTTY_MESSAGE)
+        packetLength += sprintf(buffer + packetLength, ",%s", RTTY_WWL ? locator : rtty_comment);
+    if (SEND_RTTY_TEMPERATURE)
+        packetLength += sprintf(buffer + packetLength, ",%d", si4032_temperature);
+    if (SEND_RTTY_VOLTAGE)
+        packetLength += sprintf(buffer + packetLength, ",%d.%02d", voltage / 100, voltage - voltage / 100 * 100);
+    if (SEND_RTTY_SATELLITES)
+        packetLength += sprintf(buffer + packetLength, ",%d", gpsData.sats_raw);
+    if (SEND_RTTY_GPSDATA)
+        packetLength += sprintf(buffer + packetLength, ",%d,%d,%02x",
+                gpsData.ok_packets,
+                gpsData.bad_packets,
+                flaga);
+
+    CRC_rtty = gps_CRC16_checksum(buffer + 4);
+    sprintf(buffer + packetLength, "*%04X\n", CRC_rtty & 0xffff);
+    rtty_buf = buffer;
+    radio_enable_tx();
+    tx_on = 1;
+
+    send_cun++;
+}
+
+uint16_t gps_CRC16_checksum(char *string)
+{
+    uint16_t crc = 0xffff;
+    char i;
+    while (*(string) != 0) {
+        crc = crc ^ (*(string++) << 8);
+        for (i = 0; i < 8; i++) {
+            if (crc & 0x8000)
+                crc = (uint16_t) ((crc << 1) ^ 0x1021);
+            else
+                crc <<= 1;
+        }
+    }
+    return crc;
+}
+
+void send_aprs_packet(void)
+{
+    radio_enable_tx();
+    collect_telemetry_data();
+    USART_Cmd(USART1, DISABLE);
+    aprs_send_position(gpsData, si4032_temperature, voltage);
+    USART_Cmd(USART1, ENABLE);
+    radio_disable_tx();
+}
+
+void send_morse_message(void)
+{
+    tx_enable = 0;
+    collect_telemetry_data();
+    int messageLength = sprintf(buffer, "%s", MORSE_PREFIX);
+    if (SEND_MORSE_WWL)
+        messageLength += sprintf(buffer + messageLength, " IN %s", locator);
+    if (SEND_MORSE_HEIGHT)
+        messageLength += sprintf(buffer + messageLength, " ASL %ld", (gpsData.alt_raw / 1000));
+    if (SEND_MORSE_VOLTAGE)
+        messageLength += sprintf(buffer + messageLength, " BAT %d.%02d", voltage / 100, voltage - voltage / 100 * 100);
+    messageLength += sprintf(buffer + messageLength, "%s", MORSE_SUFFIX);
+
+    // Set CW offset
+    radio_rw_register(0x73, 1, 1);
+
+    sendMorse(buffer);
+    _delay_ms(2000);
+    tx_enable = 1;
+}
+
+#ifdef  DEBUG
+void assert_failed(uint8_t* file, uint32_t line)
+{
+    while (1);
+}
+#endif
+*/