Ruander.com

How to wire a Pull-Up or Pull-Down Resistor

2024-05-18T16:06:00.000-07:00

When a digital signal is not connected to either positive (+) or negative (-), the signal is said to be “floating”. Floating simply means that the signal is not connected to anything. This will result in giving false indications when connected to an input which is expecting either a positive or negative signal. To solve this problem, one can use a Pull-Up Resistor or a Pull-Down Resistor, depending on what is needed. The figure below shows the correct way to wire a Pull-Up or Pull-Down Resistor for an active Device or Sensor with an output signal.

In general, the pull-up or pull-down resistor should have a larger resistance than the logic circuit's impedance. A good rule of thumb is that you want a resistor value on the order of 10kΩ or higher. Personally, I have had to use Pull-up and Pull-Down resistors for my Arduino projects as well as for reading fan speed on fans which have a tachometer output.

To learn more about Pull-up or Pull-Down Resistors please visit these sites:

Unveiling the Secrets of Investing: Why You're Ready to Dive In Now

2024-03-03T16:55:00.000-08:00

As we journey through the maze of financial literacy, one lesson stands out: the art of investing. Picture this – you've mastered the art of saving pennies and living within your means, but what about putting those hard-earned dollars to work for you? That's where investing steps into the spotlight.

Let's rewind a bit. Growing up, I was all about pinching pennies and stashing cash in my piggy bank. But the world of investing? It seemed like a distant galaxy, reserved for the elite with overflowing bank accounts. Little did I know, the key ingredients for investing weren't just heaps of cash – they were money and time.

Now, here's the scoop: while you might not have stacks of cash lying around, you've got something even more valuable – time. Yep, time is your secret weapon in the world of investing. Starting early means your money has more time to grow and flourish, like planting seeds in a garden and watching them sprout into mighty oak trees. Here are some charts showing why starting early is important.

But hold up – there used to be a catch. Remember those pesky commissions? Yeah, they were like the gatekeepers to the investing world, demanding hefty tolls for each trade. Imagine trying to invest $10 but getting slapped with a $5 fee – talk about a buzzkill! But fear not, my friends, because the tides have turned. Commission-free investing is now the norm, thanks to platforms like Robinhood, Fidelity, and E*TRADE among many others.

And that's not all – say hello to fractional shares, the game-changer for budding investors everywhere! Got your eye on a pricey stock or ETF but only have a few bucks to spare? No problemo! With fractional shares, you can own a piece of the pie without breaking the bank. It's like buying a slice of your favorite pizza instead of the whole pie – affordable and oh-so-satisfying.

Now, let's talk about the elephant in the room – market knowledge. Sure, you might not have time to pore over financial reports and dissect market trends. But guess what? That's totally okay! You don't need to be a Wall Street wizard to make savvy investment decisions. Instead, focus on low-cost, diversified options like index funds and ETFs. They're like the Swiss Army knives of investing – versatile, reliable, and beginner-friendly. Take a look at VTI, great place to start.

In a nutshell, there's never been a better time to dip your toes into the world of investing, especially for young bucks. Time is on our side, and with just a few bucks, we can kickstart our investment journey. So go ahead, take the plunge – whether it's $1 or $100, the world of investing is yours for the taking. And the best part? You can set it and forget it, letting your money work its magic while you focus on the fun stuff. Cheers to a bright financial future!

Compound Interest Calculator with Contribution

2020-11-27T16:20:00.000-08:00

Albert Einstein is famously quoted for saying that "Compound interest is the 8th wonder of the world. He who understands it, earns it; he who doesn't, pays it". Thankfully none of us need to be Albert Einstein to understand the rather simple and yet powerful concept of Compound Interest. There are a lot of compound interest calculators out there. I particularly like the Compound Interest Calculator from Investor.gov. The main reason I like this calculator is that it allows you to include Monthly Contributions, which if you are a serious investor, should be part of your strategy. Let's take a look at how it works. First, you need to enter some general information such as starting amount, monthly contribution, length of time and estimated interest rate. For this example, I will use the numbers below:

Once you have entered the information above, all you need to do is click "CALCULATE" and the graph below will appear showing you how your account balance is expected to grow over time. Additionally, you can also get the data in table form. Another reason I like this particular calculator is because it is so simple and yet it provides you with very powerful option beyond monthly contributions such as interest rate variance and compounding frequency.

So, if you are looking for a compound interest calculator, give this one a try!

Why use a Design-of-Experiment (DOE) Matrix

2020-11-14T13:48:00.005-08:00

The word Design-of-Experiment, or DOE, has become very popular among engineers. However, often times this word is misused and misunderstood. The principles of DOE are based on the capabilities and limitations of the analysis tools that will be used to process the data and determine cause and effect. Sometimes proper DOE matrix are followed but adequate analysis is not performed. Other times, a proper DOE matrix is not followed but yet we try to use analysis methods that would have required a proper DOE matrix. Even more confusing is when we use the word DOE when neither a DOE matrix or analysis method was followed.

First, it is important to acknowledge that DOE results are intended to be analyzed using regression analysis and something called "response surface method" or RSM. These methods rely on using a proper DOE matrix to help with variable independence or orthogonality and statistical significance.

Let's take a look at the following example. Say you have 4 variables in a process (A, B, C and D) and you want to understand their impact in your process outcome. You conduct the following study where -1, 0, and 1 represent each variable min, middle, and max value:

You may be tempted to say that you have conducted a DOE. However, the table above has not followed any proper DOE matrix design. Even with the table above, it will be difficult to understand the effect of each variable (main effects) since some variables are strongly correlated. For example, let's take a look at the relationship between Parameter A and Parameter B:

Note from the graph above that the coefficient of determination, R^2, is quite high, indicating that Parameter A and Parameter B are confounded. When parameter A goes up, Parameter B also often goes up. It will be difficult for regression analysis to decouple the effect of parameter A vs. Parameter B. If you created a table of R^2 for all the variables, it will look like this (correlation table):

In the table above, you expect to have "1" along the diagonal, but you want to minimize the non-diagonal terms (ideally they would be zero). If you are a MATLAB user, you can use the function "corrplot(X)" to graphically obtain the table above or "corrcoef(X)" to get the table in a variable. Please note that MATLAB will plot R and not R^2. You can also use the DOE Diagnostic, Evaluate design option in JMP to do the same. Other programs like R and Python have similar functionality. Some programs plot R instead of R^2 but the essence of the message is the same.

The study matrix above also present troubles if there are significant variable interactions. For example, let's take a look at the correlation between Parameter A*C Interaction vs. and Parameter A*D Interaction:

Note that the interaction between Parameter A*C and Parameter A*D are also strongly correlated. It will be difficult for the statistical tools to tell the difference between these two interaction effects. The complete correlation table (these are R^2 Values) including 2-level interactions and square terms is shown below. By exploring the table below you will see that there is a lot of variable confounding in this study.

