2-Analog and Digital Interfaces (Code).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 2: Analog & Digital Interfaces\n",
    "\n",
    "### EECS 16B: Designing Information Devices and Systems II, Spring 2023\n",
    "\n",
    "Updated by Jessica Fan (2023)\n",
    "\n",
    "jessicafan@berkeley.edu\n",
    "\n",
    "Updated by Megan Zeng, Yi-Hsuan Shih, Steven Lu (2022)\n",
    "\n",
    "zengmegan@berkeley.edu, yihsuan@berkeley.edu, stevenl@berkeley.edu\n",
    "\n",
    "Updated by Yi-Hsuan Shih (2021)\n",
    "\n",
    "yihsuan@berkeley.edu\n",
    "\n",
    "Updated by Hossein Najafi (2021)\n",
    "\n",
    "Updated by Mia Mirkovic (2020)\n",
    "\n",
    "miamirkovic@berkeley.edu\n",
    "\n",
    "Updated by Rafael Calleja, Steven Lu (2020)\n",
    "\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='part0'></a>\n",
    "# <span style=\"color:navy\">Part 0: Introduction</span>\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Digital-to-Analog Converters (DACs) and Analog-to-Digital Converters (ADCs) are some of the most commonly used circuits today. They can be found in a wide variety of electronics, such as microcontrollers like the Arduino we use in class, computers, phones, thermostats, etc. This is because our computers and chips process information from the real world that must be stored digitally, while the information that we gather is itself an analog value. DACs and ADCs play a very important role in the electronics we use everyday, and in this lab, we will be exploring how to build our own simple DAC and ADC.\n",
    "\n",
    "## Materials:\n",
    "- [Lab note](https://eecs16b.org/lab/notes/lab_note2.pdf) \n",
    "\n",
    "Review the lab note for a technical review of the concepts covered in lab as well as theoretical connections. **You should read the lab notes before your lab section.** They will be helpful as a reference during section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pre-Lab\n",
    "\n",
    " Complete the pre-lab assignment before attempting to do the lab. For all students, submit your answers to the Gradescope assignment \"[Pre-Lab 2: Analog and Digital Interfaces](https://www.gradescope.com/courses/484565/assignments/2618244)\". Pre-Lab 2 is due on Sunday, February 5. No late submissions will be accepted.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lab Group Form\n",
    "\n",
    "Before you receive your Arduino, please fill out the [lab group form](http://eecs16b.org/lab-groups)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Help Request Form\n",
    "\n",
    "Use this [form](https://eecs16b.org/lab-help) to request help in your debugging / conceptual needs. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "* [Part 1: Digital to Analog Converters (DACs)](#part1)\n",
    "* [Part 2: Analog to Digital Converters (ADCs)](#part2)\n",
    "* [Part 3: S1XT33N&#8482; Car Assembly Instructions](#part3)\n",
    "* [Part 4: Checkoff](#part4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='part1'></a>\n",
    "# <span style=\"color:navy\">Part 1: Digital to Analog Converters (DACs)</span>\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A digital to analog converter (DAC) takes an $n$-bit binary input and converts it to an analog output voltage. The bits represent whether their corresponding voltage source is on (some reference voltage $V_{ref}$) or off (0V), where $V_{ref}$ is 5V for the Arduino.\n",
    "\n",
    "<img style=\"width: 400px\" src=\"imgs/lab2_r_2r.png\">\n",
    "\n",
    "### Materials\n",
    "- Arduino + USB cable\n",
    "- Jumper wires\n",
    "- 1 $k\\Omega$ Resistors (brown, black, red, gold). Grab 3, you'll need one more for later!\n",
    "- 2 $k\\Omega$ Resistors (red, black, red, gold). Grab 5, you'll need two more for later!\n",
    "- Breadboard\n",
    "- Oscilloscope probe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1. Build the 3-bit DAC\n",
    "\n",
    "Use the diagram below to build a 3-bit DAC using the $1 k\\Omega$ and $2 k\\Omega$ resistors for $R$ and $2R$, respectively. Use the jumper wires to connect the Arduino to the circuit. For example, `\"8\"` below tells you to connect that node on the breadboard to pin `8` on the Arduino. In this circuit, the Arduino will act as a signal generator.\n",
    "\n",
    "<img style=\"width: 400px\" src=\"imgs/lab2_r_2r_pins.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2. Run the 3-bit DAC\n",
    "\n",
    "- Open the file `dac.ino` in the Arduino IDE and skim the code.\n",
    "    - **What do you expect the output of the DAC to be?** This understanding is **vital** to the debugging process: _if you don't know what you're looking for, how can you know if your result is correct or not?_\n",
    "- Connect the Arduino to the computer through the USB cable. Make sure that the selected board under _Tools > Board_ is \"Arduino Leonardo\" and that the selected port under _Tools > Port_ is the port with \"(Arduino Leonardo)\" at the end of the port name. If this port does not work for uploading, try other available ports.\n",
    "- Upload the code to your Arduino by pressing the upload button (the right pointing arrow) and make sure the terminal says \"success\".\n",
    "- The code sets pins 8, 12, 13 to output an increasing and decreasing binary number, where pin 13 is the least significant bit (LSB). Connect these pins to the inputs $V_2, V_1,$ and $V_0$ of your DAC.\n",
    "- Use an oscilloscope to probe $V_{out}$ to make sure your DAC behaves correctly. Adjust the time axis on the oscilloscope to show 100ms per division. \n",
    "- **<span style=\"color:#ba190f\"> Make sure to connect the ground of your Arduino with the ground of your circuit!**\n",
    "- <span style=\"color:#ba190f\"> **Press the `RESET` button on your Arduino.**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3. Build and run the 4-bit DAC\n",
    "- **Modify both your circuit and the Arduino code** to extend the 3-bit DAC to 4 bits. \n",
    "    - **You should use pin `7` for the new most significant bit (MSB). Keep probing the output of the DAC with an oscilloscope**.\n",
    "    - All you have to do to the code is change `BITS` to 4.\n",
    "    - Add one R-2R stage on the side of $V_{out}$ of your 3-bit DAC circuit.\n",
    "- Repeat the steps in 1.2 for the 4-bit DAC."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='part2'></a>\n",
    "# <span style=\"color:navy\">Part 2: Analog to Digital Converters (ADCs)</span>\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An N-bit Analog to Digital Converter (ADC) converts a given analog input into an N-bit binary number in the digital domain. One commonly used circuit architecture for ADCs is the Successive Approximation Register ADC (SAR ADC), which is what we'll be using today.\n",
    "\n",
    "The SAR ADC algorithm uses a DAC to generate voltages and compares them to an analog input voltage. It then uses feedback to adjust the DAC voltage to get as close as possible to the analog voltage.\n",
    "\n",
    "### Materials\n",
    "- Arduino + USB cable\n",
    "- 1 $k\\Omega$ resistors (already included in your 4-bit DAC)\n",
    "- 2 $k\\Omega$ resistors (already included in your 4-bit DAC)\n",
    "- LMC6482 Op-amp\n",
    "- Breadboard\n",
    "- Oscilloscope & probe\n",
    "- Banana alligators for the power supply"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1. Build the ADC\n",
    "\n",
    "While we've already written the code for the ADC, you'll still need to make some changes to your circuit. Specifically, you will need to build the part that compares the output of the DAC to the analog input from the 6V channel of the power supply and feeds the result of the comparison back to pin `A1` on the Arduino (Hint: it's the comparator).\n",
    "\n",
    "Here's a block diagram for the ADC that demonstrates what you need to at a high level. Use it to build the circuit. The specific implementation is up to you.\n",
    "\n",
    "The pinout of the LMC6482 op-amp in your lab kit is given as reference. The Arduino uses 5V pin logic (HIGH: 5V, Low: GND) for its input `A1` and output `7`, `8`, `12` and `13`. _What should $V_{dd}$ and $V_{ss}$ be for this op-amp?_ **Use the +25V channel for powering the op-amp and the 6V channel for the analog input. Set the current on both channels to 0.1A.** Make sure the resulting power outputs are in different nodes!\n",
    "\n",
    "**You've already built the 4-bit DAC, so just build the rest of the ADC around that.**\n",
    "\n",
    "<img style=\"width: 400px\" src=\"imgs/lab2_adc.png\">\n",
    "<img style=\"width: 400px\" src=\"imgs/op_amp_pinout.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. Run the ADC\n",
    "\n",
    "- Open the file `sar_adc.ino` and skim the code. It reads from pin `A1` and outputs the approximated result in pins `7`, `8`, `12`, `13` with pin `13` as the LSB.\n",
    "- Use 5V for all power supplies. Introducing higher voltages in the circuit risks damaging the Arduino. Use the +25V channel of the power supply to power the op-amp. **<span style=\"color:#ba190f\"> Do not use the 3.3V or 5V pin on the Arduino.**\n",
    "- Use the 6V channel as the input voltage (which ranges from 0V to 5V).\n",
    "- Probe the output of the DAC using the oscilloscope. Adjust the time axis on the oscilloscope to show 100us per division. \n",
    "- **<span style=\"color:#ba190f\"> Press the `RESET` button on your Arduino after uploading the code.**\n",
    "\n",
    "Your oscilloscope should show something like this. Should your signal look exactly like this? Think about why the signal steps up and down when it does, and why it converges to this specific voltage (~1.5V). How does this translate to the binary representation of the signal?\n",
    "\n",
    "<center>\n",
    "<img style=\"width:600px\" src=\"imgs/adc_oscope_1.5.jpg\"/>\n",
    "</center>\n",
    "\n",
    "In the image above, the input to the SAR ADC with $V_{ref}=5V$ is $1.6V$. Looking at one cycle enclosed in red, the first large voltage jump on the oscilloscope screen marks the beginning of the ADC conversion, which corresponds to the MSB being set. Setting the MSB causes our DAC output to be $\\frac{5V}{2} = 2.5V$. Since this is greater than our input of $1.6V$, the MSB bit is set back to 0. \n",
    "\n",
    "In each phase, the SAR ADC attempts to set the next most significant bit. Then, the latest bit gets set to the correct value (either 0 or 1), depending on the comparator's output. As seen in the Measurements on the right side of the oscilloscope, we settle at $1.5625V$, which is the closest the we can get to our input of $1.6V$ with this algorithm. This is equivalent to $0*(\\frac{5V}{2})+1*(\\frac{5V}{4})+0*(\\frac{5V}{8})+1*(\\frac{5V}{16})$. Think about which bits are turned on, based on what you see.\n",
    "\n",
    "Try seeing if your ADC output for different voltages makes sense according to what the SAR ADC algorithm does!\n",
    "- Does the output make sense given your input voltage? How does the output change when the input increases/decreases?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#075a04\">Set the input voltage to a value between 2.9V and 3.1V. What is the binary output of the ADC (i.e. enter it as \"XXXX\" without the quotations where X is either 0 or 1)? Describe the output signal you see on the oscilloscope. </span>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1001"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#075a04\">If we want to build a 4-bit ADC with a sampling frequency of 1.5kHz (read the input voltage 1500 times per second), what is the minimum clock frequency the ADC has to run at assuming it takes one clock cycle to set each bit in the ADC's register?</span>**\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6khz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Take a look at page 3 of the [datasheet](https://www.ti.com/lit/ds/symlink/tlc7524.pdf?HQS=TI-null-null-mousermode-df-pf-null-wwe&ts=1592345736692&ref_url=https%253A%252F%252Fwww.mouser.com%252F) for the TLC7524 8-bit DAC**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#075a04\"> Look at the table of recommended operating conditions. Could we use this DAC with the Arduino pins as the inputs? Why or why not?</span>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you could"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#075a04\">With an 8 bit DAC, we can make a more precise ADC than the 4 bit ADC we made in this lab. By adding more bits we can represent the input voltage more accurately, increasing our precision by a factor of 2 for every bit we add. If this is the case, should we just keep adding bits into our DAC and ADC to get finer and finer precision? Why or why not?</span>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "depends on the purpose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='part3'></a>\n",
    "# <span style=\"color:navy\">Part 3: S1XT33N&#8482; Car Assembly Instructions</span>\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Car Assembly\n",
    "\n",
    "If you haven't already, assemble your car before Lab 3 (Motion). See the Checkoff section below for more details!\n",
    "\n",
    "[Assembly Instructions](https://drive.google.com/file/d/13Mokqk5kPcWg4J2nQpU-MfoXxFHDuTuW/view?usp=sharing)\n",
    "\n",
    "[Assembly Video Guide](https://youtu.be/P16ziUDR3GQ)\n",
    "    \n",
    "### **DO NOT try to remove the wheels once you attach them to the axles.** \n",
    "### NOTE: The video says to scrape the inside of the wheels if you're having trouble attaching them. Be careful not to scrape away too much, or the wheels may become too loose and not stay on the axle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='part4'></a>\n",
    "# <span style=\"color:#ba190f\">CHECKOFF</span>\n",
    "-----\n",
    "\n",
    "### Checkoff Form (https://eecs16b.org/lab-checkoff)\n",
    "\n",
    "### Save this notebook somewhere you can access! \n",
    "\n",
    "We recommend making a shared Google Drive with your lab partner, since GitHub can be annoying with Jupyter notebooks. You will **NOT** need this circuit for next week's lab, but it's good to start saving your Jupyter notebooks now so that you will always have access to your lab work.\n",
    "\n",
    "**The lab computers may be wiped at any moment, so it is very important to have backups.**\n",
    "\n",
    "\n",
    "### Great job finishing 16B Lab 2! \n",
    "### <span style=\"color:red\"> Make sure to assemble your car before Lab 3 (Motion), as you will not be able to complete Lab 3 without an assembled car. </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='part5'></a>\n",
    "# <span style=\"color:navy\">Part 5: Midterm Lab Report Questions</span>\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The midterm lab report tests your understanding of EECS 16B Labs 1-5, with an emphasis on conceptual and\n",
    "analytical understanding. It also allows you to look at these labs from a bigger picture and reflect on your design\n",
    "process and choices. We will release the lab report questions relevant to each lab at the bottom of the corresponding Jupyter notebook. All of the midterm lab report questions will be compiled together [here](https://edstem.org/us/courses/34924/discussion/2428391) and updated as new questions are released. The entire midterm lab report will be due on **Friday, 03/10**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions\n",
    "\n",
    "**Summary**\n",
    "\n",
    "- Give a summary in your own words of what you did in this lab. Possible details to include: overview of the lab’s objective, new components used, issues you encountered, etc. Details NOT to include: how you left your car at home, forgot to enable high-Z mode on your function generator, etc.\n",
    "\n",
    "**1. What is the SAR ADC algorithm? What are the steps it goes through in order to find the digital representation of its input analog voltage? Besides quantization error, what is a drawback/limitation of the ADC implementation in Lab 2?**\n",
    "\n",
    "\n",
    "**2. For the following question, answer parts a) and b) in terms of $V_{ref}$ (the reference voltage of the ADC). Assume we are using the same resistor values from lab. Please include all of your work.**\n",
    "- a. What is the maximum voltage achievable by an n-bit ADC? Give your answer in terms of n.\n",
    "- b. What is the minimum voltage achievable by an n-bit ADC? Give your answer in terms of n.\n",
    "- c. In reality, there are multiple factors, e.g. area, noise, sensitivity of the comparator, that set the limit of the highest resolution (number of bits) we can build. If the smallest Least Significant Bit (LSB, the step size of the DAC voltage in the voltage transfer curve in the lab note) we can have is 2.5 mV, what is the highest resolution (number of bits) we can achieve in the binary SAR ADC with 5V reference voltage? (Note that the step size is constant across codes in the ideal ADC. The answer should be an integer for which the LSB satisfies the constraint.)\n",
    "\n",
    "**3. Refer to the [datasheet](https://www.ti.com/lit/ds/symlink/tlc7524.pdf?HQS=TI-null-null-mousermode-df-pf-null-wwe&ts=1592345736692&ref_url=https%253A%252F%252Fwww.mouser.com%252F) for the TLC7524 8-bit DAC. Please include all of your work.**\n",
    "\n",
    "**Settling time** marks the time that passes between when the input is applied to a component and when the subsequent component output has stabilized (within some error bound). Classes such as CS 61C and EECS 151 will discuss settling time and related concepts in more detail.\n",
    "\n",
    "Let's say we want to build a SAR ADC using this resistor-ladder DAC and some microprocessor (i.e. the Arduino). We will assume for this question that there is no delay between the output of one component and the input of the next (e.g. there is no delay between the output of the DAC changing and the inverting input of the comparator changing). We will also assume that the acquisition time for the ADC to read the stable input analog voltage is negligible.\n",
    "\n",
    "Assume the settling time of the comparator is 200ns.\n",
    "    \n",
    "Assume that it takes 100ns for the microprocessor to look at the comparator output and set the bit off or keep it on. Now, the algorithm repeats for the next bit.\n",
    "\n",
    "- a. What is the worst-case time required to determine the final value of a single bit in the ADC's register? (**Hint**: find the settling time of the DAC.)\n",
    "- b. How long would it take in the worst case to see the final correct 8-bit ADC output? What is the maximum frequency at which we could sample the output voltage and still be absolutely certain that the value is correct?\n",
    "- c. At $V_{DD}=5V$, provide an upper bound for the total energy dissipation of the DAC for the worst-case time to see the final correct 8-bit ADC output. (**Hint**: find the specifications related to power.)\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.9"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}