Olá pessoal.

Este script faz a conversão de números entre binários, decimais, octais e hexadecimais. Não utilizei nenhum tipo de calculadora, procurei fazer sem dependências, apenas com operadores, ER e controle de caracteres.

Funciona da seguinte forma:

$ ./convert.sh [formato de entrada] [número] [formato de saída]

Onde:

-b= binário
-o= octal
-d= decimal
-x= hexadecimal

Exemplos de uso:

Binário para hexadecimal:

$ ./convert.sh -b 1111101 -x

Ele vai retornar:
7D

Decimal para octal:

$ ./convert -d 467 -o

Retorna:
723

Espero que seja útil a alguém.

• Download convert.sh
• Enviar nova versão

Esconder código-fonte

#!/bin/bash
# convert.sh
#
# Script faz a conversão de formatos numérios entre as notações binário, 
# octal, decimal e hexadecimal.
#
# Conversor de formato numérico
# Versão 1.0: Conversor de decimal para binário
# Versão 1.1: Adicionado conversor binário para decimal
# Versão 1.2: Adicionado conversor de decimal para hexadecimal
# Versão 1.3: Adicionado conversor de hexadecimal para decimal
# Versão 1.4: Adicionado conversor de decimal para octal
# Versão 1.5: Adicionado conversor de octal para dicimal
# Versão 1.4: Adicionado demais conversores usando como base as conversões
# sobre a notação decimal
#
# Joanes Duarte, Maio 2013
#

########################[ FUNÇÕES DE INFORMAÇÃO ]#########################

opcoes_de_uso() {
echo -e "{FONTE}33[1mUso: $(basename "$0") [OPÇÕES]{FONTE}33[m"
echo './convert.sh [formato de entrada] [número] [formato de saída]'
echo
echo -e "{FONTE}33[1mOPÇÕES{FONTE}33[m

  -b --binario      Opção usada para converter número binário como formato
         de entrada ou para número binário como formato de saída.

  -o --octal      Opção usada para converter número octal como formato
         de entrada ou para número octal como formato de saída.

  -d --decimal      Opção usada para converter número decimal como formato
         de entrada ou para número decimal como formato de saída.

  -x --hexadecimal   Opção usada para converter número octal como formato
         de entrada ou para número octal como formato de saída.

  -h, --help            Mostra esta tela de ajuda do programa.

  -V, --version         Mostra a versão do programa.
"
exit 1
}

# Extrai versão diretamente do cabeçalho do programa
versao() {
echo -n $(basename "$0")
grep '^# Versão ' "$0" | tail -1 | cut -d : -f 1 | tr -d \#
exit 0
}

#########################[ FUNÇÕES DE TESTE ] ##############################

### TESTE DECIMAL
teste_decimal() {
[[ "$ENTRADA" =~ ^[0-9]+$ ]] && decimal_par_3 \
|| echo "Notação decimal inválida."
}

# TESTE BINÁRIO
teste_binario() {
[[ "$ENTRADA" =~ ^[0-1]+$ ]] && binario_par_3 \
|| echo "Notação binária inválida."
} 

# TESTE HEXADECIMAL
teste_hexadecimal() {
[[ "$ENTRADA" =~ ^[0-9a-fA-F]+$ ]] && hexadecimal_par_3 \
|| echo "Notação hexadecimal inválida."
}

# TESTE OCTAL
teste_octal() {
[[ "$ENTRADA" =~ ^[0-8]+$ ]] && octal_par_3 \
|| echo "Notação octal inválida."
}

########################[ FUNÇÕES DE CONVERSÃO ]############################

### DECIMAL PARA BINÁRIO
decimal_binario() {

while [ "$ENTRADA" -gt 1 ]
do
   RESTO=$(($ENTRADA % 2))       # Armazena o valor do resto da divisão   
   ENTRADA=$(($ENTRADA / 2))    # (1 ou 0) no arquivo de saída.
   echo -n $RESTO >> calc_temp.txt
done
   RESTO=$(($ENTRADA % 2))
   echo -n $RESTO >> calc_temp.txt
   BINARIO=$(cat calc_temp.txt | rev) ; rm calc_temp.txt
}

