Error: android.content.res.Resources$NotFoundException

Ocurre porque algun estilo o elemento no existe o no corresponde con la version de Android seleccionada para hacer el rendering.

Por ejemplo, en este caso la linea en rojo es la que produce el error:

<TextView    android:layout_width="fill_parent"    android:layout_height="wrap_content"    android:textAppearance="@color/abc_primary_text_material_dark"
    android:text="[puntaje]"    android:id="@+id/text1"    android:layout_alignParentTop="true"    android:layout_alignParentLeft="true"    android:layout_alignParentStart="true"    android:textAlignment="center"    android:textStyle="bold"    android:typeface="monospace" />

Quitando esta linea se soluciona el problema.

Listas no pasan en postback en MVC

Si se carga desde una lista otra con javascript, aunque ambas listas estén en el Modelo, la segunda lista no llega al controller cuando se hace submit.

Causa: Si bien la 2da lista se cargó con javascript, en el submit sólo se envían los datos que estén seleccionados (javascript carga la lista, pero no quedan seleccionados los elementos).
Por lo tanto, antes de hacer submit, la solucion es marcar todos los elementos de la segunda lista.

Subir un archivo en Drive mediante Google Api y OAuth

Fuente: https://developers.google.com/drive/web/quickstart/quickstart-cs


1. Ir a la consola de desarrollo de google y crear un nuevo proyecto
https://console.developers.google.com/project

2. Click en el proyecto creado

3. Abrir APIs y seleccionar el api a utilizar (en este caso Drive API)

4. Clickear en Habilitar API

5. Crear un ID de cliente nuevo (ir a Credenciales, Crear ID de cliente nuevo, y elegir "Aplicacion Instalada", y Otros

6. Luego que lo crea, presionar el boton "Descargar JSON", y guardar el archivo en la ruta Debug de la aplicacion que vamos a crear mas abajo, con el nombre client_secrets.json

7. Crear un archivo document.txt y guardarlo en el path Debug de la aplicacion.

8. Definir los campos usuario, password y dominio en NetworkCredential (estas son las credenciales del servidor proxy, si hay)

9. Crear la aplicacion de consola y ejecutarla, se va a abrir un browser pidiendo autorizacion para acceder a Drive. Si por defecto se abre el Internet Explorer, copiar la url, pegarla en Chrome y aceptar allí.

10. Ir a Drive y verificar que se haya subido el archivo (con nombre My document)

[Agregar las referencias mediante NuGet, de Google.Apis y Drive]

using System;
using System.IO;
using System.Threading;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v2;
using Google.Apis.Services;
using Google.Apis.Util.Store;
using System.Net;

namespace Drive3
{
    class DriveCommandLineSample
    {
        static void Main(string[] args)
        {
            UserCredential credential;

            HttpWebRequest webRequest = WebRequest.Create(@"http://www.google.com") as HttpWebRequest;
            webRequest.Proxy = WebRequest.DefaultWebProxy;
            webRequest.Credentials = new NetworkCredential([UsuarioProxy], [PasswordProxy], [DominioProxy]);
            webRequest.Proxy.Credentials = new NetworkCredential([UsuarioProxy], [PasswordProxy], [DominioProxy]);

            using (var filestream = new FileStream("client_secrets.json",
                FileMode.Open, FileAccess.Read))
            {
                credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                    GoogleClientSecrets.Load(filestream).Secrets,
                    new[] { DriveService.Scope.Drive },
                    "user",
                    CancellationToken.None,
                    new FileDataStore("DriveCommandLineSample")).Result;
            }

            // Create the service.
            var service = new DriveService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName = "Drive API Sample",
            });

            Google.Apis.Drive.v2.Data.File body = new Google.Apis.Drive.v2.Data.File();
            body.Title = "My document";
            body.Description = "A test document";
            body.MimeType = "text/plain";

            byte[] byteArray = System.IO.File.ReadAllBytes("document.txt");
            System.IO.MemoryStream stream = new System.IO.MemoryStream(byteArray);

            FilesResource.InsertMediaUpload request = service.Files.Insert(body, stream, "text/plain");
            request.Upload();

            Google.Apis.Drive.v2.Data.File file = request.ResponseBody;
            Console.WriteLine("File id: " + file.Id);
            Console.WriteLine("Press Enter to end this process.");
            Console.ReadLine();

        }
    }
}

