10.Output Devices

This week's brief: Group assignment:

probe an input device's analog levels and digital signals

Individual assignment:
Make and test a microcontroller development board that you designed

extra credit: make it with another processs

GROUP ASSIGNMENT
You can view our group assignment here!

INDIVIDUAL ASSIGNMENT

For this week i wanted to explore the output devices that would be required for my final project. The output devices i wanted to use this week are : led output that according to the codes, a led display for displaying the score and difficulty /volume . a buzzer for the sound effects. I wondered if i could make a modular version of a part of my final project to test out these features. So i started to design a 2x2 grid that will help me visualize how each device will act when put together. With the board that i made during the input devices week, i thought of incorporating that to control the output devices.

Understanding the Devices

Neopixel LEDs- WS2812B mini

NeoPixels are a brand of individually addressable RGB LEDs, meaning each LED can be controlled independently, allowing for a wide range of lighting patterns and effects.
When using a normal RGB Led we require 3 pins for each Led. Here is where Neopixel Leds come handy especially when handling multiple leds.
NeoPixels require only one data line for communication, making them easy to connect and control. Each light / section is controlled by an integrated circuit that processes the information and converts it into data to control the light, the data then passes to the next light / section, where LEDs are on at any given time.

PIN functions

I went on to choose WS2812B-Mini Led for my project as i wanted the size of the led to be smaller to be placed under the clicky switches.

Speaker

For this week i was instructed to use a AST0927MW-3.6Q electromagnetic transducer which is specifically designed for audio indication, with a resonant frequency of 2.73 kHz and a sound pressure level (SPL) of 85 dB. An electromechanical transducer is a type of device used to convert either an electrical signal into sound waves like in a loudspeaker or a device that converts a sound wave into an electrical signal like in a microphone. It basically converts mechanical motion into electric signals. Some electromechanical transducer examples are; a loudspeaker, a piezoelectric transducer, a microphone & permanent-magnet instrument's measuring mechanism.

Specifications of AST0927MW-3.6Q

LCD

16x2 LCD displays are widely used in various applications, including digital clocks, temperature and humidity displays, electronic voting machines, industrial automation, robotics, embedded systems, and more.

Working

At the core of the LCD is the Hitachi HD44780 controller chip. This chip takes care of generating the signals needed to drive the liquid crystals and managing the data displayed. The display works by controlling the liquid crystals to either block or allow light to pass through, creating characters and symbols on the screen.
Character LCDs are specifically designed for displaying characters. A 16x2 character LCD shows16 characters per line across two lines. You can see tiny rectangles for each character on the screen as well as the pixels that make up a character. Each of these rectangles is a grid of 5x8 pixels.
While reading through the data sheet i got to know that this LCD requires 16 pins out of which atleast 12 would be required to operate it. This led me to use the RP 2040 Raspberry Pi Pico microcontroller board as i had to connect a lot of pins from other devices as well.

Pin out Info :

After referring to some sites(which i have linked under references)about the connections i made this table to understand them easier.

(This chart below helped me understand the connection between VSS,Vo,Gnd and the potentiometer)

RP2040 Raspberry pi Pico

Raspberry Pi Pico is a low-cost, high-performance microcontroller board with flexible digital interfaces. This compact board offers versatility and functionality that allows users to build a variety of projects, from simple LED blink programs to sophisticated robotics. The Raspberry Pi Pico can be programmed in MicroPython and C/C++.

Specs

Dimensions: 21mm x51mm
CPU: Dual-core Arm Cortex-M0+ @ 133MHz
Memory: 264KB on-chip SRAM; 2MB on-board QSPI Flash
Interfacing: 26 GPIO pins, including 3 analogue inputs
Peripherals:
Input power: 1.8-5.5V DC

Pinout

Design

As i mentioned before i planned to make this board to be a small test replica to help me understand how to proceed with my final project. By doing so i believe i can analyse how certain things can be optimized while making the larger board. Since i am making the board according to an initial design i made for the final project, the devices had to be placed in certain fixed spots and i had to work around that. I had to keep in mind the positons and dimenstions of the clicky switches(Cherry MX) and the LCD while designing the PCB. I tried as much as possible to keep the board as compact as i could with the constarints. I also wanted this board to have the look and feel of an macro keypad.

I was told that i would only be able to use a single side PCB and this kind of made my task a little complex because i had to find a way to accomodate the through hole components along with the SMD components. The main issue was that the switches and the neopixel led had to be on the same side as the led was supposed to be placed right under the clicky switch. So after talking it out with my instructor , he suggested that we could make the pads of the LED into through holes and add a rivet , then solder the led on the side without the copper plate.

