Differences

This shows you the differences between two versions of the page.

--- haas:spring2019:unix:projects:spf1 [2019/04/16 15:36] – created wedge
+++ haas:spring2019:unix:projects:spf1 [2019/04/18 18:41] (current) – [Objective] wedge
@@ Line 10: / Line 10: @@
   * any bugfixes or project updates will be posted here
-=====Toolbox=====
-In addition to the tools you're already familiar with, it is recommended you check out the following tools for possible application in this project (you may not need to use them in your solution, but they definitely offer up functionality that some solutions can make use of):
-  * **basename(1)**
-  * **bc(1)**
-  * **cut(1)**
-  * **diff(1)**
-  * **grep(1)**
-  * **mktemp(1)**
-  * **sed(1)**
-  * **tr(1)**
-  * **wc(1)**
 =====Objective=====
@@ Line 30: / Line 18: @@
   * an initialization script
   * an incrementing 8-bit binary counter (0-255)
-  * a decreminting 8-bit binary counter (255-0)
+  * a decrementing 8-bit binary counter (255-0)
   * a strobing light sequence (back and forth)
@@ Line 56: / Line 44: @@
 <cli>
-lab46:~$ ssh pi@pi1b_0#
+lab46:~$ ssh pi@pi1b_0X
 </cli>
@@ Line 87: / Line 75: @@
 </cli>
-=====Process=====
+When using the **gpio** tool, we are specifically interested in the "wPi" columns.
-It is your task to write 2 scripts; one will be responsible for generating a file containing calculated digits of PI (and you must perform the calculations... no skimping on this), and the other will use that produced data to search through the digits of PI in order to find occurrences of patterns. Further details follow:
-====script1: pigen====
+====Assembly of LED circuits====
-You are to write a script, called and submitted by the name **pigen** (no extension, although it is to be a bash script, with proper shabang, comments, and solution).
+The eight LED circuits established on each pi are hooked into a unique GPIO (wiring pi numbers 0-7).
-By default, if you run the script by itself, it should calculate and produce (in a file in the current directory), a file by the name of **pi.100.out**, which will contain the first 100 digits of PI (lacking the period '.' that separates the 3 from the rest of the irrational number):
+When the pin is active (3.3V applied, the 'true' or 1 state), the LED will be lit up (turned ON).
-<cli>
+When the pin is inactive (0V applied, the 'false' or 0 state), the LED will be OFF.
-lab46:~/src/unix/spf0$ ./pigen
-lab46:~/src/unix/spf0$ ls
-pi.100.out  pigen
-lab46:~/src/unix/spf0$ cat pi.100.out
-3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067
-lab46:~/src/unix.spf0$
-</cli>
-If you provide a command-line argument, it must be a valid numeric value between 1 and 2000, and will calculate that many digits of PI, saving it in a file **pi.#.out**, where # is the number of digits requested.
+====Configuring GPIO pins for use with our LEDs====
+If you look in the table for wiringPi pins 0-7, you'll see under the "Mode" column that all the needed pins are set to IN or "input" mode (expecting to read data in).
-You also need to verify your results against the PI digit database on lab46 (do not copy this file... set a variable to it for easy access), and display the message "MISMATCH" if your calculated/processed results do NOT match the validated PI computation out to that indicated quantity of spaces.
+To utilize the LEDs, we need to instead OUTPUT from the pins.
-Additionally:
+A mode change is needed, which can be accomplished with the **gpio** command, **mode** parameter. It requires the wiringPi pin number (0-7), and the desire mode to set it to (in, out).
-  * Your script is to only produce a **pi.#.out** file in the current directory.
+To set wiringPi GPIO pin 0 for output mode, for instance, we'll want to do this:
-    * ANY temporary files need to be created in (and subsequently removed from) the **/tmp** directory, of a relatively unique name autogenerated by the **mktemp(1)** tool.
-====script2: pigrep====
-Your second script will be called **pigrep** (no extension, although it is to be a bash script, with proper shabang, comments, and solution), and will perform searches on a **pigen**-generated **pi.#.out** file for specified patterns (numerical substrings) within the generated digits.
-By default, if you run the script by itself, it should generate the following error (and exit with a non-zero value):
 <cli>
-lab46:~/src/unix/spf0$ ./pigrep
+pi@pi1b_0#:~ $ gpio mode 0 out
-ERROR: must specify PATTERN
-lab46:~/src/unix/spf0$
 </cli>
-It will have online usage information, displayed when the 'help' option is provided anywhere on the **pigrep** command-line:
+You may want to repeat (or loop) this for the remaining pins.
-<cli>
+====Writing to the GPIO pin====
-lab46:~/src/unix/spf0$ ./pigrep help
+To modify the state of the pin (it can be in a '0' or '1' state), we once again use the **gpio** command, with the **write** parameter. It requires the wiringPi pin number (0-7) and the state we wish it to become (0 is OFF, or 1 being ON).
- pigrep - search available pi digits via regex for matches;
+To write a 1 to wiringPi GPIO pin 0, we'll want to do this:
-          must be part of pipeline (send PI digits in via STDIN)
-   usage: pigrep [OPTION...] PATTERN
+<cli>
+pi@pi1b_0#:~ $ gpio write 0 1
-    note: if MAX variable is set, cap processing at that value
- options:
-  atend - calculations are based on last digit of match
- byline - output one value per line (default is space-separated)
-  drop3 - do not include leading 3 of pi (*3*14) in processing
- offset - determine offsets of matches (from start of digits)
-   help - display this help and exit
-lab46:~/src/unix/spf0$
 </cli>
-Your script should also take the following arguments (in this order):
+Similarly, to turn it back off again, we'll want to write a zero there:
-  * required argument:
-    * **PATTERN**: a string containing the numeric pattern you are looking for.
-      * for example: '76'
-  * optional arguments:
-    * **atend**: by default, offset calculations are based on the first (left-most) digit of the pattern; with this option, compute the offset based on the last (right-most) digit of the pattern
-      * **atend** is meant to be used in conjunction with **offset**, by itself it does not alter default processing
-    * **byline**: by default, matches are space-separated. With this option, display one match per line
-    * **drop3**: do not include the leading 3 of PI in processing
-    * **offset**: determine offsets of matches from start of digits
-    * **help**: display usage information
-You are also to check for the existence of a MAX variable, and if set to a valid, positive non-zero decimal (base 10) number, will cap the amount of results it processes / outputs.
-Numerical arguments are to be given as valid, positive non-zero decimal (base 10) values.
-With any of these arguments validly provided, they should adjust the script's processing and output accordingly.
-Also to keep in mind:
-  * Your script is not to produce any files as a result of operating.
-    * If your solution calls for ANY temporary files, they need to be created in (and subsequently removed from) the **/tmp** directory, and be of a relatively unique name autogenerated by the **mktemp(1)** tool.
-Some sample outputs follow:
-====Only specifying numeric pattern====
-In the event only a pattern is provided, search through the PI data for the provided pattern, displaying each match to STDOUT.
-For example:
 <cli>
-lab46:~/src/unix/spf0$ cat pi.120.out | ./pigrep '26'
+pi@pi1b_0#:~ $ gpio write 0 0
-26
-lab46:~/src/unix/spf0$
 </cli>
