Oscilloscope | Simple Oscilloscope Simulator | Game Engine library

Disclaimer : I posted for the same issue (with a different point of view) here

I use a SPH0645 I2S microphone with a custom driver.

It seams properly recognized by alsa :

I am currently working on a flutter app that will plot data from a BLE device in real-time on a line chart (where the data will be displayed in an oscilloscope style format). As a place holder for the live BLE data, I am using a timer callback to generate and plot a sine wave with the "charts_flutter" package. So far everything seems to be working. However, it seems like the chart rendering struggles to keep up when the update period is less than 500ms (for example, setting it to 200ms causes everything to freeze up). Before I start experimenting with different packages, I'd like to see if anyone has tips or suggestions to try to speed things up. It is possible that I'm just doing something wrong with state management etc. since I'm not that experienced with flutter. The code is pretty short so I've included both project files below. Thanks.

main.dart

I've set up two STM32 Boards, one as SPI-master, the other one as slave. I write directly to registers without any framework. Master to slave communication is working perfectly. But the slave sends garbage sometimes.

I first tried interrupts, but the slave would always send garbage and often receive garbage. Now I implemented DMA. This is working way better, the slave now always receives correct data. But sending is still an issue.

If the transmission is 3 to 5 Bytes long the data from the slave is correct in 95% of all cases. If the transmission is longer then 5 bytes, then after the 4th or 5th byte there is just random byte foo. But the first 4 bytes are nearly (95%) always correct.

The signals are clean, I checked them with an oscilloscope. The data which the master receives shows up properly on MISO. So I guess the slave somehow writes garbage into the SPI DR, or the data register gets messed up. I know SPI slaves on non-FPGAs are tricky, but this really is unexpected...

Anyone can point me a direction? I'm desperate and thankful for any bit of advice.

This is the code

I am trying to communicate with a LeCroy WaveRunner 640Zi oscilloscope from a Raspberry Pi, they are connected with a USB cable. I have already done this under Windows, but now I am not able to make it work in Linux.

If I run lsusb I see this:

I am trying to implement some code from this old tutorial from 2015 (which is using a VERY old version of PyVISA, so everything is different now):

I have a very simple example of a OpenGL ES program that I'm trying to get to run on RaspiOS Desktop (a.k.a. Raspbian) on Raspberry Pi 4.

My goal is very simple - to draw a red triangle in the center of the screen. However, the triangle comes out as white instead of red.

I've searched and tried everything and wasn't able to find any help. I'm very frustrated at this point because this was just supposed to be the first tutorial to introduce the world of OpenGL ES and I'm already stuck and can't continue with more complicated examples.

Anyway, here's the full example

When using interrupts, any kind of digitalRead should be obsolete, or so i think. Let me explain my understanding of this to show my problem:

Say, a quadrature incremental rotary encoder (RE) is pulled up on both signal pins and is therefore idle HIGH. If i configure an interrupt service routine (ISR) on the falling edge on both pins and have the ISR for pin B do nothing more than set the flag "flag_B" to false (representing the logic state at the pin) and the ISR for pin A sets or resets a flag "flag_clockwise" depending on the state of flag_B during A's ISR, then i should get the right direction for every turning step, right? My only task is to then set the state of pin B to high again after the ISRs and my code should be ready for the next interrupt. But that doesn't work, with many random cases of the wrong direction being displayed or showing counter clockwise on the first half of the turning step when you can feel a little "bump" while turning the knob and then going clockwise on the second half, when the shaft has completed a single step, basically performing two opposite actions while only turning one step. Is my logic flawed? All signals are debounced in hardware and look like expected on the oscilloscope.

ISRs:

Introduction

I have been working on writing my own bare metal code for a Raspberry PI as I build up my bare metal skills and learn about kernel mode operations. However, due to the complexity, amount of documentation errors, and missing/scattered info, it has been extremely difficult to finally bring up a custom kernel on the Raspberry PI. However, I finally got that working.

A very broad overview of what is happening in the bootstrap process

My kernel loads into 0x80000, sends all cores except core 0 into an infinite loop, sets up the Stack Pointer, and calls a C function. I can setup the GPIO pins and turn them on and off. Using some additional circuitry, I can drive LEDs and confirm that my code is executing.

The problem

However when it comes to the UART, I have hit a wall. I am using UART0 (PL011). As far as I can tell, the UART is not outputting, although I could be missing it on my scope since I only have an analog oscilloscope. The code gets stuck when outputting the string. I have determined through hours of reflashing my SD card with different YES/NO questions to my LEDs that it is stuck in an infinite loop waiting for the UART Transmit FIFO Full flag to clear. The UART only accepts 1 byte before becoming full. I can not figure out why it is not transmitting the data out. I am also not sure if I have correctly set my baud-rate, but I don't think that would cause the TX FIFO to stay filled.

Getting a foothold in the code

Here is my code. The execution begins at the very beginning of the binary. It is constructed by being linked with symbol "my_entry_pt" from assembly source "entry.s" in the linker script. That is where you will find the entry code. However, you probably only need to look at the last file which is the C code in "base.c". The rest is just bootstrapping up to that. Please disregard some comments/names which don't make sense. This is a port (of primarily the build infrastructure) from an earlier bare-metal project of mine. That project used a RISC-V development board which uses a memory mapped SPI flash to store the binary code of the program.:

[Makefile]

I'm a little confused about the trigger voltage for rising-falling triggered interrupts. As my previous understanding, the trigger voltage should be Vih and Vil. But some one told me Vih and Vil is not for edge triggered interrupts. The thing is, when I observe the waveform with a Oscilloscope along with an interrupt counter from Keil, I did see the interrupt happened when the voltage did not reach the Vih(rising edge). I use 3.3V voltage. The signal is only 1V around and the interrupts was triggered. I checked the manual of STM32 and did not find the answer.

Could some one help?

Thanks,