The next thing i did was to determine the exact position of where the led would be placed as the cherry MX switch already has an alloted space for the led. So i searched up to find a dimensional drawing of the switch, imported the svg into rhino3D and resized it properly to the actual dimension. I then looked up the dimensions of the LCD and placed it with the switches. I made it in a way so that if i get enough time i could make a case for the PCB too. These reference outlines were later exported into kiCad to place the footprints.

with Led in place

Making the PCB

I referred to some websites and video that would help me understand how to connect the LCD to the Raspberry Pi Pico microcontroller. Most of them used an I2C adapter to reduce the pins required. But i had to do it without using the adapter, for which only very few documentation was available. I will link the references at the end of this page.

I made an initial schematic of all the components . Later on i found out from my instructor that t he speaker has to have an n channel mosfet added along with it. The footprints of most of the components i had were not available in the existing library so i went to SnapEDA to find them. For the speaker though i couldnt find anything online so i had to edit the footprint of a buzzer that was already in the library and resize the pads by taking dimensimonal reference from the datasheet and resize the pads aand borders.

The schematic for this PCB

I had to edit the footprint of the Leds to make the SMD pads into through hole pads. You can do this by selecting the footprint>> right click and select footprint editor (shortcut: Ctrl+ E) >> double click the pad and a dialogue box appears where you can change the options as you need.

I had to keep in mind to that the footprints of the LCD, LEDs and the switches would be flipped (press 'F' to flip them) as they are on the other side.

It took a bit of time to route and had keep swapping and rearranging the pins as i couldn't move around the components due to the design. at one point i added two jumper resistors but took them out later because i could do the final arrangement without it. I was also able to reduce the size of the board a little bit more than what i thought. Overall the board looked compact with the constraints i set for myself. I can maybe find ways to make it even more modular later on while working on the final project.

To give an idea of how it is supposed to look like, here are the 3D images of the front and backside.

PCB Production

The gerber files are generated using Gerber2png

We got to use the 1/64'' endmill bit for the first time to make the traces. The milled out PCB looked like this: I acquired the components and started the soldering process.

As i mentioned before i had to make use of rivets for mounting the neopixel Leds.

The SMD components were soldered first along with the Raspberry Pi Pico. I had to tape the side of the pico as there were some pads that were exposed which are not supposed to touch the traces of my board. I also had to add a solder mask to one of my traces that was in contact with the potentiometer.

The Leds were soldered on to the rivets and the then the switches were placed on top of them. It fit perfectly.

The keypad with the screen.

Programming

I tested out example codes for each of the output devices to check if they are working properly.

Led

Using the example code available in Arduino IDE i ran a few codes to check whether all Leds are working. I had to install the Adafruit Neopixel Library to use the library operations.


  ```cpp
  // Simple demonstration on using an input device to trigger changes on your
  // NeoPixels. Wire a momentary push button to connect from ground to a
  // digital IO pin. When the button is pressed it will change to a new pixel
  // animation. Initial state has all pixels off -- press the button once to
  // start the first animation. As written, the button does not interrupt an
  // animation in-progress, it works only when idle.
  
  #include 
  #ifdef __AVR__
   #include  // Required for 16 MHz Adafruit Trinket
  #endif
  
  // Digital IO pin connected to the button. This will be driven with a
  // pull-up resistor so the switch pulls the pin to ground momentarily.
  // On a high -> low transition the button press logic will execute.
  #define BUTTON_PIN   26
  #define PIXEL_PIN    12  // Digital IO pin connected to the NeoPixels.
  
  #define PIXEL_COUNT 4  // Number of NeoPixels
  
  // Declare our NeoPixel strip object:
  Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
  // Argument 1 = Number of pixels in NeoPixel strip
  // Argument 2 = Arduino pin number (most are valid)
  // Argument 3 = Pixel type flags, add together as needed:
  //   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
  //   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
  //   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
  //   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
  //   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
  
  boolean oldState = HIGH;
  int     mode     = 0;    // Currently-active animation mode, 0-9
  
  void setup() {
    pinMode(BUTTON_PIN, INPUT_PULLUP);
    strip.begin(); // Initialize NeoPixel strip object (REQUIRED)
    strip.show();  // Initialize all pixels to 'off'
  }
  
  void loop() {
    // Get current button state.
    boolean newState = digitalRead(BUTTON_PIN);
  
    // Check if state changed from high to low (button press).
    if((newState == LOW) && (oldState == HIGH)) {
      // Short delay to debounce button.
      delay(20);
      // Check if button is still low after debounce.
      newState = digitalRead(BUTTON_PIN);
      if(newState == LOW) {      // Yes, still low
        if(++mode > 8) mode = 0; // Advance to next mode, wrap around after #8
        switch(mode) {           // Start the new animation...
          case 0:
            colorWipe(strip.Color(  0,   0,   0), 50);    // Black/off
            break;
          case 1:
            colorWipe(strip.Color(255,   0,   0), 50);    // Red
            break;
          case 2:
            colorWipe(strip.Color(  0, 255,   0), 50);    // Green
            break;
          case 3:
            colorWipe(strip.Color(  0,   0, 255), 50);    // Blue
            break;
          case 4:
            theaterChase(strip.Color(127, 127, 127), 50); // White
            break;
          case 5:
            theaterChase(strip.Color(127,   0,   0), 50); // Red
            break;
          case 6:
            theaterChase(strip.Color(  0,   0, 127), 50); // Blue
            break;
          case 7:
            rainbow(10);
            break;
          case 8:
            theaterChaseRainbow(50);
            break;
        }
      }
    }
  
    // Set the last-read button state to the old state.
    oldState = newState;
  }
  
  // Fill strip pixels one after another with a color. Strip is NOT cleared
  // first; anything there will be covered pixel by pixel. Pass in color
  // (as a single 'packed' 32-bit value, which you can get by calling
  // strip.Color(red, green, blue) as shown in the loop() function above),
  // and a delay time (in milliseconds) between pixels.
  void colorWipe(uint32_t color, int wait) {
    for(int i=0; i RGB
          strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
        }
        strip.show();                // Update strip with new contents
        delay(wait);                 // Pause for a moment
        firstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames
      }
    }
  }
  
  ```

