Documents

migration.user — Fri, 01 Oct 2021 18:07:31 GMT

Current Revision posted to Documents by migration.user on 10/1/2021 6:07:31 PM

sudo Sergeant 07: System Program Shell

tariq.ahmad — Fri, 18 Jan 2019 16:12:09 GMT

Current Revision posted to Documents by tariq.ahmad on 1/18/2019 4:12:09 PM

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

Featured Bonus Content

See All Episodes

www.youtube.com/watch

Felix gives an introduction to virtual consoles, terminal emulators, and program shells. He traces terminal emulator to its historical antecedent; an early electromechanical device known as a teleprinter, teletypewriter console, or teletype; and discusses how the terminal program emulates the legacy hardware connected to the mainframe.

A program shell is a system program for executing other programs, conducting administrative tasks, or to run scripts. It is sometimes referred to as a prompt, command line interface, console user interface, character user interface, command line/language interpreter, or interactive command line. The program shell is an interactive command interpreter intended as a scripting language and contains most of the features that are commonly considered to produce structured programs.

When you hear the words terminal the first thing you probably imagine is a dark screen with a blinking cursor that is used to type instructions to direct a machine. It wasn't always this way. The terminal emulator is the modern evolution of an early electromechanical device known as a teleprinter, teletypewriter console, or teletype. A teletype printer is an electromechanical device, similar to a typewriter, used to send commands to a mainframe and receive output. A console and a terminal were essentially the same thing, however slightly different. The console was generally comparable in hardware terms to any other terminal except that a terminal connected directly to the mainframe and was intended for system maintenance. This entire process is now emulated by software. As Linux evolved, the functionality of consoles has been built into the kernel as virtual consoles. Software has been written to emulate terminals. Its legacy can be found in the abbreviation tty, which is used to identify virtual consoles or to represent terminal connections.

A terminal is a program that emulates the legacy physical hardware connected to a mainframe. It allows text input and produces text output. Just a few of the many examples of terminals include console, gnome terminal, LX terminal X term, and terminator. A console is essentially the same as terminal, however, in historical context, it was generally considered the point of interaction with a mainframe and was intended for system maintenance. In a modern system the virtual consoles serve a very similar role. The shell is a program that receives and interprets instructions. The shell can run independently of the terminal emulator, however, we will only be examining it in terms of its relation to the terminal emulator. There are numerous shells to choose from. There are quite a few examples of this including: Bourne Shell (SH), Bourne-Again Shell (BASH), C Shell (CSH), Korn Shell (KSH), and Remote Shell (RSH/IP). The prompt is the beginning line in a program shell which signifies start of input. The command line is the space to the right of the prompt where instructions and data are input. You’ll generally find your blinking cursor here.

Felix demonstrates how to switch between different virtual consoles. From command line he types "W" which allows him to see which user is logged into which console. The screen shows that the only virtual console that’s active is tty1:

On this particular machine there are six different virtual consoles that are setup. To switch between them you simply hold down “ctrl alt” and then press either function key 1 through function key 6 sequentially. To go from tty1 to tty2 simply hold down “ctrl alt” and function key 2.

Hitting “control alt” and then function key 3 gives you tty3. After demonstrating this with all six virtual consoles he goes back to tty2 and logs into it. Felix goes back to tty3 and logs in as a different user.

Next, Felix goes to Virtual Console 2 and instantiates another instance of the graphical environment. To do this he types startx and this gives him a whole new desktop that is completely different from the previous desktop. Anything they do on the graphical environment that they’ve instantiated on virtual console 2 will be completely independent from anything they do on virtual console one. A practical instance of this would be if someone wanted to set up a machine to do multiseat. Multiseat is sort of like multihead except the difference is that there are multiple monitors connected to one computer but at each monitor there is also an addition of input devices like a keyboard and mouse. So there’s multiple keyboards and monitors, maybe even audio devices, all connected to one computer, and then it would essentially function as a mainframe did a long time ago.

In the comments below tell us about your experience with teletypes or what you’ve done with virtual consoles!

Tags: command line interface, csh, program shell, sh, sudo sergeant, command line language interpreter, terminal, mainframe, multihead, tty, terminal emulators, teleprinter, bourne shell, ksh, telewriter console, virtual consoles, korn shell, graphical environment, character user interface, interactive command line, rsh ip, bash, rpi, multiseat, program shells, remote shell, command line, startx, console user interface, bourne-again shell, prompt, c shell, teletype, terminal program, sudosergeant, linux

Community Feedback 08: Felix's Favorite Distros

tariq.ahmad — Fri, 18 Jan 2019 16:11:51 GMT

Current Revision posted to Documents by tariq.ahmad on 1/18/2019 4:11:51 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

Community Feedback

sudo Sergeant

See All Episodes

www.youtube.com/watch

Following a recent discussion on preferred Linux distributions, Felix weighs in on what works for him. Among the distros he discusses with Karen are Arch, OpenSuse, Ubuntu, and Debian. He talks about what it took to get him where he is and his transformation from Linux Evangelist to OS Agnostic.

Felix insists he doesn't have any favorites. While this may be true, he does in fact have one preferred operating system and one distribution. A distribution is a collection of software assimilated to into a suite. The distribution he prefers to spend most of his time with is Arch Linux. Arch Linux focuses on simplicity of design to create an environment that is straight forward and easy to understand rather than polished such as with point-and-click management tools. Its's package manager, for instance, does not have an official graphical front end. Maintaining it requires the succinct use of commenting, as well as, clean configuration files for quick access and editing. If you're the type of user that isn't afraid of command line, like Felix, this is something you might appreciate it. With the Arch Linux distribution, there is a repository where there is already a bunch of pre-compiled software as is the case with most distribution. He will frequently have to do additional configuration after its downloaded and installed. He basically likes Arch Linux because he has to set up and customize pretty much every feature. The next challenge for Felix, would be Linux from source where everything would need to be compiled.

Felix didn't find the distribution of Linux that's right for him immediately, he confides to Karen, like many people he started his journey through Linux-hood by installing Ubuntu. Having been use to Windows XP, Ubuntu failed to impress him as it was foreign from what he was use to using. After Windows Vista was released, he gave Linux another look after he received an install disk of OpenSuse. The big difference between openSuse and Ubuntu was the default desktop environment. The default desktop environment for openSuse was KDE whereas the default desktop environment for Ubuntu is Gnome. The KDE environment provides a user friendly-desktop environment, which gave Felix a sense of familiarity that he experienced when he was with Windows XP.

From there Felix gives Ubuntu another look, Felix bounces around a various Linux distributions over a period of years. He spends some time with Debian before exploring Fedora.. After giving all these distributions a try he discovered Arch and he’s been using that ever since. Felix believes that people should use whatever operating system they want on whatever machine they choose.

has a minimalist approach which Felix prefers because it allows him to get it set up and built the way he would like it to be. He has to do everything himself except compile. Arch Linux is largely based around binary packages. Its package manager does not have an official graphical front-end, for instance,

Have a question about any of the distros discussed in this segment?

Let us know in the comments below!

Tags: sudo sergeant, terminal, Ubuntu, sudo feedback, opensuse, gnome, fedora, command line, arch linux, kde, communityfeedbacktbhs

sudo Sergeant 06: File Permissions

tariq.ahmad — Fri, 18 Jan 2019 16:11:28 GMT

Current Revision posted to Documents by tariq.ahmad on 1/18/2019 4:11:28 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

Featured Bonus Content

See All Episodes

www.youtube.com/watch

Felix discusses how file permissions work with Linux. He covers what they mean, what they’re for, and how to set them. You’ll learn to use command line to create a file and decipher user, group, and others rights. You can then add or remove permissions by CHMOD or by permission bits in octal notation.

File permissions are the most basic form of security control on a Linux based operating system. They are implemented in a manner which can be configured to grant or deny access to files. The permissions can be modified by either the one who owns the file, or the super user. The instruction to modify the permissions can take numeric arguments or symbolic arguments.

Felix uses a command line example to show you how to see the permissions of a file: Typing “ls” shows you the root directory structure.

sergeant@raspberrypi: ~ $ ls
Desktop Documents Downloads Music Pictures Public Templates test Videos

He wants to go the test directory so he types the command cd test. Typing ls again shows that this directory has two directories that were previously mounted.

sergeant@raspberrypi: ~ $ cd test
sergeant@raspberrypi: ~ $ ls
mount0 mount 1

Next he creates a files using command line using the touch command followed by the file he is creating and uses the ls command to verify the file was created:

sergeant@raspberrypi: ~/test $ touch testfile.text
sergeant@raspberrypi: ~/test $ ls
mount0 mount1 testfile.txt

To find the file permissions of this newly created file he types in ls -l:

sergeant@raspberrypi: ~/test $ ls -l
total 8
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount0
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount1
- rw-r-- r-- 1 sergeant sergeant 0 Aug 30 09:46 testfile.txt

For testfile.txt the information to left of the number 1 are the file permissions. The first bit in the file permissions is the file type, the next 3 are the permissions of the owner, the following three bits are the permissions of the group, and the last three are the permissions of anybody who is either not in the group or not the owner. The last bit is a single character that specifies alternate access methods.

For instance, if you see "drwxr" it means that the file type is director, the r means that the owner can read the directory, the w means the owner can write to the directory, and x means the owner can execute the directory (since it's a directory it doesn't really get executed). The next 3 bits are the group rights. For testfile.txt, "r--" means that the group can read this but cannot write or execute.

There are two ways to modify the file permissions. They can either be done through numeric method or via a character method. With the character method, you would change the file permissions by sending the instruction chmod (change modify). Felix suggests expanding the help anytime you have an instruction. After, using the command "--help" Felix decides to give execution permissions to the user for the file by typing in the following command:

In this example, read and write are turned off execute is turned on:

sergeant@raspberrypi: ~/test $ chmod u=+x testfile.txt
sergeant@raspberrypi: ~/test $ ls -l
total 8
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount0
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount1
---xr-- r-- 1 sergeant sergeant 0 Aug 30 09:46 testfile.txt

In this example, read and write are added along with execute:

sergeant@raspberrypi: ~/test $ chmod u=+rwx testfile.txt
sergeant@raspberrypi: ~/test $ ls -l
total 8
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount0
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount1
-rwxr-- r-- 1 sergeant sergeant 0 Aug 30 09:46 testfile.txt

To give those same permissions to the group simply use the following command:

sergeant@raspberrypi: ~/test $ chmod g=+rwx testfile.txt
sergeant@raspberrypi: ~/test $ ls -l
total 8
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount0
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount1
-rwxrwxr-- 1 sergeant sergeant 0 Aug 30 09:46 testfile.txt

To give those permissions to others you would use the following command:

sergeant@raspberrypi: ~/test $ chmod o=+rwx testfile.txt
sergeant@raspberrypi: ~/test $ ls -l
total 8
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount0
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount1
-rwxrwxrwx 1 sergeant sergeant 0 Aug 30 09:46 testfile.txt

To take away group permissions you would use the minus sign instead of the plus sign:

sergeant@raspberrypi: ~/test $ chmod g=-rwx testfile.txt
sergeant@raspberrypi: ~/test $ ls -l
total 8
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount0
drwxr-xr-x 2 sergeant sergeant 4096 Aug 25 13:40 mount1
-rwx---rwx 1 sergeant sergeant 0 Aug 30 09:46 testfile.txt

This is covers adding and removing permissions using the character method. To change permissions via the numeric method you can head over to Unix Permissions and Lookup . Select your permissions bits. We're focusing on user, group, and others.If you want to have read write execute for user group and others you would select those permissions on the page.

sergeant@raspberrypi: ~/test $ chmod 777 testfile.txt
sergeant@raspberrypi: ~/test $ ls -l testfile.txt
-rwxrwxrwx 1 sergeant sergeant 0 Aug 30 9:46 testfile.txt

Trying again with a different numeric value changes the file permissions:

sergeant@raspberrypi: ~/test $ chmod 700 testfile.txt
sergeant@raspberrypi: ~/test $ ls -l testfile.txt
-rwx------ 1 sergeant sergeant 0 Aug 30 9:46 testfile.txt

Tags: numeric method, sudo sergeant, octal notation, file permissions, rpibeginner, character method, chmod, rpiexpert, command line, permission bits, sudosergeant, linux

sudo Sergeant 12: Group Management

tariq.ahmad — Fri, 18 Jan 2019 16:09:44 GMT

Current Revision posted to Documents by tariq.ahmad on 1/18/2019 4:09:44 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

In this segment Felix shows you how to see what groups are on your system, how to add new groups, how to add users to those groups, how to remove users from those groups, how to remove the groups, and, how to modify the groups. He’ll also dabble in file permissions and file ownership.

Felix talks about managing groups. He starts by checking out what groups are in the system. To check out what groups are in the system use:

$ cat /etc/group

To create a group you would use:

$ sudo groupadd dirshare

You’ve now created a group named dirshare that has no members. Now that the group is created, there are a couple of ways you can add members to the group. You can do it through the USERMOD method or through the GPASSWD method. Felix, shows you how to do both, starting with the GPASSWD method:

$ sudo gpasswd –a – technician dirshare

This adds user technician to the group dirshare. If you type in:

$ cat/etc/group

It should show you that technician is now part of this group:

dirshare:x:1006:technician

Next, Felix shows you how to add user buckethead to the group through the usermod method.

$ sudo usermod -aG dirshare buckethead

If you type in

$ cat/etc/group

It shows you that buckethead is now part of the group:

dirshare: x:1006:technician, buckethead

The distinction between the primary group that an account is associated with, and additional groups that an account may have, is that whenever a person goes and creates a document, it’s going to be owned by the person that made the file and the file is going to be associated with the primary group of the account that made the file. Felix goes over an example using a test directory. He uses this to create another directory called share:

$ pwd /home/technician/test
$ mkdir share

If you type in

$ /bin/ls –la

You can see that this directory is owned by technician and it’s in the group technician. Felix attempts to change the group of the shared directory to technician:

$ chown -R technician:dirshare ../share/

It gives him the error: Operation not permitted This brings him to his next point. When a user is added to a new group, the system doesn’t recognize that the user has been added to that group until the person has logged out and then logged back in. He logs back in and goes into the directory share. He wants to make a file that can be shared between different accounts within a directory that is in a shared group:

$ ls file.txt $ pwd /home/technician/share

To do this he is going to use a utility called EXA that he’s set up in his bash RC as an alias for LK. EXA is a modern replacement for LS, which is listing the contents of a directory. It basically colorizes everything, puts it in a grid, and makes it human readable. He wants to change the group from technician to dirshare. He’ll need to first check the permissions to make sure that both the owner can read and write and the group can read and write. To do this he’ll need to use two utilities, CHOWN and CHMOD.

$ chown -Rv technician:dirshare ../share/

changed ownership of ‘../share/file.txt’ from technician to technician:dirshare changed ownership of ‘..share/’ from technician to technician:dirshare

Now, any account that is in the dirshare can write files in this directory. Any account that is in dirshare can also read file.txt but cannot write to it because the write flag is not set. To make this file writeable you would use: $ chmod g+w file.txt Now that the permissions are set and the group is set, Felix opens up another terminal and logs in as Buckethead. He goes over what you need to do to allow Buckethead to write a file to the directory. Because buckethead is in the potatohead group, technician is unable to write to it. To allow technician to write to the file he’ll need to change the group. He goes over this along with what you need to do to remove a user from a group.

Tags: operation not permitted, ls, exa, chown, chmod, shared group, felix gardner, system administration, open source, group permissions, sudosergeant, linux

sudo Sergeant 20: 3D Design on a GNU/Linux System

tariq.ahmad — Fri, 18 Jan 2019 16:08:08 GMT

Current Revision posted to Documents by tariq.ahmad on 1/18/2019 4:08:08 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Felix gives a basic introduction to 3D design in a Linux environment using a tool called FreeCAD. FreeCAD is a multi-platform parametric 3D modeling program that supports many 3D formats. The program is currently under heavy development and has not even reached release version one. FreeCAD is a great program but it is not stable or reliable enough for production environments. What type of 3D modeling software do you use? Let us know in the comments below!

Tags: 3d modeling, freecad, tft screen, security, ip address, sudoers, ssh, system administration, key pair, parametric, multi-platform, fail2ban, raspbian, sudosergeant, linux

sudo Sergeant 22: Community Feedback

tariq.ahmad — Fri, 18 Jan 2019 16:07:49 GMT

Current Revision posted to Documents by tariq.ahmad on 1/18/2019 4:07:49 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

In this episode of sudo Sergeant, Felix takes a look back at past episodes of sudo Sergeant and answers community member’s questions from the comments section.

After watching sudo Sergeant 00: What Is Linux? , firemanak wants to hear Felix's thoughts on the best of distribution of Linux and whether he can use one of his Rasberry Pi's with it. If you're going to use a Raspberry Pi then go ahead and start with the Raspbian. The advantages of this are there's a huge community, it's easy to mess with, and there's a lot of documentation. His tip is to go visit the IRC channels and ask questions. Its a great place to learn by getting some real-time feedback. If you're looking at installing on a desktop or laptop, go ahead and get yourself an old laptop or old desktop. Arch Linux is a great distribution if you're looking to jump in and learn something. What makes it a great distribution to learn with is that just installing it takes a bit of effort to get it up and running, whereas, a lot of distributions you can just get an installer and the installation is pretty much automated in comparison. If you don't want to go that route, Felix recommends Fedora or Debian because they have thorough documentation.

In response to sudo Sergeant 04: Ditch the Arduino IDE for the Linux Terminal , idanre1 suggests arduino.mk which allows to develop for arduino using the makefile approach. You can find it at https://github.com/sudar/Arduino-Makefile . By using:

apt-get install arduino arduino-mk

apt-get install arduino arduino-mk

...you can have the Arduino IDE if you want to. After following the link idanre1 gave him, Felix finds it to be a really great utility. It's such a cool development tool that he’s thinking of using it in a future segment.

Finally, Felix closes things out with a correction. In sudo Sergeant 06: File Permissions he admits to making a pretty big mistake that he was right to be called on. He follows jackwhite 's example and then apologizes to the audience for providing inaccurate information. He is grateful for jackwhite having corrected him.

Tags: debian, file permissions, arduino ide, raspberry pi, fedora, e14presents_sudosergeant, arch linux, raspbian, sudosergeant

sudo Sergeant 23: Schematic Design

tariq.ahmad — Fri, 18 Jan 2019 16:07:28 GMT

Current Revision posted to Documents by tariq.ahmad on 1/18/2019 4:07:28 PM

element14 Presents

Explore Open Source with the sudo Sergeant. Improve your mastery of terminal in various Linux distributions, discuss open source related topics, and more!

Back to The element14 Presents homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Felix gives an overview of the schematics used for the Pocket Bagle bela.io Drum Sequencer using KiCad. There are six different schematic sheets for this build. There are schematics for the Bela PocketBeagle Connections, the 3 Digit 7 segment Display, the LED matrix, the Button Matrix, the Power and Motor Driver, and the Analog and Amplifier. He'll also let you know what he likes about using KiCad circuit design software, how to work off of a Pocket Beagle template for your design, and what you need to know to get started.

Watch the full Episode for this Build: Episode 342: Pocket Beagle bela.io Drum Sequencer

Tags: debian, file permissions, arduino ide, raspberry pi, fedora, e14presents_sudosergeant, arch linux, raspbian, sudosergeant

sudo Sergeant 24: Arch Linux Installation

tariq.ahmad — Fri, 18 Jan 2019 16:05:24 GMT

Current Revision posted to Documents by tariq.ahmad on 1/18/2019 4:05:24 PM

element14 Presents

Explore Open Source with the sudo Sergeant. Improve your mastery of terminal in various Linux distributions, discuss open source related topics, and more!

Back to The element14 Presents homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Felix walks you through the steps for installing Arch Linux through terminal. He’ll show you where to download the installer from archlinux.org, how to mount the Arch Linux installer to a USB, how to configure the bios to boot into the USB, and goes through the rest of the install process. Once installed, you’ll be able to login and customize the OS through the GUI.

Tags: terminal, bios, installer, gui, usb, partitions, e14presents_sudosergeant, command line, arch linux, sudo, sudosergeant

sudo Sergeant 25: Disk Drive Recovery on Linux

tariq.ahmad — Fri, 18 Jan 2019 16:04:52 GMT

Current Revision posted to Documents by tariq.ahmad on 1/18/2019 4:04:52 PM

element14 Presents

Explore Open Source with the sudo Sergeant. Improve your mastery of terminal in various Linux distributions, discuss open source related topics, and more!

Back to The element14 Presents homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

We’ve all been there before. A corrupted hard drive that doesn’t allow you boot in. Felix shows you how he repaired his corrupted disk drive in a Linux environment. He’ll show you can do this by plugging it into a different machine, and taking advantage of Terminal to repair the system file on it.

Tags: terminal, e14presents_sudosergeant, corrupted hard drive, system recovery, command line, sudo, sudosergeant

sudo Sergeant 21: 3D Desoldering a Raspberry Pi A+

tariq.ahmad — Mon, 13 Aug 2018 23:05:33 GMT

Current Revision posted to Documents by tariq.ahmad on 8/13/2018 11:05:33 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Felix does something different and focuses on hardware. He field strips the Raspberry Pi A+ by removing the GPIO, USB port, MIPI camera interface (CSI) connector, HDMI, and composite video, leaving the power and SD slot in place. If you don't have a lot of space, where do you want to slim down the Raspberry Pi to keep things really compact? Soldering overflow pins gets them flowing to get ready for the solder sucker. If you have a different method of field stripping a Raspberry Pi, or you want to see another device field stripped, let us know in the comments below!

Tags: usb port, field strip, pins, csi, mipi camera interace, gpio, rpibeginner, raspberry pi a+, soldering station, desoldering, e14presents_sudosergeant, sudosergeant

sudo Sergeant 19: Hardening the Secure Shell

tariq.ahmad — Mon, 13 Aug 2018 23:01:34 GMT

Current Revision posted to Documents by tariq.ahmad on 8/13/2018 11:01:34 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Felix goes over some basic and essential security configurations for the Raspberry Pi. He does this for the Raspbian install, however, what he shows you can be applicable to other single board computers or distributions with slight modifications. Modifying the security settings of the Raspberry Pi will allow you to connect to the network more securely.

Felix goes over modifying the sudoers file. This file manages how sudo is invoked and what groups or accounts are bestowed with the privileges of sudo. A secure practice is to require an account with sudo privileges to supply a password when calling any program with sudo. Some system administrators like to require anyone logged into the account to also know the root password. The only thing Felix is requiring is for the person to know the passphrase for the account in the sudo group.

He also shows you how to create a new key pair. A key pair consists of a public and a private key. He starts by issuing a key gen instruction via SSH. He then shows you how to install and setup fail2ban. Fail2ban is a service that can track failed attemps to the SSH port and if an IP address fails repeatedly, the IP address can be blocked for a period of time, or indefinitely. In the comments below let us know if there is anything related to security that you would like us to go into more detail about.

Tags: tft screen, security, ip address, sudoers, ssh, system administration, key pair, fail2ban, raspbian, sudosergeant, linux

sudo Sergeant 13: Driving a TFT Screen Using GPIO

tariq.ahmad — Mon, 13 Aug 2018 22:56:27 GMT

Current Revision posted to Documents by tariq.ahmad on 8/13/2018 10:56:27 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Felix shows you how to install retropie through terminal and how to drive a TFT screen with the GPIO of a Raspberry Pi. He configures SSH to login and modify some files, adds a custom device tree source file, compiles the device tree source file, and adds some additional lines to the config.txt file in order to get the kernel and operating system working together to drive the TFT screen with GPIO.

The first thing you want to do is download your disk image of retropie at https://retropie.org.uk/. You’ll have two different downloads to chose from. One is for the Raspberry Pi Zero or the first Raspberry Pi and the other is for Raspberry Pi 2 and 3. Felix downloads the version for Raspberry Pi Zero. Once it downloads Felix takes a look at it in terminal. It will show up in the image directory of terminal as retropie-4.3-rp1_zero.img.gz. The gz extension at the end means it is a compressed file. To expand it to an uncompressed file:

$ gunzip -k -v retropie-4.3-rpi1_zero.img.gz

Felix shows a comparison between the compressed and the uncompressed file in terminal. To find out where the SD card is he uses:

$ lsblk

He uses the dd utility for converting and copying a file. He goes over the man page for the dd utility to go over the various operands he needs to send to it. He enters the following in terminal:

$ sudo ./retropie=4.3-rpi1_zero.img of=/dev/sdd bs=10M status=progress

Felix suggests leaving off sudo initially to make sure you’re not writing to the wrong disk. You’ll see the progress of the operating system moving to the SD card through terminal. Now that the operating system is in the SD card they can attach it to the Raspberry Pi. As this is the Pi 1, he’ll also hook it up a USB hub with Ethernet on it, before connecting the hub to a keyboard. Once Retropie boots on the Pi, press F4 and that will take you to terminal. In terminal you will enter: $ sudo raspi –config This will take you into the configuration menu. Go to interfacing Options. From there go down to SSH and enable it. Next go into localization options and change local. You’re going to want to switch it to whatever your local region is. Felix finds and selects the region code for the US. He also goes over how to set your Timezone, Keyboard Layout, and Wi Fi country. Next, Felix goes into the Advanced Options where he selects the option to Expand the file system to ensure that all of the SD card storage is available to the OS. After you do all that, reboot the Pi. Felix consults the man page for nmap and uses the nmap utility to find the ip address of the Raspberry Pi through terminal. In his case it looks like:

$ nmap 102.1.48.1.*

This will scan the network and spit back what it finds. The nmap utiplity reports that the device is connected to the network. He’s scanning for devices that have SSH Open and there is only one device listed. Before connecting to the IP address he’ll need to modify the default SSH. To do this he logs in as Pi and edits the SSH config so that he can login as root. The reason he needs to login as root is so that he can remotely access files on the root directory. He uses the following command:

$ sudo nano /etc/ssh/sshd_config

He uncomments the option to permit root access. Now that he’s modified the SSH config file, he’ll need to restart the SSH service:

$ sudo systemctl restart ssh.service He’ll also $ sudo systemctl restart sshswitch.service

Before logging in as root he’ll need to login as pi and set the password for root:

$ sudo passwd root

Once this is done he logs back in as root. The reason he wants to login as root is so that he can use the dolphin file browser and transfer files to the root directory. Once he logs in as Pi he goes to the boot directory and edits the config.txt file. You’ll need to do this in order to add some custom lines for the TFT screen. The TFT screen is going to be driven by a device tree overlay. You can find documentation on the device tree overlay at https://www.raspberrypi.org/documentation/configuration/device-tree.md. There you can read up on device tree overlays and parameters. The device tree overlay will be compiled in the boot directory. On Felix’s local machine he’s able to login the Raspberry Pi over the fish protocol which uses SSH on the backend.

Since he’s logged in as root he can drag and edit files in the boot directory. He drag over are the gpio-tft-16bit-565.dts which is the source file that once compiled will create the DT –blob.bin file. When the system boots the config.txt file has some configuration lines that refer to the DT –blob.bin file and that enables the Raspberry Pi to drive the TFT screen directly with the GPIO. Felix walks you through the process of setting that up. Once he’s copied the lines he needs he goes back into terminal to edit the config file. At the bottom of the file he pastes the lines that he’s copied. He’s commented a compile script which he also drags over to the Pi. He compiles the DTS file and that produces a bin file. The bin file tells the kernel, the operating system, and everything how to interface with the TFT screen over the GPIO. At this point you should be able to reboot the Raspberry Pi and the TFT screen should be working.

Tags: dts file, sudo sergeant, terminal, tft screen, compile, gpio, rpibeginner, raspberry pi zero, ssh, raspberry pi, rpiexpert, retropie, boot, device tree overlay, sudo, sudosergeant, linux, man pages