-====one result per line====
+You will want to perform similar actions on the other LED-wired pins to create the desired situations as required by this project.
-Using the **byline** option, instead of displaying results horizonally, they'll be displayed vertically (one result per line) to STDOUT.
+=====Process=====
+It is your task to write 4 scripts, specifications laid out as follows:
-<cli>
+====script1: initialization script====
-lab46:~/src/unix/spf0$ cat pi.120.out | ./pigrep '26' byline
+A useful bit of logic, appropriately setting the pin modes to OUTPUT and turning the pins to an OFF state is likely something your other scripts will want to call upon before they perform their intended tasks.
-lab46:~/src/unix/spf0$
-</cli>
-====compute offsets from start of digits====
+Therefore, you will start by writing a script you can run that establishes a sane operating environment for your LED manipulations.
-The **offset** argument will, instead of displaying the numeric matches (which, aside from counting are of dubious value) will display how many digits away from the start of the PI digits the pattern resides.
-<cli>
+This script should make use of a loop to perform its task (setting OUTPUT mode and WRITING a 0 state to the pin).
-lab46:~/src/unix/spf0$ cat pi.120.out | ./pigrep '26' offset
-22
-lab46:~/src/unix/spf0$
-</cli>
-With an example like this, we should easily be able to verify its correctness:
+====script2: incrementing 8-bit binary counter====
+It is not by accident the LEDs were build next to each other, wired up in sequential fashion as they are. The intention was to create an 8-bit  quantity that you could manipulate.
-<cli>
+So, it is your task for this script to write a visual "binary counter", that, lacking any arguments, starts at 0 (00000000), and with a short delay between each state change (say, no less than 0.5 seconds), increments one at a time until it reaches 255 (11111111), where 0 indicates an LED in OFF position, and 1 indicates an LED in ON position.
-lab46:~/src/unix/spf0$ cat pi.120.out
-314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664
-lab46:~/src/unix/spf0$ cat pi.120.out | cut -c7-8,22-23
-lab46:~/src/unix/spf0$
-</cli>
-====mixing options (offset, byline)====
+You will want to create your visual output in standard observed form for binary numbers (ie the left side denotes the MOST SIGNIFICANT BIT, and the right-most side denotes the LEAST SIGNIFICANT BIT).
-And we can mix options (in any order):
-<cli>
+For example, if displaying the number 13 with this script, our binary value being output should be:
-lab46:~/src/unix/spf0$ cat pi.120.out | ./pigrep byline '26' offset
-lab46:~/src/unix/spf0$
-</cli>
-====Using atend with offset====
+<code>0 0 0 0 1 1 0 1</code>
-The **atend** option, issued by itself, has no impact on operations:
-<cli>
+Where 2^7=0, 2^6=0, 2^5=0, 2^4=0, 2^3=1, 2^2=1, 2^1=0, and 2^0=1.
-lab46:~/src/unix/spf0$ cat pi.120.out | ./pigrep atend '26'
-26
-lab46:~/src/unix/spf0$
-</cli>
-So we need to combine it with the **offset** option to make an impact:
+Also, the script should accept the following optional arguments:
-<cli>
+  * $1 - step value (the rate of incrementation; default is 1)
-lab46:~/src/unix/spf0$ cat pi.120.out | ./pigrep atend offset '26'
+  * $2 - starting point (any value between 0 and 255, inclusive)
-23
+  * $3 - ending point (any value between 0 and 255, inclusive)
-lab46:~/src/unix/spf0$
-</cli>
-====dropping the leading 3====
+Unless you merge in the decrementing script logic into this script, you should do error checking to ensure that the starting point is LOWER than the ending point, otherwise display an error message and exit, leaving the LEDs in an OFF state.
-With the **drop3** option, we merely exclude the leading 3 of pi from our calculations. This should result in everything being "off by one" from previous outputs (with any combination of arguments):
-<cli>
+If you DO choose to incorporate decrement logic into this same script, a starting point being HIGHER than the ending point indicates the script should decrement instead of increment.
-lab46:~/src/unix/spf0$ cat pi.120.out | ./pigrep atend offset '26' drop3
-22
-lab46:~/src/unix/spf0$
-</cli>
-====Using MAX to limit processing====
+If ONLY a step and starting value is given, proceed from that point to the final bound (being an incrementer if step is positive, or decrementer if step is negative).
-Sometimes, a pattern may produce an untenable quantity of results. We may wish to restrict it, and can do so with the aid of setting the **MAX** variable.
-Take this request, which produces numerous results:
+====script3: decrementing 8-bit binary counter====
+Like the script above, only its default behavior is to decrement instead of increment.
-<cli>
+NOTE that you CAN combine script2 and script3 into ONE script, with the appropriate supporting logic to handle both modes.
-lab46:~/src/unix/spf0$ cat pi.120.out | ./pigrep '2'
-2 2 2 2 2 2 2 2 2 2 2 2 2 2
-lab46:~/src/unix/spf0$
-</cli>
-We can cut that down to a smaller quantity by setting MAX accordingly (let's say, limit to 4 matches):
+====script4: strobe/flash display====
+The purpose of this script is to create a fancy flashing pattern, lighting up and turning off the LEDs to create wavy or "back and forth" style visual effects.
-<cli>
-lab46:~/src/unix/spf0$ cat pi.120.out | MAX=4 ./pigrep '2'
-2 2 2
-lab46:~/src/unix/spf0$
-</cli>
-You could also **export** MAX, mitigating the need to manually specify it for each run.
 =====Specifications=====
-Evaluation will be based on correctness of values as well as on formatting/spacing.
+Evaluation will be based on correctness of values as well as on commenting/formatting/indentation/spacing of scripts.
-You'll notice that everything lines up and is positioned similarly:
   * groupwork! This project is specifically designed to be performed in groups.
     * I want to see groups ranging from a minimum of 2 people, to a maximum of 4 people. Any less and any more are not allowed.
+    * There are 4 pi's, 1 per table. There are 11 total people in the class, and on average 9 people regularly showing up; this could mean three groups of three (for example).
     * EVERY group member needs to be identified in your scripts (in a comment listing everyone).
+    * ONE GROUP PER TABLE (no group should share a pi with another).
     * EVERY group member needs to be familiar with the end products
     * EVERY group member needs to submit a copy of the scripts (they should all be identical- I will check)
       * in the event you feel other group members have not lived up to their obligations, you may alter your scripts accordingly (be it not giving them the final product, or enhancing functionality to bring it in compliance, or leaving comments indicating who wasn't pulling their own weight).
     * EVERY group member needs to do an approximately equal portion of the work. Slackers should be called out (I'll be keeping an eye out as well) and they will lose credit.
+    * EACH group member is responsible for prolifically commenting and demonstrating functionality of ONE of the scripts. The commenter should be identified at the top of the particular script. No one person should be commenting all the scripts.
     * This project is designed to be done DURING class time. It may offer up some useful insights into other projects (that you're doing on your own).
-  * You need to check your arguments to ensure they are present and valid.
+  * You need to check your arguments to ensure if they are present and valid.
-    * all mentioned arguments implementing their indicated functionality (atend, byline, drop3, offset, help)
+    * all mentioned arguments implementing their indicated functionality
-      * help takes priority over other options
+    * any invalid arguments or operating modes should generate an error and the script terminating (ie if the 'starting' number is the letter 'g').
-      * **atend** has no appreciable impact unless **offset** is also specified
-    * any invalid arguments should be silently dropped/ignored.
   * your script needs to commence with a proper **shabang** to run using bash; your script needs to end with an "**exit 0**" at the very end
   * comments and indentation are required and necessary
     * comments should explain how or why you are doing something
     * indentation should be consistent throughout the script (no mixing of different indentation units; no mixing of tabs and spaces)
-    * indentation is to be no less than 3 on-screen spaces (I recommend tabstops of 4).
+    * indentation is to be no less than 3 on-screen spaces (I recommend tabstops/shiftwidths of 4).
   * continuing with our shell scripting, your scripts will need to employ in a core/central way (note that both scripts may not each need all of these, but across both scripts, you should make sure that each of these concepts is utilized):
     * variables
     * command-line argument parsing and usage
-    * command-line pipelines
-    * command expansions
-    * regular expressions
     * conditional/selection structures
     * loops
+    * if appropriate:
+      * command-line pipelines
+      * command expansions
+      * regular expressions
   * your logic needs to:
     * flow (one thing leads into the next, as best as possible)
@@ Line 335: / Line 222: @@
 This can be in the form of comments in your script, or even a separate file submitted at time of submission (if a file, be sure to make mention of it in your script so I can be sure to look for it).
 =====Submission=====
-By successfully performing this project, you should have a fully functioning set of scripts by the names **pigen** and **pigrep**, which are all you need to submit for project completion (no steps file, as your "steps" file ARE the scripts you wrote).
+By successfully performing this project, you should have a fully functioning set of scripts by the names **script1** through **script4** (possibly lacking **script3** if you've merged functionality with **script2**), which are all you need to submit for project completion (no steps file, as your "steps" file ARE the scripts you wrote).
 To submit this project to me using the **submit** tool, run the following command at your lab46 prompt:
 <cli>
-$ submit unix spf0 pigen pigrep
+$ submit unix spf1 script1 script2 script3 script4
-Submitting unix project "spf0":
+Submitting unix project "spf1":
-    -> pigen(OK)
+    -> script1(OK)
-    -> pigrep(OK)
+    -> script2(OK)
+    -> script3(OK)
+    -> script4(OK)
 SUCCESSFULLY SUBMITTED
@@ Line 356: / Line 244: @@
 <code>
-:spf0:final tally of results (26/26)
+:spf1:final tally of results (52/52)
-*:spf0:scripts effectively utilize variables in operations [2/2]
+*:spf1:scripts submitted in accordance with specifications [4/4]
-*:spf0:scripts effectively utilize command-line arguments [2/2]
+*:spf1:initialization script logic present and functions [4/4]
-*:spf0:scripts effectively utilize command expansions [2/2]
+*:spf1:initialization logic uses loop to automate task [4/4]
-*:spf0:scripts effectively utilize regular expressions [2/2]
+*:spf1:incrementation script logic present and functions [4/4]
-*:spf0:scripts effectively utilize selection structures [2/2]
+*:spf1:counter script logic is centrally based on loop [4/4]
-*:spf0:scripts effectively utilize looping structures [2/2]
+*:spf1:counter script logic does adequate error checking [4/4]
-*:spf0:scripts are proper bash scripts with shabang and exit [2/2]
+*:spf1:decrementation script logic present and functions [4/4]
-*:spf0:pigrep displays values in proper orientation [2/2]
+*:spf1:flashy script logic present and functions [4/4]
-*:spf0:pigrep accurately displays values as requested [2/2]
+*:spf1:scripts appropriately call the initialization logic [4/4]
-*:spf0:scripts properly manage input violations [2/2]
+*:spf1:scripts are organized and easy to read [4/4]
-*:spf0:pigen operates according to specifications [2/2]
+*:spf1:scripts effectively utilize selection structures [4/4]
-*:spf0:pigrep operates according to specifications [2/2]
+*:spf1:scripts effectively utilize looping structures [4/4]
-*:spf0:script logic is organized and easy to read [2/2]
+*:spf1:scripts are proper bash scripts with shabang and exit [4/4]
 </code>

Lab46 Wiki

User Tools

Site Tools

Differences

Page Tools