Manejo basico de un modulo i2c lcd 2x16 con Arduino

Bienvenido a mi blog, hoy hablaremos un poco de como programar un manejo básico de un modulo I²C, LCD de 2 filas por 16 columnas, con nuestro Arduino UNO Rev3,  utilizando el lenguaje de programación Arduino (basado en Wiring) y el Software Arduino IDE (basado en Processing).

No es el objetivo de este articulo abordar toda la teoria y la historia de las pantallas lcd, asi que hare un breve resumen acotando que la LCD (Liquid Crystal Display) o pantalla de cristal líquido, es un dispositivo empleado para la visualización de contenidos o información de una forma gráfica, mediante caracteres, símbolos o pequeños dibujos. La pantalla LCD de 16×2 esta basada en el controlador HD44780 de Hitachi, dicha pantalla es un periférico que se utiliza ampliamente en proyectos con microcontroladores y el modulo I²C está gobernado internamente por un controlador PCF8574, el cual es un expansor de Entradas y Salidas digitales controlado por I²C que dirige todo su funcionamiento. En este caso vamos a emplear una LCD de 16x2, esto quiere decir que dispone de 2 filas de 16 caracteres cada una. En la siguiente imagen se puede observar la estructura de sus pines. La podemos dividir en, los pines de alimentación, los pines de control y los pines del bus de datos bidireccional. Por lo general podemos encontrar ademas, en su estructura, los pines de Anodo (+) de led backlight y cátodo (-) de led backlight [Los pines 15 y 16 de backligth se deben manejar de manera pulsante con una frecuencia de 60Hz, tambien se puede utilizar una resistencia fija de 10 ohmios 1/2 watio para alimentar el positivo del backligth en caso de hacerlo manualmente sin modulo I²C].

Si estamos empleando en nuestro proyecto una LCD con Arduino UNO Rev3, necesitamos determinar la dirección del dispositivo. Podemos usar el siguiente código estandar con Arduino (basado en Wiring), para ver cual es la dirección del Módulo I²C, para ello utilizaremos el Software Arduino IDE (basado en Processing) versión 1.8.15 (recuerda que este scanner es general para cualquier dispositivo I²C que conectes a tu arduino respetando la señalizacion de sus pines):

#include <Wire.h>

void setup()

{

  Wire.begin(); 
  Serial.begin(9600);
  Serial.println("\nI2C Scanner");

}

void loop()

{

  byte error, address;
  int nDevices;
  

  Serial.println("Scanning...");

  nDevices = 0;
  for(address = 1; address < 127; address++ )

  {

 // I2c_scanner utiliza el valor de retorno de la Write.endTransmisstion para ver si un dispositivo reconoció la dirección.

    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0)

    {

      Serial.print("Dispositivo I2C encontrado en la direccion hexadecimal 0x");
      if (address<16)
       Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");

      nDevices++;

    }

    else if (error==4)

    {

      Serial.print("Unknow error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);

    }    

  }

  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");

  delay(5000);                                // wait 5 seconds for next scan

}

Utilizaremos el pin +5Vcc del arduino UNO Rev3 para alimentar la lcd con los +5 voltios del puerto usb de la pc (Vcc), el pin gnd de la placa arduino ira a gnd de la lcd, el pin SDA del arduino ira a SDA de la lcd y el pin SCL del arduino ira a SCL de la lcd, como podemos ver en el siguiente esquematico:

Despues de montado el circuito y programado el I2C scan en el IDE de Arduino, podremos ver en el monitor serie, la direccion hexadecimal de nuestro dispositivo, la cual utilizaremos para crear ahora un pequeño sketch que maneje nuestra lcd, inicialmente deberemos descargar alguna librería que sea capaz de controlar la LCD via I2C directamente con Processing, para este caso usaremos la librería "LiquidCrystal_I2C.zip" que podemos descargar gratis desde este repositorio en github.

Para que funcione esta librería, debemos añadirla en el IDE mediante el menu programa - incluir libreria - Añadir biblioteca .zip

La librería "LiquidCrystal_I2C.zip" que utilizaremos dispone de los principales métodos:

• LiquidCrystal_I2C() – Constructor de la clase, configura el hardware.
• init() – Prepara el LCD para su uso.
• clear() – Borra todos los caracteres de la pantalla LCD.
• setCursor(col, row) – Permite mover el cursor a la posición indicada en sus parámetros.
• print() – Imprime una variable o literal en la pantalla
• scrollDisplayLeft() y scrollDisplayRight() – Recorre el contenido de la pantalla a la izquierda o a la derecha
• backlight() y noBacklight() – Métodos para encender / apagar la iluminación de fondo
• createChar(num, data) –  Crear un carácter definido por el usuario en la memoria del controlador de pantalla.

Programación Display LCD – I²C

El siguiente código puede ser usado con Arduino UNO Rev3 a modo de ejemplo:

#include <LiquidCrystal_I2C.h>       // Libreria que controla el I2C
#include <Wire.h>                               // La libreria Wire viene incluida en el IDE de arduino

LiquidCrystal_I2C lcd(0x27,16,2); // dependiendo del fabricante del LCD, la direccion 0x27 puede                                                                // cambiar, utilice el I2C_Scan primero por favor!

void setup() {

  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print(" PROTOCOLO  I2C ");  // Mensaje a desplegar
  lcd.setCursor(0,1);
  lcd.print("Prueba LCD 16x2 ");    // Mensaje 2 a desplegar
  delay(3000);                                  // espera 3 segundos con el mensaje estatico 

}

void loop() { 

  for(int c=0;c<12;c++){
  lcd.scrollDisplayLeft();       // Movimiento a la Izquierda
  delay(400);

  }

  for(int c=0; c<12;c++){
  lcd.scrollDisplayRight();    // Movimiento a la Derecha 
  delay(400); 

  }

}

La libreria y los códigos .ino de los ejemplos anteriores los puedes descargar gratis del repositorio de github que mencione más arriba. Tambien tengo los mismos códigos publicados en:

I2C_Scan.ino

https://create.arduino.cc/editor/jorgechac/eaad38ae-3d58-4617-b151-8ce6decc2924/preview

I2C_LCD_16x2.ino

https://create.arduino.cc/editor/jorgechac/1dc82806-7b66-4105-bdda-47176a28fb6c/preview

Finalmente recordemos que con las pantallas OLED estos modulos lcd iran descontinuandose poco a poco, tambien recordemos que este es solo el manejo básico de una pantalla LCD con Arduino, a medida que avancemos iremos añadiendo mas funciones y aumentando la complejidad.

Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.

También te puede interesar:

Nuevo Microcontrolador Raspberry Pi Pico

Convierte facilmente una Fuente ATX de PC en una Fuente para alimentar tus proyectos Arduino y/o Raspberry Pi

Como Grabar el Bootloader de Arduino

Bootloader USB para Microcontroladores PIC 18F2550 y PIC18F4550

Diseño y fabricación de PCB profesionales con Fritzing

Conociendo La Familia de los Módulos WiFi para Arduino ESP8266

Cómo Detectar un Arduino Falsificado

ChipKIT™ Max32™ El Arduino de Microchip

Manejo básico de un modulo I2C LCD 2x16 con Raspberry Pi Pico

Bienvenido a mi blog, hoy hablaremos un poco de como realizar un manejo básico de un modulo I²C LCD, de 2 filas por 16 columnas, con nuestra Raspberry Pi Pico usando MicroPython. Inicialmente, debemos conocer las funciones del I²C con Micropython para poder determinar la dirección I²C del componente y posteriormente, conectar la Raspberry Pi Pico al LCD 16×2 I²C. A partir de la documentación oficial de MicroPython podemos determinar:

i²c = machine.I²C(id = -1 , * , scl , sda , frecuencia = 400000)

Se construye el objeto I²C usando los siguientes parámetros:

• id identifica un periférico I²C en particular. El valor predeterminado de -1 selecciona una implementación de software de I²C que puede funcionar (en la mayoría de los casos) con pines arbitrarios para SCL y SDA. Si id es -1, entonces se deben especificar los pines scl y sda . Otros valores permitidos para id dependen del puerto/placa en particular, dado que hay placas que poseen varios puertos I²C y la especificación de scl y sda puede o no ser requerida o permitida en este caso.
• scl debe ser un objeto tipo pin que especifique el pin que se utilizará para SCL.
• sda debe ser un objeto tipo pin que especifique el pin que se utilizará para SDA.
• freq debe ser un número entero que establezca la frecuencia máxima para SCL.

"Construir un objeto en Micropython significa crear una instancia de una clase. Una clase es un modelo o plantilla para crear objetos con atributos y métodos específicos. Para construir un objeto, primero se define la clase y luego se crea una instancia de esa clase utilizando paréntesis".

Para esta publicación asumo que el usuario ya ha cargado previamente el firmware de Micropython en su Raspberry Pi Pico y que ya tiene instalado el IDE de Thonny, además de que ya tenga bases de manejo de LCD en otras plataformas como Arduino o PIC.

No es el objetivo de este articulo abordar toda la teoría y la historia de las pantallas lcd, así que hare un breve resumen acotando que la LCD (Liquid Crystal Display) o pantalla de cristal líquido, es un dispositivo empleado para la visualización de contenidos o información de una forma gráfica, mediante caracteres, símbolos o pequeños dibujos. La pantalla LCD de 16×2 esta basada en el controlador HD44780 de Hitachi, dicha pantalla es un periférico que se utiliza ampliamente en proyectos con microcontroladores y el modulo I²C está gobernado internamente por un controlador PCF8574, el cúal es un expansor de Entradas y Salidas digitales controlado por I²C que dirige todo su funcionamiento. En este caso vamos a emplear una LCD de 16x2, esto quiere decir que dispone de 2 filas de 16 caracteres cada una. En la siguiente imagen se puede observar la estructura de sus pines. La podemos dividir en, los pines de alimentación, los pines de control y los pines del bus de datos bidireccional. Por lo general podemos encontrar además, en su estructura, los pines de Ánodo (+) de led backlight y cátodo (-) de led backlight [Los pines 15 y 16 de backligth se deben manejar de manera pulsante con una frecuencia de 60Hz, también se puede utilizar una resistencia fija de 10 ohmios 1/2 watio para alimentar el positivo del backligth en caso de hacerlo manualmente sin modulo I²C].

Si estamos empleando en nuestro proyecto una LCD con la Raspberry Pi Pico, necesitamos determinar la dirección del dispositivo. Podemos usar el siguiente código estándar con MicroPython para averiguar cúal es la dirección del Módulo I²C, para ello utilizaremos el IDE de Thonny (recuerda que este scanner es general para cualquier dispositivo I²C que conectes a tu Raspberry Pi Pico respetando el conexionado de sus pines):

# ----------------------------------------------------------------------------
# (| " I2C_Scan.py                                                         "|)
# (| " Este es un sencillo sketch para escanear buscando un dispositivo    "|)
# (| " I2C conectado en I2C cero, localizandolo e imprimiendo la dirección "|)
# (| " encontrada en hexadecimal, en la shell o consola, con una raspberry "|)
# (| " pi pico y MicroPython.                                              "|)
# (| "                                                                     "|)
# (| " Usaremos los valores predeterminados de I2C0, para el dispositivo   "|)
# (| " I2C: SCL= Pin GP9, SDA= Pin GP8 Vcc= VBUS GND= GND de la raspberry  "|)
# (| " pi pico.                                                            "|)
# (| "                                                                     "|)
# (| " Este código de ejemplo es de dominio público.                       "|)
# (| "                                                                     "|)
# (| " Maker: jorgechac©                                                   "|)
# (| " Visita  https://jorgechac.blogspot.com                              "|)
# (| "                                                                     "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32                 "|)
# (| " Whatsapp y Ventas NEQUI +573177295861                               "|)
# (| " Bucaramanga - Colombia                                              "|)
# (| " Simulaciön https://wokwi.com/projects/339117994278912596            "|)
# (| " Descarga gratis este sketch desde el Repositorio de GitHub:         "|)
# (| " https://github.com/jorgechacblogspot/micropython_pico               "|)
# (| " https://jorgechac.blogspot.com/2021/04/raspberry-pi-pico-pin-mapping.html "|)
# ----------------------------------------------------------------------------------

from machine import Pin                  # importamos la funcion pin del
										 # modulo machine
from machine import I2C                  # importamos la funcion I2C del
										 # modulo machine
import utime

sda = Pin(8)                             # objeto tipo pin que especifica
										 # el pin que se utilizará para SDA,
                                         # en este caso utilizaremos GP8
                                         # como sda

scl = Pin(9)                             # objeto tipo pin que especifica
										 # el pin que se utilizará para SCL,
                                         # en este caso utilizaremos GP9
                                         # como scl
                                            
i2c = I2C(0,sda=sda,scl=scl,freq=400000) # le decimos que vamos a usar
										 # I2C cero y frecuencia max de
                                         # 400k para scl
direccion = hex(i2c.scan()[0])           # primera posicion que entrega
										 # i2c.scan
print('I2C Scanner')
print('Scanning...')
print('Dispositivo I2C encontrado en la direccion hexadecimal', direccion,'!')

Figura 1

👉Simulación Wokwi del I²C Scan👈

Utilizaremos el pin 40 VBUS de la pico para alimentar la LCD con los +5 voltios del puerto USB de la PC, el pin 38 que es GND de la pico irá a GND de la LCD, el pin GP8 de la pico irá a SDA de la LCD y el pin GP9 de la pico irá a SCL de la LCD, como vimos en el simulador wokwi y como podemos ver en el siguiente esquemático hecho con Fritzing (aquí podemos ver el pin mapping de la pico):

Después de montado el circuito y programado el I²C Scan en Thonny, podremos ver en la shell o consola que nos muestra la sesión del interprete de python, la dirección hexadecimal de nuestro dispositivo, la cual utilizaremos para crear ahora un pequeño sketch que maneje nuestra lcd, inicialmente deberemos descargar alguna librería que sea capaz de controlar la LCD vía I²C directamente con MicroPython, para este caso usaremos las librerías "lcd_api.py" y "pico_i2c_lcd.py" que podemos descargar gratis desde este repositorio en github.

Para que funcionen estas librerías, debemos pasar los archivos lcd_api.py y pico_i2c_lcd.py a la memoria interna de la Raspberry Pi Pico. Eso lo podemos hacer con el IDE de Thonny, dando click en VIEW/FILES, se abrirá la ventana de archivos, donde en la parte superior te muestra los archivos que tiene tu computador y en la parte inferior los archivos de tu raspberry pi pico, debemos dar click derecho sobre los archivos que deseamos pasar a la memoria de la pico y dar click donde dice "Upload to/"

Finalmente verificamos que los archivos se encuentren dentro de la Flash de la PICO inspeccionando la parte inferior izquierda de la Figura 1.

Funciones de la librería:

• lcd.putstr (“¡El texto va aquí!”) – Envía una cadena de caracteres a la pantalla. IMPORTANTE: para imprimir una variable puedes usar la siguiente instrucción: lcd.putstr (str (Variable)) [Convierte la variable en una cadena]
• lcd.show_cursor() / lcd.hide_cursor() – Mostrar / Ocultar el cursor de la pantalla lcd (barra blanca)
• lcd.blink_cursor_on() / lcd.blink_cursor_off() – Enciende / apaga el cursor parpadeante al imprimir
• lcd.backlight_on() / lcd.backlight_off() – Enciende / apaga la luz de fondo de la pantalla LCD (controlada por un pequeño transistor en la biblioteca)
• lcd.display_on() / lcd.display_off() – Enciende / apaga la pantalla (no la retroiluminación sino todo el chip)
• lcd.clear() - borra todos los caracteres o cualquier cosa escrita en la pantalla
• lcd.move_to(Col, Row) – Mover a la posición según los valores de fila y col (Y, X)
• lcd.custom_char(Num, bytearray ([caracteres HEX]))) – Num puede ser cualquier número entero 0 – 8 (escribiendo en ubicaciones CGRAM) simplemente utilizado para numerar. Los caracteres HEX pueden ser creados usando este enlace: https://maxpromer.github.io/LCD-Character-Creator/ . El cual proporciona una cadena de caracteres hexadecimales que pueden reemplazar los “caracteres HEX” en el comando de ejemplo.

Código en MicroPython Display LCD – I²C

El siguiente código puede ser usado con la Raspberry Pi Pico a modo de ejemplo, si se desea modificar basta solo configurar los pines empleados para la comunicación I²C:

from time import sleep_ms

from machine import I2C, Pin

from pico_i2c_lcd import I2cLcd

DEFAULT_I2C_ADDR = 0x27

def test_main():

    print("Running test_main")

    i2c = I2C(0,scl=Pin(9), sda=Pin(8), freq=400000)

    lcd = I2cLcd(i2c, DEFAULT_I2C_ADDR, 2, 16)

    lcd.putstr("PROTOCOLO I2C\nLCD 2x16")

    sleep_ms(3000)

    lcd.clear()

    count = 0

while True:

        lcd.move_to(0, 0)

        lcd.putstr("  SUBSCRIBETE!  ")

        sleep_ms(1000)

        lcd.clear()

        sleep_ms(1000)

test_main()

Finalmente vamos a visualizar un mensaje inicial y lanzaremos una animación de números en esquinas, efecto backspace y uso de la función backlight on y off por 3 segundos como ejemplo:

# ------------------------------------------------------------------------------------------------------------------

# pico_i2c_lcd_test2.py Sketch que implementa una pantalla LCD 2x16 HD44780

# conectada a través de PCF8574 via I2C.

# Se utiliza I2C 0 y SDA GP8 (pin 11) y SCL GP9 (pin 12).

# Visita https://jorgechac.blogspot.com Venta de accesorios Arduino/Raspberry Pi Pico

# ------------------------------------------------------------------------------------------------------------------

import utime

from machine import I2C,Pin

from lcd_api import LcdApi

from pico_i2c_lcd import I2cLcd

# El PCF8574 tiene una dirección seleccionable por jumper: 0x20 a 0x27

# la direccion de la LCD puede cambiar, utilice el I2C_Scan.py primero por favor!

I2C_ADDR  =  0x27

I2C_NUM_ROWS = 2    # numero de filas de la lcd

I2C_NUM_COLS = 16   # numero de columnas de la lcd

i2c = I2C(0, sda=Pin(8), scl=Pin(9), freq=400000) 

lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)

def lcd_str(message, col, row):

      lcd.move_to(col, row)

      lcd.putstr(message)

    

def main():

    

    while True:       

            lcd.clear()

            lcd.move_to(0,0)

            lcd.putstr("PROTOCOLO I2C   ")

            utime.sleep(2)

            lcd.move_to(0,1)

            lcd.putstr("LCD 2x16        ")

            utime.sleep(2)

            lcd.clear()

            lcd_str(" MicroPython by ", 0, 0)

            utime.sleep(2)

            lcd_str(" Raspberry Pico ", 0, 1)

            utime.sleep(3)

    

            lcd.clear()

            lcd_str("Numeros en", 3,0)

            lcd_str("Esquinas", 4,1)

            utime.sleep(1)

    

            lcd_str("1", 0,0)

            utime.sleep(1)

            lcd_str("2", 15,0)

            utime.sleep(1)

            lcd_str("3", 0,1)

            utime.sleep(1)

            lcd_str("4", 15,1)

            utime.sleep(1)

    

            lcd.clear()

            lcd_str("Suscribete", 0, 0)

            lcd_str("Activa: CAMPANA", 0, 1)

            lcd.blink_cursor_on()

            utime.sleep(2)

    

            #Efecto Backspace

            for j in range(1, -1, -1):      # iterador J objeto que permite recorrer un contenedor

                for i in range(15, -1, -1): # contador decremental

                     lcd.move_to(i, j)

                     lcd.putstr(' ')

                     utime.sleep_ms(100)

            utime.sleep(1)

            lcd.hide_cursor()

            #BackLight OFF por 3 segundos

            lcd.clear()

            lcd.backlight_off()

            lcd_str("BackLight OFF", 0, 0)

            utime.sleep(3)

            #BackLight ON por 3 segundos

            lcd.clear()

            lcd.backlight_on()

            lcd_str("BackLight ON", 0, 0)

            utime.sleep(3)

if __name__ == '__main__':

    main()

Las librerías y los códigos .py de los ejemplos anteriores los puedes descargar gratis del repositorio de github que mencione mas arriba. Finalmente recordemos que con las pantallas OLED estos módulos lcd irán descontinuándose poco a poco.

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

Recuerda que en https://jorgechac.blogspot.com nos dedicamos a construir una electrónica mejor! y apoyamos el proyecto CTC GO! (Creative Technologies in the Classroom) que es un programa de educación steam personalizable.

Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.

También te puede interesar:

Nuevo Microcontrolador Raspberry Pi Pico

Convierte fácilmente una Fuente ATX de PC en una Fuente para alimentar tus proyectos Arduino y/o Raspberry Pi

Como Grabar el Bootloader de Arduino