sudo Sergeant 14: Enabling Buttons on the Raspberry Pi No HDMI

tariq.ahmad — Mon, 13 Aug 2018 22:55:41 GMT

Current Revision posted to Documents by tariq.ahmad on 8/13/2018 10:55:41 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

In this segment, Felix continues working on the Raspberry Pi No HDMI build. Previously, he showed you how to drive a TFT screen directly with the GPIO. Now he's going to reconfigure the Linux kernel and enable the GPIO keyboard matrix module. .

Felix takes us to a site (blog.gegg.us/category/foss/) that explains how you can enable the GIO matrix. To check to see if the keyboard matrix is already enabled use: $ sudo mod info matrix-keypad If you get an error, that mean s you need to recompile the kernel with it enabled. Felix demonstrates the steps how to cross compile the Linux kernel for the Raspberry Pi on an Arch Linux system. He starts by opening up the Kate program. It’s a plain text editor with a terminal attached to it. He utilizes the terminal to connect to the Raspberry Pi via SSH. The notes on are on the top pane and the terminal at the bottom is connected to the Raspberry Pi via SSH. You’ll need to download the cross-compile tools ($ git clone https://github.com/raspberry pi/tools ./tools) You’ll alsoneed to update the environment path and add the location of the compiled tools ($echo $PATH) which will add the tools path to the path variable. After adding the new path to the .bashrc file its necessary to source the .bashrc file that will refresh and update the path variable. You can view the path again to see the updated changes. Download the Linux source ($ git clone –depth=1 https://github.com/raspberrypi/linux). Felix runs through a list of things you can do while you wait for it to download.

As this is a Arch Linux system you need the ncurses installed ($ sudo pacman –S ncurses). Next, you’ll create the variable kernel to reflex the name of the desired new kernel ($ cd linux/ $ KERNAL=kernal). From the Linux source directory prepare the .config file. After preparing the .config file, you will need to open up the mini config and select the proper modules to compile. Make the menu config and select the proper options. Enable the keypad GPIO matrix and enable USB drivers. Navigate to: device drivers >> input device drivers >> keyboards >> GPIO driven matrix keypad support Save and exit. You’ll also need to enable some USB modules. He goes into the USB options and checks some of those. After checking the USB drives he saves and completes the configuration file. Felix starts the compile ($ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf - zImage modules dtbs –j 8). The magic argument in this sauce is -j 8. The –j 8 flag enables multi-thread compiling to reduce compile time. Next, Felix takes the newly compiled kernel and all the support files and transfers them over to the SD card. He’ll need to mount the SD card and then copy the files over. He lists the block devices ($ lsblk) and then mounts the sd card ($sudo mount /dev/ssd1 ../../Mount/boot) which is boot partition to the mount point he’s created in the filesystem. Once the boot partition is mounted you can list the directory ($ ls ../../Mount/boot/ ) and does the same for the root ($ ls ../Mount/root/). Next, he installs the modules with the make instruction ($sudo make ARCH=arm CROSS_COMPILE=arm -linux -gnueabihf – INSTALL_MOD_PATH=../ ../ ../Mount / root modules_install). Felix makes a backup of the stock image that came with the operating system ($ sudo cp ../../ ../Mount/boot/$KERNEL.img ../../ ../Mount/boot/$KERNEL -backup.img). He then copies the Z image to the boot directory.

He names the kernel he wants to boot into($ sudo cp ../ ../ ../Mount/boot/$KERNEL.img ../ ../ ../Mount/boot/$KERNEL-backup.img). He then copies the compiled device tree files to the boot directory. He also modifies the .config file so that when the Raspberry Pi boots, it loads the modified kernel. He does this by adding a line (kernel=kernel –gpio-matrix.img). Once you unmount the partitions you’ll be able to boot into the Raspberry Pi with the new kernel without getting an error. Felix shows you how to create the GPIO matix .DTS file and compile it. You can do this by referencing the TFT connections and finding the GPIO pins to use. He also shows you a reference to all the connections that have been made. She shows you the lines that define the GPIO rows and columns to use for the matrix. The next section defines the key map. It has a hex code that relates to a column, a row, and a Linux key code that we want it to represent. The code of the input key comes from the Linux keyboard.h file or the input-event-codes .h file. Felix transfers the source file and a compile script onto the Raspberry Pi. He compiles into the device tree overlay directory. He adds the device tree overlay to the config.txt file. He reboots to check to see if the button matrix is functional. He’ll need to invoke LS input which requires installing the input utilities package ($ sudo apt –get install input -utils). This will list the devices connected to the GPIO matrix. You can now see the results of key presses with input events and the event number zero. Now events happen when the key is pressed. Felix creates a UDEV rule to prevent the GPIO kernel matrix from conflicting with the SDL library used to make the emulator.

Tags: terminal, tft screen, rpiintermediate, boot directory, gpio, matrix, usb, raspberry pi, sdl library, open source, kernel, command line, no hdmi, device tree overlay, sudo, sudosergeant, linux

sudo Sergeant 15: Pi-Top Teardown

tariq.ahmad — Mon, 13 Aug 2018 22:55:15 GMT

Current Revision posted to Documents by tariq.ahmad on 8/13/2018 10:55:15 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Felix unboxes the Pi-Top. The second version of the Pi-Top includes a lot of mini posters that weren’t part of the first release. Included are guide booklets, an inventor’s kit, a Raspberry Pi (optional), a box of accessories, and the power supply. There’s also a Pi Top pulse accessory which has also been included. The guide booklets include a getting started guide and an inventor’s guide.

The Pi-top is marketed as a kit for kids to learn about computing. Felix goes into the box of accessories and finds s buttons, potentiometers, jumper cables, and a breakout board. Felix compares the Pi-top with its previous iteration. He takes out the cooling bridge. It’s a heatsink but it also ports over the GPIO to a header located on the hub. He shows you how to plug the Raspberry Pi into the hub. It’s going to supply power, and give you HDMI. It also connects to the cooling bridge and the breakout board. Now that he’s shown you how easy it is to put together, he’s ready to take it apart.

He starts with the hub and then precedes to voids the warranty by removing the ribbon cable and prying off the rails. After snapping off the parts, he admires the included battery bank. Next, he takes apart the screen. The screen pops out after he loosens the ribbon cable. Some of the parts that he finds included in the hub are the ATtiny88, a multiplexer demultiplexer for the GPIO, and for video there is an HDMI to embedded Display Port converter. For the battery there is a lithium-ion battery integrated circuit and a gas gauge. Felix admires the battery pack. On the Pi-top proto plus, Felix discovers an ATtiny20.

Tags: potentiometer, battery bank, gpio, multiplexer, power supply, breakout board, attiny20, raspberry pi, gas gauge, ribbon cable, demultiplexer, open source, kernel, jumper cables, integrated circuit, pi-top, attiny88, sudo, sudosergeant, display port converter, pi laptop

sudo Sergeant 16: Pi-Top OS Overview

tariq.ahmad — Mon, 13 Aug 2018 22:54:45 GMT

Current Revision posted to Documents by tariq.ahmad on 8/13/2018 10:54:45 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

The pi-top OS is great for learning to code using Python, discover Scratch, or to have fun while interacting with electronics. It also comes with some really great kits. In this segment, Felix boots into the Pi-top OS and goes through initial setup. After selecting his preferences he goes over the tour of the desktop. He also introduces you to the pi-topCODER, a learning tutorial on how to interface with the GPIO using Python.

Felix opens up the terminal to learn more about the OS. The pi-top runs a modified version of Raspbian called Polaris. The Polaris OS is basically the same as Raspbian except that it’s been modified to accommodate the additional hardware and include the pi-top dashboard. You can get anything you want from the dashboard through the menus. Felix goes over the programming menu option which supports several coding environments for Python, Java, Scratch, and Sonic Pi. He walks through some of the other menu options such as what’s included with Office, Games, and Settings. He returns to the desktop and demonstrates how you would use the built in pi-top coder to create a circuit using a breadboard.

Tags: scratch, gpio, circuit, pi-topcoder, breadboard, pi-top, raspbian, polaris, sudosergeant, pi laptop, linux, java

sudo Sergeant 17: Pi No HDMI Revisited GPIO

tariq.ahmad — Mon, 13 Aug 2018 22:54:07 GMT

Current Revision posted to Documents by tariq.ahmad on 8/13/2018 10:54:07 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Felix reviews the connections between the Raspberry Pi, the TFT adapter, and the button matrix for the Raspberry Pi No HDMI projects.

sudo Sergeant 13: Driving a TFT Screen Using GPIO

sudo Sergeant 14: Enabling Buttons on the Raspberry Pi No HDMI

Episode 322: Rasp Pi No HDMI - Portable MAME Part 1

Episode 328: Rasp Pi No HDMI - Portable MAME Part 2

Felix revisits the Raspberry Pi no HDMI project. There were quite a few questions on the community regarding the GPIO connections between the Raspberry Pi and the TFT along with the button matrix. The github repository for this project includes the bill of material, data sheets, enclosure, OS setup, and schematics. In there you can find the GPIO set up, along with a spreadsheet for the GPIO connections, under the OS set up. A good reference for this can be found at www.raspberrypi.org/documentation/hardware/raspberrypi/dpi/README.md. There you can find a chart that shows the different modes that can output the display through the GPIO.

They are using the 565 configuration for the TFT display. It opens up GPIO 27 to 20 for the button matrix. The connections they go with for the TFT screen are GPIO 27, 22, 26, 23, 24, 25, 20, and 21. Finally, Felix shows you where to look for the connections on the Raspberry Pi itself.

Tags: tft screen, raspberry pi no hdmi, gpio, schematics, button matrix, gpio connections, device tree overlay, raspbian, sudosergeant, linux

sudo Sergeant 18: Pi No HDMI Revisited Security

tariq.ahmad — Mon, 13 Aug 2018 22:53:42 GMT

Current Revision posted to Documents by tariq.ahmad on 8/13/2018 10:53:42 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Felix revisits the No Pi HDMI project. This time he’s going to take a look at the security vulnerability that he opened up allowing remote login over SSH as root. He’s going to first close up that security vulnerability and then show you another way to access files over the network in a more secure manner.

sudo Sergeant 13: Driving a TFT Screen Using GPIO

sudo Sergeant 14: Enabling Buttons on the Raspberry Pi No HDMI

Episode 322: Rasp Pi No HDMI - Portable MAME Part 1

Episode 328: Rasp Pi No HDMI - Portable MAME Part 2

sudo Sergeant 17: Pi No HDMI Revisited GPIO

Tags: tft screen, raspberry pi no hdmi, security, gpio, schematics, button matrix, ssh, gpio connections, system administration, device tree overlay, raspbian, sudosergeant, linux

sudo Sergeant 04: Ditch the Arduino IDE for the Linux Terminal

tariq.ahmad — Sun, 18 Mar 2018 17:54:24 GMT

Current Revision posted to Documents by tariq.ahmad on 3/18/2018 5:54:24 PM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

Featured Bonus Content

See All Episodes

www.youtube.com/watch

The Arduino Development Environment is cross platform which is another way of saying that its available for Linux. What you might not be aware of is that you're not locked down to it, not even on Linux. If you're like Felix, you may find the Arduino Development Environment to clunky for your taste. sudo Sergeant shows you how you can sidestep the Arduino Development Environment, and code the way you want to!

Felix Exclusive: Arduino Development Environment Alternatives . . .

clear;
programTitle="${1}";
programFind="`find ../Development -name ${programTitle}`";
programPath="${programFind%/*}";
programName="${programFind##*/}";
cd "${programPath}/${programName}";
currentPath="`pwd`";
echo;
echo "Program Info";
echo;
echo "Program Title = ${programTitle}";
echo "Program Find  = ${programFind}";
echo "Program Path  = ${programPath}";
echo "Program Name  = ${programName}";
echo "Current Path  = ${currentPath}";
echo;
# this is where arduino does all the work
arduino --board adafruit:avr:feather32u4 --verbose-build --verbose-upload --preserve-temp-files --upload --port /dev/ttyACM0 ${programName}.ino
programBuildTmpPath="`find /tmp -name ${programTitle}.ino.elf 2>/dev/null | sed 's|^/tmp/||' `" # | sed 's|^/tmp/||'"; #find /tmp \( -not -readable -o -not -executable \) -prune -name 'adruino_build*'
programBuild="`dirname ${programBuildTmpPath}`";
programBuildPath="/tmp/${programBuild}";
programParentPath="`dirname ${currentPath}`";
programBuildPathNew="${programParentPath}/${programTitle}_Build";
echo "Program Info";
echo;
echo "Program Title = ${programTitle}";
echo "Program Find  = ${programFind}";
echo "Program Path  = ${programPath}";
echo "Program Name  = ${programName}";
echo "Current Path  = ${currentPath}";
echo;
echo "Program Build Info";
echo;
echo "Program Build Path Tmp  = ${programBuildPath}";

In this segment the sudo Sergeant demonstates how you can sidestep the Arduino Development Environment. If you're like Felix and you are familiar with the Arduino IDE, you can press "Ctrl ," to go to the preferences and interface with an external editor. While you'll still need the Arduino Development Environment open in order to compile and upload code, you can choose an environment that is more comfortable for you while you are coding. Felix was looking for more flexibility than that so he went looking for ways to compile to terminal. He stumbled upon some instructions on how to do this on the Arduino manual page. He walks you through how to call Arduino directly from terminal. He's already looked up and found the arguments you need to send to it and written a script so it takes the argument, uses that argument to find out where the code is, and takes the .INO file and uses it as the input for the arguments going into the Arduino through terminal. In order to find out all the arguments that would be necessary to send to Arduino from the terminal in the preferences of Arduino you need to click on show verbose output during compilation and upload.

Felix shares his screen to show you what the output looks like when you go to compile. He goes through the output and finds the line that tells him the microcontroller argument that he needs to send to. He also sends along the argument for the .INO file that he wants to compile. Its at this point that he closes out the output screen, as he's got his script right in front of him. The editor of choice for handling his script on Linux is the K Develop IDE. He appreciates its look and feel as well as the fact that he can split his windows into two, giving him a pane on the left and the right. This also allows him to use a dropdown to go to run and configure launches. Felix demonstrates the steps he takes to call the script he wrote, Soroban Programmer. He sends an argument to the script. This is the point where you hit "Shift F9" on your keyboard. This does the same thing as hitting "Ctrl u" on the Arduino Development Environment.

Do you have a preferred way to code outside the Arduino Development Environment?

Let us know in the comments below!

Tags: arduino programing, sudo sergeant, arduino terminal, sudo feedback arduino, arduino_vcp, gnu linux, arduino ide, arduino_tutorials, arduino, sudosergeant

sudo Sergeant 11: Account Management

tariq.ahmad — Sat, 24 Feb 2018 03:02:02 GMT

Current Revision posted to Documents by tariq.ahmad on 2/24/2018 3:02:02 AM

element14's The Ben Heck Show

Join the Ben Heck team every week for amazing hacks! Watch them build and mod community-inspired projects using electronics!

Back to The Ben Heck Show homepage

sudo Sergeant

The Learning Circuit

See All Episodes

www.youtube.com/watch

Linux is a multi-user operating system that allows more than one user to use Linux at the same time. An important role of a system administrator is managing accounts. Felix goes over some of the mechanisms used for account management. He shows you how to create accounts, modify accounts, and remove accounts.

From terminal, Felix takes a look at all the accounts on his machine:

$ cat /etc/passwd

This takes him to all the accounts that are on the system. To add an account you would use:

$ sudo useradd -m -G sudo -s /bin/bash username

This creates a user account named username with sudo privileges. To login to your new account you will need to first setup a password:

$ sudo passwd username

You’ll be asked to create a new password and the system will tell you when it has been updated. To login to your new account you would switch users using:

$ su username

To get out of the directory you were just in use:

$ cd ~

You’ve now created a new account, given it a password, given it sudo privileges, created a login shell, and home directory. You can now view the new user account by using:

$ cat/etc/password

To change the directory that the user account is located in use:

$ sudo usermod -d /home/newdirectory -m user

This will change the directory from username to user. To change the shell from /bin/bash to /bin/zsh you would use:

$ sudo usermod -s /bin/zsh

To change the account name you would use following command:

$ sudo usermod -l newusername username

This changes the account name from username to newusername. You can confirm this by typing in:

$ cat /etc/passwd

To add a system account you would use the user add instruction again:

$ sudo useradd -r -s /usr/nologin system-account

This would be useful, for instance, if you had some kind of a background daemon running that needed a user. You would assign a system account to the group. To delete this account when you no longer need it, you would use the following command:

$ sudo userdel -r system-account

Tags: multiuseroperatingsystem, putty, system administration, open source, command line, sudo, sudosergeant, linux