Then i added a code to make the led operate when the switch is turned on

Speaker

I used an example code to on the speaker making it beep at intervals. I worked quite well .I would later need to mmake the buttons control the sound too.


  // Define the GPIO pin connected to the speaker
  const int speakerPin = 22
  ; // Or any other GPIO pin
  
  void setup() {
    // Set the speaker pin as an output
    pinMode(speakerPin, OUTPUT);
  }
  
  void loop() {
    // Generate a tone (e.g., 1000 Hz) for 1 second
    tone(speakerPin, 1000, 1000); // Frequency (Hz), Duration (ms)
    delay(1000); // Wait for 1 second
  
    // Stop the tone
    noTone(speakerPin);
    delay(1000); // Wait for 1 second
  }

LCD

The LCD was a little tricky to code and i found out a lot of connection errors while testing the code.Initially the code was not working at all which made me realise that i had switched the enable and read write pins with each other. We had initially thought the enable pin was supposed to be connected to the ground but turns out it required a GPIO pin and viceversa with the read write pin.

Luckily the tracks were easy to swap using copper wires.

We thought i would work now but again i made a major error. The data pins were supposed to start from the 14th pin instead i gave it from the 7th pin which made the LCD not register the 4 bit commands. Thankfully again the tracks i had made initially was close enoght to easliy rewire with the help of my instructor. We added a solder mask to prevent the wires from touching each other.


  #include 

    // initialize the library by associating any needed LCD interface pin
    // with the arduino pin number it is connected to
    const int rs = 6, en = 7, d4 = 8, d5 = 9, d6 = 11, d7 = 13;
    LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
    
    void setup() {
      // set up the LCD's number of columns and rows:
      lcd.begin(16, 2);
      // Print a message to the LCD.
      lcd.print("hello, world!");
      delay(1000);
    }
    
    void loop() {
      // scroll 13 positions (string length) to the left
      // to move it offscreen left:
      for (int positionCounter = 0; positionCounter < 13; positionCounter++) {
        // scroll one position left:
        lcd.scrollDisplayLeft();
        // wait a bit:
        delay(150);
      }
    
      // scroll 29 positions (string length + display length) to the right
      // to move it offscreen right:
      for (int positionCounter = 0; positionCounter < 29; positionCounter++) {
        // scroll one position right:
        lcd.scrollDisplayRight();
        // wait a bit:
        delay(150);
      }
    
      // scroll 16 positions (display length + string length) to the left
      // to move it back to center:
      for (int positionCounter = 0; positionCounter < 16; positionCounter++) {
        // scroll one position left:
        lcd.scrollDisplayLeft();
        // wait a bit:
        delay(150);
      }
    
      // delay at the end of the full loop:
      delay(1000);
    
    }

Finally when we ran the code the display was working fine , BUT it was upside down (╥﹏╥).As my design involves fixing the lcd at a certain place i cant remove it and keep it separate. I did not know that the orientation was flipped before i designed the pcb. The LCDs that i refered to were of a slightly differnt model and the pins were flipped in that. So for anyone read please make sure to test the LCD once before fixing it in place.

The solution we found was to make anothe pcb just for the LCD with the pins and the tracks rotated. It cant be wired as there will be waay too many intersecting paths.

With Integrated Program

