viernes, 25 de agosto de 2017

Abren las reservas del Core i9 7980XE, 18 núcleos y 36 hilos por 1.999 dólares

El minorista OCUK ha abierto las reservas de los procesadores Core i9 7980XE, nuevo tope de gama de Intel que como sabemos está basado en la arquitectura Skylake-X y cuenta con un total de 18 núcleos y 36 hilos.
Ese alto conteo de núcleos ha obligado a Intel a utilizar una velocidad de trabajo de 2,6 GHz, una cifra bastante baja si comparamos con los Core i7 7700K para consumo general de cuatro núcleos y ocho hilos ya que funcionan a 4,2 GHz de frecuencia base, aunque gracias al modo turbo los Core i9 7980XE pueden llegar a los 4,4 GHz reduciendo los núcleos activos.
El precio de los Core i9 7980XE es de 1.999 dólares, una cifra que en su llegada a Europa y tras la conversión a euros y la aplicación de impuestos podría acabar superando sin problema los 2.000 euros.
Tened en cuenta que aunque ya estén disponibles para precompra las primeras unidades no empezarán a llegar hasta el próximo 28 de agosto, así que todavía quedan unos días para que tengan disponibilidad real en el canal minorista.
Los procesadores Core X de intel se dividen en dos grandes grupos, Skylake-X y Kaby Lake-X. Los primeros se comercializan en configuraciones que van desde los seis núcleos y doce hilos hasta los 18 núcleos y 36 hilos, mientras que los segundos sólo llegan a los cuatro núcleos físicos y ocho hilos en su versión más potente.
Aunque ambos comparten la plataforma X299 y el socket LGA2066 también presentan diferencias importantes en este sentido, puesto que los primeros soportan memorias en cuádruple canal y hasta 44 líneas PCI, mientras que los segundos sólo soportan memorias en doble canal y 16 líneas PCIE.

Fuente:
http://www.muycomputer.com/2017/08/24/reservas-del-core-i9-7980xe/

domingo, 20 de agosto de 2017

Android Oreo será anunciado oficialmente el 21 de agosto


El gigante de Mountain View ha confirmado que Android Oreo será anunciado de forma oficial el próximo día 21 de agosto en un evento que celebrarán en la ciudad de Nueva York.
Se trata de un anuncio muy esperado y aunque Google no ha dicho de forma directa que vaya a utilizar el nombre Android Oreo ha acabado por confirmarlo de forma indirecta, ya que uno de los vídeos que subió a Gooogle+ relacionados con este anuncio se titulaba “GoogleOreo_Teaser_0817_noDroids (1).mp4”.
Por otro lado también debemos tener en cuenta el detalle que se ha marcado el conocido filtrador Evan Blass, quien ha lanzado un guiño a Android Oreo y a su fecha de presentación (coincide con el día del próximo eclipse de Sol) con la imagen adjunta al tweet que acompañamos en el artículo.
Es importante tener en cuenta que poco después Google decidió cambiar el nombre del vídeo por “Octopus”, que significa pulpo. Esto sugiere que cometieron un error y refuerza las teorías que dan por confirmado el nombre de Oreo, pero hasta que la firma de Mountain View lo comunique de forma oficial no hay nada seguro.
Los primeros terminales en recibir la actualización a Android O serán los de las series Nexus y Pixel. En el caso de los primeros sólo mantienen el soporte los Nexus 5X y Nexus 6P, que cerrarán con dicho sistema operativo el ciclo de actualizaciones de dos años que ofrece Google.
El resto de terminales que podemos dar por seguro que actualizarán a Android Oreo serán los tope de gama de los principales fabricantes lanzados este año; como el Galaxy S8, el HTC U11, el Huawei P10 y el LG G6.
También deberían actualizar los tope de gama del año pasado (Galaxy S7, HTC 10, Huawei P9 y LG G5), pero es muy probable que no reciban Android O hasta el primer o segundo trimestre de 2018.

Fuente:
http://www.muycomputer.com/2017/08/19/android-oreo-21-de-agosto/

viernes, 18 de agosto de 2017

Sony no Arduino: conocer Spritzer

Not long after the announcement by Intel that they would be withdrawing many of their embedded products, Sony have decided to enter the fray and will be showcasing an Arduino-compatible development board at the Tokyo Maker Faire. The board specification promises a multi-core ARM processor and built-in GPS/GLONASS capability.

Sony is normally associated with mass-produced electronic products such as TVs and more recently, high-quality professional cameras. An Arduino-sized development board bearing the name of Sony may at first look a little out of place in the world of open-source products and hacker-space projects that normally use boards bearing the names of semiconductors Manufacturers - especially microcontrollers and SoC producers. Sony is, never the less also a semiconductor manufacturer and is particularly strong in ​​camera sensor technology. The fact that Sony is also synonymous with SoCs, is also obvious from the Spritzer board layout which mixes ARM technology with Ardunio features.