### BINARIO PARA DECIMAL
binario_decimal() {

NUM_CARAC=$(echo ${#ENTRADA}) # Conta nº de caracteres da variavel
EXPOENTE=0
DECIMAL=0
while [ "$NUM_CARAC" -gt 0 ]
do
   (( NUM_CARAC -- ))

   CARACTERE=$(echo ${ENTRADA:${NUM_CARAC}:1}) # Do último para o primeiro
   MULT=$((2 ** $EXPOENTE * $CARACTERE))       # pega cada caractere,
   DECIMAL=$(($DECIMAL + $MULT))          # calcula o valor e soma                           # na variavel
   (( EXPOENTE ++ ))
done
}

### DECIMAL PARA HEXADECIMAL
decimal_hexadecimal() {

if [ "$ENTRADA" -lt 10 ]
then
   HEXADECIMAL=$ENTRADA

elif [ "$ENTRADA" -lt 16 ]
then
   [[ "$ENTRADA" -eq 10 ]] && HEXADECIMAL=A
   [[ "$ENTRADA" -eq 11 ]] && HEXADECIMAL=B
   [[ "$ENTRADA" -eq 12 ]] && HEXADECIMAL=C
   [[ "$ENTRADA" -eq 13 ]] && HEXADECIMAL=D
   [[ "$ENTRADA" -eq 14 ]] && HEXADECIMAL=E
   [[ "$ENTRADA" -eq 15 ]] && HEXADECIMAL=F

else
while [ "$ENTRADA" -gt 1 ]
do
   RESTO=$(($ENTRADA % 16))   
   ENTRADA=$(($ENTRADA / 16))
   [[ "$RESTO" -eq 10 ]] && RESTO=A
   [[ "$RESTO" -eq 11 ]] && RESTO=B
   [[ "$RESTO" -eq 12 ]] && RESTO=C
   [[ "$RESTO" -eq 13 ]] && RESTO=D
   [[ "$RESTO" -eq 14 ]] && RESTO=E
   [[ "$RESTO" -eq 15 ]] && RESTO=F
   echo -n $RESTO >> calc_temp.txt
done
   RESTO=$(($ENTRADA % 16))
   [[ "$RESTO" -eq 10 ]] && RESTO=A
   [[ "$RESTO" -eq 11 ]] && RESTO=B
   [[ "$RESTO" -eq 12 ]] && RESTO=C
   [[ "$RESTO" -eq 13 ]] && RESTO=D
   [[ "$RESTO" -eq 14 ]] && RESTO=E
   [[ "$RESTO" -eq 15 ]] && RESTO=F
   echo -n $RESTO >> calc_temp.txt
   HEXADECIMAL=$(cat calc_temp.txt | rev | sed 's/^0//') ; rm calc_temp.txt
fi
}

### HEXADECIMAL PARA DECIMAL
hexadecimal_decimal() {

NUM_CARAC=$(echo ${#ENTRADA}) # Conta nº de caracteres da variavel
EXPOENTE=0
DECIMAL=0
while [ "$NUM_CARAC" -gt 0 ]
do
   (( NUM_CARAC -- ))

   CARACTERE=$(echo ${ENTRADA:${NUM_CARAC}:1})

   [[ "$CARACTERE" = [Aa] ]] && CARACTERE=10   # Trecho faz a
   [[ "$CARACTERE" = [Bb] ]] && CARACTERE=11   # transformaçao
   [[ "$CARACTERE" = [Cc] ]] && CARACTERE=12   # da letra
   [[ "$CARACTERE" = [Dd] ]] && CARACTERE=13   # no número
   [[ "$CARACTERE" = [Ee] ]] && CARACTERE=14   # equivalente
   [[ "$CARACTERE" = [Ff] ]] && CARACTERE=15

   MULT=$((16 ** $EXPOENTE * $CARACTERE))
   DECIMAL=$(($DECIMAL + $MULT))

   (( EXPOENTE ++ ))
done
}

### DECIMAL PARA OCTAL
decimal_octal() {

while [ "$ENTRADA" -gt 1 ]
do
   RESTO=$(($ENTRADA % 8))       # Armazena o valor do resto da divisão   
   ENTRADA=$(($ENTRADA / 8))    # (1 ou 0) no arquivo de saída.
   echo -n $RESTO >> calc_temp.txt
done
   RESTO=$(($ENTRADA % 8))
   echo -n $RESTO >> calc_temp.txt
   OCTAL=$(cat calc_temp.txt | rev | sed 's/^0//') ; rm calc_temp.txt
}

### OCTAL PARA DECIMAL
octal_decimal() {

NUM_CARAC=$(echo ${#ENTRADA}) # Conta nº de caracteres da variavel
EXPOENTE=0
DECIMAL=0
while [ "$NUM_CARAC" -gt 0 ]
do
   (( NUM_CARAC -- ))

   CARACTERE=$(echo ${ENTRADA:${NUM_CARAC}:1}) # Do último para o primeiro
   MULT=$((8 ** $EXPOENTE * $CARACTERE))       # pega cada caractere,
   DECIMAL=$(($DECIMAL + $MULT))                  # calcula o valor e soma na variavel
   (( EXPOENTE ++ ))
done
}

################[ Tratamento das opções de linha de comando ]#################

### DIRECIONAMENTO DO PARÂMETRO 3
decimal_par_3() {
        case "$SAIDA" in
                -b | --binario) decimal_binario ;
      echo -e "{FONTE}33[1m${BINARIO}{FONTE}33[m" ; exit 0 ;;

      -d | --decimal) echo -e "{FONTE}33[1m${ENTRADA}{FONTE}33[m" ; exit 0 ;;

                -x | --hexadecimal) decimal_hexadecimal ;
      echo -e "{FONTE}33[1m${HEXADECIMAL}{FONTE}33[m" ; exit 0 ;;

                -o | --octal) decimal_octal ; echo -e "{FONTE}33[1m${OCTAL}{FONTE}33[m" ;
      exit 0;;
        esac
}

binario_par_3() {
       case "$SAIDA" in
      -b | --binario) echo -e "{FONTE}33[1m${ENTRADA}{FONTE}33[m"; exit 0 ;;

                -d | --decimal) binario_decimal ;
      echo -e "{FONTE}33[1m${DECIMAL}{FONTE}33[m" ; exit 0 ;;

                -x | --hexadecimal) binario_decimal ; ENTRADA="$DECIMAL" ;
      decimal_hexadecimal ; echo -e "{FONTE}33[1m${HEXADECIMAL}{FONTE}33[m"
      exit 0 ;;

                -o | --octal) binario_decimal ; ENTRADA="$DECIMAL" ;
      decimal_octal ; echo -e "{FONTE}33[1m${OCTAL}{FONTE}33[m" ; exit 0 ;;
        esac
}