Ideally, if you have 4 parameters at 3 Levels, you would want to do a Full Factorial (FF) DOE which will result in 3^4 = 81 runs (#Levels^#Factors = # runs). If you did this, you would have perfect decoupling and the DOE would be perfectly orthogonal. The correlation matrix (now in absolute value of R) would look something like this with 1 along the diagonal and zero everywhere else. This design is ideal to find all the main effects and interactions as well as squared terms.

However, 81 runs is a lot of runs. You may perhaps be limited to a much smaller number of runs. Here is where you can choose some other DOE matrix designs such as a central composite design (CCD). A CCD design will look like this having a total of 26 runs.

The corresponding correlation plot will look like this. Note that only the square terms (X1^2, X2^2, X3^2, and X4^2) are confounded but not the first level interactions.

You may still be limited to a much smaller number of runs. After all, the original study only had 6 runs. Here is where one must understand the trade-offs and limitations of what you can do with such a small number of runs and large number of factors and levels. You can use something called D-optimal design to find the an optimal design with a constrain in the number of runs given that perhaps you are most interested in the main effects. For example, the table below is from a D-optimal design focusing around the main effects:

In the correlation matrix above one can see that the main effects have been decoupled as much as possible but some interactions are stilled coupled to main effects. This matrix was created to decouple the variables as much as possible given only 6 runs.

In summary:

1. Don't use the word DOE if you have not followed proper DOE matrix designs and/or used adequate regression modeling to evaluate your results for significant cause and effect

2. Do spend some time comparing DOE matrix design tables to understand the trade-off with number of runs and variable confounding and thus analysis capabilities

3. Be aware of the modeling limitations you may have (linear, second order, main effects, interactions, main effect second order, etc.)

4. Always use your engineering judgement when performing DOE studies. Follow statistical recommendations as long as they make engineering sense for your application

Monte Carlo Analysis: Right Triangle

2020-11-01T16:47:00.000-08:00

Here is a very simple problem. Assume you want to build a right triangle of known base (10) and height (3) dimension. However, the sigma tolerance of these dimensions are 1% of its value. Your goal is to find the variability that you will obtain for the dimension of the hypotenuse and the largest of the two complementary angles. It is straight forward to do some simple math to figure out the nominal value for the two variables of interest. This is shown in the figure below:

Note that the variables of interest are not linear with respect to the known variables. Therefore, it is not possible to simply add the variances of the two known dimensions. It is possible to use the principles of propagation of uncertainty to propagate the known variation through the non-linear equations. This exercise will be left to the reader. Here, I will show how you can quickly use my Excel Monte Carlo Workbook to solve this problem. First, download the free version of this workbook or if you wish, you can also purchase the non free version here. Set up the problem with 2 input variables of normal distribution with the given mean and sigma values. The inputs will look like this:

After setting up the problem, simply run a large enough number of simulations by entering the number of simulations in cell F6 and then click the "2. Simulate" bottom. I recommend running at least 500K simulations. For this example, I will run 1M simulations. After the simulation is completed, just type in the formula to compute the hypotenuse and the angle as shown in the first figure above. Drag this equation down for all the simulations performed.

Finally, simply compute the average and standard deviation for the variables of interest. The results are the following:

As mentioned earlier, if you follow the principles of uncertainty propagation using partial derivatives, you will arrive at this same result (Rule No. 5 here). This is shown in the table above under the Analytical column. Using the Monte Carlo Excel you can also visualize the distribution of these two variables.

I hope this example is useful to help identify other relevant applications where a Monte Carlo Analysis can help you understand variation of non-linear problems.

Monte Carlo: Roll 2 Dice

2020-06-20T13:00:00.000-07:00

Sometime ago I posted about the Sum of Two Dice. In that post, I explained the math behind it and I also performed a Monte Carlo Simulation in R. I would like to go back to this problem to show how my free Monte Carlo Simulation Excel file can be used in this situation.

Assuming a fair die, each die has six different possible output values (1, 2, 3, 4, 5, and 6) and the probability of any of these values should be equal (1/6). The probability function that describes this behavior is the uniform discrete probability function with a lower bound of 1 and an upper bound of 6. The reason that this is a discrete probability is that in between values that are not integers (such as 1.5) are not an option.

Using my Monte Carlo Simulation Excel file to simulate the sum of two dice is very straight forward. First, click "0. Reset" in the Simulator sheet to make sure you are starting with a fresh and clean sheet. Indicate that the number of inputs is 2 by typing this value in cell F5. Remember, each input will represent one die. Now, click on "1. Define Inputs" and select the Uniform_Discrete probability function for both inputs with 1 as the lower bound (parameter 1) and 6 as the upper bound (parameter 2). Leave the other parameters empty. Your Simulator sheet should look like this:

Now indicate the number of simulations to perform by typing the number of simulations in cell F6. For this example, I will perform 1 million simulations knowing that this large number of simulations will likely take some time to complete so I will have to be patient. It took ~30 mins in a very slow computer on battery. Note that if I would have done 100K simulations it would have only taken about 3 minutes (time is approximately linear with number of simulations). Faster computers will finish faster.

Once the simulation is completed, there are a couple of things to do. First, in the "Y=" column, you will want to type the equation which is basically the sum of die 1 and die 2. This should look like this:

First, let's explore the output of each die. My Monte Carlo Simulation Excel file automatically outputs a histogram of your X1 variable if you have excel 2016 or higher. However, for discrete outcomes, I like making my own using the Excel Function COUNTIF. Doing this I obtained very similar outputs for both X1 and X2. Below I show the output for X1. Note that the number of occurrences for each number is about 1/6 of the total as expected.

In the same way, we can plot the histogram of our Y= X1 + X2. Note that in accordance with my previous post, the number 7 occurred approximately 16.6667% of the time. It is pretty interesting how the sum of two variables that have a uniform discrete probability function results in an output variable with a discrete triangular distribution function.

Now that we have looked into the sum of 2 dice, how about the sum of 3 dice, or 7 dice? Can you use my Monte Carlo Simulation Excel file to do this with more than 2 dice?

Monte Carlo Simulation Excel

2020-05-30T15:28:00.000-07:00

If you are looking for a FREE excel calculator to perform Monte Carlo Simulations you have arrived at the right place. Just download my FREE Excel Monte Carlo Simulator and start doing Monte Carlo simulations right in your already familiar Excel Environment. I will provide a short intro below, but feel free to download my Excel Monte Carlo Simulator to get started right away.

If you are searching the Word Wide Web for “Monte Carlo Excel” you probably already know or have a general idea of how Monte Carlo Simulations work. The user typically has one or more variables with known probability distributions as well as a transfer function (basically an equation) to translate these input variables into the desired output variable. The goal in a Monte Carlo Simulation is to randomly retrieve a value for each of the input variables according to their probability distribution. Do this over and over multiple times (1k, 100k, 500k, 1 million times, and so on) and you can now understand what your output distribution (and statistics) will look like in the limit as the number of iterations go to infinity.

Monte Carlo Simulations can be performed in a number of different software tools including Python, R, MATLAB, JMP, and many more. However, from my engineering experience, there is a broad audience of Excel users who would like to do this right within the familiar excel environment and without the need to code. It is for this reason that I created my Free Excel Monte Carlo Simulator. This is a simple to use Excel Workbook where the user can perform Monte Carlo Simulations and use the results in any way they wish within Excel.

Disclaimer:

Every time a user runs a simulation using my Free Excel Monte Carlo Simulator, this website will open in their browser. I have done this to help support the development of tools just like this. However, if you would prefer for this not to occur, I have also included a for-purchase version here that will not open this website upon performing a simulation.

For Purchase:

https://gumroad.com/l/ZOzQL

Free:

https://onedrive.live.com/?id=B6BC22119A0A836B%21110&cid=B6BC22119A0A836B

Excel Gage R&R Macro

2019-10-14T18:46:00.001-07:00

A Gage R&R is a measurement system capability study whose purpose is to assess how much variation is associated with a measurement system and to compare it to the total process variation or tolerance. The gage variation is divided into two main groups: Repeatability and Reproducibility, thus the name Gage R&R. Repeatability is the variation obtained by the same person using the same instrument on the same product for repeated measurements (within operator). Reproducibility is the variation obtained due to differences in people who are taking the measurements (between operators). There are multiple software tools that would run a Gage R&R analysis including QuantumXL, Minitab, JMP, MATLAB, R, and many others. However, it has been my experience that often engineers do not feel comfortable with the results due to a lack of clarity on how the variance components were computed. While it is possible to perform a Gage R&R in a tool as simple as Excel using ANOVA, these calculations are numerous and tedious. It is for this reason that I created an Excel Gage R&R Macro, which does not only compute the variance components but also shows the math used to compute them within the excel file. These calculations can be used by engineers to get more familiar with the variance component calculations.

This link will take you to my personal one drive where you can download the file "Anova_GageR&R_Rev0"

Is VTSAX really cheaper on Mondays?

2018-10-11T19:34:00.001-07:00

On my last blog post I looked at which day of the week is better to buy VTSAX over time. On that post I showed that over the time period ranging from 11/13/2000 thru 10/5/2018, the median price difference between the daily price and the weekly average was the lowest on Monday. The plot showing this result is once again shared below

Box Plot for daily price difference from weekly average:

Since this post, I have received a few comments asking if the difference is “really real” meaning is this difference statistically significant? One way to answer this question is through hypothesis testing. For those asking a similar question, I decided to share my findings here: Looking at the price variation from the weekly average, the Kruskal-Wallis test rejects the null hypothesis that all days come from the same distribution at a 1% significance level. The Wilcoxon rank sum test also rejects the null hypothesis of equal medians at the 1% significance level between Monday and any other day except for Tuesday. So basically, I would say yes, this difference is statistically significant. Now, while these results help answer this question, I am more of a graphical person. Therefore, I decided to plot the 95% confidence intervals for the median daily price deviation from weekly average. This plot is shown below with blue circles indicating the Median Value and Red Circles indicading the +/- 95% Confidence Intervals (CI). Once again, since the Monday CI does not overlap with the CI of any of the other days except Tuesday, I would say that this difference is significant. Even with Tuesday, the tails of the CI are just barely overlaping.

+/- 95% Confidence Intervals for Median Daily Price Difference:

By the way, I have decided the use the median and not the mean here since there are a number of outliers in the data, as seen on the box plot above. The median value would be less affected by these points.

Best Day of the Week to Buy VTSAX

2018-10-07T18:13:00.001-07:00

If you are into low cost index investing, you have probably heard and are buying the Vanguard Total Stock Market Index Fund, particularly VTSAX. One of the great tools that Vanguard offers is free recurring automatic investment. Using this tool, one can automatically buy VTSAX at any desired frequency such as weekly, bi-weekly, monthly and so on. Just let Vanguard know the day of the week you want to purchase and the frequency. This particular process led me to ask the following question: Which day of the week is the best day to buy VTSAX? Assuming we define the best day to buy as the day of the week on which the VTSAX closing price is lowest, we can take a look at past data to answer this question. To do this, I downloaded the VTSAX price history from 11/13/2000 up to 10/5/2018 from Yahoo Finance. Using this historical dataset, I looked at 1) the closing price distribution per day of the week and 2) the price difference between the daily closing price and the weekly average price per day of the week. Using this data, one can easily see (plots are shown below) that Monday is the day of the week with the lowest median closing price as well as the largest negative closing price difference from weekly average. This result may or may not come as a surprise since on average, the market always goes up. Therefore, one would expect the Monday closing price to be, on average, lower than the Friday closing price. However, it is great to be able to confirm this using past price data. In addition to looking at the data over the time period mentioned above, I also took a look at the data over the last ~5 years. The results are the same and indicate that if you are doing recurring automatic investment, you probably want to buy on Mondays. Please feel free to take a look at the results below.