Bootloader USB para Microcontroladores PIC 18F2550 y PIC18F4550

Diseño y fabricación de PCB profesionales con Fritzing

Conociendo La Familia de los Módulos WiFi para Arduino ESP8266

Cómo Detectar un Arduino Falsificado

ChipKIT™ Max32™ El Arduino de Microchip

Cómo borrar aplicaciones Preinstaladas de fabrica en móviles Android sin Root

Bienvenido a mi blog, hoy hablaremos un poco de como borrar aplicaciones preinstaladas de fabrica en móviles Android sin Root, si has comprado un móvil habrás visto que viene con aplicaciones preinstaladas como juegos y otras cosas que solo ocupan espacio y al final muchas veces no utilizamos ni queremos, este contenido se denomina "bloatware" y hoy vamos a ver cómo borrarlo. Gracias a este articulo podrás borrar cualquier app que esté instalada en tu dispositivo de fabrica, sea un navegador, una aplicación de banco, una aplicación del sistema, un juego, etc.

Bloatware es la combinación de bloat (inflado) y ware, la forma en la que afecta a tu móvil el bloatware es acaparando recursos, además si la app  se ejecuta por si sola, también usará memoria RAM y potencia de la CPU. Los fabricantes instalan bloatware en los dispositivos a cambio de acuerdos comerciales millonarios: si una aplicación está preinstalada y no se puede borrar fácilmente, tiende a ser utilizada. Esto ocurre con NetFlix, Google Chrome o incluso BBVA en el caso de algunos móviles Xiaomi. Si las aplicaciones pagan tanto dinero no es para que los usuarios las puedan eliminar de forma sencilla. Es por esto que necesitamos algo más que una app Android y un par de pasos para acabar borrando estas aplicaciones preinstaladas de fabrica. Si sigues todos los pasos con detenimiento podrás dejar tu móvil bien limpio de bloatware en poco tiempo.

Para este proceso necesitas un ordenador (Windows, Mac o Linux) y una herramienta gratuita para desarrolladores: SDK Manager.

• Entra en este enlace desde tu pc y descarga SDK Manager para Windows (en mi ejemplo tengo Windows 11)
• Debes pulsar sobre el archivo descargado .zip click derecho y seleccionar la opción ‘Extraer en Platform-tools’

Con estos dos sencillos pasos podrás tener lista la herramienta SDK Manager que más adelante utilizaremos para borrar apps preinstaladas de fábrica. Recuerda que el sdk platform tools o SDK Manager, es una herramienta independiente de la versión de Android Studio y es utilizada tanto por el entorno de desarrollo como por la línea de comandos. Algunas de las funciones que ofrece incluye la depuración de aplicaciones, la instalación y desinstalación de aplicaciones en dispositivos Android, la ejecución de comandos de shell en el dispositivo y mucho más.

En tu dispositivo Android también vas a necesitar una herramienta gratuita y sencilla. Se trata de la aplicación "App Inspector". Una vez la tengas instalada en tu Android debes seguir estos pasos:

• Entra en App Inspector
• Busca la aplicación de fábrica que quieres desinstalar
• Pulsa sobre ella y copia el ‘Package Name‘
• En mi caso he elegido la app de navegador google chrome con el Package Name ‘com.android.chrome‘. Este es el nombre que debes copiar y guardar para más adelante.
• Activa la ‘Depuración USB’ y conecta el móvil a la PC.
• En la ventana emergente que te aparece en tu móvil debes pulsar sobre ‘Transferir Archivos‘ para que el PC lo reconozca correctamente.
• Durante el proceso tu Android te pedirá permiso para acceder así que hay que estar pendiente de los mensajes en la pantalla del móvil y dar la autorización.

Para poder borrar estas aplicaciones tan molestas es necesario abrir una ventana de comandos específica en tu ordenador.

• Abre en tu pc la carpeta ‘Platform-tools’
• Deja pulsada la tecla shift y haz click derecho dentro de la carpeta
• Selecciona la opción ‘Abrir la ventana de PowerShell aquí’

Ahora debemos ir digitando los siguientes comandos para que la ventana PowerShell reconozca el dispositivo y sepa qué aplicaciones debe borrar.

1. Digita el comando ".\adb.exe devices" y pulsa la tecla enter

2. Digita el comando ".\adb.exe shell" y pulsa la tecla enter

3. Digita el comando "pm uninstall -k –-user 0 nombredelpaquete" y pulsa la tecla enter

En el comando ‘pm uninstall -k –user 0 nombredelpaquete’ debes sustituir ‘nombredelpaquete’ por el nombre que habías apuntado desde la aplicación App Inspector. En mi caso el comando para borrar la aplicación del navegador google chrome sería el siguiente: "pm uninstall -k –-user 0 com.android.chrome"

Finalmente debes realizar el paso 3 con todas las aplicaciones que quieras borrar de tu dispositivo y con esto ya tendrás desinstaladas las apps y sin necesidad de ser usuario root.

App Inspector es una aplicacion ligera, completamente segura y confiable, te invito a leer su Politica de Privacidad (PrivacyPolicy).

Puedes descargar App Inspector aqui.

Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.

También te puede interesar:

Magisk

BusyBox

Unroot

APKUpdater - Mantén Actualizadas tus Aplicaciones Android

adAway - Bloqueo de Publicidad en Android

SatFinder

Spirit2 - Radio FM en tu Móvil

Creacion de Particiones desde simbolo del sistema

Bienvenido a mi blog, hoy hablaremos un poco acerca de la creación de particiones desde el símbolo del sistema durante la instalación de Windows 11, recordemos que las particiones son divisiones del disco duro que funcionan como una unidad independiente, al formatear una pc desde cero el procedimiento que sigo a nivel personal es el siguiente:

1. Sacar una copia de la información personal del usuario a un disco duro externo usb.

2. Formateo a bajo de nivel del disco duro (destruye todo, virus, datos, tabla de particiones y asegura un inicio limpio desde cero, NO APLICA PARA SSD).

3. Creación de Particiones.

4. Instalación de Windows.

5. Configuración, instalación de software's, actualización y optimización.

El formateo a bajo nivel ya fue expuesto en el articulo hdd-low-level-format-tool que puedes ver aqui.

Desde el mismo hirents bootcd, después del formateo a bajo nivel podemos crear las particiones necesarias en el formato requerido, ya sea Windows (NTFS) o Linux (EXT), con herramientas embedidas como disk genius o partition manager, pero el día de hoy vamos a realizar y aprender el procedimiento realizándolo desde el símbolo del sistema, una vez booteada la pc desde la unidad usb e iniciado el instalador de Windows tenemos como ejemplo este disco duro de 1 tera byte:

Lo que queremos es crear una partición primaria (y marcada como activa) de 120 GB, donde se almacenara el sistema operativo, los software y drivers y el resto de espacio que sea una partición extendida y dentro de ella una partición lógica, donde el usuario alojara toda su información personal y guardara allí todo lo que creara y con lo que trabajara. Antiguamente se creaban particiones de 20, 40, 60 o 80 GB para el sistema operativo, pero hoy en día con el tamaño del Windows, las actualizaciones, el office y la cantidad de programas que la gente maneja, una partición de 120 GB es un tamaño razonable para la mayoría de usuarios.

Estando en la pantalla mostrada anteriormente, procedemos a pulsar simultáneamente la combinación de teclas "shift+F10" (en portatiles y equipos todo en uno puede ser necesaria la combinación Fn+Shift+F10) lo cual nos abrirá el símbolo del sistema y allí escribiremos el comando "diskpart" y a continuación digitamos el comando "list disk", el cual nos mostrara un listado de los discos detectados con su respectivo tamaño, para este ejemplo nuestro disco de 1 TB aparece como disco 0 como vemos a continuación y procedemos a seleccionarlo escribiendo el comando "select disk 0" y procedemos a crear nuestra primera partición primaria de 120GB. Recordemos que 120GB son 120 x 1024 = 122880 MB entonces ejecutamos el comando "create partition primary size=122880"

Con esto acabamos de crear un partición primaria de 120GB, ahora ejecutamos el comando "list partition" con esto nos visualizara el listado de particiones en el disco seleccionado al principio y allí podremos ver el número y la partición primaria o principal acabada de crear, ahora ejecutamos el comando "select partition 1" para seleccionar esa partición y con el comando "active" procedemos a marcarla como la partición activa.