The Spritzer board has the same dimensions and headers assignments as the classic Arduino Uno. It is equipped with its own ARM-SoC with six Cortex-M4F cores, which can be clocked at up to 156 MHz. There are also 1.5 MB SRAM, 8 MB Flash, 6 analog inputs, 8-channel audio processing and in addition to serial interfaces such as SPI, I2C, UART, four PWM outputs and GPS / GLONASS for global position information. The physical compatibility with the Arduino Uno makes it possible to use normal Arduino shields and the Arduino IDE can be used for software development. The board should be available at the start of 2018; the price has not yet been announced. Sony has a website (in Japanese) for the Spritzer and you can read a translation (courtesy of Google) here.

Fuente:
https://www.elektormagazine.com/news/sony-does-arduino-meet-spritzer


MPLAB de Microchip recibe nuevo depurador en circuito ICD 4

Para cargar un nuevo firmware en un microcontrolador y luego depurarlo usualmente se necesita una herramienta especial: el programador / depurador en circuito. Los microcontroladores PIC de Microchip no son una excepción a esto, y hasta hoy la herramienta preferida para programar y depurar micros PIC era el MPLAB ICD 3, el dispositivo en forma de disco que soportaba toda la gama de dispositivos PIC y dsPIC. Ahora, después de muchos años de servicios leales, el MPLAB ICD 3 finalmente está siendo reemplazado por el MPLAB ICD 4.
Al igual que su predecesor, el nuevo depurador MPLAB en circuito (ICD) 4 es redondo y está alojado en un estuche durable negro con una tapa de aluminio cepillado. El estado se indica con una tira de LED colorida (la barra azul en la foto) en lugar de los tres LEDs en el ICD 3. El ICD 4 incluye todas las características de la CIE 3, pero es aproximadamente dos veces más rápido. Este aumento de velocidad se debe a un MCU de 32 bits que funciona a 300 MHz ya una memoria intermedia de 2 MB.
Otras características nuevas son un rango de voltaje más amplio de 1,20 a 5,5 V y la posibilidad de conectar una fuente de alimentación externa para alimentar la placa de destino a través de la CIE 4. Proporciona resistencias de pull-up / pull-down seleccionables en el conector de depuración Conectados a través de relés), la velocidad de interfaz es configurable; Ha mejorado la detección de fallos y la inmunidad y también funciona con interfaces JTAG.
Una pregunta sigue siendo: ¿el CIE 4 también apoyará dispositivos AVR y ARM en el futuro?


Fuente:
https://www.elektormagazine.com/news/icd

lunes, 14 de agosto de 2017

Arduino Consola y puerto serie

Tutorial Arduino Consola y puerto serie. Interfaz creado con diversos lenguajes como C#, C++ CLR y VB .net bajo Visual Studio Community que puedes controlar el puerto serie a Arduino encendiendo y apagando un Led, manejar el LCD y recibes mensajes hacia el ordenador o PC.


En este apartado mostramos el código fuente en C#, en el PDF se encuentra C#, C++ CLR y VB .net.

Código C#:

 using System;
using System.IO.Ports;
using System.Text;

namespace Arduino_Consola_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Arduino Consola C#";

            // Tamaño ventana consola.
            Console.WindowWidth = 55; // X. Ancho.
            Console.WindowHeight = 18; // Y. Alto.

            // Cree un nuevo objeto SerialPort con la configuración predeterminada.
            SerialPort Puerto_serie = new SerialPort("COM4");

            Puerto_serie.BaudRate = 115200;
            Puerto_serie.Parity = Parity.None;
            Puerto_serie.StopBits = StopBits.One;
            Puerto_serie.DataBits = 8;
            Puerto_serie.Handshake = Handshake.None;
            Puerto_serie.RtsEnable = true;

            // Establecer los tiempos de espera de lectura / escritura.
            Puerto_serie.ReadTimeout = 500; // Milisegundos.
            Puerto_serie.WriteTimeout = 500;

            // Detecta cualquier dato recibido.
            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            Puerto_serie.Open(); // Abrir puerto.

            ConsoleKey tecla;
            Console.WriteLine("Pulse tecla 1 para encender y 2 para apagar:");

            do
            {
                tecla = Console.ReadKey(true).Key; // Espera pulsación de teclas.

                switch (tecla)
                {
                    case ConsoleKey.D1: // Tecla 1 del teclado estandar.
                    case ConsoleKey.NumPad1: // Tecla 1 del número del pad.
                        byte[] miBuffer1 = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
                        Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.
                        Console.WriteLine("Comando \"Luz_ON\" enviado."); // Muestra en pantalla comandos enviado.
                        break;

                    case ConsoleKey.D2:
                    case ConsoleKey.NumPad2:
                        byte[] miBuffer2 = Encoding.ASCII.GetBytes("Luz_OFF");
                        Puerto_serie.Write(miBuffer2, 0, miBuffer2.Length);
                        Console.WriteLine("Comando \"Luz_OFF\" enviado.");
                        break;

                    default:
                        Console.WriteLine("Tecla el 1, el 2 y Escape para salir.");
                        break;
                }
            } while (tecla != ConsoleKey.Escape); // Pulsa Escape para salir del menú.

            Console.WriteLine("Presione cualquier tecla para terminar...");
            Console.WriteLine();
            Console.ReadKey(); // Espera pulsar una tecla cualquiera.
            Puerto_serie.Close(); // Cierra el puerto serie.
        }

        // Detecta cualquier dato entrante.
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
            Console.WriteLine("Dato recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.
        }
    }
}





