redpitaya / jupyter

Python API and interactive web applications

What is Red Pitaya?

Credit size mobile IoT hardware & software platform that replaces many expensive laboratory measurements and control instruments. Open-source software examples, easy interfacing with sensors and actuators, and the possibility to control it using Python, Jupyter, MATLAB or LabVIEW & C, makes it a perfect tool in education or rapid product development.

Where to get one?

Red Pitaya boards can be purchased @ RedPitaya online store. To better understand how product specifications differ from each other we suggest you look at the hardware specifications comparison table & Supported features and apps by Red Pitaya model table.

How can I start using it?

First step is to connect to your device by following the quick start guide.

How to start using Red Pitaya as a test & measurement instrument?

Once you connect to Red Pitaya from WEB browser it can be immediately used as:

• Oscilloscope
• Spectrum analyzer
• Signal generator
• Bode analyzer
• LCR meter
• Vector Network Analyzer
• and more... There are also many other (contributed) applications available on RedPitaya marketplace. For more information about RedPitaya apps click here.

How to start using Red Pitaya as SDR (software defined radio)?

SDR support for RedPitaya is done and maintained by Pavel Demin. The best place to get the latest software from is Pavel’s repository.

How to start programming Red Pitaya or developing your own applications?

There are several ways to program / develop with Red Pitaya.

1. Remote control / programming

   Remote control can be done by using most popular rapid prototyping development tools MATLAB, LABview, SCILAB or Python remotely. There are several examples available.

2. Programming Red Pitaya directly from WEB browser / Python Red Pitaya can be programmed in Python directly from the WEB browser using Jupyter.

3. C/C++ programming

RedPitaya hardware features can be easily accessed through C APIs. Many starting examples are available at this link.

4. FPGA programming Information on how to compile Red Pitaya open source FPGA code is here.

5. Creating own WEB applications Instructions on how to create your own Red Pitaya WEB applications can be found here.

How to interface Red Pitaya with other hardware or sensors?

Besides fast analog inputs and outputs Red Pitaya comes with an extension connector that enables users to interface with other hardware devices or sensors over standard i2c, UART, SPI interfaces or additional slow analog inputs and outputs and digital GPIOs.

There are two main extension possibilities:

1. Using already available sensor extension module by RedPitaya Sensors extension module provides direct connection to GroveSensors (e.g. Temperature sensor, Motion sensor,Touch sensor, Button, Switch, Tilt, Potentiometer, Light sensor, Air quality sensor, Vibration sensor, Moisture sensor, Water sensor, Alcohol sensor, Barometer not supported at the moment, Sound sensor, UV sensor, Accelerometer, Relay). Sensor extension module also provide compatibility with Arduino extension modules. More examples and information can be found at this link.

2. Creating own add on module that connects to extension connector For more information about extension connector click here

How to start teaching with RedPitaya?

Teaching lectures / material. Red Pitaya Knowledge Base

jupyter's Issues

average setter needs import

Using the average setter fails , since it uses the [unimported] math library. A simple import math at the top of osc_fil.py fixes this.

Error reading analog output

When I try to read the analog output value in

from redpitaya.overlay.mercury import mercury as FPGA
overlay = FPGA()
pdm = FPGA.analog_out()
pdm.write(3, 0.5)
pdm.read(3)

I get the following error:

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-105-1acf23d1c1a6> in <module>()
----> 1 print(pdm.read(0))

/home/jupyter/RedPitaya/redpitaya/overlay/mercury.py in read(self, ch)
     93 
     94         def read(self, ch: int) -> float:
---> 95             return (super().read(ch) / super().DWr * self.V)
     96 
     97         def write(self, ch: int, value: float):

AttributeError: 'super' object has no attribute 'DWr'

To solve it, please change super().Drw to super()._Drw.

segmentation fault on closing python kernel (or interpreter)

The proper order for running object destructors should be to first destroy all UIO class instances and then close the overlay instance, otherwise UIO device files are removed, before the file is closed.

Example code:

from redpitaya.overlay.mercury import mercury as FPGA
overlay = FPGA()
pdm = FPGA.analog_out()
#pdm = overlay.analog_out()

A failing sequence looks like:

Overlay __del__ was activated.
UIO __del__ was activated.
Segmentation fault

While a successful sequence looks like:

UIO __del__ was activated.
Overlay __del__ was activated.

The order seems to be the same every time, but it depends if the code is executed as a script or in the interpreter is closed or a notebook kernel is restarted.

If every UIO object contained a reference to the overlay object then the destruction order should be correct, but I am not sure how to achieve this.

Oscilloscope forced trigger: Error on closing objects

Using the jupyter example "Oscilloscope forced trigger" on the Red Pitaya web interface creates errors:

Closing the objects osc0 using osc0.close() and fpga using fpga.close() creates the errors:

AttributeError Traceback (most recent call last)
in ()
----> 1 osc0.close()

AttributeError: 'osc' object has no attribute 'close'

and

---

AttributeError Traceback (most recent call last)
in ()
----> 1 fpga.close()

AttributeError: 'mercury' object has no attribute 'close'