Procedemos ahora a arrastrar un poco hacia abajo la ventana del símbolo del sistema y en la pantalla inicial de la instalación de Windows hacemos click en actualizar, de esta forma veremos la partición primaria o de sistema que acabamos de crear y el espacio restante el cual utilizaremos para crear nuestra segunda partición, en este caso nos visualiza que aun hay disponibles 811.5 GB:

Volvemos a la ventana del símbolo del sistema y vamos a crear ahora una partición extendida de 811.5 x 1024 = 830976 MB, para ello ejecutamos el comando "create partition extended size= 830976" y a continuación digitamos "list partition" para ver el número de la partición que acabamos de crear, en nuestro ejemplo creo la partición extendida numero cero y la seleccionamos ejecutando el comando "select partition 0" y ya teniendo seleccionada nuestra partición extendida creamos dentro de ella la partición lógica con el comando "create partition logical size=830976" y finalmente cerramos el símbolo de sistema.

Ahora procedemos a actualizar nuevamente y debemos obtener un resultado como este, donde nos muestra una partición primaria de 120 GB y una partición lógica de 811.5 GB:

Para terminar procedemos a formatear cada partición seleccionándola y dando click en formatear, y finalmente seleccionamos la partición de sistema de 120 GB y hacemos click en siguiente, para iniciar el proceso de instalación de Windows.

Como los ves es muy sencillo, solo debemos seguir la lógica y la sintaxis de la utilidad Diskpart, aunque debemos tener en cuenta, si la forma de almacenar la información sobre las particiones se hará en formato MBR (Master Boot Record) o en formato GPT (GUID Partition Table) 😱.

Preguntas frecuentes:

1. ¿Qué es MBR?

MBR, Master Boot Record, es un tipo de disco más antiguo introducido por primera vez con IBM PC DOS 2.0 en 1983. Se llama así por el sector de arranque situado al principio de un disco (el primer sector) llamado MBR.

La desventaja más obvia de un disco MBR es que sólo funciona con un tamaño máximo de 2TB (≈2.2TB) en un disco. Esto significa que si tienes un disco más grande que 2TB con el estilo de partición MBR, sólo puedes usar como máximo el espacio de 2TB en él.

2. Como comprobar el estilo de partición actual de un disco?

- Presione las teclas Win + R para abrir la ventana Ejecutar.

- Escribe "diskmgmt.msc" y haga clic en Aceptar para abrir la administración de discos.

- Haga clic con el botón secundario en el disco que desea comprobar y haga clic en Propiedades.

- Elija la pestaña Volumen para verificar el estilo de partición.

También podemos verificar el esquema de partición mediante diskpart, ejecutamos list disk y en el listado de discos que nos muestra veremos con un asterisco aquellos que tengan particionamiento GPT:

Desde alli mismo podremos modificar el sistema de particionamiento de GPT a MBR o de MBR a GPT.

3. Cuando se trabaja con particionamiento GPT?

Se trabaja con GPT por lo general en equipos más nuevos que cuentan con bios UEFI, te podrás dar cuenta porque si creaste una usb con Rufus y seleccionaste "esquema de partición GPT", al intentar instalar el sistema operativo y el disco esté configurado como MBR, arrojara error.

Si tu hardware soporta GPT, utiliza GPT.

4. Que ventajas presenta GPT?

Es más flexible y tiene mejor compatibilidad con el hardware moderno. Teóricamente, puedes crear un número ilimitado de particiones en un disco GPT. Sin embargo, el número de particiones que puede crear estará limitado por el sistema operativo. Por ejemplo, en Windows, cada entrada de partición es de 128 bytes, por lo tanto, puede crear un número máximo de 128 (32*512/128=128) particiones en Windows. Esto es lo que diferencia notablemente un disco GTP de un disco MBR.

No hay una partición extendida o particiones lógicas en un disco GPT ya que no hay límites en cuanto a la cantidad de particiones primarias que se pueden crear.

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

Recuerda que en https://jorgechac.blogspot.com nos dedicamos a construir una electrónica mejor!

Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.

Compra ya tu conversor M2 a USB 3.0

También te puede interesar:

DISCOS SSD - GENERALIDADES

UEFI y BIOS - Generalidades

ShowKeyPlus - Muestra la licencia actual de Windows

Activa tu Windows 11 fácil

WinRAR x64

USB Killer

Convierte fácilmente una Fuente ATX de PC en una Fuente para alimentar tus proyectos Arduino y/o Raspberry Pi