Código fuente en C# avanzado:

using System;
using System.IO;
using System.IO.Ports;
using System.Text;
using System.Speech.Recognition; // No olvidar. Micro.
using System.Speech.Synthesis; // No olvidar. Altavoz.

namespace Arduino_Consola_Color_Voz_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            string COM = "";

            // Título de la ventana.
            Console.Title = "Arduino Consola color y voz C#";

            // Tamaño ventana consola.
            Console.WindowWidth = 55; // X. Ancho.
            Console.WindowHeight = 18; // Y. Alto.

            SerialPort Puerto_serie;

            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
            Puerto_serie = new SerialPort();

            // Configuración.
            Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.

Puerto: ");
            COM = Console.ReadLine(); // Escribir el número del puerto.
            Console.Clear();

            Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.


            Puerto_serie.BaudRate = 115200; // Baudios.
            Puerto_serie.Parity = Parity.None; // Paridad.
            Puerto_serie.DataBits = 8; // Bits de datos.
            Puerto_serie.StopBits = StopBits.Two; // Bits de parada.
            Puerto_serie.Handshake = Handshake.None; // Control de flujo.

            // Establecer la lectura / escritura de los tiempos de espera.
            Puerto_serie.ReadTimeout = 500;
            Puerto_serie.WriteTimeout = 500;

            try
            {
                Puerto_serie.Open(); // Abrir el puerto serie.
            }

            catch (IOException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
                o no lo encuentra.");
                Console.ReadKey();   // Pulse cualquier tecla.
                Environment.Exit(1); // Salir de la aplicación.
            }



            // Detecta cualquier dato recibido.
            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            ConsoleKey tecla;
            Console.WriteLine("Pulse tecla 1 para encender, 2 para apagar y \n" +
                "Escape para salir. \n" +
                "--------------------------------------------------------------\n");

            do
            {
                tecla = Console.ReadKey(true).Key; // Espera pulsación de teclas.
                                                   // Inicializar una nueva instancia de SpeechSynthesizer.
                using (SpeechSynthesizer altavoz = new SpeechSynthesizer())
                {
                    // Configure la salida de audio.
                    altavoz.SetOutputToDefaultAudioDevice();

                    // Velocidad de la voz.
                    altavoz.Rate = -2; // Valores entre -10 a 10.

                    // Volumen de la voz.
                    altavoz.Volume = 100; // Valores entre 0 y 100.

                    switch (tecla)
                    {
                        case ConsoleKey.D1: // Tecla 1 del teclado estandar.
                        case ConsoleKey.NumPad1: // Tecla 1 del número del pad.
                            byte[] miBuffer1 = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
                            Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.
                            Console.ForegroundColor = ConsoleColor.Gray;
                            Console.Write("Comando"); // Muestra en pantalla comandos enviado.
                            Console.ForegroundColor = ConsoleColor.Green;
                            Console.Write(" \"Luz_ON\" ");
                            Console.ForegroundColor = ConsoleColor.Gray;
                            Console.WriteLine("enviado.");
                            Console.ForegroundColor = ConsoleColor.Gray;
                            altavoz.Speak("Luz encendida.");
                            break;

                        case ConsoleKey.D2:
                        case ConsoleKey.NumPad2:
                            byte[] miBuffer2 = Encoding.ASCII.GetBytes("Luz_OFF");
                            Puerto_serie.Write(miBuffer2, 0, miBuffer2.Length);
                            Console.ForegroundColor = ConsoleColor.Gray;
                            Console.Write("Comando"); // Muestra en pantalla comandos enviado.
                            Console.ForegroundColor = ConsoleColor.Green;
                            Console.Write(" \"Luz_OFF\" ");
                            Console.ForegroundColor = ConsoleColor.Gray;
                            Console.WriteLine("enviado.");
                            Console.ForegroundColor = ConsoleColor.Gray;
                            altavoz.Speak("Luz apagada.");
                            break;

                        case ConsoleKey.Escape:
                            Console.WriteLine("Saliendo...");
                            altavoz.Speak("Saliendo.");
                            break;

                        default:
                            Console.WriteLine("Tecla el 1, el 2 y Escape para salir.");                          
                            break;
                    }
                }
            } while (tecla != ConsoleKey.Escape); // Pulsa Escape para salir del menú.

            Console.ForegroundColor = ConsoleColor.Yellow;

            Console.WriteLine();
            Console.WriteLine("╔═════════════════════════════════════════════════════╗");
            Console.WriteLine("║ Electrónica PIC                 metaconta@gmail.com ║");
            Console.WriteLine("║                                                     ║");
            Console.WriteLine("║               Ángel Acaymo M. G.                    ║");
            Console.WriteLine("╚═════════════════════════════════════════════════════╝");
            Console.WriteLine();

            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("Pulse cualquier tecla para salir...");
            Console.WriteLine();
            Console.ReadKey(); // Espera pulsar una tecla cualquiera.
            Puerto_serie.Close(); // Cierra el puerto serie.
        }

        // Detecta cualquier dato entrante.
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
            Console.ForegroundColor = ConsoleColor.Gray;
            Console.Write("Dato recibido desde Arduino: "); // Muestra en pantalla los datos recibidos.
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(entradaDatos + "\n");
            Console.ForegroundColor = ConsoleColor.Gray;
        }

        // Maneje el evento SpeechRecognized.
        static void recognizer_SpeechRecognized(object sender, SpeechRecognizedEventArgs e)
        {
            Console.WriteLine("Texto reconocido: " + e.Result.Text);

            string palabras = e.Result.Text;
        }
    }
}



