Wednesday, May 23, 2018

Building an RGB LED Display Part 1

In video series we build a scalable RGB LED Display or matrix and control it with Arduino. In part 1 we take a close look at the magic of the WS2812B RGB IC and Arduino options for controlling a large display of them.



//***************Arduino Code from Video*************************************
/* This Arduino sketch was made for a tutorial entitled "Building a Fun and Scalable RGB LED Display Part 1" for the ForceTronics YouTube Channel
 *  This sketch was leveraged from an example with the Adafruit NeoPixel library.This sketch was used to compare performance of an Arduino UNO versus 
 *  the Altrium Sno FPGA based Arduino for controlling the ADafruit NeoMatrix. This sketch randomly changes each pixel's brightness and color in a timed
 *  loop.
 *  This code is free for others to use and modify at their own risk
 */

#include <Adafruit_NeoPixel.h> //uncomment this library when using an AVR based Arduino
//#include <XLR8NeoPixel.h> //uncomment this library when using the SNO

// Defines single pin to control NeoMatrix from Arduino
#define PIN            6

//defines number of pixels in the NeoMatrix that was used
#define NUMPIXELS      64

// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use
//We can also set the comm speed and settings related to the how the NeoMatrix is configured
//For more information on how to use arguments for this function go to: https://learn.adafruit.com/adafruit-neopixel-uberguide/neomatrix-library
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); //decomment this function if you are using an AVR based Arduino
//XLR8NeoPixel pixels = XLR8NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); //uncomment this function if you are using the SNO FPGA Arduino

int delayval = 10; // delay for 10 msec

void setup() {
  pixels.begin(); // This initializes the NeoPixel or XLR8NeoPixel library.
}