I tried to integrate the codes for the lights and the buzzer. I am still trying to figure out how to code the LCD.

    
    // Simple demonstration on using an input device to trigger changes on your
    // NeoPixels. Wire a momentary push button to connect from ground to a
    // digital IO pin. When the button is pressed it will change to a new pixel
    // animation. Initial state has all pixels off -- press the button once to
    // start the first animation. As written, the button does not interrupt an
    // animation in-progress, it works only when idle.
    
    #include 
    #ifdef __AVR__
     #include  // Required for 16 MHz Adafruit Trinket
    #endif
    
    // Digital IO pin connected to the button. This will be driven with a
    // pull-up resistor so the switch pulls the pin to ground momentarily.
    // On a high -> low transition the button press logic will execute.
    #define switch1   18
    #define switch2   26
    #define PIXEL_PIN    12 // Digital IO pin connected to the NeoPixels.
    
    #define PIXEL_COUNT 4  // Number of NeoPixels
    
    const int buzzerPin = 22;
    // Declare our NeoPixel strip object:
    Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
    // Argument 1 = Number of pixels in NeoPixel strip
    // Argument 2 = Arduino pin number (most are valid)
    // Argument 3 = Pixel type flags, add together as needed:
    //   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
    //   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
    //   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
    //   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
    //   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
    
    boolean oldState = HIGH;
    int     mode     = 0;    // Currently-active animation mode, 0-9
    int switchState = 0;
    void setup() {
      pinMode(switch1, INPUT_PULLUP);
     pinMode(switch2, INPUT_PULLUP);
      
      strip.begin(); // Initialize NeoPixel strip object (REQUIRED)
      strip.show();  // Initialize all pixels to 'off'
    }
    
    void loop() {
       switchState = digitalRead(switch1);
       if (switchState == HIGH) { // Assuming the switch is active when HIGH
        // Play a beep sound
        tone(buzzerPin, 2000, 20); // Play a 2000 Hz tone for 200 milliseconds
         }// Wait for 200 milliseconds
       else if (switchState == LOW)  { noTone(buzzerPin); // Stop the tone
      }// Get current button state.
      boolean newState = digitalRead(switch1);
    
      // Check if state changed from high to low (button press).
      if((newState == LOW) && (oldState == HIGH)) {
        // Short delay to debounce button.
        delay(20);
        // Check if button is still low after debounce.
        newState = digitalRead(switch1);
        if(newState == LOW) {      // Yes, still low
          if(++mode > 8) mode = 0; // Advance to next mode, wrap around after #8
          switch(mode) {           // Start the new animation...
            case 0:
              colorWipe(strip.Color(  0,   0,   0), 50);    // Black/off
              break;
            case 1:
              colorWipe(strip.Color(255,   0,   0), 50);    // Red
              break;
            case 2:
              colorWipe(strip.Color(  0, 255,   0), 50);    // Green
              break;
            case 3:
              colorWipe(strip.Color(  0,   0, 255), 50);    // Blue
              break;
            case 4:
              theaterChase(strip.Color(127, 127, 127), 50); // White
              break;
              case 5:
              colorWipe(strip.Color(  0,   0,   0), 50);    // Black/off
              break;
          }
        }
      }
    
      // Set the last-read button state to the old state.
      oldState = newState;
    
    
      boolean iState = digitalRead(switch2);
    
      // Check if state changed from high to low (button press).
      if((iState == LOW) && (oldState == HIGH)) {
        // Short delay to debounce button.
        delay(20);
        // Check if button is still low after debounce.
        iState = digitalRead(switch2);
        
        if(iState == LOW) {      // Yes, still low
          if(++mode > 8) mode = 0; // Advance to next mode, wrap around after #8
          switch(mode) {           // Start the new animation...
            case 0:
              colorWipe(strip.Color(  0,   0,   0), 50);    // Black/off
              break;
            case 1:
              colorWipe(strip.Color(255,   0,   0), 50);    // Red
              break;
            case 2:
              colorWipe(strip.Color(  0, 255,   0), 50);    // Green
              break;
            case 3:
              colorWipe(strip.Color(  0,   0, 255), 50);    // Blue
              break;
            case 4:
              theaterChase(strip.Color(127, 127, 127), 50); // White
              break;
              case 5:
              colorWipe(strip.Color(  0,   0,   0), 50);    // Black/off
              break;
          }
        }
      }
    
      // Set the last-read button state to the old state.
      oldState = newState;
    }
    
    // Fill strip pixels one after another with a color. Strip is NOT cleared
    // first; anything there will be covered pixel by pixel. Pass in color
    // (as a single 'packed' 32-bit value, which you can get by calling
    // strip.Color(red, green, blue) as shown in the loop() function above),
    // and a delay time (in milliseconds) between pixels.
    void colorWipe(uint32_t color, int wait) {
      for(int i=0; i

-->