Embedded Lovers : B 97 :Work log /Useful Information only --NO QUERIES PLZ--

sankalpnegi2310

Share the work done or any useful info u come across while learning..it may include info/tips/tricks..DO NOT POST QUERIES..For queries use the query forum..

sankalpnegi2310

General issue when using close();

compression.c:18:2: warning: implicit declaration of function ‘close’ [-Wimplicit-function-declaration]
close(fd);
^
gcc -c decompression.c
decompression.c: In function ‘decompression’:
decompression.c:18:2: warning: implicit declaration of function ‘close’ [-Wimplicit-function-declaration]
close(fd);

Solution:

we need to include unistd.h header file for close() sys call

just add : #include<unistd.h>

prerequisite can be known by reading the MAN pages for the particular function..
eg man close

sankalpnegi2310

in case of makefiles...

gen format
Target: Dependencies
           Rule

but every new line will be taken as a rule hence it will get difficult to write a conditional or structure etc which constitutes more than one line within itself..

for

clean:
        if ( rm *.o )
        then
        echo cleaned
        else
        echo already cleaned

will give errors...

Solution:

clean:
        ./script

now include all statements/structures in this script
make it "chmod +x script"

now use : make clean
it may now also be done under: ./script

sankalpnegi2310

Script to display the contents of current directory via 'ls -alt' by iterating through each line of text using IFS value as '\n'. number at last displays total iterations or basically no of files/dir.

#! /bin/bash

#IFS=$' ' #space as as separator any no of spaces

IFS=$'\n' #new line as separator

var=0
for i in `ls -atl`
do
echo $i
#sleep 1
var=$[$var+1]   #using $[] for var++ spaces are optional in $[]

#var=`expr $var + 1`    #using expr for var++ spaces are mandatory

done
echo $var #counts items in file depending on IFS value.

sankalpnegi2310

Some cool scripts i wrote as a beginner...let me know of the tweaks if any:

Note: The scripts have been tested.However, @sankalpnegi2310 will not be responsible for any undesired results to your system due to these scripts.

1.) To update system and checking unmet dependencies

#! /bin/bash

sudo apt-get update -y
sudo apt-get upgrade -y
sudo apt-get dist-upgrade -y

if (sudo apt-get check)
then
        echo
        echo All dependencies are good

else
        echo
        echo Checking broken dependencies
        echo
        if (sudo apt-get install -f)
        then
                echo All broken dependencies have been fixed..!!
        else
                echo Unable to fix:Manual fix required
        fi
fi

2.) To backup all data (C_programs in this case) to windows drive by mounting the drive and then unmounting the same..

#! /bin/bash

if (sudo umount /dev/sda6)
then
        sudo mount /dev/sda6 /mnt
        sudo cp -r -f -u -v /home/xenial-xerus/Desktop/C_programs /mnt/C_Programs_Backup
        sudo umount /dev/sda6
        echo
        echo "Backup Done. We are safe !!"

else
        clear
        sudo mount /dev/sda6 /mnt
        sudo cp -r -f -u -v /home/xenial-xerus/Desktop/C_programs /mnt/C_Programs_Backup
        sudo umount /dev/sda6
        echo
        echo "Backup Done. We are safe !!"
fi

#SO AT THE END OF THE DAY WE SAY:
# ./update && ./backup ---->> TO UPDATE AND BACKUP

sankalpnegi2310

Just BASH things:

1.Each cmd returns 0 on successful execution.

2.A script is never compiled but executed,hence no thing as compile time errors.

3.Error values from 1-255....eg. 127: no such cmd

4.There are no datatypes, everything is string.

5.use back ticks for storing cmds in variable.

6.Env Var IFS is use to decide as to what will be treated as a separator, by default it has blanks spaces,tabs,newlines.However its value can be modified using--> $IFS=$'\n' on new line will be treated as a separator nothing else.

7.The control parses the contents of the function but does not execute /enter the func body unless externally called from some other place.The function definition should always be before the calling cmd.

8.Env Var $? stores the exit value of the last cmd.The exit value of the last cmd is also the exit value of that func unless return is specified in which case the value returned shall be stored in $? as the exit value of the function.

9.functional parameters beginning with $1,$2...$n for n no of arguments passed on to the function/script.
$0----> name of the script not function (cannot be changed) as it is the first argument for shell that is the cmd itself,hence $0.
$# ---> no of arguments passed
$@ / $* ---> all the arguments passed in the form of a set

9.shift cmd is used to shift the values for function parameters eg. $1 will now have value of $2...as so on
shift affects reduces one argument every time it is read hence $# value will be reduced by 1 each time.

10.Each function has its own set of functional parameters which are different from the script's parameters.

11. Env variable $REPLY will give value of user entry even when we do not explicitly use a variable to read that.

sankalpnegi2310

Useful tips:

1. RCS
we can use : "co -l -r<version> <filename.ext>" to get back the required version of our source file ssaved in rcs...just replace version with the required version and filename.ext with required filename and extension..but make sure u check in the current file using : "ci <filename.ext>" or u will get two locks..which may prevent further revision of the file.

2. If we want to replace a string with another in vim editor use the following:
":%s/<previous>/<new>/g"
This will change all the occurrences..no need to change manually..:)

sankalpnegi2310

Multi Linux Distros Grub issue?

Soln.

When we install multiple linux distros.. booting is cool unless we have distros belonging to different linux family like debian, redhat etc.. In which case we need to deal with the differences in certain haeic cmds... for example fedora doesnt understand the basic "linux" and "initrd" cmd so it will show cmd not found error..

Solution is to boot into the preferred OS and then run a Boot repair.. proceed as instructed.. and u will end up with a new grub menu enabling booting into any of tge installed OS.

