mirror
/
pico-tracker
kopia lustrzana https://github.com/bristol-seds/pico-tracker
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
pico-tracker/firmware/src/ax25.c

348 wiersze
8.7 KiB
C
Czysty Bezpośredni odnośnik Wina Historia

/*
* Outputs ax25 to the si_trx
* Copyright (C) 2015 Richard Meadows <richardeoin>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <string.h>
#include <math.h>
#include "samd20.h"
#include "system/gclk.h"
#include "system/pinmux.h"
#include "tc/tc_driver.h"
#include "hw_config.h"
#include "ax25.h"
#include "telemetry.h"
#include "si_trx.h"
enum ax25_symbol_t next_symbol;
uint8_t bit_index;
struct ax25_byte_t current_byte;
uint8_t current_bit;
uint8_t one_count;
uint32_t byte_index;
enum ax25_state_t ax25_state;
uint8_t ax25_frame[AX25_MAX_FRAME_LEN];
uint32_t ax25_index, ax25_frame_length;
void ax25_gpio1_pwm_init(void);
/**
* USEFUL RESOURCES
* =============================================================================
*
* http://en.wikipedia.org/wiki/AX.25
* https://www.tapr.org/pub_ax25.html#2.4.1.2
* http://owenduffy.net/blog/?p=2101
* http://n1vg.net/packet/
*/
/**
* Frame Check Sequence (FCS)
* =============================================================================
*/
/**
* CRC Function for CCITT-16. Poly = 0x8408
* http://www.nongnu.org/avr-libc/user-manual/group__util__crc.html#ga1c1d3ad875310cbc58000e24d981ad20
*/
uint16_t crc_ccitt_update (uint16_t crc, uint8_t data)
{
data ^= (crc & 0xff);
data ^= data << 4;
return ((((uint16_t)data << 8) | ((crc >> 8) & 0xff)) ^ (uint8_t)(data >> 4)
^ ((uint16_t)data << 3));
}
/**
* Calculates the Frame Check Sequence (FCS) using the CRC algorithm
*/
uint16_t crc_fcs(uint8_t *string, uint32_t length)
{
size_t i;
uint16_t crc;
uint8_t c;
crc = 0xFFFF;
for (i = 0; i < length; i++) {
c = string[i];
crc = crc_ccitt_update(crc, c);
}
return crc ^ 0xFFFF;
}
/**
* Starts the transmission of an ax25 frame
*/
void ax25_start(char* addresses, uint32_t addresses_len,
char* information, uint32_t information_len)
{
uint32_t i = 0;
uint16_t fcs;
/* Process addresses */
for (i = 0; i < addresses_len; i++) {
if ((i % 7) == 6) { /* Secondary Station ID */
ax25_frame[i] = ((addresses[i] << 1) & 0x1F) | 0x60;
} else {
ax25_frame[i] = (addresses[i] << 1);
}
}
ax25_frame[i-1] |= 0x1; /* Set HLDC bit */
ax25_frame[i++] = AX25_CONTROL_WORD;
ax25_frame[i++] = AX25_PROTOCOL_ID;
/* Process information */
memcpy(ax25_frame+i, information, information_len);
i += information_len;
/* Frame Check Sequence (FCS) */
fcs = crc_fcs(ax25_frame, i);
ax25_frame[i++] = (fcs >> 0) & 0xFF;
ax25_frame[i++] = (fcs >> 8) & 0xFF;
/* Length */
ax25_frame_length = i;
/* Init */
next_symbol = AX25_MARK;
bit_index = 8;
current_bit = 1;
one_count = 0;
ax25_state = AX25_PREAMBLE;
ax25_index = 0;
/* Hardware init */
ax25_gpio1_pwm_init();
}
/**
* Sets up gpio1 for the afsk pwm output. Uses gclk 7
*/
void ax25_gpio1_pwm_init(void)
{
float gclk1_frequency = (float)system_gclk_gen_get_hz(1);
float divide_needed = round(gclk1_frequency / 13200);
uint32_t top = (uint32_t)divide_needed & ~0x1;
uint32_t capture = top >> 1; /* 50% duty cycle */
if (top > 0xFFFF) while (1); // It's only an 16-bit counter
/* Setup GCLK genertor 7 */
system_gclk_gen_set_config(GCLK_GENERATOR_7,
GCLK_SOURCE_GCLKGEN1, /* Source */
false, /* High When Disabled */
AX25_DIVISION_MARK,/* Division Factor */
false, /* Run in standby */
false); /* Output Pin Enable */
system_gclk_gen_enable(GCLK_GENERATOR_7);
/* Configure timer */
bool capture_channel_enables[] = {false, false};
uint32_t compare_channel_values[] = {top, capture};
tc_init(TC5,
GCLK_GENERATOR_7,
TC_COUNTER_SIZE_16BIT,
TC_CLOCK_PRESCALER_DIV1,
TC_WAVE_GENERATION_MATCH_PWM,
TC_RELOAD_ACTION_GCLK,
TC_COUNT_DIRECTION_UP,
TC_WAVEFORM_INVERT_OUTPUT_NONE,
false, /* Oneshot = false */
false, /* Run in standby = false */
0x0000, /* Initial value */
top, /* Top value */
capture_channel_enables, /* Capture Channel Enables */
compare_channel_values); /* Compare Channels Values */
/* Enable the output pin */
system_pinmux_pin_set_config(SI4xxx_GPIO1_PINMUX >> 16, /* GPIO Pin */
SI4xxx_GPIO1_PINMUX & 0xFFFF, /* Mux Position */
SYSTEM_PINMUX_PIN_DIR_INPUT, /* Direction */
SYSTEM_PINMUX_PIN_PULL_NONE, /* Pull */
false); /* Powersave */
tc_enable(TC5);
tc_start_counter(TC5);
}
void ax25_gpio1_pwm_deinit(void)
{
tc_stop_counter(TC5);
tc_disable(TC5);
}
/**
* Returns the next byte to transmit
*/
uint8_t ax25_get_next_byte(struct ax25_byte_t* next) {
switch (ax25_state) {
case AX25_PREAMBLE: /* Preamble */
/* Return flag */
next->val = AX25_HDLC_FLAG;
next->stuff = 0;
/* Check for next state */
ax25_index++;
if (ax25_index >= AX25_PREAMBLE_FLAGS) {
/* Next state */
ax25_state = AX25_FRAME;
ax25_index = 0;
}
break;
case AX25_FRAME: /* Frame */
/* Return data */
next->val = ax25_frame[ax25_index];
next->stuff = 1;
/* Check for next state */
ax25_index++;
if (ax25_index >= ax25_frame_length) {
/* Next state */
ax25_state = AX25_POSTAMBLE;
ax25_index = 0;
}
break;
case AX25_POSTAMBLE: /* Postamble */
/* Return flag */
next->val = AX25_HDLC_FLAG;
next->stuff = 0;
/* Check for next state */
ax25_index++;
if (ax25_index >= AX25_POSTAMBLE_FLAGS) {
/* Next state */
ax25_state = AX25_IDLE;
ax25_index = 0;
}
break;
default:
return 0;
}
return 1;
}
/**
* Returns the next symbol to transmit
*/
enum ax25_symbol_t ax25_get_next_symbol(void)
{
/* Get next byte if we need to */
if (bit_index >= 8) {
/* Attempt to get the next byte */
if (!ax25_get_next_byte(&current_byte)) {
return AX25_NONE; /* We're done */
}
bit_index = 0;
}
/* transmit bits lsb first */
if (current_byte.val & 0x01) { /* One */
one_count++;
/* Check if we need to stuff this bit */
if (one_count >= AX25_BITSTUFFINGCOUNT && current_byte.stuff) {
current_byte.val &= ~0x01;/* Next bit is zero */
one_count = 0;
} else {
current_byte.val >>= 1; /* Move along one bit */
bit_index++;
}
} else { /* Zero */
one_count = 0; /* Clear concecutive ones */
current_byte.val >>= 1; /* Move along one bit */
bit_index++;
/* NRZI encoding */
current_bit ^= 0x01;
}
return current_bit;
}
/**
* Called at our tick rate, controls the pwm gclk
*
* Returns 1 when more work todo, 0 when finished
*/
uint8_t ax25_tick(void)
{
if (next_symbol == AX25_NONE) {
ax25_gpio1_pwm_deinit();
return 0; /* We're done */
}
if (next_symbol == AX25_SPACE) {
/* Space */
system_gclk_gen_set_config(GCLK_GENERATOR_7,
GCLK_SOURCE_GCLKGEN1, /* Source */
false, /* High When Disabled */
AX25_DIVISION_SPACE, /* Division Factor */
false, /* Run in standby */
false); /* Output Pin Enable */
} else {
/* Mark */
system_gclk_gen_set_config(GCLK_GENERATOR_7,
GCLK_SOURCE_GCLKGEN1, /* Source */
false, /* High When Disabled */
AX25_DIVISION_MARK, /* Division Factor */
false, /* Run in standby */
false); /* Output Pin Enable */
}
next_symbol = ax25_get_next_symbol();
return 1;
}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik