mirror
/
pimoroni-pico
kopia lustrzana https://github.com/pimoroni/pimoroni-pico
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Fixes post rebase

encoder-pio
ZodiusInfuser 2022-04-13 11:29:40 +01:00
rodzic 33c0453515
commit a5572e5e44
6 zmienionych plików z 277 dodań i 286 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

14
drivers/encoder-pio/CMakeLists.txt
Wyświetl plik

@ -1,13 +1 @@
add_library(encoder-pio INTERFACE) include(encoder-pio.cmake)
target_sources(encoder-pio INTERFACE
${CMAKE_CURRENT_LIST_DIR}/encoder.cpp
${CMAKE_CURRENT_LIST_DIR}/capture.cpp
)
pico_generate_pio_header(encoder-pio ${CMAKE_CURRENT_LIST_DIR}/encoder.pio)
target_include_directories(encoder-pio INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need
target_link_libraries(encoder-pio INTERFACE pico_stdlib hardware_pio)

17
drivers/encoder-pio/encoder-pio.cmake
Wyświetl plik

@ -1,12 +1,17 @@
add_library(encoder-pio INTERFACE) set(DRIVER_NAME encoder-pio)
add_library(${DRIVER_NAME} INTERFACE)
target_sources(encoder-pio INTERFACE target_sources(${DRIVER_NAME} INTERFACE
${CMAKE_CURRENT_LIST_DIR}/msa301.cpp ${CMAKE_CURRENT_LIST_DIR}/encoder.cpp
${CMAKE_CURRENT_LIST_DIR}/capture.cpp
) )
pico_generate_pio_header(encoder-pio ${CMAKE_CURRENT_LIST_DIR}/encoder.pio) pico_generate_pio_header(${DRIVER_NAME} ${CMAKE_CURRENT_LIST_DIR}/encoder.pio)
target_include_directories(encoder-pio INTERFACE ${CMAKE_CURRENT_LIST_DIR}) target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
# Pull in pico libraries that we need # Pull in pico libraries that we need
target_link_libraries(encoder-pio INTERFACE pico_stdlib hardware_i2c) target_link_libraries(${DRIVER_NAME} INTERFACE
pico_stdlib
hardware_pio
)

36
drivers/encoder-pio/encoder.cpp
Wyświetl plik

@ -17,7 +17,7 @@ namespace pimoroni {
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void Encoder::pio0_interrupt_callback() { void Encoder::pio0_interrupt_callback() {
//Go through each of encoders on this PIO to see which triggered this interrupt // Go through each of encoders on this PIO to see which triggered this interrupt
for(uint8_t sm = 0; sm < NUM_PIO_STATE_MACHINES; sm++) { for(uint8_t sm = 0; sm < NUM_PIO_STATE_MACHINES; sm++) {
if(pio_encoders[0][sm] != nullptr) { if(pio_encoders[0][sm] != nullptr) {
pio_encoders[0][sm]->check_for_transition(); pio_encoders[0][sm]->check_for_transition();
@ -27,7 +27,7 @@ namespace pimoroni {
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void Encoder::pio1_interrupt_callback() { void Encoder::pio1_interrupt_callback() {
//Go through each of encoders on this PIO to see which triggered this interrupt // Go through each of encoders on this PIO to see which triggered this interrupt
for(uint8_t sm = 0; sm < NUM_PIO_STATE_MACHINES; sm++) { for(uint8_t sm = 0; sm < NUM_PIO_STATE_MACHINES; sm++) {
if(pio_encoders[1][sm] != nullptr) { if(pio_encoders[1][sm] != nullptr) {
pio_encoders[1][sm]->check_for_transition(); pio_encoders[1][sm]->check_for_transition();
@ -50,13 +50,13 @@ namespace pimoroni {
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
Encoder::~Encoder() { Encoder::~Encoder() {
//Clean up our use of the SM associated with this encoder // Clean up our use of the SM associated with this encoder
encoder_program_release(enc_pio, enc_sm); encoder_program_release(enc_pio, enc_sm);
uint index = pio_get_index(enc_pio); uint index = pio_get_index(enc_pio);
pio_encoders[index][enc_sm] = nullptr; pio_encoders[index][enc_sm] = nullptr;
pio_claimed_sms[index] &= ~(1u << enc_sm); pio_claimed_sms[index] &= ~(1u << enc_sm);
//If there are no more SMs using the encoder program, then we can remove it from the PIO // If there are no more SMs using the encoder program, then we can remove it from the PIO
if(pio_claimed_sms[index] == 0) { if(pio_claimed_sms[index] == 0) {
pio_remove_program(enc_pio, &encoder_program, enc_offset); pio_remove_program(enc_pio, &encoder_program, enc_offset);
} }
@ -70,10 +70,10 @@ namespace pimoroni {
bool Encoder::init() { bool Encoder::init() {
bool initialised = false; bool initialised = false;
//Are the pins we want to use actually valid? // Are the pins we want to use actually valid?
if((pinA < NUM_BANK0_GPIOS) && (pinB < NUM_BANK0_GPIOS)) { if((pinA < NUM_BANK0_GPIOS) && (pinB < NUM_BANK0_GPIOS)) {
//If a Pin C was defined, and valid, set it as a GND to pull the other two pins down // If a Pin C was defined, and valid, set it as a GND to pull the other two pins down
if((pinC != PIN_UNUSED) && (pinC < NUM_BANK0_GPIOS)) { if((pinC != PIN_UNUSED) && (pinC < NUM_BANK0_GPIOS)) {
gpio_init(pinC); gpio_init(pinC);
gpio_set_dir(pinC, GPIO_OUT); gpio_set_dir(pinC, GPIO_OUT);
@ -83,9 +83,9 @@ namespace pimoroni {
enc_sm = pio_claim_unused_sm(enc_pio, true); enc_sm = pio_claim_unused_sm(enc_pio, true);
uint pio_idx = pio_get_index(enc_pio); uint pio_idx = pio_get_index(enc_pio);
//Is this the first time using an encoder on this PIO? // Is this the first time using an encoder on this PIO?
if(pio_claimed_sms[pio_idx] == 0) { if(pio_claimed_sms[pio_idx] == 0) {
//Add the program to the PIO memory and enable the appropriate interrupt // Add the program to the PIO memory and enable the appropriate interrupt
enc_offset = pio_add_program(enc_pio, &encoder_program); enc_offset = pio_add_program(enc_pio, &encoder_program);
encoder_program_init(enc_pio, enc_sm, enc_offset, pinA, pinB, freq_divider); encoder_program_init(enc_pio, enc_sm, enc_offset, pinA, pinB, freq_divider);
hw_set_bits(&enc_pio->inte0, PIO_IRQ0_INTE_SM0_RXNEMPTY_BITS << enc_sm); hw_set_bits(&enc_pio->inte0, PIO_IRQ0_INTE_SM0_RXNEMPTY_BITS << enc_sm);
@ -99,11 +99,11 @@ namespace pimoroni {
} }
} }
//Keep a record of this encoder for the interrupt callback // Keep a record of this encoder for the interrupt callback
pio_encoders[pio_idx][enc_sm] = this; pio_encoders[pio_idx][enc_sm] = this;
pio_claimed_sms[pio_idx] |= 1u << enc_sm; pio_claimed_sms[pio_idx] |= 1u << enc_sm;
//Read the current state of the encoder pins and start the PIO program on the SM // Read the current state of the encoder pins and start the PIO program on the SM
stateA = gpio_get(pinA); stateA = gpio_get(pinA);
stateB = gpio_get(pinB); stateB = gpio_get(pinB);
encoder_program_start(enc_pio, enc_sm, stateA, stateB); encoder_program_start(enc_pio, enc_sm, stateA, stateB);
@ -175,16 +175,16 @@ namespace pimoroni {
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
Capture Encoder::perform_capture() { Capture Encoder::perform_capture() {
//Capture the current values // Capture the current values
int32_t captured_count = count; int32_t captured_count = count;
int32_t captured_cumulative_time = cumulative_time; int32_t captured_cumulative_time = cumulative_time;
cumulative_time = 0; cumulative_time = 0;
//Determine the change in counts since the last capture was performed // Determine the change in counts since the last capture was performed
int32_t count_change = captured_count - last_captured_count; int32_t count_change = captured_count - last_captured_count;
last_captured_count = captured_count; last_captured_count = captured_count;
//Calculate the average frequency of state transitions // Calculate the average frequency of state transitions
float average_frequency = 0.0f; float average_frequency = 0.0f;
if(count_change != 0 && captured_cumulative_time != INT_MAX) { if(count_change != 0 && captured_cumulative_time != INT_MAX) {
average_frequency = (clocks_per_time * (float)count_change) / (float)captured_cumulative_time; average_frequency = (clocks_per_time * (float)count_change) / (float)captured_cumulative_time;
@ -233,7 +233,7 @@ namespace pimoroni {
// For rotary encoders, only every fourth transition is cared about, causing an inaccurate time value // For rotary encoders, only every fourth transition is cared about, causing an inaccurate time value
// To address this we accumulate the times received and zero it when a transition is counted // To address this we accumulate the times received and zero it when a transition is counted
if(!count_microsteps) { if(!count_microsteps) {
if(time_received + microstep_time < time_received) //Check to avoid integer overflow if(time_received + microstep_time < time_received) // Check to avoid integer overflow
time_received = INT32_MAX; time_received = INT32_MAX;
else else
time_received += microstep_time; time_received += microstep_time;
@ -270,7 +270,7 @@ namespace pimoroni {
if(count_microsteps || last_travel_dir == CLOCKWISE) if(count_microsteps || last_travel_dir == CLOCKWISE)
microstep_up(time_received); microstep_up(time_received);
last_travel_dir = NO_DIR; //Finished turning clockwise last_travel_dir = NO_DIR; // Finished turning clockwise
break; break;
// A ‾‾‾‾|____ // A ‾‾‾‾|____
@ -291,7 +291,7 @@ namespace pimoroni {
if(count_microsteps) if(count_microsteps)
microstep_up(time_received); microstep_up(time_received);
last_travel_dir = CLOCKWISE; //Started turning clockwise last_travel_dir = CLOCKWISE; // Started turning clockwise
break; break;
// A ‾‾‾‾‾‾‾‾‾ // A ‾‾‾‾‾‾‾‾‾
@ -300,7 +300,7 @@ namespace pimoroni {
if(count_microsteps) if(count_microsteps)
microstep_down(time_received); microstep_down(time_received);
last_travel_dir = COUNTERCLOCK; //Started turning counter-clockwise last_travel_dir = COUNTERCLOCK; // Started turning counter-clockwise
break; break;
} }
break; break;
@ -321,7 +321,7 @@ namespace pimoroni {
if(count_microsteps || last_travel_dir == COUNTERCLOCK) if(count_microsteps || last_travel_dir == COUNTERCLOCK)
microstep_down(time_received); microstep_down(time_received);
last_travel_dir = NO_DIR; //Finished turning counter-clockwise last_travel_dir = NO_DIR; // Finished turning counter-clockwise
break; break;
} }
break; break;

90
examples/pico_explorer_encoder/demo.cpp
Wyświetl plik

@ -16,24 +16,24 @@ static const uint8_t ENCODER_PIN_B = 0;
static const uint8_t ENCODER_PIN_C = Encoder::PIN_UNUSED; static const uint8_t ENCODER_PIN_C = Encoder::PIN_UNUSED;
static const uint8_t ENCODER_SWITCH_PIN = 4; static const uint8_t ENCODER_SWITCH_PIN = 4;
static constexpr float COUNTS_PER_REVOLUTION = 24; //24 is for rotary encoders. For motor magnetic encoders uses static constexpr float COUNTS_PER_REVOLUTION = 24; // 24 is for rotary encoders. For motor magnetic encoders uses
//12 times the gear ratio (e.g. 12 * 20 with a 20:1 ratio motor // 12 times the gear ratio (e.g. 12 * 20 with a 20:1 ratio motor
static const bool COUNT_MICROSTEPS = false; //Set to true for motor magnetic encoders static const bool COUNT_MICROSTEPS = false; // Set to true for motor magnetic encoders
static const uint16_t FREQ_DIVIDER = 1; //Increase this to deal with switch bounce. 250 Gives a 1ms debounce static const uint16_t FREQ_DIVIDER = 1; // Increase this to deal with switch bounce. 250 Gives a 1ms debounce
static const int32_t TIME_BETWEEN_SAMPLES_US = 100; //Time between each sample, in microseconds static const int32_t TIME_BETWEEN_SAMPLES_US = 100; // Time between each sample, in microseconds
static const int32_t WINDOW_DURATION_US = 1000000; //The full time window that will be stored static const int32_t WINDOW_DURATION_US = 1000000; // The full time window that will be stored
static const int32_t READINGS_SIZE = WINDOW_DURATION_US / TIME_BETWEEN_SAMPLES_US; static const int32_t READINGS_SIZE = WINDOW_DURATION_US / TIME_BETWEEN_SAMPLES_US;
static const int32_t SCRATCH_SIZE = READINGS_SIZE / 10; //A smaller value, for temporarily storing readings during screen drawing static const int32_t SCRATCH_SIZE = READINGS_SIZE / 10; // A smaller value, for temporarily storing readings during screen drawing
static const bool QUADRATURE_OUT_ENABLED = true; static const bool QUADRATURE_OUT_ENABLED = true;
static constexpr float QUADRATURE_OUT_FREQ = 800; //The frequency the quadrature output will run at (note that counting microsteps will show 4x this value) static constexpr float QUADRATURE_OUT_FREQ = 800; // The frequency the quadrature output will run at (note that counting microsteps will show 4x this value)
static const float QUADRATURE_OUT_1ST_PIN = 6; //Which first pin to output the quadrature signal to (e.g. pins 6 and 7) static const float QUADRATURE_OUT_1ST_PIN = 6; // Which first pin to output the quadrature signal to (e.g. pins 6 and 7)
static const uint64_t MAIN_LOOP_TIME_US = 50000; //How long there should be in microseconds between each screen refresh static const uint64_t MAIN_LOOP_TIME_US = 50000; // How long there should be in microseconds between each screen refresh
static const uint16_t EDGE_ALIGN_ABOVE_ZOOM = 4; //The zoom level beyond which edge alignment will be enabled to ma static const uint16_t EDGE_ALIGN_ABOVE_ZOOM = 4; // The zoom level beyond which edge alignment will be enabled to ma
@ -71,8 +71,7 @@ uint16_t current_zoom_level = 1;
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// FUNCTIONS // FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
uint32_t draw_plot(Point p1, Point p2, volatile bool (&readings)[READINGS_SIZE], uint32_t readingPos, bool edge_align) uint32_t draw_plot(Point p1, Point p2, volatile bool (&readings)[READINGS_SIZE], uint32_t readingPos, bool edge_align) {
{
uint32_t reading_window = READINGS_SIZE / current_zoom_level; uint32_t reading_window = READINGS_SIZE / current_zoom_level;
uint32_t start_index_no_modulus = (readingPos + (READINGS_SIZE - reading_window)); uint32_t start_index_no_modulus = (readingPos + (READINGS_SIZE - reading_window));
uint32_t start_index = start_index_no_modulus % READINGS_SIZE; uint32_t start_index = start_index_no_modulus % READINGS_SIZE;
@ -82,17 +81,17 @@ uint32_t draw_plot(Point p1, Point p2, volatile bool (&readings)[READINGS_SIZE],
uint32_t alignment_offset = 0; uint32_t alignment_offset = 0;
if(edge_align) { if(edge_align) {
//Perform edge alignment by first seeing if there is a window of readings available (will be at anything other than x1 zoom) // Perform edge alignment by first seeing if there is a window of readings available (will be at anything other than x1 zoom)
uint32_t align_window = (start_index_no_modulus - readingPos); uint32_t align_window = (start_index_no_modulus - readingPos);
//Then go backwards through that window // Then go backwards through that window
for(uint32_t i = 1; i < align_window; i++) { for(uint32_t i = 1; i < align_window; i++) {
uint32_t align_index = (start_index + (READINGS_SIZE - i)) % READINGS_SIZE; uint32_t align_index = (start_index + (READINGS_SIZE - i)) % READINGS_SIZE;
bool align_reading = readings[align_index]; bool align_reading = readings[align_index];
//Has a transition from high to low been detected? // Has a transition from high to low been detected?
if(!align_reading && align_reading != last_reading) { if(!align_reading && align_reading != last_reading) {
//Set the new start index from which to draw from and break out of the search // Set the new start index from which to draw from and break out of the search
start_index = align_index; start_index = align_index;
alignment_offset = i; alignment_offset = i;
break; break;
@ -103,22 +102,21 @@ uint32_t draw_plot(Point p1, Point p2, volatile bool (&readings)[READINGS_SIZE],
last_reading = readings[start_index % READINGS_SIZE]; last_reading = readings[start_index % READINGS_SIZE];
} }
//Go through each X pixel within the screen window // Go through each X pixel within the screen window
uint32_t reading_window_start = 0; uint32_t reading_window_start = 0;
for(int32_t x = 0; x < screen_window; x++) for(int32_t x = 0; x < screen_window; x++) {
{
uint32_t reading_window_end = ((x + 1) * reading_window) / screen_window; uint32_t reading_window_end = ((x + 1) * reading_window) / screen_window;
//Set the draw state to be whatever the last reading was // Set the draw state to be whatever the last reading was
DrawState draw_state = last_reading ? DRAW_HIGH : DRAW_LOW; DrawState draw_state = last_reading ? DRAW_HIGH : DRAW_LOW;
//Go through the readings in this window to see if a transition from low to high or high to low occurs // Go through the readings in this window to see if a transition from low to high or high to low occurs
if(reading_window_end > reading_window_start) { if(reading_window_end > reading_window_start) {
for(uint32_t i = reading_window_start; i < reading_window_end; i++) { for(uint32_t i = reading_window_start; i < reading_window_end; i++) {
bool reading = readings[(i + start_index) % READINGS_SIZE]; bool reading = readings[(i + start_index) % READINGS_SIZE];
if(reading != last_reading) { if(reading != last_reading) {
draw_state = DRAW_TRANSITION; draw_state = DRAW_TRANSITION;
break; //A transition occurred, so no need to continue checking readings break; // A transition occurred, so no need to continue checking readings
} }
last_reading = reading; last_reading = reading;
} }
@ -126,9 +124,8 @@ uint32_t draw_plot(Point p1, Point p2, volatile bool (&readings)[READINGS_SIZE],
} }
reading_window_start = reading_window_end; reading_window_start = reading_window_end;
//Draw a pixel in a high or low position, or a line between the two if a transition // Draw a pixel in a high or low position, or a line between the two if a transition
switch(draw_state) switch(draw_state) {
{
case DRAW_TRANSITION: case DRAW_TRANSITION:
for(uint8_t y = p1.y; y < p2.y; y++) for(uint8_t y = p1.y; y < p2.y; y++)
pico_explorer.pixel(Point(x + p1.x, y)); pico_explorer.pixel(Point(x + p1.x, y));
@ -142,7 +139,7 @@ uint32_t draw_plot(Point p1, Point p2, volatile bool (&readings)[READINGS_SIZE],
} }
} }
//Return the alignment offset so subsequent encoder channel plots can share the alignment // Return the alignment offset so subsequent encoder channel plots can share the alignment
return alignment_offset; return alignment_offset;
} }
@ -193,14 +190,12 @@ void setup() {
} }
if(QUADRATURE_OUT_ENABLED) { if(QUADRATURE_OUT_ENABLED) {
//Set up the quadrature encoder output // Set up the quadrature encoder output
PIO pio = pio1; PIO pio = pio1;
uint offset = pio_add_program(pio, &quadrature_out_program); uint offset = pio_add_program(pio, &quadrature_out_program);
uint sm = pio_claim_unused_sm(pio, true); uint sm = pio_claim_unused_sm(pio, true);
quadrature_out_program_init(pio, sm, offset, QUADRATURE_OUT_1ST_PIN, QUADRATURE_OUT_FREQ); quadrature_out_program_init(pio, sm, offset, QUADRATURE_OUT_1ST_PIN, QUADRATURE_OUT_FREQ);
} }
pico_explorer.set_backlight(255);
} }
@ -210,10 +205,10 @@ void setup() {
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
int main() { int main() {
//Perform the main setup for the demo // Perform the main setup for the demo
setup(); setup();
//Begin the timer that will take readings of the coder at regular intervals // Begin the timer that will take readings of the coder at regular intervals
struct repeating_timer timer; struct repeating_timer timer;
add_repeating_timer_us(-TIME_BETWEEN_SAMPLES_US, repeating_timer_callback, NULL, &timer); add_repeating_timer_us(-TIME_BETWEEN_SAMPLES_US, repeating_timer_callback, NULL, &timer);
@ -223,31 +218,33 @@ int main() {
while(true) { while(true) {
//Has enough time elapsed since we last refreshed the screen? // Has enough time elapsed since we last refreshed the screen?
uint64_t current_time = time_us_64(); uint64_t current_time = time_us_64();
if(current_time > last_time + MAIN_LOOP_TIME_US) { if(current_time > last_time + MAIN_LOOP_TIME_US) {
last_time = current_time; last_time = current_time;
gpio_put(PICO_DEFAULT_LED_PIN, true); //Show the screen refresh has stated gpio_put(PICO_DEFAULT_LED_PIN, true); // Show the screen refresh has stated
//If the user has wired up their encoder switch, and it is pressed, set the encoder count to zero // If the user has wired up their encoder switch, and it is pressed, set the encoder count to zero
if(ENCODER_SWITCH_PIN != Encoder::PIN_UNUSED && gpio_get(ENCODER_SWITCH_PIN)) { if(ENCODER_SWITCH_PIN != Encoder::PIN_UNUSED && gpio_get(ENCODER_SWITCH_PIN)) {
encoder.zero_count(); encoder.zero_count();
} }
//Take a capture, or snapshot of the current encoder state // Take a capture, or snapshot of the current encoder state
Capture capture = encoder.perform_capture(); Capture capture = encoder.perform_capture();
//Spin Motor 1 either clockwise or counterclockwise depending on if B or Y are pressed // Spin Motor 1 either clockwise or counterclockwise depending on if B or Y are pressed
if(pico_explorer.is_pressed(PicoExplorer::B) && !pico_explorer.is_pressed(PicoExplorer::Y)) if(pico_explorer.is_pressed(PicoExplorer::B) && !pico_explorer.is_pressed(PicoExplorer::Y)) {
pico_explorer.set_motor(PicoExplorer::MOTOR1, PicoExplorer::FORWARD, 1.0f); pico_explorer.set_motor(PicoExplorer::MOTOR1, PicoExplorer::FORWARD, 1.0f);
else if(pico_explorer.is_pressed(PicoExplorer::Y) && !pico_explorer.is_pressed(PicoExplorer::B)) }
else if(pico_explorer.is_pressed(PicoExplorer::Y) && !pico_explorer.is_pressed(PicoExplorer::B)) {
pico_explorer.set_motor(PicoExplorer::MOTOR1, PicoExplorer::REVERSE, 0.2f); pico_explorer.set_motor(PicoExplorer::MOTOR1, PicoExplorer::REVERSE, 0.2f);
else }
else {
pico_explorer.set_motor(PicoExplorer::MOTOR1, PicoExplorer::STOP); pico_explorer.set_motor(PicoExplorer::MOTOR1, PicoExplorer::STOP);
}
// If A has been pressed, zoom the view out to a min of x1
//If A has been pressed, zoom the view out to a min of x1
if(pico_explorer.is_pressed(PicoExplorer::A)) { if(pico_explorer.is_pressed(PicoExplorer::A)) {
if(!aPressedLatch) { if(!aPressedLatch) {
aPressedLatch = true; aPressedLatch = true;
@ -258,7 +255,7 @@ int main() {
aPressedLatch = false; aPressedLatch = false;
} }
//If X has been pressed, zoom the view in to the max of x512 // If X has been pressed, zoom the view in to the max of x512
if(pico_explorer.is_pressed(PicoExplorer::X)) { if(pico_explorer.is_pressed(PicoExplorer::X)) {
if(!xPressedLatch) { if(!xPressedLatch) {
xPressedLatch = true; xPressedLatch = true;
@ -284,7 +281,7 @@ int main() {
pico_explorer.set_pen(0, 255, 255); pico_explorer.set_pen(0, 255, 255);
draw_plot(Point(0, 80), Point(PicoExplorer::WIDTH, 80 + 50), encB_readings, (localPos + (READINGS_SIZE - alignment_offset)) % READINGS_SIZE, false); draw_plot(Point(0, 80), Point(PicoExplorer::WIDTH, 80 + 50), encB_readings, (localPos + (READINGS_SIZE - alignment_offset)) % READINGS_SIZE, false);
//Copy values that may have been stored in the scratch buffers, back into the main buffers // Copy values that may have been stored in the scratch buffers, back into the main buffers
for(uint16_t i = 0; i < next_scratch_index; i++) { for(uint16_t i = 0; i < next_scratch_index; i++) {
encA_readings[next_reading_index] = encA_scratch[i]; encA_readings[next_reading_index] = encA_scratch[i];
encB_readings[next_reading_index] = encB_scratch[i]; encB_readings[next_reading_index] = encB_scratch[i];
@ -293,6 +290,7 @@ int main() {
if(next_reading_index >= READINGS_SIZE) if(next_reading_index >= READINGS_SIZE)
next_reading_index = 0; next_reading_index = 0;
} }
drawing_to_screen = false; drawing_to_screen = false;
next_scratch_index = 0; next_scratch_index = 0;
@ -338,8 +336,8 @@ int main() {
pico_explorer.set_pen(255, 255, 128); pico_explorer.text(sstream.str(), Point(80, 210), 220, 3); pico_explorer.set_pen(255, 255, 128); pico_explorer.text(sstream.str(), Point(80, 210), 220, 3);
} }
pico_explorer.update(); //Refresh the screen pico_explorer.update(); // Refresh the screen
gpio_put(PICO_DEFAULT_LED_PIN, false); //Show the screen refresh has ended gpio_put(PICO_DEFAULT_LED_PIN, false); // Show the screen refresh has ended
} }
} }
} }