Here are the plots for the entire time period:

Here are the plots for the last ~5 years starting in Jan 2013:

Disclaimer: All investments involve risk. Past performance doesn’t guarantee future results. Use the material contained here at your own risk.

RainCloud Matlab Source: https://git.fmrib.ox.ac.uk/marshall/public/tree/master/raincloud_plots

Remembering DOE Resolution

2018-09-12T20:35:00.001-07:00

Engineering often relies on Design of Experiments (DOE) to effectively understand significant dependencies of different input or control parameters to a desire measurable outcome. It is critical to properly design your experiments in a way that maximizes your ability to distinguish between the impact or contribution that each input variable has on your outcome. Different types of DOE designs have different resolutions. As stated here, a DOE resolution describes the degree to which main effects are confounded with 2-level interactions, 3-level interactions and so on. For example, in a resolution III design main effects are confounded with 2-level interactions. Ideally, we would like to have the highest resolution possible DOE. Full factorial designs have no confounding and thus are considered resolution “infinity”. However, having full factorial designs is often not possible due to the very large number of runs required. As a result, I often end up working with different resolution DOEs and often I need to remember which factors are confounded. For this, I always use a hand trick that was thought to me during my Design for Lean Six Sigma Training. I wanted to share this hand trick for those looking to remember this. However, rather than explaining it, I put together the following picture:

The nice thing about this trick is that it also holds true when you are dealing with say resolution VI or greater DOE. For DOE resolutions higher than V, just use your two hands, and work with the number of fingers equal to the DOE resolution as indicated above.

ME Software Flow Chart

2018-07-25T18:33:00.001-07:00

Engineers solve problems every day. I have been practicing the Mechanical Engineering profession for over 10 years and every day I solve problems. Every big problem can be broken down in small bits, which become a problem to solve on their own. Like in any profession, one very important step to solve a problem is to find the right tool to get the job done in the most effective and efficient way. In the digital age, most of these tool that I am talking about end up being some type of computer software. I often find myself mentally evaluating different software packages against the details of the problem at hand. For this reason, I have tried here to provide a decision tree style flow chart to illustrate the typical thinking process used by many mechanical engineers to choose the right software for the job.

Access your Raspberry Pi from Anywhere

2016-07-08T22:45:00.001-07:00

The Raspberry Pi is such a small, versatile, and cost-effective computer that it has found several uses in multiple applications. The Raspberry Pi’s ability to interact with the physical world through its GPIO makes it the perfect computer for Makers and DIY projects. For these reasons, it is not uncommon to have several Raspberry Pi computers located in different geographical areas performing a variety of tasks. Therefore, there is naturally a need, especially for IoT applications, to securely access the Raspberry Pi over the internet from anywhere and any time. A very effective method that I have been now reliably using for a couple of months is a FREE service provided by Weaved. I first came across this option on raspberrypi.org and I learned more on weaved.com. The installation process was simple. I installed the SSH service as well as the VNC service. On my PC at home, I use PuTTY to access my Raspberry Pi using SSH. For the VNC service, which allows me to interact with the Raspberry Pi’s GUI, I use TightVNC which works great. A great thing about SSH is that it allows you to use FileZilla for file management and transfer. I have been using the FileZilla software to transfer images taken by a USB camera connected to the Raspberry Pi.

Once you have completed the installation process described here or here, you should be able to login to Weaved and see your services online:

I strongly recommend that you change your Raspberry Pi password to something other than the default password for increased security.

If you select the SSH service, you will be given the following information:

And the information for VNC acces looks like this:

More information on using Weaved with PuTTY and FileZilla can be found HERE. My next IoT project using the Raspberry Pi will most likely involve the use of WebIOPi which can also be accessed using Weaved.

How much does it cost to charge a cell phone or Tesla vehicle?

2016-05-15T12:48:00.001-07:00

Have you ever wondered how much money does it cost to charge a cell phone or perhaps a Tesla vehicle? The first step to answer this question is to know how much you pay for electricity. This website from the Nebraska Goverment gives us an idea of the average cost of electricity per state, in cents per KiloWatt-hour. The next step is to find out the capacity of the battery for the device of interest.

The battery capacity for an Iphone 6 is about 6.9 Watt-hour, and about 9.8 Watt-hour for a Samsung Galaxy S6. For these calculations we will need to make a couple of assumptions and approximations. I decided to include a 95% efficiency in the charging process and also decided that my device will be charged 1.5 times per day, 365 days per year. It turns out that it costs about 50 cents per year to charge a cell phone. Overall, I was surprised how relatively inexpensive it is to charge a cell phone given everything that a cell phone does for us these days.

The battery capacity of a Tesla vehicle ranges from 70 KiloWatt-hour to 90 KiloWatt-hour (about 10,000x larger than your phone). The average range of a Model S is about 240 miles, battery-only. On average, a vehicle is driven 12,000 miles per year, which would be equivalent to charging your Tesla 0.137 times per day (about once every 7 days). Using a 95% charging efficiency and 365 days per year, it costs about $440 per year to charge a Tesla Model S. I do not own a Tesla yet, but I will do some approximations to relate this number to the cost of driving a gasoline vehicle. An average of 12K miles per year is equivalent to 27.3 miles/$ for Tesla. My current 4 cylinder 2.0L car gets about 30 MPG. Currently, gas is about $2.5/gallon (May 2016). Therefore, my 4 cylinder 2.0L car costs 12 miles/$ or 2.3x the price of Tesla for the same distance.

For reference, here are the numbers for the cost to charge per year:

CELL PHONE:

TESLA:

Driven Cavity Flow Results

2016-02-22T20:29:00.001-08:00

A few days ago I wrote about the Driven Cavity Flow Problem. Since then, I decided to re-solve the problem with a 100² grid size and with a more strick residual tolerance of 10^-6. Three days later and with nearly 700,000 iterations, the residuals had tapered off nearly to the target. I had to stop the code because I needed the computer for other work. However, here are the results I obtained:

For the velocity vectors, I am plotting every third data point to make it easier to see. The background color is a countour of the pressure field.

Driven Cavity Flow

2016-02-18T21:23:00.001-08:00

In graduate school I took several courses on Computational Fluid Dynamics (CFD). During one of these courses, a classmate and I worked together to model a driven cavity flow. Driven cavity flows appear quite often in our regular lives. For example, driven cavity flows are often encountered in transportation such as a convertible car, or when an airplane is about to deploy the landing gear. In 2-D, a driven cavity flow can be simplified as the following:

To solve this flow problem numerically, we assumed steady state flow, no body forces, no source terms, and constant fluid properties. The mass and momentum equations governing the flow are the following:

To discretize the domain, we used a staggered grid configuration and the equations were solved iteratively using the Semi-Implicit Method for Pressure Linked Equations (SIMPLE algorithm) with Upwind Differencing Scheme (UDS).

Visually, the velocity boundary conditions can be represented as follows:

We found that it was quite difficult and computationally expensive to converge a solution. Small relaxation factors seemed to aid in the convergence process. Nevertheless, we sucessfully converged a solution with the relatively low Re=100 with 2 different grid sized.

This is an example of the residuals as a function of iteration number:

clear
clc
close all

%% Constants
rho=1; % kg/m^3
mu=1e-5; % N/m-s
% Geometery
M=10; % Square Grid Size
N=M;
dx=.001/N; % meters, square cavity with side of 1
dy=dx; % meters
% Convergence
alpha_p=.001; % Pressure under-relaxtion
alpha_u=.02; % u-momentum under-relaxation
alpha_v=.02; % v-momentum under-relaxation
max_iter=200000; % maximum number of iterations
max_res=1e-6; % Maximum Residual
inner_iter=1; % Number of iterations before velocity is updated
% Parameters
Dn=mu*dx/dy;Ds=Dn;
De=mu*dy/dx;Dw=De;

% Boundary Conditions
P_free=10; % Pascals
u_free=1; % meters/second
Re=rho*.001*u_free/mu;

%% Creating the variables (initial guesses)
% Starred velocities
u_s=zeros(M+2,N+1); % m/s
u_s(1,:)=u_free*ones(1,N+1);
u_s(2:end-1,2:end-1)=u_free*ones(size(u_s)-2);
u_s=(rot90(u_s,3)); % rotating to get i corresponding
% to an x column and j to a y row
v_s=zeros(M+1,N+2); % m/s
v_s(2:end-1,2:end-1)=u_free*ones(size(v_s)-2);
v_s=(rot90(v_s,3)); % rotating to get i corresponding
% %% Load Previous Velocity Solution
% load('10_square_sol.mat','v')
% XI=linspace(0,11,M+1);
% YI=linspace(0,12,N+2);
% [XI YI]=meshgrid(XI,YI);
% X=1:11;
% Y=1:12;
% [X Y]=meshgrid(X,Y);
% v_s = interp2(X,Y,v,XI,YI);
% clear v
% %% Load Previous Pressure Solution
% load('10_square_sol.mat','u')
% XI=linspace(0,12,M+2);
% YI=linspace(0,11,N+1);
% [XI YI]=meshgrid(XI,YI);
% X=1:12;
% Y=1:11;
% [X Y]=meshgrid(X,Y);
% u_s = interp2(X,Y,u,XI,YI);
% clear u

% to an x column and j to a y row
% Old Velocities
u_o=1*u_s; % m/s
v_o=1*v_s; % m/s
% New Velocities
u=u_s; % m/s
apm_u=zeros(size(u)); % The u momentum :a" coefficient matrix
v=v_s; % m/s
apm_v=zeros(size(v)); % The v momentum "a" coefficient matrix
% Acutal Pressure
x=linspace(0,1,M);
y=x;
[x y]=meshgrid(x,y);
z=1./((x-1).^2+(y).^2+.5);
P=P_free*z; % Pascals
P=(rot90(P,3)); % Pascals, rotating to get i corresponding
% to an x column and j to a y row
% Starred Pressure
% %% Load Previous Pressure Solution
% load('10_square_sol.mat','P')
% XI=linspace(0,10,N);
% YI=linspace(0,10,M);
% [XI YI]=meshgrid(XI,YI);
% X=1:10;
% Y=X;
% [X Y]=meshgrid(X,Y);
% P = interp2(X,Y,P,XI,YI);
P_s=P; % Pascals
% Old Pressure
P_o=P; % Pascals
% Pressure Correction
P_p=zeros(size(P)); % Pascals

%% Initiating the Simple Algorithm Infinite Loop
% Begin the while loop
count=0;
residual=zeros(3,max_iter);

while 1
    count=count+1; % Counting the iterations
    disp(count)
    for k=1:inner_iter
    %% Solving starred momentum equations