Shift registers 74HC595 con arduino

Resistencias: 220Ohm
Capacitor: 1uF



Para agregar otro set de 8 leds:


Codigo (knightrider :)

//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 8;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 12;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 11;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
}

void loop() {
  for (int j=0; j<=7; j++)
  {
    registerWrite(j, HIGH);
    delay(100);
  }
 
  for (int j=6; j>=1; j--)
  {
    registerWrite(j, HIGH);
    delay(100);
  }  
}

// This method sends bits to the shift register:

void registerWrite(int whichPin, int whichState)
{
  // the bits you want to send
  byte bitsToSend = 0;

  // turn off the output so the pins don't light up
  // while you're shifting bits:
  digitalWrite(latchPin, LOW);

  // turn on the next highest bit in bitsToSend:
  bitWrite(bitsToSend, whichPin, whichState);

  // shift the bits out:
  shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend);

  // turn on the output so the LEDs can light up:
  digitalWrite(latchPin, HIGH);
}



Fuente: http://arduino.cc/en/tutorial/ShiftOut





PCB Wizard

1. Abrir PCB Wizard y desplegar la Circuit Symbol Gallery




2. Arrastrar los componentes




3. Crear las conexiones (posicionar el mouse sobre uno de los pines y arrastrarlo hasta el pin del otro componente al cual se quiere conectar)





4. Convertirlo a PCB: Tools / Convert / Design to Printed Circuit Board
Marcar "Yes, I wish to decide how my design is converted" / Next

Luego setear lo siguiente:



En esta configuración es posible cambiar el ancho de las pistas (en el combo Grid):
Esto es útil en el caso en que se quiera utilizar una mecha de mayor diámetro:




La placa quedará así:




5. Agregar los pads de referencia

Para esto, colocar dos pads a cada lado de la placa (pueden estar dentro o fuera). Deben estar alineados y equidistantes de los bordes de la placa (estas referencias serán utilizadas mas adelante por el software Line Grinder).

Luego de posicionar los pads, editar sus propiedades, y en el tamaño establecer 0.125in en el largo y ancho




Es posible mover los componentes para distribuirlos de otra manera.
En este caso, el ruteo se pierde, y hay que volver a realizarlo mediante el menú Tools / Auto Route / Route all Nets


Y queda así:



6. Marcar el punto de origen

Para esto, ir a View / Co-ordinates / Origin / Change origin
y marcar la esquina inferior izquierda como origen:



7. Exportar a GERBER

Tools / CAD Cam / Export GERBER

Dejar marcado sólamente Solder side y Drill holes


Generacion de GCODE con FlatCam (version utilizada: 8.92 Beta)

8. Generar GCODE utilizando FlatCam  (tutorial en: https://www.youtube.com/watch?v=IbsBCMlQB_c)

        a. File / Open / Open Gerber  --> abrir el archivo .gb0 generado por el pcb wizard que corresponde a los isolation.

        b. File / Open / Open Excellon --> abrir el archivo .drl que contiene los agujeros

9. Seleccionar de la ficha Project, el archivo abierto en el paso a.

10. Ir a la ficha Selected

11. En Tool dia: 0.016 / Passes: 1 / Pass overlap: 0.1500

12. Click en full geo

13. Para generar el cutout (recuadro alrededor):
           a. Ir a ficha Project, click en el .gb0
           b. Ir a ficha Selected
           c. Click en cutout tool
           d. Tool Dia: 0.031 / Margin 0.05 / Gap size: -.1

           e. Donde dice Free form, click en Generate Geo

14. Para generar los drills:
           a. Ir a la ficha Project, click en el .drl
           b. Ir a ficha Selected
           c. Seleccionar todos los drills de la tools table, y en Drills Tool Dia poner: 0.031
           d. Click en Mill Drills Geo
           e. Cut Z: -0.25 / Travel Z: 0.1 / Feed rate: 3.0
           f. Click en Generate

Los pasos anteriores generan los Geometry.
A partir de los Geometry se pueden generar los paths gcode:

1. En la ficha Project, dentro de Geometry, click en el archivo (termina en _mill)

2. Click en Selected

3. Cut Z: -0.05 / Travel Z: 0.4 / Feed rate: 15.0 / Tool dia: 0.016

4. Click en Generate

Hacer lo mimo con el geometry cutout, con estos parametros:

Cut Z: -0.063 / Travel Z: 0.4 / Feed rate: 6.0 / Tool dia: 0.031

Y hacer lo mismo con el archivo de drill:

Cut Z: -0.063 / Travel Z: 0.4 / Feed rate: 15.0 / Tool dia: 0.031


10. Procesar el GCode con Grbl Controller (EL UNIVERAL GCODE SENDER NO FUNCIONA CON LOS ARCHIVOS GENERADOS ANTERIORMENTE... DON'T KNOW WHY)

Conectar al COM donde se encuentre el Arduino.

Cargar el archivo .nc grabado en el paso anterior y enviarlo a Arduino.





8. Generar GCODE con Line Grinder

En Line Grinder, abrir el archivo .gb0 (el que corresponde al Solder side que exportamos en el paso anterior)


Como el gcode que generemos lo vamos a utilizar en una fresadora, es necesario hacer flip de este diseño.
Para esto, ir a Settings y en IsoFlipMode elegir X_Flip


Luego de esto, el diseño queda así:



Si se va a utilizar una fresadora, dejar el parámetro IsoZCutLevel en -0.002
Si se va a utilizar un drypen, cambiarlo a 0.000

Presionar Convert to GCode

y luego, click en Isolation GCode

En la ficha "Isolation GCode" está el código G que necesitamos.

Guardarlo en un archivo con extension .nc, que a continuación abriremos con el Grbl Controller


9.






Compilar solución de Visual Studio en x86 o x64

Para compilar específicamente en 32 bits (x86):

1. Ir a Configuration Manager, y ver si existe la opción x86, si no existe, agregarla




2. En las propiedades del proyecto, elegir en Platform x86 (observar que la ruta de build cambia, tenerlo en cuenta a la hora de copiar el .exe, porque a veces confunde)



3. En las propiedades de la solución, asegurarse que figura en Active config: Release|x86




Arduino MIDI drums - Secuencia completa de MIDI para Ableton desde Arduino


#include <MIDI.h>

MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  MIDI.begin();
}

/*
44 hi hat apretado
42 hi hat normal
46 hi hat abierto

49 splash
32 crash
51 ride

34 bass
33 snare
37 tick
48 tom 1
45 tom 2
41 tom 3
*/

unsigned char notas[12] = {44, 42, 46, 49, 32, 51, 34, 33, 37, 48, 45, 41};    

void loop() {
  for (int i=0; i<12; i++)
  {
    MIDI.sendNoteOn(notas[i],127,10);  // Send a Note (pitch, velo 127 on channel 10)
    delay(1000);  
    MIDI.sendNoteOff(notas[i],0,10);   // Stop the note  
  }

      delay(3000);    
}

Crear PCB con DesignSpark para CNC


1. En DesignSpark, File / New / PCB Design


2. Presionar Next y luego elegir default.ptf en "Choose Technology File"

3. En unidades, elegir mm, luego Next

4. Marcar "Define Layers", y elegir Single Sided Board, y luego Next

5. Especificar el tamaño de la placa, luego Next

6. Definir un nombre

Establecer el origen de la esquina inferior izquierda

Click derecho en la esquina inferior izquierda de la placa
Elegir Origins / Set System Origins at Item
Debe aparecer un círculo con una cruz




Establecer los Reference Pin Pad

Los reference pin pads deben ser por lo menos dos y deben estar equidistantes de los bordes de la placa y alineados.

Pueden definirse tanto adentro de la placa como afuera (si no quisieran incluirse en el diseño)
Sirven para que puedan ser alineadas las diferentes capas de PCB que se hagan.

Para definirlos, elegir Add Pad de la barra de herramientas:
Por ejemplo:




El tamaño de estos pines debe ser 0.125 pulgadas, pero como estamos trabajando con mm, los definimos de 3.175mm
Para esto, click derecho sobre el pin, luego Propiedades / Width
Hacer lo mismo para los otros reference pin pads que se hayan creado


Dibujar la placa

Con Add Pad y con Sketch Track, dibujar la placa
** Los Pad's deben medir 1.5mm **



Generar los archivos .gbr y .drl

Output / Manufacturing Plots
Dejar marcado sólamente Bottom Copper y Drill Data [Through Hole]
Marcar Gerber y presionar RUN




Generar Isolation routes y GCODE para la placa

Abrir el software Line Grinder (v01.04)
Open Gerber/Drill File
Abrir el archivo xxxx - Bottom Copper.gbr



Presionar "Convert to GCode"
Elegir "Isolation GCode" en el menu de la izquierda



Settings para Line Grinder [TENER EN CUENTA QUE ESTA TODO EN INCHES, DEJARLO ASI]




Settings para drl:



En la ficha Isolation GCode aparece el codigo G necesario para rutear la placa de PCB



Para procesarlo en el CNC, guardar el codigo G en un archivo .nc y abrirlo con Grbl Controller (3.6.1)

NOTA!!! observar que en el codigo G aparece un comentario (... pad touchdown start ...)
Lo que esta debajo de esto son las marcas de los agujeros, para que sirvan de guia para hacer el perforado manual luego.



Generar GCode para los agujeros (Drill)

Abrir el archivo xxxx - Drill Data - [Through Hole].drl que creó DesignSpark



Abrir la siguiente URL
http://eng-serve.com/cnc/excellon_gcode.html

Pegar el texto contenido en el archivo .drl y presionar "Generate G-Code"


Guadar el texto generado (ej, drill.nc) y luego abrirlo con el Grbl Controller

OJO!!! LAS COORDENADAS NO ESTAN BIEN!!



Fuente:
http://www.ofitselfso.com/LineGrinder/LineGrinderHelp/LineGrinderHelp_DesignSparkConfiguration.html


Uncheck radio button con jQuery


<html>
<head>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.2/jquery.min.js"></script>
</head>

<input type="radio" name="opt1" value="Opcion1">Opcion1</input>
<input type="radio" name="opt1" value="Opcion2">Opcion2</input>
<script>
$(document).ready(function() {


$("[name=opt1]").mousedown(function(event) {
if ( $(this).prop('checked') )
$(this).prop('checked', false);
else
$(this).prop('checked', true);

event.preventDefault();
});

$("[name=opt1]").click(function(event) {
event.preventDefault();
});
});
</script>
</html>

avrdude: Yikes! Invalid device signature.

Cuando me pasó esto era porque el servo estaba mal.
Lo desconecté y se arregló.

Si es un led que esta conectado, quitarlo y probar de nuevo.

Arduino MIDI drums paso a paso - instalacion de hiduino

ATENCION: Todo esto fue testeado en arduino UNO R3, que corresponde a atmega16u2
LOS PROBLEMAS DE LATENCIA SE SOLUCIONAN CON ESTE POST!

ANTES QUE NADA
Hay que pasar el sketch que queramos utilizar, porque despues de actualizar el firmware ya no es posible pasarlo. Lo que si se puede es revertir (colocar el firmware original de arduino UNO)
(ver un sketch de ejemplo al final de este post)


Para instalar hiduino:

Tocar y soltar los dos pines que aparecen en la imagen:


NOTA: Si en los próximos pasos el dfu-programmer da error diciendo que no encuentra libusb0.dll:
           Copiar el archivo libusb0_x86.dll
               desde dfu-programmer-win-0.7.0\dfu-prog-usb-1.2.2\x86
               hacia dfu-programmer-win-0.7.0
           Entrar a dfu-programmer-win-0.7.0 y renombrar libusb0_x86.dll a libusb0.dll


Transferir el firmware hiduino de esta forma:

dfu-programmer atmega16u2 erase
dfu-programmer atmega16u2 flash arduino_midi.hex
dfu-programmer atmega16u2 reset

[Para ver los dispositivos usb se puede usar la utilidad lsusb.exe]

Para volver el arduino UNO a su origen

dfu-programmer atmega16u2 erase
dfu-programmer atmega16u2 flash "c:\Program Files (x86)\Arduino\hardware\arduino\avr\firmwares\atmegaxxu2\Arduino-COMBINED-dfu-usbserial-atmega16u2-Uno-Rev3.hex" --suppress-bootloader-mem

[Para ver los dispositivos usb se puede usar la utilidad lsusb.exe]


Acá está la lista de notas utilizadas para DRUMS
http://soundprogramming.net/file-formats/general-midi-drum-note-numbers/


Sketch de ejemplo (toca DO cuando el piezo se golpea)

#include <MIDI.h> // Incluimos la libreria MIDI

//Xylophone
//Adapted for an ArduinoMega
//from Jenna deBoisblanc and Spiekenzie Labs initial code

//*******************************************************************
// User settable variables
//*******************************************************************
MIDI_CREATE_DEFAULT_INSTANCE();

int pinRead;
char pinAssignments[6] ={'A0','A1','A2','A3','A4','A5'};
byte PadNote[16] = {57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72};         // MIDI notes from 0 to 127 (Mid C = 60)
int PadCutOff[16] =
{
  400,400,200,800,400,400,400,400,400,400,400,400,400,400,400,400};           // Minimum Analog value to cause a drum hit
int MaxPlayTime[16] = {
  90,90,90,90,90,90,90,90,90,90,90,90,90,90,90,90};               // Cycles before a 2nd hit is allowed
#define  midichannel 1;                              // MIDI channel from 0 to 15 (+1 in "real world")
boolean VelocityFlag  = true;                           // Velocity ON (true) or OFF (false)

//*******************************************************************
// Internal Use Variables
//*******************************************************************
boolean activePad[16] = {
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};                   // Array of flags of pad currently playing
int PinPlayTime[16] = {
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};                     // Counter since pad started to play
byte status1;

int pin = 0;  
int hitavg = 0;
//*******************************************************************
// Setup
//*******************************************************************
void setup()
{
    MIDI.begin();
}
//*******************************************************************
// Main Program
//*******************************************************************
void loop()
{
  for(int pin=0; pin < 16; pin++)                          //
  {
    //int pin = 3;
    //   for (pinRead=0; pinRead < 16, pin++){
    hitavg = analogRead(pinAssignments[pin]);
    //Serial.println(hitavg);
    // read the input pin

    if((hitavg > PadCutOff[pin]))
    {
      if((activePad[pin] == false))
      {
        if(VelocityFlag == true)
        {
          //          hitavg = 127 / ((1023 - PadCutOff[pin]) / (hitavg - PadCutOff[pin]));    // With full range (Too sensitive ?)
          hitavg = (hitavg / 8) -1 ;                                                 // Upper range
        }
        else
        {
          hitavg = 127;
        }
//        MIDI.sendNoteOn(144,PadNote[pin],hitavg); //note on
MIDI.sendNoteOn(48, 127, 1);

        PinPlayTime[pin] = 0;
        activePad[pin] = true;
      }
      else
      {
        PinPlayTime[pin] = PinPlayTime[pin] + 1;
      }
    }
    else if((activePad[pin] == true))
    {
      PinPlayTime[pin] = PinPlayTime[pin] + 1;
      if(PinPlayTime[pin] > MaxPlayTime[pin])
      {
        activePad[pin] = false;
        MIDI.sendNoteOn(144,PadNote[pin],0);
      }
    }
  }
}



Fuentes:
http://geekytheory.com/arduinomidi-tu-propio-piano/
http://bartruffle.blogspot.com/2013/09/dfu-programming-atmega16u2-on-arduino.html
http://answers.microsoft.com/en-us/windows/forum/windows_7-pictures/latency-problem-using-ms-gs-wavetable-synth/1e85704a-803c-438f-b472-fb0cb5211be4

Solucionar problema de latencia en Microsoft GS Wavetable Synth / latency

1. Descargar VirtualMidiSynth desde aquí: http://coolsoft.altervista.org/en/virtualmidisynth
(o bajarlo desde Drive, del proyecto Arduino DRUMS)

2. Descargar un sound font desde la misma página (o bajarlo del Drive)

3. Instalar VirtualMidiSynth y configurarlo:
             Establecerlo como el dispositivo midi por defecto
             Agregarle el sound font que bajamos en el paso 2

4. En la ficha "Advanced" reducir el "additional output buffer" a cero.

5. Ejecutar Ableton, y elegir como salida VirtualMidiSynth en lugar de Microsoft GS Wavetable
(tambien se puede probar con synthesia)


Fuentes:

http://answers.microsoft.com/en-us/windows/forum/windows_7-pictures/latency-problem-using-ms-gs-wavetable-synth/1e85704a-803c-438f-b472-fb0cb5211be4

http://kbd-infinity.com/kbd-infinity-blog/replacing-microsoft-gs-wavetable-synth/