adeshagarwal02

worked on
RCS
check in ci
and co
created version file
head    1.1;
access;
symbols;
locks
        root:1.1; strict;
comment @ * @;

1.1
date    2017.05.29.09.09.59;    author root;    state Exp;
branches;
next    ;

vishwajeet.gaur1989

Generating an event when new file or Directory is created

Let us automate some of the things which we always need in our source code directory :-

We have always noticed that whenever we create any project we need rcs file in our directory of source code which is nothing but a shell script which automates our compiling job and also revision control.

By using below mentioned trick you can automate the manual procedure of creating RCS file whenever you create Project Directory/Folder.

Whenever a new folder is created it is empty. We can use inotifywait API which will wait for the creation of new Directory or file and once a file/Folder is created it can trigger set commands which can copy your generalised RCS file in the required Directory. If inotifywait API is not located in your system then kindly install inotify-tool package which can be downloaded using "sudo apt-get install inotify-tools". inotifywait API is located in inotify-tool package.
Considering inotifytool is installed in your system , Use below script --

#! /bin/bash
inotifywait -m -r /home/vishwajeet/Documents/Coding -e create -e moved_to |
while read path action file; do
if [[ -d $path$file ]]
then
cp rcs $path$file
fi
done

Save this file as filename (Example "create_rcs" or "notify" )
Give executable permission using chmod +x create_rcs
Now once you run this script in your terminal using ./notify you will be able to create any Folder in the above specified path(/home/vishwajeet/Document/Coding/ along with RCS file in it.

Please note:: This will only work till you execute ./notify and do not interrupt this process with any signal interrupt. Also after every reboot you will need to execute this script again.

To avoid this open your terminal and navigate to path of your notify file i.e., create_rcs file and type crontab -e .
Type @reboot /home/vishwajeet/notify
Close the terminal and reboot
Now you never need to run notify script or create_rcs script manually anymore. Every time you start your system notify process will run automatically and in your Coding path you will be always able to have rcs will in any new directory you create.

Tested on Xubuntu 16.04

sankalpnegi2310

@vishwajeet.gaur1989 great job !!

sankalpnegi2310

RCS issue while changing username !!!

We face an issue if we have a file with rcs applied and then try to access that with rcs again with a different username.
the issue is very logical as we should ot be allowed to to access the the locked rcs file and edit it with a different username even if we are root
for example if we are were working on a project with rcs applied over it, and then we change to root, we will be able to compile our new code but the version file wont be changed as the author is different
it will show us that the file is previously been locked by 'old user'

SOLUTION

We need to break the lock ( unlock -u argument )using the cmd :

rcs -u <filename>,v (for a specific file)

rcs -u *,v (for all files)

This will reset the user name, however no loss of any other information is seen.
hence now we can re-rcs our files and then lock them as required.
NOTE: it may show u to delete any writable files present, so do it, u wont lose anything as we have a RCS version file for it.

Post issues, if any !!

sankalpnegi2310

Static variables -- Explained

Static variables are created and initialized only once, i.e they wont be initialized again even if the same statement(that initialized the static variable is called again), meaning their value cannot be changed by re-initialization.
However, the keyword "static" does not make the variable a constant, its value can be changed by performing arithmetic operations (but not re-initialization).
they are registered in the DATA segment of the program, and thus are present even when the function ends, till the time the program stays up, as they are not part of the local STACK segment, that gets destroyed every time the '}' bracket is encountered for the function (when ending the function).
Although the static variable present in the DATA segment doesn't get destroyed, it cannot be accessed by outside functions.
Static does not change the scope of the variable.
They come of handy when we wish to prevent any unintentional change via re-initialization for a variable in a function.

sankalpnegi2310

Compilation Process -- EXPLAINED

Compiler converts a C program into an executable. There are four phases for a C program to become an executable:

Pre-processing
Compilation
Assembly
Linking

By executing below command, We get the all intermediate files in the current directory along with the executable.

 $gcc –Wall –save-temps filename.c –o filename

Pre-processing

This is the first phase through which source code is passed. This phase include:

Removal of Comments
Expansion of Macros
Expansion of the included files.

if we open the .i file we will see :

Comments have gone
Macros have been expanded
Data from withim the header file has been copied to the source
Our C code is place at last

Compiling

The next step is to compile filename.i and produce an; intermediate compiled output file filename.s. This file is in assembly level instructions. Let’s see through this file using $vi filename.s

Assembly

In this phase the filename.s is taken as input and turned into filename.o
by assembler. This file contain machine level instructions. At this
phase, only existing code is converted into machine language, the
function calls like printf() are not resolved.

Linking

This is the final phase in which all the linking of function calls
with their definitions are done. Linker knows where all these functions
are implemented. Linker does some extra work also, it adds some extra
code to our program which is required when the program starts and ends.
For example, there is a code which is required for setting up the
environment like passing command line arguments. This task can be easily
verified by using $size filename.o and $size filename.
Through these commands, we know that how output file increases from an
object file to an executable file. This is because of the extra code
that linker adds with our program.

sankalpnegi2310

Little and Big Endian :

Little and big endian are two ways of storing multibyte data-types (
int, float, etc).
In little endian machines, last byte of binary representation of the multibyte data-type is stored first.
On the other hand, in big endian machines, first byte of binary representation of the multibyte data-type is stored first.
The below program checks for the system to be Little or big endian :
#include <stdio.h>
int main()
{
   unsigned int i = 1;
   char *c = (char*)&i;
   if (*c)
       printf("Little endian");
   else
       printf("Big endian");
   getchar();
   return 0;
}