%     u=u+.5*exp(-0.05*count);
%     v=v+5*exp(-0.1*count);
%     P=P+50*exp(-count);
    % u-momentum
    for i=2:size(u,1)-1
        for j=2:size(u,2)-1

            % Computing the face fluxes:
            Fe=rho*dy/2*(u_o(i+1,j)+u_o(i,j)); Fw=rho*dy/2*(u_o(i,j)+u_o(i-1,j));
            Fn=rho*dx/2*(v_o(i,j)+v_o(i+1,j)); Fs=rho*dx/2*(v_o(i,j-1)+v_o(i+1,j-1));

            % Computing the "a" coefficients:
            ae=De-min(0,Fe); aw=Dw+max(0,Fw);
            an=Dn-min(0,Fn); as=Ds+max(0,Fs);
            apm_u(i,j)=ae+aw+an+as+(Fe-Fw+Fn-Fs);

            u_s(i,j)=1/apm_u(i,j)*(ae*u_s(i+1,j)+aw*u_s(i-1,j)... % x-direction
                +an*u_s(i,j+1)+as*u_s(i,j-1)...% y-direction
                -dy*(P_s(i,j-1)-P_s(i-1,j-1))); % Pressure term

        end % the j loop
    end % the i loop

    % v-momentum
    for i=2:size(v,1)-1
        for j=2:size(v,2)-1

            % Computing the face fluxes:
            Fe=rho*dy/2*(u_o(i,j+1)+u_o(i,j)); Fw=rho*dy/2*(u_o(i-1,j+1)+u_o(i-1,j));
            Fn=rho*dx/2*(v_o(i,j+1)+v_o(i,j)); Fs=rho*dx/2*(v_o(i,j)+v_o(i,j-1));

            % Computing the "a" coefficients:
            ae=De-min(0,Fe); aw=Dw+max(0,Fw);
            an=Dn-min(0,Fn); as=Ds+max(0,Fs);
            apm_v(i,j)=ae+aw+an+as+(Fe-Fw+Fn-Fs);

            v_s(i,j)=1/apm_v(i,j)*(ae*v_s(i+1,j)+aw*v_s(i-1,j)... % x-direction
                +an*v_s(i,j+1)+as*v_s(i,j-1)...% y-direction
                -dx*(P_s(i-1,j)-P_s(i-1,j-1))); % Pressure term


        end % the j loop
    end % the I loop

    %% Enforcing conservation of mass on the top boundary
%     v_s(2:end-1,end)=v_s(2:end-1,end-1);
    %     for i=2:N+1
%         u_s(i,M+2)=u_s(i-1,M+2)+v_s(i,M+1);
%     end

%% Solving the pressure correction equations

    % Pressure correction loop
    for I=1:N
        for J=1:M
           if I==1 && J==1
               % Bottom left corner
               ae=rho*dy^2/apm_u(I+1,J+1); aw=0;
               an=rho*dx^2/apm_v(I+1,J+1); as=0;
               ap=ae+aw+an+as;
               b=rho*(dy*u_s(I,J+1)-dy*u_s(I+1,J+1)+dx*v_s(I+1,J)-dx*v_s(I+1,J+1));
               P_p(I,J)=1/ap*(ae*P_p(I+1,J)+an*P_p(I,J+1)+b);
           elseif I==1 && J~=1 && J~=M
               % Left wall
               ae=rho*dy^2/apm_u(I+1,J+1); aw=0;
               an=rho*dx^2/apm_v(I+1,J+1); as=rho*dx^2/apm_v(I+1,J);
               ap=ae+aw+an+as;
               b=rho*(dy*u_s(I,J+1)-dy*u_s(I+1,J+1)+dx*v_s(I+1,J)-dx*v_s(I+1,J+1));
               P_p(I,J)=1/ap*(ae*P_p(I+1,J)+an*P_p(I,J+1)+as*P_p(I,J-1)+b);
           elseif J==1 && I~=1 && I~=N
               % Bottom wall
               ae=rho*dy^2/apm_u(I+1,J+1); aw=rho*dy^2/apm_u(I,J+1);
               an=rho*dx^2/apm_v(I+1,J+1); as=0;
               ap=ae+aw+an+as;
               b=rho*(dy*u_s(I,J+1)-dy*u_s(I+1,J+1)+dx*v_s(I+1,J)-dx*v_s(I+1,J+1));
               P_p(I,J)=1/ap*(ae*P_p(I+1,J)+aw*P_p(I-1,J)+an*P_p(I,J+1)+b);
           elseif I==N && J==1
               % Bottom right corner
               ae=0; aw=rho*dy^2/apm_u(I,J+1);
               an=rho*dx^2/apm_v(I+1,J+1); as=0;
               ap=ae+aw+an+as;
               b=rho*(dy*u_s(I,J+1)-dy*u_s(I+1,J+1)+dx*v_s(I+1,J)-dx*v_s(I+1,J+1));
               P_p(I,J)=1/ap*(aw*P_p(I-1,J)+an*P_p(I,J+1)+b);
           elseif I==N && J~=1 && J~=M
               % Right wall
               ae=0; aw=rho*dy^2/apm_u(I,J+1);
               an=rho*dx^2/apm_v(I+1,J+1); as=rho*dx^2/apm_v(I+1,J);
               ap=ae+aw+an+as;
               b=rho*(dy*u_s(I,J+1)-dy*u_s(I+1,J+1)+dx*v_s(I+1,J)-dx*v_s(I+1,J+1));
               P_p(I,J)=1/ap*(aw*P_p(I-1,J)+an*P_p(I,J+1)+as*P_p(I,J-1)+b);
           elseif I==1 && J==M
               % Top Left
               ae=rho*dy^2/apm_u(I+1,J+1); aw=0;
               an=0; as=rho*dx^2/apm_v(I+1,J);
               ap=ae+aw+an+as;
               b=rho*(dy*u_s(I,J+1)-dy*u_s(I+1,J+1)+dx*v_s(I+1,J)-dx*v_s(I+1,J+1));
               P_p(I,J)=1/ap*(ae*P_p(I+1,J)+as*P_p(I,J-1)+b);
           elseif I==N && J==M
               % Top Right
               ae=0; aw=rho*dy^2/apm_u(I,J+1);
               an=0; as=rho*dx^2/apm_v(I+1,J);
               ap=ae+aw+an+as;
               b=rho*(dy*u_s(I,J+1)-dy*u_s(I+1,J+1)+dx*v_s(I+1,J)-dx*v_s(I+1,J+1));
               P_p(I,J)=1/ap*(aw*P_p(I-1,J)+as*P_p(I,J-1)+b);
           elseif I~=N && I~=1 && J==M
               % Top Row
               ae=rho*dy^2/apm_u(I+1,J+1); aw=rho*dy^2/apm_u(I,J+1);
               an=0; as=rho*dx^2/apm_v(I+1,J);
               ap=ae+aw+an+as;
               b=rho*(dy*u_s(I,J+1)+dx*v_s(I+1,J)-dx*v_s(I+1,J+1));
               P_p(I,J)=1/ap*(ae*P_p(I+1,J)+aw*P_p(I-1,J)+as*P_p(I,J-1)+b);
           else
               % Interior nodes
               ae=rho*dy^2/apm_u(I+1,J+1); aw=rho*dy^2/apm_u(I,J+1);
               an=rho*dx^2/apm_v(I+1,J+1); as=rho*dx^2/apm_v(I+1,J);
               ap=ae+aw+an+as;
               b=rho*(dy*u_s(I,J+1)-dy*u_s(I+1,J+1)+dx*v_s(I+1,J)-dx*v_s(I+1,J+1));
               P_p(I,J)=1/ap*(ae*P_p(I+1,J)+aw*P_p(I-1,J)+an*P_p(I,J+1)+as*P_p(I,J-1)+b);

            end % the conditional boundary node statement
        end % the J loop
    end % the I loop

    %% Correcting the pressure and velocities
    P=P_s+alpha_p*P_p; % Relaxed Pressure

    % u-correction
    for i=2:size(u,1)-1
        for j=2:size(u,2)-1
            u(i,j)=u_s(i,j)+dy/apm_u(i,j)*(P_p(i-1,j-1)-P_p(i,j-1));
        end
    end
    % v-correction
    for i=2:size(v,1)-1
        for j=2:size(v,2)-1
            v(i,j)=v_s(i,j)+dx/apm_v(i,j)*(P_p(i-1,j-1)-P_p(i-1,j));
        end
    end
    %% Enforcing conservation of mass on the top boundary