hexadecimal_par_3() {
       case "$SAIDA" in
      -b | --binario) hexadecimal_decimal ; ENTRADA="$DECIMAL" ;
      decimal_binario ; echo -e "{FONTE}33[1m${BINARIO}{FONTE}33[m" ; exit 0 ;;

                -d | --decimal) hexadecimal_decimal ;
      echo -e "{FONTE}33[1m${DECIMAL}{FONTE}33[m" ; exit 0 ;;

                -x | --hexadecimal) echo -e "{FONTE}33[1m${ENTRADA}{FONTE}33[m" ;
      exit 0 ;;

                -o | --octal) hexadecimal_decimal ; ENTRADA="$DECIMAL" ;
      decimal_octal ; echo -e "{FONTE}33[1m${OCTAL}{FONTE}33[m" ; exit 0 ;;
        esac
}

octal_par_3() {
       case "$SAIDA" in
      -b | --binario) octal_decimal ; ENTRADA="$DECIMAL" ;
      decimal_binario ; echo -e "{FONTE}33[1m${BINARIO}{FONTE}33[m" ; exit 0 ;;

                -d | --decimal) octal_decimal ;
      echo -e "{FONTE}33[1m${DECIMAL}{FONTE}33[m" ; exit 0 ;;

                -x | --hexadecimal) octal_decimal ; ENTRADA=$DECIMAL ;
      decimal_hexadecimal ; echo -e "{FONTE}33[1m${HEXADECIMAL}{FONTE}33[m" ;
      exit 0 ;;

                -o | --octal) echo -e "{FONTE}33[1m${ENTRADA}{FONTE}33[m"; exit 0 ;;
        esac
}

### DIRECIONAMENTO DO PARÂMETRO 1

# Aceita 3 parâmetros ou -V, --version, -h e --help como único parâmetro
[[ "$1" =~ -(h|V)|--(version|help) ]] || [ "$#" -eq '3' ] || { opcoes_de_uso ; }

# Passado teste inicial define variaveis $1 e $2 e testa o parâmetro $1
ENTRADA=$2
SAIDA=$3

   case "$1" in
      -b | --binario) teste_binario ;;

      -d | --decimal) teste_decimal ;;

      -x | --hexadecimal) teste_hexadecimal ;;

      -o | --octal) teste_octal ;;

      -h | --help) opcoes_de_uso ;;

      -V | --version) versao ;;

      * ) opcoes_de_uso ;;
   esac

Criar .deb para sua aplicação

Script - Shell

Gerenciamento de espaço em disco

Script para gravar DVD, gera imagem e grava na mídia

rc.firewall