void loop() {

  // For a set of NeoPixels the first NeoPixel is 0, second is 1, all the way up to the count of pixels minus one.
  //This loops through all the pixels (1 to 64) and then starts back at 1
  for(int i=0;i<NUMPIXELS;i++){
    //This function sets the brightness of a pixel. Brightness can be 0 to 255. Using random() to generate psuedo random value between 0 and 255
    pixels.setBrightness(random(0,255));
    //This function sets the color scheme of an RGB LED, so values are red 0 to 255, green 0 to 255, blue 0 to 255.
    //'i' is the pixel number that is being set and the other arguments are the RGB values which are set using psuedo random values between 0 and 255
    pixels.setPixelColor(i, pixels.Color(random(0,255),random(0,255),random(0,255))); // Moderately bright green color.
    //This function updates the pixels
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
}

Monday, April 9, 2018

Ground Considerations for PCB Layout of Mixed Signal Designs Part 2

In this video series we look at considerations when laying out a ground plane on a PCB when working with a mixed signal designs. If you want to ensure you are making accurate noise free ADC measurements in your design this video series is a must watch.




Reference material:
Partitioning and Layout of a Mixed-Signal PCB http://www.hottconsultants.com/pdf_files/june2001pcd_mixedsignal.pdf

Grounding in mixed-signal systems demystified, Part 1 and 2
http://www.ti.com/lit/an/slyt499/slyt499.pdf
http://www.ti.com/lit/an/slyt512/slyt512.pdf

Tuesday, April 3, 2018

Ground Considerations for PCB Layout of Mixed Signal Designs Part 1

In this video we look at considerations when laying out a ground plane on a PCB when working with a mixed signal designs. If you want to ensure you are making accurate noise free ADC measurements in your design this video series is a must watch.



Partitioning and Layout of a Mixed-Signal PCB http://www.hottconsultants.com/pdf_files/june2001pcd_mixedsignal.pdf

Saturday, March 24, 2018

How to Calculate the Thermal Range of a Linear Regulator

In this video we look at how to determine whether an IC is going to work in a design from a thermal standpoint or is it going to get too hot and break / burn up. In the video we look at the popular LM317 Linear Regulator as an example.


Here is a link to the app note referenced in the video: http://www.ti.com/lit/an/spra953c/spra953c.pdf

Sunday, February 11, 2018

Converting an Arduino PWM Output to a DAC Output

In this video we look at how to convert a PWM output or signal to a analog or DAC signal.



To access the low pass filter tutorial mentioned in the video got to: https://youtu.be/gW5oF8vcYb8


//*************Arduino code from video***************************
/*This code was made for a vidoe tutorial on the ForceTronics YouTube Channel called
 * Converting an Arduino PWM Output to a DAC Output. This code is free to use and 
 * modify at your own risk
 */

uint8_t pVal = 127; //PWM value 
const float pi2 = 6.28; //Pie times 2, for building sinewave
const int samples = 100; //number of samples for Sinewave. This value also affects frequency
int WavSamples[samples]; //Array for storing sine wave points
int count = 0; //tracks where we are in sine wave array

void setup() {
// Serial.begin(115200); //for debugging
  pinMode(10, OUTPUT); //pin used for analog voltage value
  pinMode(4,OUTPUT); //pin used to fake PWM for sinewave
  setPwmFrequency(10,1); //function for setting PWM frequency
  analogWrite(10,127); //set duty cycle for PWM

  float in, out; //used for building sine wave
  
  for (int i=0;i<samples;i++) //loop to build sinewave
  {
    in = pi2*(1/(float)samples)*(float)i; //calculate value for sine function
    WavSamples[i] = (int)(sin(in)*127.5 + 127.5); //get sinewave value and store in array
   // Serial.println(WavSamples[i]); //for debugging
  }
}

void loop() {
  if(count > samples) count = 0; //reset the count once we are through array
  bitBangPWM(WavSamples[count],4); //function for turning sinewave into "fake" PWM signal
  count++; //increment position in array
}

//Function to bit bang a PWM signal (we are using it for the sinewave)
//input are PWM high value for one cycle and digital pin for Arduino
//period variable determines frequency along with number of signal samples
//For this example a period of 1000 (which is 1 millisecond) times 100 samples is 100 milli second period so 10Hz
void bitBangPWM(unsigned long on, int pin) {
  int period = 1000; //period in micro seconds
  on = map(on, 0, 255, 0, period); //map function that converts from 8 bits to range of period in micro sec
 // Serial.println(on); //debug check
  unsigned long start = micros(); //get current value of micro second timer as start time
  digitalWrite(pin,HIGH); //set digital pin to high
  while((start+on) > micros()); //wait for a time based on PWM duty cycle
  start = micros(); 
  digitalWrite(pin,LOW); //set digital pin to low
  while((start+(period - on)) > micros()); //wait for a time based on PWM duty cycle
}

/**
 * https://www.arduino.cc/en/Tutorial/SecretsOfArduinoPWM
 * Divides a given PWM pin frequency by a divisor.
 * 
 * The resulting frequency is equal to the base frequency divided by
 * the given divisor:
 *   - Base frequencies:
 *      o The base frequency for pins 3, 9, 10, and 11 is 31250 Hz.
 *      o The base frequency for pins 5 and 6 is 62500 Hz.
 *   - Divisors:
 *      o The divisors available on pins 5, 6, 9 and 10 are: 1, 8, 64,
 *        256, and 1024.
 *      o The divisors available on pins 3 and 11 are: 1, 8, 32, 64,
 *        128, 256, and 1024.
 * 
 * PWM frequencies are tied together in pairs of pins. If one in a
 * pair is changed, the other is also changed to match:
 *   - Pins 5 and 6 are paired on timer0
 *   - Pins 9 and 10 are paired on timer1
 *   - Pins 3 and 11 are paired on timer2
 * 
 * Note that this function will have side effects on anything else
 * that uses timers:
 *   - Changes on pins 3, 5, 6, or 11 may cause the delay() and
 *     millis() functions to stop working. Other timing-related
 *     functions may also be affected.
 *   - Changes on pins 9 or 10 will cause the Servo library to function
 *     incorrectly.
 * 
 * Thanks to macegr of the Arduino forums for his documentation of the
 * PWM frequency divisors. His post can be viewed at:
 *   http://forum.arduino.cc/index.php?topic=16612#msg121031
 */
void setPwmFrequency(int pin, int divisor) {
  byte mode;
  if(pin == 5 || pin == 6 || pin == 9 || pin == 10) {
    switch(divisor) {
      case 1: mode = 0x01; break;
      case 8: mode = 0x02; break;
      case 64: mode = 0x03; break;
      case 256: mode = 0x04; break;
      case 1024: mode = 0x05; break;
      default: return;
    }
    if(pin == 5 || pin == 6) {
      TCCR0B = TCCR0B & 0b11111000 | mode;
    } else {
      TCCR1B = TCCR1B & 0b11111000 | mode;
    }
  } else if(pin == 3 || pin == 11) {
    switch(divisor) {
      case 1: mode = 0x01; break;
      case 8: mode = 0x02; break;
      case 32: mode = 0x03; break;
      case 64: mode = 0x04; break;
      case 128: mode = 0x05; break;
      case 256: mode = 0x06; break;
      case 1024: mode = 0x07; break;
      default: return;
    }
    TCCR2B = TCCR2B & 0b11111000 | mode;
  }
}

Wednesday, January 31, 2018

Designing a Driver Circuit for a Bipolar Stepper Motor Part 2

In this video we design a low cost driver circuit for a four wire bipolar stepper motor using two H bridges.


Link to Eagle files on GitHub: https://github.com/ForceTronics/Bipolar_Stepper_Driver_Circuit/tree/master


Sunday, January 7, 2018

Getting Your First PCB Design Manufactured

In this video we go over how to take your PCB design from software and get it manufactured. We cover everything from PCB CAD software packages, to generating your Gerber files, and finish with understanding the different options PCB manufacturers offer.