commit d6691d68d6d24bfe0123292408feb5b7b09e09c9 from: Tracey Emery date: Tue Feb 20 20:39:58 2024 UTC Initial commit commit - /dev/null commit + d6691d68d6d24bfe0123292408feb5b7b09e09c9 blob - /dev/null blob + 378eac25d311703f3f2cd456d8036da525cd0366 (mode 644) --- /dev/null +++ .gitignore @@ -0,0 +1 @@ +build blob - /dev/null blob + c750c652a69a8208b4e16188ce1bade5fa766715 (mode 644) --- /dev/null +++ CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.13) + +include(/usr/local/raspberrypi-pico-sdk/pico_sdk_init.cmake) + +project(si5351) + +# initialize the Raspberry Pi Pico SDK +pico_sdk_init() + +add_executable(si5351 + si5351.cpp + libsi5351.cpp + ) + +# pull in common dependencies +target_link_libraries(si5351 + pico_stdlib + pico_malloc + hardware_i2c + ) + +add_compile_options( + -Wall + -Wno-format + -Wno-unused-function + -Wno-maybe-uninitialized + ) + +pico_enable_stdio_usb(si5351 1) +pico_enable_stdio_uart(si5351 0) + +# create map/bin/hex/uf2 file etc. +pico_add_extra_outputs(si5351) blob - /dev/null blob + 12d8786faad841f94446a68d327092ab3fb2894a (mode 644) --- /dev/null +++ LICENSE.md @@ -0,0 +1,25 @@ +BSD 2-Clause License + +Copyright (c) 2022, 2024 Tracey Emery K7TLE +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. blob - /dev/null blob + 7d7a446e13933051546971a5c22b53f1c85aa967 (mode 644) --- /dev/null +++ README.md @@ -0,0 +1,35 @@ +# Raspberry Pi Pico Si5351 Library + +Raspberry Pi Pico Si5351 Library + +This Si5351 library is a driver for the Si5351A clock generator chip. + +Usage +----- + +Clone the library to your project: + + git clone https://github.com/basepr1me/Raspberry-Pi-Si5351.git + +One class instantiation method in place: + + Si5351(config); + +Example +------- + +See the [144.05MHz Example](si5351.cpp) file for more information. + +Notes +----- + +The make.sh file is designed for OpenBSD ksh. + +Author +------ + +[Tracey Emery](https://github.com/basepr1me/) + +If you like this software, consider [donating](https://k7tle.com/?donate=1). + +See the [License](LICENSE.md) file for more information. blob - /dev/null blob + b6f2146dfe591027e4234838e8eaf554a253201c (mode 644) --- /dev/null +++ libsi5351.cpp @@ -0,0 +1,563 @@ +/* + * Copyright (c) 2022, 2024 Tracey Emery + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include +#include + +#include "pico/stdlib.h" +#include "hardware/i2c.h" + +#include "libsi5351.h" + +#define DEBUG 1 +#define DPRINTF(x,y) do { if (DEBUG) { printf("%s", x); sleep_ms(y); }} \ + while(0) + +static void begin(struct env *); +static void stop(void); +static void write(struct env *, const uint8_t *, size_t, bool); +static void read(struct env *, uint8_t *, size_t, bool); +static void set_phase(struct env *, uint8_t, uint8_t); + +Si5351::Si5351(struct env *config) +{ + uint8_t i; + + if (DEBUG) + sleep_ms(3000); + DPRINTF("Initializing I2C\n", 500); + + switch(config->i2c_channel) { + case I2C1: + config->i2c = i2c1; + i2c_init(config->i2c, config->i2c_speed); + gpio_set_function(PICO_I2C1_SDA_PIN, GPIO_FUNC_I2C); + gpio_set_function(PICO_I2C1_SCL_PIN, GPIO_FUNC_I2C); + gpio_pull_up(PICO_I2C1_SDA_PIN); + gpio_pull_up(PICO_I2C1_SCL_PIN); + break; + case I2C0: + default: + config->i2c = i2c0; + i2c_init(config->i2c, config->i2c_speed); + gpio_set_function(PICO_I2C0_SDA_PIN, GPIO_FUNC_I2C); + gpio_set_function(PICO_I2C0_SCL_PIN, GPIO_FUNC_I2C); + gpio_pull_up(PICO_I2C0_SDA_PIN); + gpio_pull_up(PICO_I2C0_SCL_PIN); + break; + } + + begin(config); +} + +void +Si5351::enable(struct env *config) +{ + uint8_t data[2]; + + if (!config->initialized) { + DPRINTF("SI5351 not initialized!\n", 0); + stop(); + } + + memset(&data, 0, sizeof(data)); + data[0] = SI5351_REGISTER_3_OUTPUT_ENABLE_CONTROL; + data[1] = 0x00; + write(config, data, 2, true); + + DPRINTF("Outputs enabled\n", 500); +} + +void +Si5351::disable(struct env *config) +{ + uint8_t data[2]; + + if (!config->initialized) { + DPRINTF("SI5351 not initialized!\n", 0); + stop(); + } + + DPRINTF("Outputs disabled\n", 500); + + memset(&data, 0, sizeof(data)); + data[0] = SI5351_REGISTER_3_OUTPUT_ENABLE_CONTROL; + data[1] = 0xFF; + write(config, data, 2, true); +} + +static void +begin(struct env *config) +{ + int ret; + uint8_t data[2]; + uint8_t status = 1; + + /* give module a little initization time when not debugging */ + if (!DEBUG) + sleep_ms(100); + + DPRINTF("Checking for SI5351 device on bus\n", 500); + + memset(&data, 0, sizeof(data)); + ret = i2c_read_blocking(config->i2c, SI5351_ADDR_LOW, &data[0], 1, + false); + + if (ret < 0) { + ret = i2c_read_blocking(config->i2c, SI5351_ADDR_HIGH, &data[1], + 1, false); + if (ret < 0) { + DPRINTF("SI5351 not found\n", 0); + stop(); + } else + DPRINTF("SI5351 found at 0x61\n", 500); + } else + DPRINTF("SI5351 found at 0x60\n", 500); + + DPRINTF("Checking SI5351 status\n", 500); + + memset(&data, 0, sizeof(data)); + + data[0] = SI5351_REGISTER_0_DEVICE_STATUS; + while (status) { + write(config, &data[0], 1, true); + read(config, &data[1], 1, false); + + if (ret < 0) { + DPRINTF("Status read failed!\n", 0); + stop(); + } else { + status = ((data[1] >> 7) & 0x01); + if (status) + DPRINTF(".", 500); + } + } + + DPRINTF("Configuring SI5351\n", 1000); + + memset(&data, 0, sizeof(data)); + data[0] = SI5351_REGISTER_3_OUTPUT_ENABLE_CONTROL; + data[1] = 0xFF; + write(config, data, 2, true); + + DPRINTF("Outputs disabled\n", 500); + + data[0] = SI5351_REGISTER_16_CLK0_CONTROL; + data[1] = 0x80; + write(config, data, 2, false); + + data[0] = SI5351_REGISTER_17_CLK1_CONTROL; + data[1] = 0x80; + write(config, data, 2, false); + + data[0] = SI5351_REGISTER_18_CLK2_CONTROL; + data[1] = 0x80; + write(config, data, 2, false); + + data[0] = SI5351_REGISTER_19_CLK3_CONTROL; + data[1] = 0x80; + write(config, data, 2, false); + + data[0] = SI5351_REGISTER_20_CLK4_CONTROL; + data[1] = 0x80; + write(config, data, 2, false); + + data[0] = SI5351_REGISTER_21_CLK5_CONTROL; + data[1] = 0x80; + write(config, data, 2, false); + + data[0] = SI5351_REGISTER_22_CLK6_CONTROL; + data[1] = 0x80; + write(config, data, 2, false); + + data[0] = SI5351_REGISTER_23_CLK7_CONTROL; + data[1] = 0x80; + write(config, data, 2, false); + + data[0] = SI5351_REGISTER_183_CRYSTAL_INTERNAL_LOAD_CAPACITANCE; + data[1] = config->crystal_load; + write(config, data, 2, false); + + data[0] = SI5351_REGISTER_149_SPREAD_SPECTRUM_PARAMETERS; + data[1] &= ~0x80; + write(config, data, 2, false); + + config->initialized = true; +} + +void +Si5351::setup_pll(struct env *config, uint8_t pll) +{ + uint32_t P1, P2, P3; + uint8_t addr, data[9]; + float freq_vco; + + DPRINTF("Configuring PLL\n", 500); + + if (pll < SI5351_PLL_A || pll > SI5351_PLL_B) { + DPRINTF("Bad PLL value!\n", 0); + stop(); + } + if (!config->initialized) { + DPRINTF("SI5351 not initialized!\n", 0); + stop(); + } + if (config->f_multiplier < 15 || config->f_multiplier > 90) { + DPRINTF("Bad config->f_multiplier!\n", 0); + stop(); + } + if (config->f_denominator == 0) { + DPRINTF("Divide by zero!\n", 0); + stop(); + } + if (config->f_numerator > 0xFFFFF) { + DPRINTF("config->f_numerator exceeds 20-bit limit!\n", 0); + stop(); + } + if (config->f_denominator > 0xFFFFF) { + DPRINTF("config->f_denominator exceeds 20-bit limit!\n", 0); + stop(); + } + + if (config->f_numerator == 0) { + P1 = 128 * config->f_multiplier - 512; + P2 = config->f_numerator; + P3 = config->f_denominator; + } else { + P1 = (uint32_t) (128 * config->f_multiplier + floor (128 * + ((float) config->f_numerator / + (float) config->f_denominator)) - 512); + P2 = (uint32_t) (128 * config->f_numerator - + config->f_denominator * floor (128 * + ((float) config->f_numerator / + (float) config->f_denominator))); + P3 = config->f_denominator; + } + + switch(pll) { + case SI5351_PLL_A: + addr = SI5351_REGISTER_26_MSNA_P3_A_15_8; + break; + case SI5351_PLL_B: + addr = SI5351_REGISTER_34_MSNA_P3_B_15_8; + break; + } + memset(&data, 0, sizeof(data)); + data[0] = addr; + data[1] = (P3 & 0x0000FF00) >> 8; + data[2] = (P3 & 0x000000FF); + data[3] = (P1 & 0x00030000) >> 16; + data[4] = (P1 & 0x0000FF00) >> 8; + data[5] = (P1 & 0x000000FF); + data[6] = ((P3 & 0x000F0000) >> 12) | ((P2 & 0x000F0000) >> 16); + data[7] = (P2 & 0x0000FF00) >> 8; + data[8] = (P2 & 0x000000FF); + write(config, data, 9, false); + + memset(&data, 0, sizeof(data)); + data[0] = SI5351_REGISTER_177_PLL_RESET; + data[1] = 0xAC; + write(config, data, 2, false); + + freq_vco = config->crystal_freq * (config->f_multiplier + + (float) config->f_numerator / + (float) config->f_denominator); + + switch(pll) { + case SI5351_PLL_A: + default: + DPRINTF("SI5351_PLL_A configured\n", 500); + config->pll_a_configured = true; + config->pll_a_freq = (uint32_t) floor(freq_vco); + break; + case SI5351_PLL_B: + DPRINTF("SI5351_PLL_B configured\n", 500); + config->pll_b_configured = true; + config->pll_b_freq = (uint32_t) floor(freq_vco); + break; + } +} + +void +Si5351::setup_multisynth(struct env *config, uint8_t output, uint8_t pll) +{ + uint32_t P1, P2, P3; + uint8_t clk_ctrl_reg = 0x0F; + uint8_t addr, data[9]; + + DPRINTF("Configuring Multisynth\n", 500); + + if (output < SI5351_OUTPUT_1 || output > SI5351_OUTPUT_3) { + DPRINTF("Bad output value!\n", 0); + stop(); + } + if (pll < SI5351_PLL_A || pll > SI5351_PLL_B) { + DPRINTF("Bad PLL value!\n", 0); + stop(); + } + if (!config->initialized) { + DPRINTF("SI5351 not initialized!\n", 0); + stop(); + } + if (config->m_divider < 3 || config->m_divider > 2049) { + DPRINTF("Bad config->m_divider!\n", 0); + stop(); + } + if (config->m_denominator == 0) { + DPRINTF("Divide by zero!\n", 0); + stop(); + } + if (config->m_numerator > 0xFFFFF) { + DPRINTF("config->m_numerator exceeds 20-bit limit!\n", 0); + stop(); + } + if (config->m_denominator > 0xFFFFF) { + DPRINTF("config->m_denominator exceeds 20-bit limit!\n", 0); + stop(); + } + + switch(pll) { + case SI5351_PLL_A: + default: + if (!config->pll_a_configured) { + DPRINTF("PLL A not configured!\n", 0); + stop(); + } + break; + case SI5351_PLL_B: + if (!config->pll_b_configured) { + DPRINTF("PLL B not configured!\n", 0); + stop(); + } + break; + } + + switch(output) { + case SI5351_OUTPUT_1: + addr = SI5351_REGISTER_42_MULTISYNTH0_PARAMETERS_1; + break; + case SI5351_OUTPUT_2: + addr = SI5351_REGISTER_50_MULTISYNTH1_PARAMETERS_1; + break; + case SI5351_OUTPUT_3: + addr = SI5351_REGISTER_58_MULTISYNTH2_PARAMETERS_1; + break; + } + + if (config->m_numerator == 0) { + P1 = 128 * config->m_divider - 512; + P2 = 0; + P3 = config->m_denominator; + } else if (config->m_denominator == 1) { + P1 = 128 * config->m_divider + 128 * config->m_numerator - 512; + P2 = 128 * config->m_numerator - 128; + P3 = 1; + } else { + P1 = (uint32_t) (128 * config->m_divider + floor(128 * + ((float) config->m_numerator / + (float) config->m_denominator)) - 512); + P2 = (uint32_t) (128 * config->m_numerator - + config->m_denominator * + floor(128 * ((float) config->m_numerator / + (float) config->m_denominator))); + P3 = config->m_denominator; + } + + memset(&data, 0, sizeof(data)); + data[0] = addr; + data[1] = (P3 & 0xFF00) >> 8; + data[2] = P3 & 0xFF; + data[3] = ((P1 & 0x30000) >> 16); + data[4] = (P1 & 0xFF00) >> 8; + data[5] = P1 & 0xFF; + data[6] = ((P3 & 0xF0000) >> 12) | ((P2 & 0xF0000) >> 16); + data[7] = (P2 & 0xFF00) >> 8; + data[8] = P2 & 0xFF; + write(config, data, 9, false); + + switch (output) { + case SI5351_OUTPUT_1: + addr = SI5351_REGISTER_16_CLK0_CONTROL; + break; + case SI5351_OUTPUT_2: + addr = SI5351_REGISTER_17_CLK1_CONTROL; + break; + case SI5351_OUTPUT_3: + addr = SI5351_REGISTER_18_CLK2_CONTROL; + break; + } + + if (config->phase != PHASE0) { + clk_ctrl_reg |= (1 << 4); + set_phase(config, pll, output); + } + if (pll == SI5351_PLL_B) + clk_ctrl_reg |= (1 << 5); + if (config->m_numerator == 0 && config->phase == PHASE0) + clk_ctrl_reg |= (1 << 6); + + memset(&data, 0, sizeof(data)); + data[0] = addr; + data[1] = clk_ctrl_reg; + write(config, data, 2, false); +} + +void +Si5351::setup_r_div(struct env *config, uint8_t output, uint8_t divider) +{ + uint8_t addr, data[2]; + + if (output < SI5351_OUTPUT_1 || output > SI5351_OUTPUT_3) { + DPRINTF("Bad output value!\n", 0); + stop(); + } + if (!config->initialized) { + DPRINTF("SI5351 not initialized!\n", 0); + stop(); + } + + switch(output) { + case SI5351_OUTPUT_1: + addr = SI5351_REGISTER_44_MULTISYNTH0_PARAMETERS_3; + break; + case SI5351_OUTPUT_2: + addr = SI5351_REGISTER_52_MULTISYNTH1_PARAMETERS_3; + break; + case SI5351_OUTPUT_3: + addr = SI5351_REGISTER_60_MULTISYNTH2_PARAMETERS_3; + break; + } + + memset(&data, 0, sizeof(data)); + data[0] = addr; + + write(config, &data[0], 1, true); + read(config, &data[1], 1, false); + + data[1] &= 0x0F; + divider &= 0x07; + divider <<= 4; + data[1] &= divider; + + write(config, data, 2, false); +} + +static void +set_phase(struct env *config, uint8_t pll, uint8_t output) +{ + float freq_vco; + uint8_t offset, p_m, addr, data[6]; + + DPRINTF("Configuring Phase\n", 500); + + if (output < SI5351_OUTPUT_1 || output > SI5351_OUTPUT_3) { + DPRINTF("Bad output value!\n", 0); + stop(); + } + if (pll < SI5351_PLL_A || pll > SI5351_PLL_B) { + DPRINTF("Bad PLL value!\n", 0); + stop(); + } + if (!config->initialized) { + DPRINTF("SI5351 not initialized!\n", 0); + stop(); + } + if (config->phase < PHASE0 || config->phase > PHASE270) { + DPRINTF("Bad phase setting!\n", 0); + stop(); + } + switch(pll) { + case SI5351_PLL_A: + freq_vco = (float) config->pll_a_freq; + break; + case SI5351_PLL_B: + freq_vco = (float) config->pll_b_freq; + break; + } + switch (output) { + case SI5351_OUTPUT_1: + addr = SI5351_REGISTER_165_CLK0_INITIAL_PHASE_OFFSET; + break; + case SI5351_OUTPUT_2: + addr = SI5351_REGISTER_166_CLK1_INITIAL_PHASE_OFFSET; + break; + case SI5351_OUTPUT_3: + addr = SI5351_REGISTER_167_CLK2_INITIAL_PHASE_OFFSET; + break; + } + + if (config->phase == PHASE180) + p_m = 2; + else + p_m = 4; + + offset = floor((1 / (p_m * (freq_vco / config->m_divider))) * 4 * + freq_vco); + + if (offset % 2) + offset += 1; + + if (offset > 126) + offset = 126; + + memset(&data, 0, sizeof(data)); + data[0] = addr; + data[1] = offset; + write(config, data, 9, false); + + memset(&data, 0, sizeof(data)); + data[0] = SI5351_REGISTER_177_PLL_RESET; + data[1] = 0xAC; + write(config, data, 2, false); +} + +static void +write(struct env *config, const uint8_t *src, size_t len, bool nostop) +{ + int ret; + + ret = i2c_write_blocking(config->i2c, config->i2c_addr, src, len, + nostop); + sleep_us(200); + if (ret == PICO_ERROR_GENERIC) { + DPRINTF("WRITE FAILED!\n", 0); + stop(); + } +} + +static void +read(struct env *config, uint8_t *dst, size_t len, bool nostop) +{ + int ret; + + ret = i2c_read_blocking(config->i2c, config->i2c_addr, dst, len, + nostop); + sleep_us(200); + if (ret < 0) { + DPRINTF("READ FAILED!\n", 0); + stop(); + } +} + +static void +stop(void) +{ + DPRINTF("STOPPING ...", 10); + while(1); +} blob - /dev/null blob + 8ff57f5c9f7fcdbaf50b137c1fcd1a87f5ffa5cb (mode 644) --- /dev/null +++ libsi5351.h @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2022, 2024 Tracey Emery + * Copyright (c) 2021 Limor Fried/Ladyada for Adafruit Industries, for typing + * most of the SI5351 registers and values + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _LIBSI5351_H +#define _LIBSI5351_H + +struct env { + uint8_t i2c_addr; + uint8_t i2c_channel; + uint32_t i2c_speed; + i2c_inst_t *i2c; + + bool initialized; + uint32_t crystal_freq; + uint16_t crystal_load; + uint16_t phase; + + uint32_t f_multiplier; + uint32_t f_numerator; + uint32_t f_denominator; + + uint32_t m_divider; + uint32_t m_numerator; + uint32_t m_denominator; + + bool pll_a_configured; + uint32_t pll_a_freq; + + bool pll_b_configured; + uint32_t pll_b_freq; +}; + +enum I2C_t { + I2C0, + I2C1 +}; + +/* change to what you want */ +#define PICO_I2C0_SDA_PIN 4 +#define PICO_I2C0_SCL_PIN 5 +#define PICO_I2C1_SDA_PIN 2 +#define PICO_I2C1_SCL_PIN 3 + +/* SI5351 addresses */ +#define SI5351_ADDR_LOW 0x60 +#define SI5351_ADDR_HIGH 0x61 + +/* + * registers + * https://cdn-shop.adafruit.com/datasheets/Si5351.pdf + * + * registers 26 - 41 + * https://www.skyworksinc.com/-/media/Skyworks/SL/documents/public/application-notes/AN619.pdf + */ + +#define SI5351_CRYSTAL_LOAD_6PF (1 << 6) +#define SI5351_CRYSTAL_LOAD_8PF (2 << 6) +#define SI5351_CRYSTAL_LOAD_10PF (3 << 6) + +#define SI5351_CRYSTAL_FREQ_25MHZ (25000000) +#define SI5351_CRYSTAL_FREQ_27MHZ (27000000) + +#define SI5351_MULTISYNTH_DIV_4 4 +#define SI5351_MULTISYNTH_DIV_6 6 +#define SI5351_MULTISYNTH_DIV_8 8 + +enum SI5351_PHASE_t { + PHASE0, + PHASE90, + PHASE180, + PHASE270 +}; + +enum SI5351_OUTPUT_t { + SI5351_OUTPUT_1, + SI5351_OUTPUT_2, + SI5351_OUTPUT_3 +}; + +enum SI5351_PLL_t { + SI5351_PLL_A, + SI5351_PLL_B +}; + +enum SI5351_R_DIV_t { + SI5351_R_DIV_1, + SI5351_R_DIV_2, + SI5351_R_DIV_4, + SI5351_R_DIV_8, + SI5351_R_DIV_16, + SI5351_R_DIV_32, + SI5351_R_DIV_64, + SI5351_R_DIV_128 +}; + +enum SI5351_REGISTER_t { + SI5351_REGISTER_0_DEVICE_STATUS = 0, + SI5351_REGISTER_1_INTERRUPT_STATUS_STICKY = 1, + SI5351_REGISTER_2_INTERRUPT_STATUS_MASK = 2, + SI5351_REGISTER_3_OUTPUT_ENABLE_CONTROL = 3, + SI5351_REGISTER_9_OEB_PIN_ENABLE_CONTROL = 9, + SI5351_REGISTER_15_PLL_INPUT_SOURCE = 15, + SI5351_REGISTER_16_CLK0_CONTROL = 16, + SI5351_REGISTER_17_CLK1_CONTROL = 17, + SI5351_REGISTER_18_CLK2_CONTROL = 18, + SI5351_REGISTER_19_CLK3_CONTROL = 19, + SI5351_REGISTER_20_CLK4_CONTROL = 20, + SI5351_REGISTER_21_CLK5_CONTROL = 21, + SI5351_REGISTER_22_CLK6_CONTROL = 22, + SI5351_REGISTER_23_CLK7_CONTROL = 23, + SI5351_REGISTER_24_CLK3_0_DISABLE_STATE = 24, + SI5351_REGISTER_25_CLK7_4_DISABLE_STATE = 25, + SI5351_REGISTER_26_MSNA_P3_A_15_8 = 26, + SI5351_REGISTER_27_MSNA_P3_A_7_0 = 27, + SI5351_REGISTER_28_MSNA_P1_A_17_16 = 28, + SI5351_REGISTER_29_MSNA_P1_A_15_8 = 29, + SI5351_REGISTER_30_MSNA_P1_A_7_0 = 30, + SI5351_REGISTER_31_MSNA_P32_A_19_16 = 31, + SI5351_REGISTER_32_MSNA_P2_A_15_8 = 32, + SI5351_REGISTER_33_MSNA_P2_A_7_0 = 33, + SI5351_REGISTER_34_MSNA_P3_B_15_8 = 34, + SI5351_REGISTER_35_MSNA_P3_B_7_0 = 35, + SI5351_REGISTER_36_MSNA_P1_B_17_16 = 36, + SI5351_REGISTER_37_MSNA_P1_B_15_8 = 37, + SI5351_REGISTER_38_MSNA_P1_B_7_0 = 38, + SI5351_REGISTER_39_MSNA_P32_B_19_16 = 39, + SI5351_REGISTER_40_MSNA_P2_B_15_8 = 40, + SI5351_REGISTER_41_MSNA_P2_B_7_0 = 41, + SI5351_REGISTER_42_MULTISYNTH0_PARAMETERS_1 = 42, + SI5351_REGISTER_43_MULTISYNTH0_PARAMETERS_2 = 43, + SI5351_REGISTER_44_MULTISYNTH0_PARAMETERS_3 = 44, + SI5351_REGISTER_45_MULTISYNTH0_PARAMETERS_4 = 45, + SI5351_REGISTER_46_MULTISYNTH0_PARAMETERS_5 = 46, + SI5351_REGISTER_47_MULTISYNTH0_PARAMETERS_6 = 47, + SI5351_REGISTER_48_MULTISYNTH0_PARAMETERS_7 = 48, + SI5351_REGISTER_49_MULTISYNTH0_PARAMETERS_8 = 49, + SI5351_REGISTER_50_MULTISYNTH1_PARAMETERS_1 = 50, + SI5351_REGISTER_51_MULTISYNTH1_PARAMETERS_2 = 51, + SI5351_REGISTER_52_MULTISYNTH1_PARAMETERS_3 = 52, + SI5351_REGISTER_53_MULTISYNTH1_PARAMETERS_4 = 53, + SI5351_REGISTER_54_MULTISYNTH1_PARAMETERS_5 = 54, + SI5351_REGISTER_55_MULTISYNTH1_PARAMETERS_6 = 55, + SI5351_REGISTER_56_MULTISYNTH1_PARAMETERS_7 = 56, + SI5351_REGISTER_57_MULTISYNTH1_PARAMETERS_8 = 57, + SI5351_REGISTER_58_MULTISYNTH2_PARAMETERS_1 = 58, + SI5351_REGISTER_59_MULTISYNTH2_PARAMETERS_2 = 59, + SI5351_REGISTER_60_MULTISYNTH2_PARAMETERS_3 = 60, + SI5351_REGISTER_61_MULTISYNTH2_PARAMETERS_4 = 61, + SI5351_REGISTER_62_MULTISYNTH2_PARAMETERS_5 = 62, + SI5351_REGISTER_63_MULTISYNTH2_PARAMETERS_6 = 63, + SI5351_REGISTER_64_MULTISYNTH2_PARAMETERS_7 = 64, + SI5351_REGISTER_65_MULTISYNTH2_PARAMETERS_8 = 65, + SI5351_REGISTER_66_MULTISYNTH3_PARAMETERS_1 = 66, + SI5351_REGISTER_67_MULTISYNTH3_PARAMETERS_2 = 67, + SI5351_REGISTER_68_MULTISYNTH3_PARAMETERS_3 = 68, + SI5351_REGISTER_69_MULTISYNTH3_PARAMETERS_4 = 69, + SI5351_REGISTER_70_MULTISYNTH3_PARAMETERS_5 = 70, + SI5351_REGISTER_71_MULTISYNTH3_PARAMETERS_6 = 71, + SI5351_REGISTER_72_MULTISYNTH3_PARAMETERS_7 = 72, + SI5351_REGISTER_73_MULTISYNTH3_PARAMETERS_8 = 73, + SI5351_REGISTER_74_MULTISYNTH4_PARAMETERS_1 = 74, + SI5351_REGISTER_75_MULTISYNTH4_PARAMETERS_2 = 75, + SI5351_REGISTER_76_MULTISYNTH4_PARAMETERS_3 = 76, + SI5351_REGISTER_77_MULTISYNTH4_PARAMETERS_4 = 77, + SI5351_REGISTER_78_MULTISYNTH4_PARAMETERS_5 = 78, + SI5351_REGISTER_79_MULTISYNTH4_PARAMETERS_6 = 79, + SI5351_REGISTER_80_MULTISYNTH4_PARAMETERS_7 = 80, + SI5351_REGISTER_81_MULTISYNTH4_PARAMETERS_8 = 81, + SI5351_REGISTER_82_MULTISYNTH5_PARAMETERS_1 = 82, + SI5351_REGISTER_83_MULTISYNTH5_PARAMETERS_2 = 83, + SI5351_REGISTER_84_MULTISYNTH5_PARAMETERS_3 = 84, + SI5351_REGISTER_85_MULTISYNTH5_PARAMETERS_4 = 85, + SI5351_REGISTER_86_MULTISYNTH5_PARAMETERS_5 = 86, + SI5351_REGISTER_87_MULTISYNTH5_PARAMETERS_6 = 87, + SI5351_REGISTER_88_MULTISYNTH5_PARAMETERS_7 = 88, + SI5351_REGISTER_89_MULTISYNTH5_PARAMETERS_8 = 89, + SI5351_REGISTER_90_MULTISYNTH6_PARAMETERS = 90, + SI5351_REGISTER_91_MULTISYNTH7_PARAMETERS = 91, + SI5351_REGISTER_92_CLOCK_6_7_OUTPUT_DIVIDER = 92, + SI5351_REGISTER_149_SPREAD_SPECTRUM_PARAMETERS = 149, + SI5351_REGISTER_165_CLK0_INITIAL_PHASE_OFFSET = 165, + SI5351_REGISTER_166_CLK1_INITIAL_PHASE_OFFSET = 166, + SI5351_REGISTER_167_CLK2_INITIAL_PHASE_OFFSET = 167, + SI5351_REGISTER_168_CLK3_INITIAL_PHASE_OFFSET = 168, + SI5351_REGISTER_169_CLK4_INITIAL_PHASE_OFFSET = 169, + SI5351_REGISTER_170_CLK5_INITIAL_PHASE_OFFSET = 170, + SI5351_REGISTER_177_PLL_RESET = 177, + SI5351_REGISTER_183_CRYSTAL_INTERNAL_LOAD_CAPACITANCE = 183 +}; + +class +Si5351 +{ + public: + Si5351(struct env *); + void setup_pll(struct env *, uint8_t); + void setup_multisynth(struct env *, uint8_t, uint8_t); + void setup_r_div(struct env *, uint8_t, uint8_t); + void enable(struct env *); + void disable(struct env *); +}; + +#endif // _LIBSI5351_H blob - /dev/null blob + 53083494aae683f7c4aec7c813583596adcfaa9d (mode 644) --- /dev/null +++ license.txt @@ -0,0 +1,13 @@ +Copyright (c) 2022 Tracey Emery K7TLE + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. blob - /dev/null blob + 7395a32ce9b3be3ab120794d9dd03a38f6d6c432 (mode 755) --- /dev/null +++ make.sh @@ -0,0 +1,23 @@ +#!/bin/ksh +clear +printf "\nRUNNING THIS WILL DESTROY YOUR BUILD DIRECTORY!!!" +printf "\nDo you wish to proceed? [Y|n]: " + +read proceed + +if [[ $proceed != "y" && $proceed != "Y" && $proceed != "" ]]; then + printf "\nExitting!\n" + exit +fi + +printf "\nBuilding project...\n\n"; + +rm -rf build +mkdir build && cd build +cmake -DPICO_TOOLCHAIN_PATH=/usr/local/arm-none-eabi/bin .. +make + +printf "\nFiles built:\n\n" +ls -lah . + +printf "\nDone\n\n"; blob - /dev/null blob + 42f530b399a987e89b4b773f136b9fdeb36514b4 (mode 755) --- /dev/null +++ make2.sh @@ -0,0 +1,12 @@ +#!/bin/ksh +clear +printf "\nBuilding project...\n\n"; + +cd build +cmake -DPICO_TOOLCHAIN_PATH=/usr/local/arm-none-eabi/bin .. +make + +printf "\nFiles built:\n\n" +ls -lah . + +printf "\nDone\n\n"; blob - /dev/null blob + e1ea08234ae6f923bf33e52ee96cccd244695654 (mode 644) --- /dev/null +++ si5351.cpp @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2022, 2024 Tracey Emery + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include + +#include "pico/malloc.h" +#include "pico/stdlib.h" + +#include "hardware/i2c.h" +#include "libsi5351.h" + +int main(void); + +/* + * PLL A + * Input Frequency (MHz) = 25.000000000 + * VCO Frequency (MHz) = 864.300000000 + * Feedback Divider = 34 143/250 + * SSC disabled + * + * Output Clocks + * Channel 0 + * Output Frequency (MHz) = 144.050000000 + * Multisynth Output Frequency (MHz) = 144.050000000 + * Multisynth Divider = 6 + * R Divider = 1 + * PLL source = PLLA + * Initial phase offset (ns) = 0.000 + * Powered down = No + * Inverted = No + * Drive Strength = b11 + * Disable State = Low + * Clock Source = b11 + */ + +/* PLL A + * Input Frequency (MHz) = 25.000000000 + * VCO Frequency (MHz) = 864.210000000 + * Feedback Divider = 34 1421/2500 + * SSC disabled + * + * Output Clocks + * Channel 0 + * Output Frequency (MHz) = 144.035000000 + * Multisynth Output Frequency (MHz) = 144.035000000 + * Multisynth Divider = 6 + * R Divider = 1 + * PLL source = PLLA + * Initial phase offset (ns) = 0.000 + * Powered down = No + * Inverted = No + * Drive Strength = b11 + * Disable State = Low + * Clock Source = b11 + */ + +/* + * XXX: Trying to set the SI5351 to the 144.05 frequency resulted in a central + * frequency of 144.06, with a 1MHz bandwidth output. Setting to 144.035 + * frequency outputs 144.045 - 144.055, with the central desired frequency of + * 144.05. Not sure if this is isolated to this particular board or not. + */ + +int +main() +{ + struct env *config; + + config = (struct env *) malloc(sizeof(struct env *)); + + config->i2c_addr = SI5351_ADDR_LOW; + config->i2c_channel = I2C0; + config->i2c_speed = 400000; + config->initialized = false; + config->crystal_freq = SI5351_CRYSTAL_FREQ_25MHZ; + config->crystal_load = SI5351_CRYSTAL_LOAD_10PF; + config->phase = PHASE180; + + config->pll_a_configured = false; + config->pll_a_freq = 0; + config->pll_b_configured = false; + config->pll_b_freq = 0; + + /* + * Get these values from the SILabs Clockbuilder tool + */ + + config->f_multiplier = 34; + config->f_numerator = 1421; + config->f_denominator = 2500; + + config->m_divider = 6; + config->m_numerator = 0; + config->m_denominator = 1; + + stdio_init_all(); + + Si5351 si(config); + si.setup_pll(config, SI5351_PLL_A); + si.setup_multisynth(config, SI5351_OUTPUT_1, SI5351_PLL_A); + si.setup_r_div(config, SI5351_OUTPUT_1, SI5351_R_DIV_1); + si.enable(config); + + free(config); + + printf("\nDone!\n"); + while(1); + + return 0; +}