The Pocket Science Lab as we all know is on the verge of development and new features and UI are added almost every day. One such feature is the implementation of multimeter which I have also discussed in my previous blogs.
Figure (1) : Screenshot of the multimeter
But although many functionality of multimeter such as resistance measurement are working perfectly, there are still various bugs in the multimeter. This blog is dedicated to using multimeter in the android app.
Using the multimeter
Figure (2): Screenshot showing guide of multimeter
Figure (2) shows the guide of the multimeter, i.e how basic basic elements such as resistance and voltage are measured using the multimeter. The demonstration of measuring the resistance and voltage are given below.
Measuring the resistance
The resistance is measure by connecting the SEN pin to the positive end of resistor and the GND pin to the negative end of resistor and then clicking the RESISTANCE button.
Figure (3) : Demonstration of resistance measurement
Measuring the voltage
To measure the voltage as said in the Guide, directly connect the power source to the the channel pins, although currently only the CH3 pin will show the most accurate results, work is going on other channel improvisation as well.
Figure (4) : Demonstration of Voltage measurement
And thus this is how the multimeter is used is used in the android app. Of course there are still many many features such as capacitance measurements which are yet to be implemented and the work is going on them
The Pocket Science Lab Android app has various functionalities which have been already implemented but it been on the verge of development, many functionalities are yet to be implemented completely, one such functionality is how the users report the issues of the app, to which comes the idea of using a Google form inside the app for the users to fill it and the issue get directly opened in Github.
Submitting a Github issue through a Google forms requires two things:-
A Github access token which gives access to open a new issue.
To generate a Github access token one must follow these steps[2]
Go to the personal settings.
Select Developers settings option from it.
In Developers settings option Go to personal access tokens and generate an access token.
A fully-structured Google form which has all the details about the issue i.e the title of the issue, the body of the issue, label, etc..
Using a Google account create a Google Form which have all the relevant questions about that issue such as title of the issue, body of the issue, label etc..
Once done with all the steps follow these steps to send a Github issue[1]
Click the Responses tab, in it click the More icon.
Select Choose a response destination.
Select New spreadsheet: Creates a new spreadsheet in Google Sheets for responses.
Click Create to create and open the sheet.
Configure the App Script Logic[1]
You should have a newly created blank spreadsheet with headers automatically generated from your form.
Click Tools > Script editor… to launch the App Script editor coding environment. This Script will be bound to your sheet, so you can listen for form submissions and fire off a new issue to your GitHub repo.
In the script editor write the following code
function onFormSubmit(e) {
vartitle = e.values[1];
var body = e.values[2];
varlabel = "User opened issue"var payload = {
"title": title,
"body": a_body,
"label": label,
};
var options = {
"method": "POST",
"contentType": "application/json",
"payload": JSON.stringify(payload)
};
var response = UrlFetchApp.fetch("https://api.github.com/repos/abhinavraj23/AgeGroup/issues?access_token="+ghToken, options)
}
Note:The onFormSubmit function includes an event object e, which includes the form/spreadsheet field values as a simple array with values in the same order as they appear in the spreadsheet. e.values[0] is the first spreadsheet column
The following google-app script uses GitHub Issues API for posting a new issue in Github.
4.Give your app script project a name and save it .
Set up the Trigger[1]
From within the app script editor, click Resources > Current project’s triggers.
Click to add a trigger
Run: onFormSubmit
Events: From spreadsheet, On form submit
Click Save and accept any authorizations to access your forms and access web services on your behalf.
This trigger will listen to form submissions and pass the data to your function, which POSTs the new issue to your GitHub repo.
Thus using these steps one can submit an issue in github through a Google Form and thus the Google Forms can be used in the app as the users can send the issues using a google form, and through this method one can also get the email-id of the user for further contact and thus this is a very useful method.
The PSLab Android App and the PSLab Desktop App come with built-in experiments which include the experiment setups as well as the experiment docs. The experiment docs for PSLab have been written in the Markdown format. So, the markdown support had to be enabled in the PSLab Android App.
There are numerous markdown file renderers for android. The most popular among them is MarkdownView (https://github.com/falnatsheh/MarkdownView) which is an open-source service.
This blog covers how to enable the support for markdown in apps and use to generate elegant documentation.
Enabling MarkdownView
MarkdownView can be enabled by simply adding a dependency in the build.gradle file
compile'us.feras.mdv:markdownview:1.1.0'
Creating the layout file
The layout file for supporting a markdown file is fairly simple. The inclusion of the above dependency simplifies the things. The view holder for markdown is created and an id is assigned to it.
In order to load the markdown file, a MarkdownView object is created. Since, in the PSLab Android app, markdown files which form the documentation part are a part of the experiments. So, the files are displayed in the documentation fragment of the experiments.
The MarkdownView object created is assigned to markdown viewholder of the relevant layout file. Here, the layout file was named experiment_doc_md and the view holder was assigned the id perform_experiment_md. The markdown files were stored in the assets directory of the app and the files were loaded from the there.
loadMarkdownFromFile – loads markdown from a file stored in the app not present in the assets directory
mMarkdownView.loadMarkdownFromFile(newFile());
loadMarkdownFromUrl – loads markdown from the specified URL (requires internet connection, as file is loaded from the web)
mMarkdownView.loadMarkdownFromUrl("url");
Important points for consideration
Avoid using elements of GitHub Flavoured Markdown (GFM) as it is not fully supported. It is better to stick to the traditional markdown style.
While adding images in the markdown files, avoid using specific dimensions as the images may not load properly in some cases due to the wide variety of screen sizes in android devices.
It is better to store the Markdown files to be loaded in the assets directory of the app and load it from there instead of the other methods mentioned above.
The PSLab Android App works as an oscilloscope and a wave generator using the audio jack of the Android device. The implementation of the oscilloscope in the Android device using the in-built mic has been discussed in the blog post “Using the Audio Jack to make an Oscilloscope in the PSLab Android App” and the same has been discussed in the context of wave generator in the blog post “Implement Wave Generation Functionality in the PSLab Android App”. This post is a continuation of the post related to the implementation of wave generation functionality in the PSLab Android App. In this post, the subject matter of discussion is the way to fill the audio buffer so that the resulting wave generated is either a Sine Wave, a Square Wave or a Sawtooth Wave. The resultant audio buffer would be played using the AudioTrack API of Android to generate the corresponding wave. The waves we are trying to generate are periodic waves.
Periodic Wave: A wave whose displacement has a periodic variation with respect to time or distance, or both.
Thus, the problem reduces to generating a pulse which will constitute a single time period of the wave. Suppose we want to generate a sine wave; if we generate a continuous stream of pulses as illustrated in the image below, we would get a continuous sine wave. This is the main concept that we shall try to implement using code.
Initialise AudioTrack Object
AudioTrack object is initialised using the following parameters:
STREAM TYPE: Type of stream like STREAM_SYSTEM, STREAM_MUSIC, STREAM_RING, etc. For wave generation purposes we are using stream music. Every stream has its own maximum and minimum volume level.
SAMPLING RATE: It is the rate at which the source samples the audio signal.
BUFFER SIZE IN BYTES: Total size of the internal buffer in bytes from where the audio data is read for playback.
MODES: There are two modes-
MODE_STATIC: Audio data is transferred from Java to the native layer only once before the audio starts playing.
MODE_STREAM: Audio data is streamed from Java to the native layer as audio is being played.
getMinBufferSize() returns the estimated minimum buffer size required for an AudioTrack object to be created in the MODE_STREAM mode.
Depending on the values in the audio buffer, the wave is generated by the AudioTrack object. Therefore, to generate a specific kind of wave, we need to fill the audio buffer with some specific values. The values are governed by the wave equation of the signal that we want to generate.
publicshort[] createBuffer(int frequency) {short[] buffer = newshort[minTrackBufferSize];double f = frequency;double q = 0;double level = 16384;finaldouble K = 2.0 * Math.PI / SAMPLING_RATE;for (int i = 0; i < minTrackBufferSize; i++) { f += (frequency - f) / 4096.0; q += (q < Math.PI) ? f * K : (f * K) - (2.0 * Math.PI); buffer[i] = (short) Math.round(Math.sin(q)); }return buffer;}
Fill Audio Buffer to Generate Square Wave
To generate a square wave, let’s assume the time period to be t units. So, we need the amplitude to be equal to A for t/2 units and -A for the next t/2 units. Repeating this pulse continuously, we will get a square wave.
buffer[i] = (short) ((q > 0.0) ? 1 : -1);
Fill Audio Buffer to Generate Sawtooth Wave
Ramp signals increases linearly with time. A Ramp pulse has been illustrated in the image below:
We need repeated ramp pulses to generate a continuous sawtooth wave.
buffer[i] = (short) Math.round((q / Math.PI));
Finally, when the audio buffer is generated, write it to the audio sink for playback using write() method exposed by the AudioTrack object.
PSLab has the capability to perform a variety of experiments. The PSLab Android App and the PSLab Desktop App have built-in support for about 70 experiments. The experiments range from variety of trivial ones which are for school level to complicated ones which are meant for college students. However, it is nearly impossible to support a vast variety of experiments that can be performed using simple electronic circuits.
So, the blog intends to show how PSLab can be efficiently used for performing experiments which are otherwise not a part of the built-in experiments of PSLab. PSLab might have some limitations on its hardware, however in almost all types of experiments, it proves to be good enough.
Identifying the requirements for experiments
The user needs to identify the tools which are necessary for analysing the circuit in a given experiment. Oscilloscope would be essential for most experiments. The voltage & current sources might be useful if the circuit requires DC sources and similarly, the waveform generator would be essential if AC sources are needed. If the circuit involves the use and analysis of data of sensor, the sensor analysis tools might prove to be essential.
The circuit diagram of any given experiment gives a good idea of the requirements. In case, if the requirements are not satisfied due to the limitations of PSLab, then the user can try out alternate external features.
Using the features of PSLab
Using the oscilloscope
Oscilloscope can be used to visualise the voltage. The PSLab board has 3 channels marked CH1, CH2 and CH3. When connected to any point in the circuit, the voltages are displayed in the oscilloscope with respect to the corresponding channels.
The MIC channel can be if the input is taken from a microphone. It is necessary to connect the GND of the channels to the common ground of the circuit otherwise some unnecessary voltage might be added to the channels.
Using the voltage/current source
The voltage and current sources on board can be used for requirements within the range of +5V. The sources are named PV1, PV2, PV3 and PCS with V1, V2 and V3 standing for voltage sources and CS for current source. Each of the sources have their own dedicated ranges.
While using the sources, keep in mind that the power drawn from the PSLab board should be quite less than the power drawn by the board from the USB bus.
USB 3.0 – 4.5W roughly
USB 2.0 – 2.5W roughly
Micro USB (in phones) – 2W roughly
PSLab board draws a current of 140 mA when no other components are connected. So, it is advisable to limit the current drawn to less than 200 mA to ensure the safety of the device.
It is better to do a rough calculation of the power requirements in mind before utilising the sources otherwise attempting to draw excess power will damage the device.
Using the Waveform Generator
The waveform generator in PSLab is limited to 5 – 5000 Hz. This range is usually sufficient for most experiments. If the requirements are beyond this range, it is better to use an external function generator.
Both sine and square waves can be produced using the device. In addition, there is a feature to set the duty cycle in case of square waves.
Sensor Quick View and Sensor Data Logger
PSLab comes with the built in support for several plug and play sensors. The support for more sensors will be added in the future. If an experiment requires real time visualisation of sensor data, the Sensor Quick View option can be used whereas for recording the data for sensors for a period of time, the Sensor Data Logger can be used.
Analysing the Experiment
The oscilloscope is the most common tool for circuit analysis. The oscilloscope can sample data at very high frequencies (~250 kHz). The waveform at any point can be observed by connecting the channels of the oscilloscope in the manner mentioned above.
The oscilloscope has some features which will be essential like Trigger to stabilise the waveforms, XY Plot to plot characteristics graph of some devices, Fourier Transform of the Waveforms etc. The tools mentioned here are simple but highly useful.
For analysing the sensor data, the Sensor Quick View can be paused at any instant to get the data at any instant. Also, the logged data in Sensor Data Logger can be exported as a TXT/CSV file to keep a record of the data.
Additional Insight
The PSLab desktop app comes with the built-in support for the ipython console.
The desired quantities like voltages, currents, resistance, capacitance etc. can also be measured by using simple python commands through the ipython console.
A simple python script can be written to satisfy all the data requirements for the experiment. An example for the same is shown below.
This is script to produce two sine waves of 1 kHz and capturing & plotting the data.
frompylabimport*fromPSLimportsciencelabI=sciencelab.connect()I.set_gain('CH1',2)# set input CH1 to +/-4V rangeI.set_gain('CH2',3)# set input CH2 to +/-4V rangeI.set_sine1(1000)# generate 1kHz sine wave on output W1I.set_sine2(1000)# generate 1kHz sine wave on output W2#Connect W1 to CH1, and W2 to CH2. W1 can be attenuated using the manual amplitude knob on the PSlabx,y1,y2=I.capture2(1600,1.75,'CH1')plot(x,y1)#Plot of analog input CH1plot(x,y2)#plot of analog input CH2show()
PSLab has the capability to perform a variety of experiments. The PSLab Android App and the PSLab Desktop App have built-in support for over 70 experiments which are commonly performed by students. In addition to that, it can be used in other experiments conveniently. This blog post is in continuation with the previous two posts regarding performing experiments (links in the reference) and this blog deals with another category of experiments that can be performed using PSLab.
The blog lists experiments which mainly involve the basic circuit elements like resistors, capacitors and inductors. These experiments involve the study of R-C, L-R, L-C and L-C-R circuits. These circuits have properties which make them important in real life applications and this blog attempts to give a rough picture of their importance.
Ohm’s Law, Capacitive Reactance and Inductive Reactance
These experiments involve the study of each of the basic circuit element individually. The current and voltage characteristics of each of the elements is studied.
The definitions of the above are:
Ohm’s Law – This is a law familiar to most. It relates the voltage and current of a purely resistive circuit stating that the voltage and current are proportional to each other and their ratio is a constant called the resistance. In this case, the current and voltage are in the same phase.
Capacitive Reactance – Across a capacitor in an AC circuit, the current and voltage are not in the same phase and the current leads the voltage. For a purely capacitive circuit, this difference is 90o.
Inductive Reactance – Across an inductor in an AC circuit, the current and voltage are not in the same phase and the current lags behind the voltage. For a purely inductive circuit, this difference is 90o.
The reactance is given for capacitor and inductor is given by 1/wC and wL respectively, where C & L are the values of capacitance and inductance respectively and w is the frequency of the AC signal.
The circuit for the setup is shown below. We need to observe the plot of the input waveform and the plot of the voltage across individual elements to observe the phase shift.
Connect CH1 & GND across the input terminals and CH2 & GND across the terminals of any of the elements.
An external signal can be used or can be generated using the PSLab. Use the PSLab to generate a sinusoidal signal of frequency 1000 Hz. by connecting the ends of PV1 in the circuit.
Observe the waveforms. In case of the resistor, there should be no observable phase lag between the two. In case of the capacitor and inductor, there will be an observable phase difference of 90o.
For the capacitive and inductive circuits, just replace the resistor in the above circuit with capacitor/inductor.
RC Circuits
Drawing their names from their respective calculus functions, the integrator produces a voltage output proportional to the product (multiplication) of the input voltage and time; and the differentiator (not to be confused with differential) produces a voltage output proportional to the input voltage’s rate of change.
RC Integrator circuit
For constructing the RC integrator circuit, connect the circuit as shown in the diagram.
Construction of the integrator circuit is fairly simple once the differentiator circuit is done.
Interchange the positions of the capacitor and resistor in the above circuit and the circuit for the integrator is complete.
Observe the output waveform. Plot both the CH1 and CH2 data simultaneously to compare the waveforms.
RC Differentiator circuit
For constructing the RC differentiator circuit, connect the circuit as shown in the diagram.
The values of resistance and capacitance used here are 10k ohm and 0.01uF.
Connect the CH1 and GND pins of the board with the input side marked as Vi. Ensure that GND is connected to the GND of the circuit.
Similarly, connect CH2 and GND with the corresponding ends of the output side marked as Vo.
PSLab can also be used for supplying the input to the circuit. Connect the ends of W1 and GND across Vi. W1 can be used to generate a square wave of 10V peak to peak voltage with a frequency of 500 Hz.
Observe the output waveform. Plot both the CH1 and CH2 data simultaneously to compare the waveforms.
RL Circuits
RL Integrator Circuit.
For constructing the RL integrator circuit, connect the circuit as shown in the diagram.
Construction of the integrator circuit is fairly simple once the differentiator circuit is done.
Interchange the positions of the inductor and resistor in the above circuit and the circuit for the integrator is complete.
Observe the output waveform. Plot both the CH1 and CH2 data simultaneously to compare the waveforms.
RL Differentiator Circuit
For constructing the RL differentiator circuit, connect the circuit as shown in the diagram.
The values of resistance and inductance used here are 470 ohm and 10mH.
Connect the CH1 and GND pins of the board with the input side marked as Vi. Ensure that GND is connected to the GND of the circuit.
Similarly, connect CH2 and GND with the corresponding ends of the output side marked as Vo.
PSLab can also be used for supplying the input to the circuit. Connect the ends of W1 and GND across Vi. W1 can be used to generate a square wave of 2V peak to peak voltage with a frequency of 5000 Hz.
Observe the output waveform. Plot both the CH1 and CH2 data simultaneously to compare the waveforms.
Frequency Response
Frequency Response of an electric or electronics circuit allows us to see exactly how the output gain (known as the magnitude response) and the phase (known as the phase response) changes at a particular single frequency, or over a whole range of different frequencies from 0Hz, (d.c.) to many thousands of megahertz, (MHz) depending upon the design characteristics of the circuit.
Frequency response of a circuit can be studied using different tools like Bode plots, phase plots etc. However, this blog would limit to using simple RC and RL circuits as they can be easily visualised using an oscilloscope.
RC Circuits
For observing the frequency response of RC circuits, the circuit can be constructed as shown below.
The values of resistance and capacitance used here are 10k ohm and 0.01uF.
Connect the CH1 and GND pins of the board with the input side marked as Vi. Ensure that GND is connected to the GND of the circuit.
Similarly, connect CH2 and GND with the corresponding ends of the output side marked as Vo.
PSLab can also be used for supplying the input to the circuit. Connect the ends of W1 and GND across Vi. W1 can be used to generate a square wave of 10V peak to peak voltage with a frequencies ranging from 100 Hz to 5000 Hz.
Switch to the X-Y mode of the oscilloscope and observe the waveform formed.
RL Circuits
For observing the frequency response of RL circuits, the circuit can be constructed as shown below.
The values of resistance and inductance used here are 470 ohm and 10mH.
Connect the CH1 and GND pins of the board with the input side marked as Vi. Ensure that GND is connected to the GND of the circuit.
Similarly, connect CH2 and GND with the corresponding ends of the output side marked as Vo.
Note: PSLab in this case cannot be used as an AC source as the maximum frequency of waveforms produced by PSLab is limited to 5kHz. However, this experiment would also need frequencies much higher than 5 Hz i.e upto 50 kHz. So, a dedicated function generator is needed. However, the oscilloscope would work just fine.
Switch to the X-Y mode of the oscilloscope and observe the waveform formed.
The PSLab Android App allows users to log data from the sensors connected to the PSLab hardware device. Sensor Data is stored locally but can be exported in various formats. Currently the app supports exporting data in .txt and .csv (comma-separated values) format. Exported data can be used by other users or scientists to study or analyze the data. Data can also be used by other softwares like Python, GNU octave, Matlab to further process it or visualise it in 3D. In this post, we will discuss how to export the locally stored realm data in .txt or .csv format. We will take the data of MPU6050 sensor as an example for understanding how locally logged data is exported.
Query Local Realm Data
We have attached a long click listener to sensor list view that detects which list item is selected. Clicking any sensor from sensor list for slightly longer than usual would result in a dialog popping up with the option to
Export Data: Results in exporting data in a format which is selected in App settings
Share Data: Shares sensor data with other users or on social media (yet to be implemented)
As soon as the Export Data option is selected from the dialog, sensor data of the corresponding sensor is queried. The data model of the sensor and how it’s saved in the local realm database is discussed in the post Sensor Data Logging in the PSLab Android App.
Once we get the required data, we need to write it in .txt or .csv format depending on what the user has selected as a preference in App Settings.
Getting User Preference from App Settings
The format in which the sensor data should be exported is presented to the user as a preference in App Settings. Currently the app supports two formats .txt and .csv.
private String format;SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);String formatValue = preferences.getString("export_data_format_list", "0");if ("0".equals(formatValue)) format = "txt";else format = "csv";
Export Data in .txt Format
To export the sensor data in .txt format, we need to create a .txt file in the external storage. folder variable is a path to PSLab Android folder in the external storage. If the folder doesn’t exist, it will be created.
File folder = new File(Environment.getExternalStorageDirectory() + File.separator + "PSLab Android");
After getting reference of the app folder in the external storage, we would create a text file in the PSLab Android folder. As soon as the text file is created, we initialize the FileOutputStream object to write data into the text file. The sensor data that was queried in the previous section is written into the text file just created. Finally after the complete sensor data is written, the stream is closed by stream.close() method.
Writing data in .csv format is similar to that in .txt format. As CSV stands for Comma Separated Values, which means each data value is separated by “,” (comma). It is similar to an excel sheet. The first row consists of labels that denote the type of value in that particular column. The other rows consist of the sensor data, with each row corresponding to a sample of the sensor data.
The PSLab Android App allows users to log data from sensors connected to the PSLab hardware device. The Connected sensors should support I2C, SPI communication protocols to communicate with the PSLab device successfully. The only prerequisite is the additional support for the particular sensor plugin in Android App. The user can log data from various sensors and measure parameters like temperature, humidity, acceleration, magnetic field, etc. These parameters are useful in predicting and monitoring the environment and in performing many experiments.
The support for the sensor plugins was added during the porting python communication library code to Java. In this post, we will discuss how we logged real time sensor data from the PSLab Hardware Device. We used Realm database to store the sensor data locally. We have taken the MPU6050 sensor as an example to understand the complete process of logging sensor data.
Creating Realm Object for MPU6050 Sensor Data
The MPU6050 sensor gives the acceleration and gyroscope readings along the three axes X, Y and Z. So the data object storing the readings of the mpu sensor have variables to store the acceleration and gyroscope readings along all three axes.
To sample the sensor data at 500ms interval, we created a runnable object and passed it to another thread which would prevent lagging of the UI thread. We can start/stop logging by changing the value of the boolean loggingThreadRunning on button click. TaskMPU6050 is an AsyncTask which reads each sample of sensor data from the PSLab device, it gets executed inside a while loop which is controlled by boolean loggingThreadRunning. Thread.sleep(500) pauses the thread for 500ms, this is also one of the reason to transfer the logging to another thread instead of logging the sensor data in UI thread. If such 500ms delays are incorporated in UI thread, app experience won’t be smooth for the users.
Runnable loggingRunnable = new Runnable() {@Overridepublicvoidrun() {try { MPU6050 sensorMPU6050 = new MPU6050(i2c);while (loggingThreadRunning) { TaskMPU6050 taskMPU6050 = new TaskMPU6050(sensorMPU6050); taskMPU6050.execute(); // use lock object to synchronize threads Thread.sleep(500); } } catch (IOException InterruptedException e) { e.printStackTrace(); } }};
Sampling of Sensor Data
We created an AsyncTask to read each sample of the sensor data from the PSLab device in the background thread. The getRaw() method read raw values from the sensor and returned an ArrayList containing the acceleration and gyro values. After the values were read successfully, they were updated in the data card in the foreground which was visible to the user. This data card acts as a real-time screen for the user. All the samples read are appended to ArrayList mpu6050DataList, when the user clicks on button Save Data, the collected samples are saved to the local realm database.
There is an option for Start/Stop Logging, clicking on which will change the value of boolean loggingThreadRunning which stops starts/stops the logging thread.
When the Save Data button is clicked, all the samples of sensor data collected from the PSLab device till that point are saved to the local realm database.
PSLab can be extensively used in a variety of experiments ranging from the traditional electrical and electronics experiments to a number of innovative experiments. The PSLab desktop app and the Android app have all the essential features that are needed to perform the experiments. In addition to that there is a large collection of built-in experiments in both these experiments.
This blog is an extension to the blog post mentioned here. This blog lists some of the basic electrical and electronics experiments which are based on the same principles which are mentioned in the previous blog. In addition to that, some interesting and innovative experiments where PSLab can be used are also listed here. The experiments mentioned here require some prerequisite knowledge of electronic elements and basic circuit building. (The links mentioned at the end of the blog will be helpful in this case)
Op-Amp as an Inverting and a Non-Inverting Amplifier
There are two methods of doing this experiment. PSLab already has a built-in experiment dedicated to inverting and non-inverting amplification of op-amps. In the Android App, just navigate to Saved Experiments -> Electronics Experiments -> Op-Amp Circuits -> Inverting/ Non-Inverting. In case of the Desktop app, select Electronics Experiments from the main drop-down at the top of the window and select the Inverting/Non-inverting op-amp experiment.
This experiment can also performed using the basic features of PSLab. The only advantage of this methodology is that it allows much more tweaking of values to observe the Op-Amp behaviour in greater detail. However, the built-in experiment is good enough for most of the cases.
Construct the above circuits on a breadboard.
For the amplifier, connect the terminals of CH1 and GND of PSLab on the input side i.e. next to Vi and the terminals of CH2 and GND on the output side i.e next to Vo.
Usually, an Op-Amp like LM741 have a set of pins, one dedicated for the inverting input and the other dedicated for the non-inverting input. It is recommended to consult the datasheet of the Op-Amp IC used in order to get the pin number with which the input has to be connected.
The terminals of W1 and GND are also connected on the input side and they are used to generate a sine wave.
The resistors displayed in the figure have the values R1 = 10k and R2 = 51k. Resistance values other than these can also be considered. The gain of the op-amp would depend on the ratio of R2/R1, so it is better to consider values of R2 which are significantly larger than R1 in order to see the gain properly.
Use the PSLab Desktop App and open the Waveform Generator in Control. Set the wave type of W1 to Sine and set the frequency at 1 kHz and magnitude to 0.1 V. Then go ahead and open the Oscilloscope.
CH1 would display the input waveform and CH2 will display the output waveform and the plots can be observed.
If the input is connected to the inverting pin of the op-amp, the output obtained will be amplified and will have a phase difference of 90o with the input waveform whereas when the non-inverting pin is selected, the output is just amplified and no such phase difference is observed.
Note: Take proper care while connecting the V+ and V- pins of the op-amp, else the op-amp will be damaged.
Diode as an Integrator and Differentiator
An integrator in measurement and control applications is an element whose output signal is the time integral of its input signal. It accumulates the input quantity over a defined time to produce a representative output.
Integration is an important part of many engineering and scientific applications. Mechanical integrators are the oldest application, and are still used in such as metering of water flow or electric power. Electronic analogue integrators are the basis of analog computers and charge amplifiers. Integration is also performed by digital computing algorithms.
In electronics, a differentiator is a circuit that is designed such that the output of the circuit is approximately directly proportional to the rate of change (the time derivative) of the input. An active differentiator includes some form of amplifier. A passive differentiator circuit is made of only resistors and capacitors.
Construct the above circuits on a breadboard.
For both the circuits, connect the terminals of CH1 and GND of PSLab on the input side i.e. next to input voltage source and the terminals of CH2 and GND on the output side i.e next to Vo.
Ensure that the inverting and the non-inverting terminals of the op-amp are connected correctly. Check for the +/- signs in the diagram. ‘+’ corresponds to non-inverting and ‘-’ corresponds to inverting.
The terminals of W1 and GND are also connected on the input side and they are used to generate a sine wave.
The resistors displayed in the figure have the values R1 = 10k and R2 = 51k. Resistance values other than these can also be considered. The gain of the op-amp would depend on the ratio of R2/R1, so it is better to consider values of R2 which are significantly larger than R1 in order to see the gain properly.
Use the PSLab Desktop App and open the Waveform Generator in Control. Set the wave type of W1 to Sine and set the frequency at 1 kHz and magnitude to 5V (10V peak to peak). Then go ahead and open the Oscilloscope.
CH1 would display the input waveform and CH2 will display the output waveform and the plots can be observed.
If all the connections are made properly and the values of the parameters are set properly, then the waveform obtained should be as shown below.
The experiments mentioned so far including the ones mentioned in the previous blog post involved analog circuits and so they required features like the arbitrary waveform generator. However, digital circuits work using discrete values only. PSLab has the features needed to perform digital experiments which mainly involve the use of a square wave generator with a variable duty cycle.
PSLab board has dedicated pins named SQR1, SQR2, SQR3 and SQR4. The options for configuring these pins is present under the Advanced Control section in the Desktop app and in the Android app Applications->Control->Advanced. The options include selecting the pins which we want to use for digital outputs and then configuring the frequency and duty cycle of the square wave generated from that particular pin.
Innovative Experiments using PSLab
PSLab has quite a good number of interesting built-in experiments. These experiments can be found in the dropdown list at the top in the Desktop App and under the Saved Experiments header in the Android App. The built-in experiments come bundled with good quality documentation having circuit diagrams and detailed procedure to perform the experiments.
Some of the interesting experiments include:
Lemon Cell Experiment: In this experiment, the internal resistance and the voltage supplied by the lemon cell are measured.
Sound Beats: In acoustics, a beat is an interference pattern between two sounds of slightly different frequencies, perceived as a periodic variation in volume whose rate is the difference of the two frequencies.
When tuning instruments that can produce sustained tones, beats can readily be recognized. Tuning two tones to a unison will present a peculiar effect: when the two tones are close in pitch but not identical, the difference in frequency generates the beating.
This experiment requires producing two waves together of different frequencies and connecting them to the same oscilloscope channel. The pattern observed is shown below.
The PSLab Android App works as an Oscilloscope using the audio jack of Android device. The implementation for the scope using in-built mic is discussed in the post Using the Audio Jack to make an Oscilloscope in the PSLab Android App. Another application which can be implemented by hacking the audio jack is Wave Generation. We can generate different types of signals on the wires connected to the audio jack using the Android APIs that control the Audio Hardware. In this post, I will discuss about how we can generate wave by using the Android APIs for controlling the audio hardware.
Configuration of Audio Jack for Wave Generation
Simply cut open the wire of a cheap pair of earphones to gain control of its terminals and attach alligator pins by soldering or any other hack(jugaad) that you can think of. After you are done with the tinkering of the earphone jack, it should look something like shown in the image below.
If your earphones had mic, it would have an extra wire for mic input. In any general pair of earphones the wire configuration is almost the same as shown in the image below.
Android APIs for Controlling Audio Hardware
AudioRecord and AudioTrack are the two classes in Android that manages recording and playback respectively. For Wave Generation application we only need AudioTrack class.
Creating an AudioTrack object: We need the following parameters to initialise an AudioTrack object.
STREAM TYPE: Type of stream like STREAM_SYSTEM, STREAM_MUSIC, STREAM_RING, etc. For wave generation purpose we are using stream music. Every stream has its own maximum and minimum volume level.
SAMPLING RATE: it is the rate at which source samples the audio signal.
BUFFER SIZE IN BYTES: total size in bytes of the internal buffer from where the audio data is read for playback.
MODES: There are two modes
MODE_STATIC: Audio data is transferred from Java to native layer only once before the audio starts playing.
MODE_STREAM: Audio data is streamed from Java to native layer as audio is being played.
getMinBufferSize() returns the estimated minimum buffer size required for an AudioTrack object to be created in the MODE_STREAM mode.
Function createBuffer() creates the audio buffer that is played using the audio track object i.e audio track object would write this buffer on playback stream. Function below fills random values in the buffer due to which a random signal is generated. If we want to generate some specific wave like Square Wave, Sine Wave, Triangular Wave, we have to fill the buffer accordingly.
publicshort[] createBuffer(int frequency) {// generating a random buffer for nowshort[] buffer = newshort[minTrackBufferSize];for (int i = 0; i < minTrackBufferSize; i++) { buffer[i] = (short) (random.nextInt(32767) + (-32768)); }return buffer;}
We created a write() method and passed the audio buffer created in above step as an argument to the method. This method writes audio buffer into audio stream for playback.
Amplitude of the signal can be controlled by changing the volume level of the stream on which the buffer is being played. As we are playing the audio in music stream, so STREAM_MUSIC is passed as a parameter to the setStreamVolume() method.
value: value is amplitude level of the stream. Every stream has its different amplitude levels. getStreamMaxVolume(STREAM_TYPE) method is used to find the maximum valid amplitude level of any stream. flag:this stackoverflow post explain all the flags of the AudioManager class.
We are working on implementing methods to fill audio buffer with specific values such that waves like Sinusoidal wave, Square Wave, Sawtooth Wave can be generated during the playback of the buffer using the AudioTrack object.