%     v(2:end-1,end)=v(2:end-1,end-1);

    %% Relaxing the velocities
    % Similar equations to "solving the starred momentum", only the starred
    % quantities are the new guesses (both velocity and pressure)

    % u-momentum
    for i=2:size(u,1)-1
        for j=2:size(u,2)-1

            % Computing the face fluxes:
            Fe=rho*dy/2*(u_o(i+1,j)+u_o(i,j)); Fw=rho*dy/2*(u_o(i,j)+u_o(i-1,j));
            Fn=rho*dx/2*(v_o(i,j)+v_o(i+1,j)); Fs=rho*dx/2*(v_o(i,j-1)+v_o(i+1,j-1));

            % Computing the "a" coefficients:
            ae=De-min(0,Fe); aw=Dw+max(0,Fw);
            an=Dn-min(0,Fn); as=Ds+max(0,Fs);
            ap=ae+aw+an+as+(Fe-Fw+Fn-Fs);

            u(i,j)=alpha_u/ap*(ae*u(i+1,j)+aw*u(i-1,j)... % x-direction
                +an*u(i,j+1)+as*u(i,j-1)...% y-direction
                -dy*(P(i,j-1)-P(i-1,j-1)))+(1-alpha_u)*u_o(i,j); % Pressure term

        end % the j loop
    end % the i loop

    % v-momentum
    for i=2:size(v,1)-1
        for j=2:size(v,2)-1

            % Computing the face fluxes:
            Fe=rho*dy/2*(u_o(i,j+1)+u_o(i,j)); Fw=rho*dy/2*(u_o(i-1,j+1)+u_o(i-1,j));
            Fn=rho*dx/2*(v_o(i,j+1)+v_o(i,j)); Fs=rho*dx/2*(v_o(i,j)+v_o(i,j-1));

            % Computing the "a" coefficients:
            ae=De-min(0,Fe); aw=Dw+max(0,Fw);
            an=Dn-min(0,Fn); as=Ds+max(0,Fs);
            ap=ae+aw+an+as+(Fe-Fw+Fn-Fs);

            v(i,j)=alpha_v/ap*(ae*v(i+1,j)+aw*v(i-1,j)... % x-direction
                +an*v(i,j+1)+as*v(i,j-1)...% y-direction
                -dx*(P(i-1,j)-P(i-1,j-1)))+(1-alpha_v)*v_o(i,j); % Pressure term

        end % the j loop
    end % the I loop
     %% Enforcing conservation of mass on the top boundary
%         v(2:end-1,end)=v(2:end-1,end-1);
    %     for i=2:N+1
