I successfully replaced the broken Micro-USB B port on my KC60 keyboard with a USB Type-C port.
The problem: dropped my KC60 keyboard off the side of my bed too many times and the connector got all mangled up.
Here is the housing disconnected from the board with the pins exposed.
Desoldered the pins from the board.
Soldering wires onto the USB Type-C breakout board.
Soldered the breakout board onto the main PCB board and put a little electric tape to insulate the housing. I used the post-its to keep track of which pins solder where, and testing results.
Hot glue and clamp.
The connector didn't lie flush so I had to file the hole a little larger.
Because it's USB, it just works. Tested it on Fedora 25 & Windows 10.
After a few months of experimenting and tinkering, I finally realised that a keyboard with USB n-key rollover is not necessary, and that keyboards with 10-key rollover are good enough.
I ended up purchasing 3 keyboards which claim to have n-key rollover. These have made me happy so far:
Noppoo Choc Pro with Cherry MX Red switches
Ducky DK9008G2 with PBT keycaps and Cherry MX Blue switches
Max Nighthawk X8 with Cherry MX Brown switches
Here are the results of my work:
Conclusion
I am confident that the firmware and HID descriptor I developed had working n-key rollover for Windows and Linux operating systems. Further testing was needed for OSX, but I am certain that I can get at least 50+ key rollover on that operating system.
Testing:
To test the system, I used the KeyboardStatus app I developed for Windows, OSX, and Linux: http://engineer-dan.tumblr.com/post/45749016127/keyboardstatus-multiplatform-n-key-rollover-test in combination with the PIC18F4550 dev board I showed in a previous post.
I programmed the dev board to spam all the keys when the button on the dev board was pressed, and release all keys when the button was released. This presented issues with OSX because there was no way to disable the command and apple keys, or read their raw input. For OSX I ended up not testing with those keys.
USB HID Report Descriptor:
Trying multiple different types of descriptors, I found the one below to be the most reliable across all platforms. I've also attached the *.hid file here, which can be viewed using USB Forum's HID Descriptor tool.
Through experimentation I found that some platforms didn't like reports which had too many key changes in a single report. Multiple reports had to be sent instead of a single report, with each consecutive report having the key changes from the previous one as well as a number of new key changes.
The Linux HID drivers had this issue. If more than 30 keys were pressed simultaneously (not held down simultaneously), the 31st and onward key would not be registered. The controller has to be programmed to count the number of new key presses in that frame, and if the number is greater than 30, send a report with the first 30 key presses, then send another report right away with the remainder key presses. This has to be done in blocks of 30 keys, so if 31, 61, or 91 keys are pressed simultaneously, 2, 3, or 4 reports respectively will have to be sent in that single frame. The maximum number of key releases per report was found to be 31 (instead of 30 for key presses).
For Windows, I've experimented up to 36 key presses and releases per report and encountered no issue. I did not test past this because Linux is at a lower number of updates per report (30).
OSX needs further testing. I was able to send reports with a maximum number of 8 key changes and get most of the keyboard held down. The keypad would only register releases, not presses.
Improvements:
BIOS systems do not have HID drivers and expect the USB keyboard boot protocol report format described in the HID specifications (Appendix F.4 in version 1.11, p. 75). What I had planned to do was to make my keyboard use the boot protocol report format until it receives the signal to upload its USB and HID descriptors. Once the request for the descriptors was complete, my keyboard would then switch to the n-key roll-over reports described above.
KeyboardStatus: Multiplatform N-Key Rollover test application
I developed an application which is used to test Keyboards. It is inspired by Aqua Key Test. KeyboardStatus is a multiplatform alternative.
The Windows and Linux versions were made with Qt 4.8.4. Qt DLL files are required to use the application on Windows. For Linux, you'll need to install the Qt package for your distribution or compile Qt.
The Mac version was made with Cocoa.
Windows binary (Requires Qt 4.8 DLLs)
Mac binary
Source code for the Qt version (Windows and Linux)
Using a PIC18F4550 with a dev board that my friend made, I've been testing different HID report descriptors to find a good keyboard N-key rollover report format.
I've been sending reports straight from the chip at the press of one of the dev board buttons, and also through a simulated keyboard with 5.1V zener diodes (1N751) for anti-ghosting.
There have been some successful tests with Linux and Windows, but both systems seem to have bugs in their HID parsing which prevent me from using the same descriptor on both systems. I don't have a Mac computer at home but I do plan on testing the dev board with a Mac.
Recently I've wanted to purchase a computer keyboard which connected through USB, had n-key rollover, and mechanical switches. After much searching, I never found my dream keyboard. So I decided to make my own.
Here are the criteria I will base my design on:
Minimalist/Utilitarian: A keyboard that's meant to be a keyboard. No flashy LCD or colour LEDs.
Mechanical Switches: Mechanical keys will be used because they feel better and last longer than membrane keys.
N-key Rollover: All keys can be pressed independently. Holding a certain number of keys won't block further key presses.
USB Connectivity
Driverless: The keyboard should be able to connect to as many devices without requiring a driver to be installed. I'll try to use the USB-HID standard common to all operating systems.
Lightweight: I want the keyboard to be relatively lightweight to carry, yet sturdy and hard to displace when set down.
Durable: Must be able to withstand sufficient forces. A factor of safety of 1.2 will be used.
The keys must also have a long lifespan.
I am not sure whether I should use an existing casing or construct my own. I will start building prototypes with existing cases but might end up creating my own for the final version.
Installing SyntaxHighlighter with its Autoloader in <head> using jQuery
When I add javascript code which effects the whole website, such as jQuery, I prefer to put it in the <head> tag. Here are my installation instructions on how to install SyntaxHighlighter with its Autoloader feature in the <head> tag using jQuery.
To install SyntaxHighlighter in your <head> tag, paste the following within it:
In this article, I will give a minimalist template to start your very own HTML/CSS/JS desktop application which can be run on Windows, Mac, and Linux. All of the files are available at the bottom of the page.
After creating a few GUI interfaces with Visual C#.NET and Qt using built-in widgets, I decided to try to make an HTML/CSS/JS based application. Although Qt has an option to create a new "HTML5 Application" project, I found the template had too much code which didn't apply to my needs. Here is an alternative and minimalist template to start your very own Qt based Webkit HTML/CSS/JS desktop application.
Note that all files created were done so in the root directory of the project. However you can place any of the files in sub-directories for convenience.
First, you must create a project and add the WebKit module to it. You can do this after creating the project and double-clicking on your .pro project file from within Qt Creator and adding the line:
QT += webkit
Secondly, create a class named HTML_CSS_JS_Application. This class is the main Qt class which creates the WebKit instance, initialises it, and binds itself to it to allow 2-way Qt/Javascript communication.
html_css_js_application.h:
#ifndef HTML_CSS_JS_APPLICATION_H #define HTML_CSS_JS_APPLICATION_H #include <QObject> #include <QWebView> class HTML_CSS_JS_Application : public QObject { Q_OBJECT private: QWebView window; // WebKit window displaying the application public: HTML_CSS_JS_Application(); // Constructor which initialises the QWebView and binds this class to it signals: // Functions defined in javascript which we can call on the Qt side // This is a way for the Qt part of the application to communicate with the javascript part // Do not define these functions in the cpp file void qt_to_js(QString text); public slots: // Functions defined in Qt/C++ which javascript can call through the "Qt" object // This is a way for the javascript part of the application to communicate with the Qt part // These functions are defined in the cpp file void js_to_qt(QString text); }; #endif // HTML_CSS_JS_APPLICATION_H
html_css_js_application.cpp:
#include "html_css_js_application.h" #include <QWebFrame> HTML_CSS_JS_Application::HTML_CSS_JS_Application() { window.setWindowTitle("Your Appplication Title"); window.setContextMenuPolicy(Qt::PreventContextMenu); // Prevent context menu window.setUrl(QString("qrc:/application.html")); // Load embeded .html file window.page()->mainFrame()->addToJavaScriptWindowObject("Qt", this); // Bind WebFrame with this object to allow for javascript/Qt communication //window.showFullScreen(); // Display fullscreen window.setFixedSize(1180, 800); // Set window size (if not fullscreen) window.showNormal(); // Display in a window } // js_to_qt - Public slot which is called in javascript via "Qt.js_to_qt(parameters...)" void HTML_CSS_JS_Application::js_to_qt(QString text) { qt_to_js("Qt recevied: "+text+", and sent this message back"); // Calling qt_to_js() triggers the signal on the javascript side }
Create main.cpp, the entry point of the application which creates an instance of the HTML_CSS_JS_Application class.
main.cpp:
#include <QApplication> #include "html_css_js_application.h" int main(int argc, char *argv[]) { QApplication a(argc, argv); HTML_CSS_JS_Application myApp; // Constructor creates the window and displays it return a.exec(); }
Next, the HTML file is created. I named it application.html and referenced the external javascript library jquery-1.8.2.min.js. I downloaded this file and placed it in the root directory of the project.
application.html:
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <style type="text/css"> /* CSS */ </style> <!-- jQuery --> <script type="text/javascript" src="jquery-1.8.2.min.js"></script> <script type="text/javascript"> $(function() { // DOM ready (jQuery) Qt.qt_to_js.connect(qt_to_js); // Connect signal sent from Qt to javascript function $("button").click(function() { Qt.js_to_qt($("input").val()); // Invoke js_to_qt() with the text-field content as its passed parameter }); }); // qt_to_js - Signal which is called in Qt via "qt_to_js(parameters...)" function qt_to_js(text) { $("#received").text(text); // Set text in the "received" div to to text received from Qt } </script> </head> <body> <p> <h3>Send:</h3> <div> <input type="text"> <button>Send to Qt</button> </div> </p> <p> <h3>Receive:</h3> <div id="received"></div> </p> </body> </html>
Finally, you will need to create the Qt Resource file which will reference and embed your application.html file, and any other dependancies such as image files, css files, javascript files, and so on. In this example, we will have to attach application.html and jquery-1.8.2.min.js.
From the Qt SDK, click "File" -> "New File or Project..."
Under "Files and Classes" on the left column, select "Qt"
In the right column, select "Qt Resource file" and press "Choose..."
Name the file anything you want and press "Next" then "Finish"
Open the Qt Resource file by double-clicking it in your Projects panel
Press "Add" -> "Add Prefix" located at the lower part of the file edit view
Name the prefix "/"
Press "Add" -> "Add Files"
From the browser, select application.html and jquery-1.8.2.min.js and press "Open"
Alternatively: you can choose to not embed the html file in your application, and have it sit somewhere outside the executable. If this is done, you do not need to create a Qt Resource file. Also, you will have to replace line 7 of html_css_js_application.cpp with
window.setUrl(QUrl("application.html"));
where you must specify the url to point to either a local or online file.
Now you can run the project. WebKit supports CSS3 animations, HTML5 tags, and executes javascript fairly quickly. It is a powerful framework with which to build a GUI with.
The project files can be downloaded here: https://dl.dropbox.com/u/44280351/HTML_CSS_JS_Application.zip
vaporwave
2087
blakekathryn
origamiaround
jacobvanloon
turnnoffyourmind
kaledo-art