Código de Arduino:

// ----- Electrónica PIC -----
//
// Ejercicio 2.
//
// Encendido y apagado del Led 13 mediante puerto serie con pantalla.
// Es lo mismo que el Ejercicoi 1, pero usando el LCD Keypad Shield.

#include

// Inicializa la librería con sus pines indicados.
// RS, RW, Enable, D4, D5, D6, D7.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Pin 10 para saber que es luz de fondo.
const byte LuzFondo = 10;

const byte Led = 13;   // Declaramos la variable pin del Led.
char caracter;
String comando;

void setup()
{
  pinMode(Led, OUTPUT);  // Inicializa el pin del LED como salida:
  Serial.begin(115200);     // Puerto serie 115200 baudios.
  lcd.begin(16, 2);         // Formato de pantalla.
  lcd.clear();      // Borra la pantalla y su posición superior izquierda.
  lcd.print("    Arduino     ");
  delay(1000);
}

void loop()
{
  /*
    Voy leyendo carácter a carácter lo que se recibe por el canal serie
    (mientras llegue algún dato allí), y los voy concatenando uno tras otro
    en una cadena. En la práctica, si usamos el "Serial monitor" el bucle while
    acabará cuando pulsamos Enter. El delay es conveniente para no saturar el
    canal serie y que la concatenación se haga de forma ordenada.
  */
  while (Serial.available() > 0)
  {
    caracter = Serial.read();
    comando.concat(caracter);
    delay(10);
  }

  /*
    Una vez ya tengo la cadena "acabada", compruebo su valor y hago que
    la placa Arduino reacciones según sea este. Aquí podríamos hacer lo
    que quisiéramos: si el comando es "tal", enciende un Led, si es cual,
    mueve un motor... y así.
  */

  // Si los carácteres es recibido y verdadero.
  if (comando.equals("Luz_ON") == true)
  {
    digitalWrite(Led, HIGH); // Enciende el Led 13.
    Serial.write("ON - Led encendido.");    // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz ON.         "); // Mostrar en el LCD.
  }


  if (comando.equals("Luz_OFF") == true)
  {
    digitalWrite(Led, LOW); // Apaga el Led 13.
    Serial.write("OFF - Led apagado. ");  // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz OFF.        "); // Mostrar en el LCD.
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando = "";
}



Ver vídeo:

Ver visor:



Arduino consola y puerto serie from Ángel Acaymo M. G.

 Autor: Ángel Acaymo M. G.

Descarga:

PDF
PDF
PDF

XPS
XPS

Nintendo asume riesgos y no se deja influir por otros, dice NVIDIA

Es un hecho que Nintendo asume riesgos, basta echar un vistazo a todas las generaciones de consolas que ha lanzado la compañía nipona desde la Nintendo 64 (ésta incluida) hasta la actual Nintendo Switch.
La propia NVIDIA ha destacado esa cualidad de la firma japonesa, pero también ha indicado que Nintendo es una compañía a la que le gusta trabajar de forma independiente. Por ello Nintendo asume riesgos y además no se deja influir por otros, no se limita a seguir los estándares del mercado sino que se esfuerza por crear otros nuevos.
Un ejemplo claro lo vimos precisamente en Nintendo 64. La veterana consola introdujo el stick analógico en el mando de control y daba la opción de disfrutar de respuesta háptica (vibración), un movimiento que luego fue copiado hasta la saciedad por Sony (primer DualShock para PS1), SEGA (mando de Dreamcast) y Microsoft (primera Xbox).
Con GameCube, Wii y Wii U volvieron a demostrar que iban “por libre” aunque sólo tuvieron un gran éxito con la segunda, gracias a la idea de los sensores de movimiento y a los juegos sociales que lanzaron centrados en dicho sistema de control.
Durante su última conferencia de resultados Jen-Hsun Huang alabó el buen hacer de Nintendo con su última consola, la Switch, y dio a entender claramente que la innovación y los riesgos han vuelto a dar sus frutos, una referencia que podemos entender perfectamente al ver el enorme éxito que ha tenido la nueva consola de la gran N.
Es evidente que el hecho de que Nintendo Switch monte un SoC Tegra X1 ha “motivado” al CEO de NVIDIA a hablar de dicha consola, pero siendo justos hay que reconocer que la gran N asumió un gran desafío con dicha consola y que al final todo le ha salido de maravilla.

Fuente:
 http://www.muycomputer.com/2017/08/11/nintendo-asume-riesgos-nvidia/

Android O apunta al 21 de agosto

Android O (Android 8.0), la versión final de la nueva edición del sistema operativo que monopoliza el mercado del móvil inteligente, estaría disponible el 21 de agosto según el prolífico filtrador Evan Blass.
Android O debutará en los dispositivos propios de Google, los Pixel, Pixel XL, Nexus 5X, Nexus 6P, Nexus Player y Google Pixel C. Su llegada al resto de móviles Android dependerá de cada uno de los fabricantes. Y -con honrosas excepciones- no tendrán prisa y con ello aumentará la fragmentación de la plataforma y las acusaciones de obsolescencia tecnológica programada para vender nuevos modelos y seguir la cadena.
A falta de conocer el nombre del dulce, pastel o galleta con el que Google renombrará este Android O como ha venido sucediendo en versiones anteriores, la importancia de cada versión del sistema es notable, teniendo en cuenta que solo en 2017 serán comercializados cerca de 1.500 millones de nuevos terminales con Android.

Novedades Android O

Haremos el correspondiente análisis en su momento pero ve quedándote con algunas de las novedades. Entre otras:
  • Límite automático de apps en segundo plano. Continuando el trabajo iniciado en Nougat, Android O pondrá una gran prioridad en mejorar la vida de la batería y el rendimiento interactivo del dispositivo. Limitar el impacto de las aplicaciones que funcionan en segundo plano apunta a ello.
  • Canales de Notificaciones. Además de mejorar el sistema de notificaciones, poder posponer las mismas e incluir nuevos efectos visuales y de sonido, Google implementará los canales de notificaciones, nuevas categorías definidas por su contenido, que ofrecerán un mayor control del usuario para recibir, bloquear o administrar categorías completas de avisos. O distintas notificaciones dentro de la misma app.
  • Picture in Picture. Android O ofrecerá una mayor capacidad de multitarea (un aspecto solo “arañado” en Nougat) implementando de forma nativa la función Picture in Picture en móviles y tablets, que nos permitiría -por ejemplo- ver un vídeo de YouTube en una ventana flotante encima de otra aplicación.
  • Iconos adaptativos. Los desarrolladores podrá crear iconos de distintas formas para cada interfaz de usuario.
  • Navegación con teclado. Google mejorará el soporte y funcionamiento del sistema con este periférico. El motivo es claro, mejorar el funcionamiento una vez que las apps Android se han integrado en Chrome OS.
  • Conectividad. Para lograr la máxima fidelidad de audio, Android O añadirá compatibilidad con códecs Bluetooth de audio de alta calidad, como el códec LDAC.
  • WebView. Android O permite el modo multiproceso de forma predeterminada con una API para que una aplicación pueda controlar errores, ganando seguridad y una mayor estabilidad en la ejecución.
  • Java 8. La nueva versión incluye soporte para las nuevos APIs Lenguaje Java, incluyendo la nueva API java.time. Google promete que el tiempo de ejecución será más rápido que nunca, con mejoras de hasta 2 veces en algunos puntos de referencia.

Pruebas Android O

Si no quieres esperar al lanzamiento de la versión final, Google publicó un SDK actualizado con imágenes del sistema que ha ido actualizando con diferentes versiones de prueba. Las imágenes y las instrucciones de instalación están disponibles en la página para desarrolladores Android. Sólo se recomiendan para testeo y no para producción. Si estás desarrollando para la plataforma de wearables de Google, también está disponible un emulador para pruebas Android Wear 2.0 en Android O.

Fuente:
http://www.muycomputer.com/2017/08/14/android-o/

Cómo formatear dispositivos FAT32 mayores a 32 TB


FAT32 es uno de los sistemas de archivos más utilizados en unidades externas/extraíbles por su simplicidad y versatilidad. Una mejora del antiguo FAT creado para MS-DOS y usado en ediciones de consumo de Windows hasta Windows Me, soportado además en otros sistemas como GNU/Linux, FreeBSD y BeOS.
Aunque hay sistemas de archivos más avanzados en Windows (exFAT o NTFS), FAT32 sigue utilizándose en múltiples formatos por las ventajas mencionadas de soporte y portabilidad. El problema es que la herramienta estándar presente en Windows no puede formatear discos externos FAT32 con capacidades mayores a 32 TB, aunque sí puede manejarlos porque su límite teórico sube hasta 16 TB.

FAT32 con herramientas de terceros

Si tienes discos duros externos, pendrives USB o tarjetas microSD con capacidades de 64 GB o superiores, y quieres utilizar FAT32, hay herramientas de terceros que puedes utilizar para salvar la limitación de la herramienta estándar de Windows.
Una de ellas es FAT32 Format. Una aplicación gratuita y portable que no necesita instalación y facilita la tareas de formatear unidades FAT32 con capacidad superior a los 32 GB. Simplemente: descarga (botón Start del enlace), ejecuta, selecciona la unidad, activa el formateo rápido e inicia.

FAT32 con Powershell

La aplicación anterior es la recomendada por facilidad de uso y rapidez de ejecución, pero si quieres utilizar el mismo Windows hay otro método que salva la limitación de la herramienta de formateo estándar. Simplemente accede y usa el comando “format /FS:FAT32 X:” donde “X” es la unidad que queremos formatear:


La consola tarda bastante más tiempo en realizar el formateo por lo que te recomendamos el uso de FAT32 Format. En ambos casos recuerda que el manejo de archivos individuales en FAT 32 es de 4 Gbytes. El límite teórico de la capacidad de la unidad con este tipo de sistema de archivos es de 16 TB, sobrado para toda la base de dispositivos en el mercado.

Fuente:
http://www.muycomputer.com/2017/08/14/fat32/

domingo, 6 de agosto de 2017

Microsoft actualiza los colores de la consola de Windows después de 20 años

La consola de Windows también existe y cuenta con opciones interesantes si se sabe manejar, especialmente en su versión avanzada PowerShell.
Hablamos del símbolo del sistema (Command prompt o CMD), la aplicación utilizada en sistemas basados en NT (Windows XP, Windows 7 o Windows 10) para ejecutar comandos MS-DOS (.exe de 16 bits) y otros como scripts con formato .bat y .sys.
Esta línea de comandos permite comunicarnos directamente con el equipo y realizar una serie de tareas. Escribimos el comando (y sus modificadores en su caso) y la aplicación CMD hace de intérprete para su ejecución. La aplicación funciona en modo texto y no es necesariamente intuitiva, aunque sigue siendo una opción recomendable para usuarios medios o avanzados ya que permite realizar tareas de forma más flexible y rápida o acceder a información o funciones que no están disponibles de ninguna otra manera.
La consola de Windows no ha cambiado sustancialmente a lo largo de su historia, pero Microsoft ha ido realizando cambios ligeros para mejorar su funcionalidad, además de lo que supone la llegada de una característica como Bash para ejecutar binarios de Linux en Windows 10 desde la línea de comandos, scripts Bash, comandos de Linux como sed, awk, grep y herramientas como Ruby, Git o Python, directamente en Windows.
Otro de los cambios ha llegado al canal Insider (a partir de la compilación 16257) y se implementará en la versión final de la próxima versión, Fall Creators Update. Se trata de la actualización de la paleta de color de la consola de Windows, después de 20 años de usar la misma. Un cambio sutil que habían pedido los desarrolladores y que debe mejorar la legibilidad en las pantallas de visualización modernas de alto contraste.
Si quieres introducirte en la consola de Windows no dejes de repasar nuestra guía a los Comandos CMD.

Fuente:
http://www.muycomputer.com/2017/08/04/consola-de-windows-color/

Raspberry Pi 3 Slim, la computadora más delgada del mundo

Raspberry Pi 3 Slim es un proyecto de NODE que pretende adelgazar aún más la última versión del desarrollo más interesante del segmento del Mini-PC de placa única.
Una versión slim que recorta puertos adicionales a la placa de Raspberry Pi 3 y suma un chasis creado mediante impresión 3D. El resultado es un ordenador totalmente funcional que cabe en un bolsillo, más potente que la versión reducida oficial (Raspberry Pi Zero W), con el tamaño de una baraja de cartas y un grosor de 7 mm.
Raspberry Pi 3 Slim
NODE ha eliminado los puertos USB, HDMI, Ethernet y pines GPIO. A cambio, ha añadido tres puertos microUSB soldados a la placa. El desarrollo conserva la conectividad inalámbrica Wi-Fi y Bluetooth, la tarjeta microSD accesible en la parte inferior del dispositivo, el chipset Broadcom BCM2837 con procesador de 64 bits, una GPU VideoCore IV a 400 MHz y el Gbyte de memoria LPDDR2.
Raspberry Pi 3 Slim
Aunque pierde funcionalidad respecto al original, Raspberry Pi 3 Slim es una auténtica chulada, muestra de lo mucho que se puede hacer con Raspberry Pi, un desarrollo responsabilidad de la fundación británica sin ánimo de lucro del mismo nombre, que se está haciendo muy popular en amplios ámbitos más allá de su objetivo original: estimular la enseñanza de ciencias de la computación en las escuelas.
NODE proporciona en GitHub los archivos necesarios para crear el chasis en impresión 3D y distinta información del desarrollo por si terceros se animan a realizarlo.

Fuente:
http://www.muycomputer.com/2017/08/04/raspberry-pi-3-slim/

La NASA capta una enorme tormenta en el polo norte de Júpiter

Gracias a la sonda Juno la NASA ha podido captar imágenes de una tormenta enorme situada en el polo norte de Júpiter. Su forma ovalada ocupa una gran parte del planeta, pero lo más impresionante es que la misma lleva activa varias décadas.
Según las observaciones previas que se han llevado a cabo de esta tormenta, conocida con el nombre de “North North Temperate Little Red Spot 1”, sabemos que está en activo desde 1993 pero su antigüedad podría ser mucho mayor.
En la información oficial que ha dado la NASA hemos podido confirmar que esta tormenta ubicada en el polo norte de Júpiter tiene un diámetro de 6.000 kilómetros y que es de tipo anticiclónico, lo que significa que es una zona de altas presiones en la que su aire interior es más estable que el aire que tiene a su alrededor.
Por tamaño es la tercera tormenta más grande de Júpiter pero además cambia de color. En la imagen podemos ver que la parte más externa de la tormenta aparece en blanco y que su interior, donde se encuentran los vientos más rápidos, tiene un tono anaranjado.
Como sabemos Júpiter es un gigante de gas y por tanto las tormentas y los vientos huracanados son algo habitual en dicho planeta, aunque las acumulaciones tormentosas tan grandes como ésta siempre consiguen sorprendernos.
La sonda Juno también nos permitió ver de nuevo la gran mancha roja de Júpiter, una enorme tormenta que tiene un diámetro de 16.000 kilómetros, cifra que supera de largo los 12.742 kilómetros de la Tierra.

Fuente:
http://www.muycomputer.com/2017/08/04/tormenta-polo-norte-jupiter/

Nanopartículas para facilitar trasplantes y evitar rechazos, un avance importante

Los trasplantes de órganos se han convertido en un auténtico salvavidas para muchas personas. Es un tratamiento esencial que no entiende de edades y que en la mayoría de los casos da una segunda oportunidad a los pacientes, pero al mismo tiempo resulta muy complicado.
Para que sea posible llevar a cabo un trasplante primero hay que encontrar a un donante que sea compatible, luego hay que llevar a cabo una complicada operación y finalmente hay que realizar un tratamiento para reducir las posibilidades de rechazo por parte del sistema inmunitario del paciente, que puede reconocer el nuevo órgano como un cuerpo extraño y atacarlo.
Investigadores de la Universidad de Yale han logrado desarrollar un tratamiento basado en nanopartículas que una vez aplicado interfiere con la actuación de los glóbulos blancos, evitando que éstos consideren a los órganos trasplantados como cuerpos extraño y haciendo que no los ataquen.
No es un tratamiento definitivo ya que tiene una duración máxima de seis semanas, pero ofrece un periodo de tiempo que permite a los médicos prepararse para hacer frente a un posible rechazo y evitar que las consecuencias del mismo escalen con gran rapidez.
La aplicación de este tratamiento se produce de forma totalmente dirigida, es decir gracias a esas nanopartículas es posible llevar los fármacos que evitan el rechazo directamente al órgano que queremos proteger. Esto es muy importante, ya que potencia la eficacia el mismo y a su vez evita que se puedan llegar a producir daños colaterales.
Es un planteamiento muy prometedor dentro del mundo de los trasplantes, pero debemos tener en cuenta que todavía se encuentra en una etapa temprana así que aún queda mucho camino por recorrer antes de que este tratamiento se empiece a aplicar en entornos reales.

Fuente:
http://www.muycomputer.com/2017/08/06/nanoparticulass-facilitar-trasplantes/

IBM y Sony destruyen el récord de almacenamiento en cinta con un cartucho de 330 TB

Y no es más grande que la palma de tu mano

 

El usuario promedio lo ha abandonado hace años, pero el almacenamiento en cinta demuestra una vez más que tiene mucha tela para cortar. Gracias a un nuevo desarrollo en conjunto, IBM Research y Sony lograron crear un prototipo de cinta magnética con una densidad de 201 gigabits por pulgada cuadrada, lo que equivale a un cartucho compacto de 330 terabytes. Si consideramos que la mejor cinta del mercado guarda un máximo de 15 terabytes, nos encontramos ante un avance extraordinario, e imaginamos que el mundo empresarial no puede esperar para clavar sus garras en esta tecnología.

Los usuarios necesitan cada vez más capacidad de almacenamiento en sus ordenadores, cortesía de juegos gigantescos y contenido 4K, entre otras cosas. Tanto Western Digital como Seagate ofrecen unidades de 12 terabytes, y aún recordamos bien a cierto prototipo de SSD con unos escalofriantes 60 terabytes. Sin embargo, cuando nos trasladamos al entorno empresarial, las soluciones en cinta presentan números muy interesantes. La próxima generación del estándar LTO llegará a los 12.8 terabytes, e IBM ya comercializa su cartucho 3592 de 15 TB. Por supuesto, las aplicaciones son muy diferentes, pero eso no le quita méritos a una tecnología que lleva más de 60 años en desarrollo.

En el día de ayer, el almacenamiento magnético dio otro paso gigantesco con la ayuda de IBM Research y Sony. El resultado es una nueva cinta basada en una deposición física de vapor conocida como «sputtering» que guarda un máximo de 201 gigabits por pulgada cuadrada, acompañada por un sistema de cabezales y procesamiento de señales especialmente diseñado para leer y escribir a semejante densidad. Si a eso sumamos el detalle de que Sony puede colocar más de un kilómetro de cinta en un cartucho, los cálculos sugieren una capacidad teórica que pasa de 220 de 330 terabytes sin compresión, en algo tan grande como la palma de nuestra mano.

Lógicamente, IBM visualiza para la nueva cinta aplicaciones de respaldo en la nube, almacenamiento frío y el ocasional entorno WORM, pero esos 201 gigabits por pulgada cuadrada son apenas un escalón. Los voceros de la compañía están convencidos de que la escala del almacenamiento en cinta seguirá subiendo en los próximos años, tal y como lo ha hecho hasta ahora.

Fuente:
http://www.neoteo.com/ibm-y-sony-destruyen-el-record-de-almacenamiento-en-cinta-con-un-cartucho-de-330-tb/
 

martes, 1 de agosto de 2017

Recordando a la Mega 32X, un periférico de 32 bits para Mega Drive

Mega 32X fue un accesorio que SEGA lanzó para intentar alargar la vida útil de Mega Drive, una especie de actualización intergeneracional que llegó después del MegaCD y antes de Saturn, una consola ésta última que representaba el verdadero cambio de generación.
La idea era buena, Mega 32X iba a servir para llevar a Mega Drive juegos en 3D con una calidad cercana a la de las máquinas arcade. Esto permitiría a SEGA seguir aprovechando la base de usuarios de dicha consola tras el lanzamiento de Saturn, pero al final las promesas no se cumplieron y la ejecución acabó siendo un completo desastre.
SEGA prometió una potencia y una calidad que no se acabó cumpliendo ni por asomo, pero además la Mega 32X era una accesorio caro e incómodo de utilizar, ya que contaba con su propio adaptador de corriente y necesitaba conectar un cable de imagen adicional, puesto que el trabajo gráfico se repartía con Mega Drive.
Es cierto, fue un fracaso, pero hay que reconocer que tuvo juegos bastante buenos que demostraron el potencial de la consola, como Virtua Fighter, Virtua Racing Deluxe o After Burner.
Sin embargo, y en contra de lo que mucha gente cree, el problema no fue su falta de potencia sino lo complicado que era desarrollar para ella aprovechando totalmente su potencial.
SEGA integró dos procesadores SH2 de Hitachi en Mega 32X, un error muy grave que luego volvió a cometer con el lanzamiento de Saturn, una consola que estaba llena de posibilidades pero que no pudo brillar como merecía.
Los chicos de Digital Foundry han publicado un interesante vídeo en el que hacen un repaso a las claves más importantes de dicha consola y sus particularidades técnicas, pero además se han propuesto jugar a su catálogo completo para mostrarnos los mejores y los peores juegos que recibió Mega 32X.
Este vídeo es una primera parte así que os recomiendo echar un vistazo a su canal en los próximos días para disfrutar de la segunda parte.




Fuente:
http://www.muycomputer.com/2017/08/01/mega-32x-32-bits-mega-drive/