%         u(i,M+2)=u(i-1,M+2)+v(i,M+1);
%     end
    end % the inner iterations
    %% Checking for convergence
    if sum(isnan(u(:)))+sum(isnan(v(:)))+sum(isnan(P(:)))>=1
        disp('Error: Solution has diverged');
        break % End the simple algorithm
    end
    if count>max_iter
        disp('Maximum number of iterations has been reached')
        break % End the simple algorithm
    end
    if max(abs(u_o(:)-u(:)))<max_res && max(abs(v_o(:)-v(:)))<max_res && max(abs((P_o(:)-P(:))./P_o(:)))<10*max_res
        disp('Success: Solution has converged');
        break % End the simple algorithm
    else % Plotting the residuals
        residual(1,count)=max(abs(u_o(:)-u(:)));
        residual(2,count)=max(abs(v_o(:)-v(:)));
        residual(3,count)=max(abs((P_o(:)-P(:))./P_o(:)));
        figure(1)
        plot(1:count,residual(1,1:count),'r-','linewidth',1.5);hold on % u-mom
        plot(1:count,residual(2,1:count),'g-','linewidth',1.5); % v-mom
        plot(1:count,residual(3,1:count),'b-','linewidth',1.5); % Pressure
        plot(1:count,max_res*ones(1,count),'k--','linewidth',1.5);hold off
        %         legend('u-momentum','v-momentum','Pressure','Maximum
        %         Residual')
        xlabel('Iterations','fontsize',16)
        ylabel('Residual','fontsize',16)
        set(gca,'fontsize',16,'yscale','log');
        set(gcf,'color','white')
        drawnow
        figure(2)
        pcolor(P);shading interp;drawnow
        pause(0.01)
    end
    %% Re-initiating old values
    % Since the algorithm did not converge, the new values are now the old
    % values
    u_s=u;
    v_s=v;
    P_s=P;
    u_o=u;
    v_o=v;
    P_o=P;
end

%% Plotting Results
x=linspace(0,1,N+1);
y=x;
[x y]=meshgrid(x,y);
figure,quiver(x,y,u(:,2:end)',v(2:end,:)',2,'k');hold on
xlabel('x','fontsize',16);
ylabel('y','fontsize',16);
set(gca,'fontsize',16);
x=linspace(0,1,N);
y=x;
[x y]=meshgrid(x,y);
pcolor(x,y,P');shading interp
pco=get(gca,'children');
set(pco(1),'facealpha',.5);
xlabel('x','fontsize',16);
ylabel('y','fontsize',16);
set(gca,'fontsize',16);
colorbar
% figure,surf(u);shading interp
% figure,surf(v);shading interp

Arduino Control System

2016-01-10T14:09:00.001-08:00

Here is the Problem:

My parents live in Costa Rica and they have their own water system. The water system consists of a handmade well for the water supply and an elevated tank for storage. A pump is used to bring the water from the well to the storage tank. There is an overflow pipe at the top of the tank which leaks water out to indicate that the tank is full. Unfortunately, the amount of water in the well is limited. The pump can only run for about 22 minutes in the rainy season and for 12 minutes in the dry season before the well runs out of water. After the well runs out, it takes two hours for the water in the well to be replenished.

My family has managed this system by physically walking to the water management site, and manually activating the pump as often as every 2 hours, then waiting until the well runs dry to turn off the pump. As you can image, this is a very tedious and inconvenient process. The need to keep the tank full is constant and the frequency at which the pump needs to be turned on increases with increasing water demands. On a positive note, despite the inconvenience, this method has served my family for about 15 years.

Here are a couple of pictures of the water management site:

Here is a schematic representation of the water system:

Here is the Solution:

After considering many options to provide my family with a more convenient solution to manage the water system, I selected the following method: I programmed an Arduino Uno to control the system autonomously. The water pump is 220VAC. I used two 220VAC 25A rated solid state relays to turn on and off the pump through a +5VDC signal from the Arduino. The relays were properly mounted on heat sinks using thermal paste to maintain adequate heat dissipation. A digital liquid level sensor powered by the Arduino was installed on the overflow pipe of the tank. This sensor will tell the Arduino when the tank is full. The Arduino will constantly turn on the pump for 10 minutes every two hours year-round. When the water sensor tells the Arduino that the tank is full, the Arduino will turn off the pump and wait for two hours before turning on the pump again. I also installed a manual switch which, when activated, overrides the system and forces the pump to be on. I installed two indicator LEDs. One turns on when the pump is on and the other indicates that the water level sensor has been activated. The system has been successfully working for four weeks now.

Here is a picture of inside the Arduino control box:

Here is a picture of the installed control box and relays which adapts to the current electrical system control set up:

The feedback sensor at the end of the overflow pipe:

The schematic of the control system is as follows:

The control system design was influenced by the previous electrical wiring and water pipes, as well as the contraints that come with tropical environments. Were the system to fail, the set up is such that it can easily be returned to the previous method with minimum effort.

Part List:

Micro-Controller: Arduino Uno (QTY: 1)

Liquid Level Sensor: Optomax Series Digital Range LLT600D3SH (QTY: 1)

Solid State Relays: Crydom D2425 (QTY: 2)

Heat Sinks (QTY: 2)

Enclosure box (QTY: 1)

Prototype Printed Circuit Board (QTY: 1)

Dsub9 connector (QTY: 1)

9V Power Supply (QTY: 1)

Indicator LEDs (QTY: 2)

Resistors 320 ohms (QTY: 2)

ON-OFF Switch (QTY: 1)

Electrical Wire Assorted Colors (~20AWG)

Screw terminal blocks (QTY: 2)

Heat shrinks Assorted Sizes

Fastening Screws Assorted Sizes

*Code:

/*============================================================================================

==============================================================================================

Costa Rica Water Tank / Water Well Management

Fully Autonomous with Switch Option

Created by Ruander Cardenas

Last Updated on: 12/19/2015

==============================================================================================

=============================================================================================*/

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++ USER INPUTS +++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//Define Pins to be Used

#define pinSensor 12 // Water Sensor: Not using 13 due to onboard LED circuit

#define pinRelay1 11 // Relay No. 1 signal

#define pinRelay2 10 // Relay No. 2 signal

#define pinLED1 9 // Pump On or Off status LED

#define pinLED2 8 // Sensor Air or Water LED

#define pinButton 7 // Manual on and off switch

//Define Constants

const unsigned long ontime = 600000; // Units of millisecons: (min)x(s/min)x(ms/s)=ms (10 mins --> 600000 ms)

const unsigned long offtime = 7200000; // (10/60/60)(60)(60)*(1000); //Units of millisecons:(hr)x(min/hr)x(s/min)x(ms/s)=ms (2.5 hrs --> 9000000 ms)

const int t_inc = 250; // Milliseconds to wait inside the loop

// Define Variables

int sensorState; // Variable for tank full (LOW) or not full (HIGH)

int buttonState; // Variable for manual switch: ON (LOW) or OFF (HIGH)

unsigned long t_on = 0; // Variable for time pump has been on. Assumes pump has not been on

unsigned long t_off = offtime; // Variable for time pump has been off. Assumes pump has been off for atleast offtime limit

unsigned long ti; // Time at the start of the loop

unsigned long tf; // Time at the end of the loop

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void setup() {

// put your setup code here, to run once:

pinMode(pinSensor, INPUT);

pinMode(pinButton, INPUT_PULLUP);

pinMode(pinRelay1, OUTPUT);

pinMode(pinRelay2, OUTPUT);

pinMode(pinLED1, OUTPUT);

pinMode(pinLED2, OUTPUT);

// Initialize Serial for debugging purposes

//Serial.begin (9600);

}

void loop() {

// put your main code here, to run repeatedly:

ti=micros();

sensorState = digitalRead(pinSensor);

buttonState = digitalRead(pinButton);

if (sensorState == LOW) { //Turn on LED2 to indicate tank is full

digitalWrite(pinLED2,HIGH);

t_off=0; //Reset off time to zero (prevents jerking on and off pump)

}

if (sensorState == HIGH) { //Turn off LED2 to indicate tank is not full

digitalWrite(pinLED2,LOW);

}

if (buttonState == LOW) { on2(); //Pump on

} else {

if (t_off < offtime) {off(); //Pump off while water in well replenishes

} else {

if (sensorState == LOW) {off(); //Pump off since tank is full

} else {

if (t_on < ontime) { on(); //Pump on

}

if (t_on > ontime) { off(); //Pump off

}

delay(t_inc);

tf=micros();

//Serial Commands for debugging Purposes

//Serial.print("On Time = ");

//Serial.println(t_on);

//Serial.print("Off Time = ");

//Serial.println(t_off);

}

//=================================================================================

void on(){

digitalWrite(pinRelay1,HIGH);

digitalWrite(pinRelay2,HIGH);

digitalWrite(pinLED1,HIGH);

t_on = t_on + t_inc;

if(t_on > ontime - t_inc){ t_off=0; //Reset off time to zero

}

//=================================================================================

void off(){

digitalWrite(pinRelay1,LOW);

digitalWrite(pinRelay2,LOW);

digitalWrite(pinLED1,LOW);

t_off = t_off + t_inc;

if(t_off > offtime - t_inc){ t_on=0; //Reset on time to zero

}

//=================================================================================

void on2(){

digitalWrite(pinRelay1,HIGH);

digitalWrite(pinRelay2,HIGH);

digitalWrite(pinLED1,HIGH);

t_off = 0; //Assumes well needs a full braek after manual switch

t_on = ontime; // Assmes pump was manually turned on for the max time

}

*Please note that the timing of the code is based on a 250ms delay. Therefore, times are approximations and not exact (code takes around 48 us to run without delay). For my applications, this is just fine. I did an error approximation test and my expected times are off by about 1.5 seconds every 2 hours. I did look into timing rollover and variable overflow (http://playground.arduino.cc/Code/TimingRollover) but decided to go with the delay option since for my application, this was simpler and adequate.

Send your name to Mars, Again

2015-08-20T21:30:00.001-07:00

NASA is giving an opportunity again to send your name to Mars. This time will be on NASA’s InSight lander. All you need to do is go to this site (click here) and enter your information. The launch is scheduled for March, 2016! With your submission you get a Boarding Pass similar to mine shown below. Make sure to invite your friends to participate and check out the world participation map to see all the countries represented.

NI CompactDAQ and CompactRIO

2015-07-05T18:50:00.000-07:00

National Instruments (NI) is a familiar name in many engineering fields. I first became aware of this company during my undergraduate engineering studies at Oregon State University where we used their LabVIEW software and data acquisition hardware to collect and analyze engineering data in several instrumentation and laboratory courses. This was the beginning of a long term relationship as I would continue to use their software and hardware to instrument both my experimental Master's and Doctorate theses as well as other automation and data collection task in my current industry engineering position. I recently attended a one day free (yes, free) NI hands-on seminar using their CompactDAQ and CompactRIO hardware and I must say I was pretty happy with this time investment. The CompactDAQ section was very familiar as I have done a fair amount of this in the past. However, the CompactRIO was new and exciting. I enjoyed learning about the benefits of a Real Time operating system and programing FPGAs. I strongly encourage anyone interested in learning more about CompactDAQ and CompactRIO to take advantage of these opportunities. Get your hands "dirty" with NI software and hardware and you will get a feel for how it can help you work smarter and more efficiently.

CompactDAQ

CompactRIO

Franklin Chang’s Second Book

2015-03-15T13:38:00.001-07:00

On a prior post, I had already written about Franklin Chang’s First Book. I am now happy to say that the wait for the second book is over. Last week I received by mail the copy I purchased online.

Dr. Chang’s second book is titled “Dream’s Journey” and in contrast to his first book, his second book is in English. He tells us that he has decided to share his memories in the language in which they were lived.

I am looking forward to reading this book and I encourage all dreamers out there to pick up copy and read it. I have said it before; Dr. Franklin Chang Diaz has always been a hero of mine and he has inspired me in many stages of my life. Thank you Dr. Chang Diaz for sharing your memories with us.

Costa Rica from Space

2015-02-24T15:06:00.001-08:00

I typically enjoy looking at pictures of earth taken from space. I often hear from those who have had the opportunity to see earth from space that it is an incredible feeling.I could not agree more with the fact that we discovered earth when we flew into space. I would like to thank Dr. Franklin Chang Diaz @FranklinChangD for sharing this amazing picture of Costa Rica from space which he took in 1996. This is not only a great picture of my country but, I also appreciate that it was taken by a heroe of mine.

Arduino Servo Motor

2014-02-22T14:22:00.001-08:00

Finally had a chance to hook up a small servo motor to an Arduino Uno board and get it working. I bought these components with the goal of learning more about the operation of servo motors, particularly for motion control and automation purposes.

Instead of using the standard Arduino IDE software, I am running my Arduino using LabVIEW to take advantage and to further develop my skills with this software.

Initially, I was having trouble getting the servo motor working properly. After troubleshooting, I found that the power supplied to the Arduino through the USB cable was not enough to power both the board and the servo motor. As you can see in the first image above, I had to add an additional power source using a 9V battery.

FEZ Panda II

2013-11-10T14:34:00.001-08:00

For a few weeks now I have been learning how to program the FEZ panda II microcontroller. This microcontroller uses the .NET Micro Framework (.NET MF) which allows the user to program and debug code using Microsoft’s free Visual Studio Express through the C# language. The controller consist of a 72MHz, 32-bit ARM7 processor, 512 KB Flash and 96 KB RAM. The board has several digital and analog inputs and outputs some with Pulse-width modulation and serial port capabilities among several key features (more features here). Overall, this has been a great learning experience for me as I had never programmed microcontrollers in the past. It has been a little slow since I am not very experienced with the C# language and object oriented programming.

To continue to learn more about microcontrollers, I have recently purchase an Arduino Uno board. One of the reasons I purchased this board is that I should be able to program it using using LabVIEW and MATLAB which are languages that I am more experienced with. Here is a link to a great resource I found about microcontroller comparison. I have been tempted several times to buy a Raspberry Pi, but this would require learning yet another programming language (Python) which I may consider in the near future. Right now, I am trying to get more experience using microcontrollers for Control Systems Engineering.

Autumn Colors

2013-11-05T20:04:00.001-08:00

Leaves are typically green due to the high chlorophyll content. Chlorophyll captures sunlight and uses this energy to make simple sugars from which the plant feeds (photosynthesis). Chlorophyll is lost during this process and is continuously replenished by the plant. As summer days come to an end, the veins that carry the chlorophyll into the leaves gradually close and the hidden yellow and orange pigments are revealed. As a result, beautiful colored leaves, as the ones below, are observed at the beginning of fall.

Full Moon Thu Sep-19, 2013

2013-09-19T22:00:00.001-07:00

Here are a few shots of the moon on Thursday September 19, 2013 at around 9:35 pm. According to this website, the moon was 99% full at the time. The view was looking east from Wilsonville, OR.

Ruander.com

How to wire a Pull-Up or Pull-Down Resistor

Unveiling the Secrets of Investing: Why You're Ready to Dive In Now

Compound Interest Calculator with Contribution

Why use a Design-of-Experiment (DOE) Matrix

Monte Carlo Analysis: Right Triangle

Monte Carlo: Roll 2 Dice

Monte Carlo Simulation Excel

Excel Gage R&R Macro

Is VTSAX really cheaper on Mondays?

Best Day of the Week to Buy VTSAX

Remembering DOE Resolution

ME Software Flow Chart

Access your Raspberry Pi from Anywhere

How much does it cost to charge a cell phone or Tesla vehicle?

Driven Cavity Flow Results

Driven Cavity Flow

Arduino Control System

/*============================================================================================

==============================================================================================

==============================================================================================

Costa Rica Water Tank / Water Well Management

Fully Autonomous with Switch Option

Created by Ruander Cardenas

Last Updated on: 12/19/2015

==============================================================================================

==============================================================================================

=============================================================================================*/

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++ USER INPUTS +++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//Define Pins to be Used

#define pinSensor 12 // Water Sensor: Not using 13 due to onboard LED circuit

#define pinRelay1 11 // Relay No. 1 signal

#define pinRelay2 10 // Relay No. 2 signal

#define pinLED1 9 // Pump On or Off status LED

#define pinLED2 8 // Sensor Air or Water LED

#define pinButton 7 // Manual on and off switch

//Define Constants

const unsigned long ontime = 600000; // Units of millisecons: (min)x(s/min)x(ms/s)=ms (10 mins --> 600000 ms)

const unsigned long offtime = 7200000; // (10/60/60)*(60)*(60)*(1000); //Units of millisecons:(hr)x(min/hr)x(s/min)x(ms/s)=ms (2.5 hrs --> 9000000 ms)

const int t_inc = 250; // Milliseconds to wait inside the loop

// Define Variables

int sensorState; // Variable for tank full (LOW) or not full (HIGH)

int buttonState; // Variable for manual switch: ON (LOW) or OFF (HIGH)

unsigned long t_on = 0; // Variable for time pump has been on. Assumes pump has not been on

unsigned long t_off = offtime; // Variable for time pump has been off. Assumes pump has been off for atleast offtime limit

unsigned long ti; // Time at the start of the loop

unsigned long tf; // Time at the end of the loop

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void setup() {

// put your setup code here, to run once:

pinMode(pinSensor, INPUT);

pinMode(pinButton, INPUT_PULLUP);

pinMode(pinRelay1, OUTPUT);

pinMode(pinRelay2, OUTPUT);

pinMode(pinLED1, OUTPUT);

pinMode(pinLED2, OUTPUT);

// Initialize Serial for debugging purposes

//Serial.begin (9600);

}

void loop() {

// put your main code here, to run repeatedly:

ti=micros();

sensorState = digitalRead(pinSensor);

buttonState = digitalRead(pinButton);

if (sensorState == LOW) { //Turn on LED2 to indicate tank is full

digitalWrite(pinLED2,HIGH);

t_off=0; //Reset off time to zero (prevents jerking on and off pump)

}

if (sensorState == HIGH) { //Turn off LED2 to indicate tank is not full

digitalWrite(pinLED2,LOW);

}

if (buttonState == LOW) { on2(); //Pump on

} else {

if (t_off < offtime) {off(); //Pump off while water in well replenishes

} else {

if (sensorState == LOW) {off(); //Pump off since tank is full

const unsigned long offtime = 7200000; // (10/60/60)(60)(60)*(1000); //Units of millisecons:(hr)x(min/hr)x(s/min)x(ms/s)=ms (2.5 hrs --> 9000000 ms)