Raspberryfield - IT, video games and comics

/* -NESControllerLightVersion -
 * Converts button presses on a NES controller into emulated keyboard presses.
 * This code is a simple implementation of the NES controller protocol. 
 * It contains repetitive code and unnecessarily function calls. It is made for educational purposes.
 * People with little knowledge in programming should be able to follow along and then improve the code by them self, 
 * with for loops, last button state check etc. 
 * Created by Raspberryfield.life August 2018
 */
 /* *NES Controller Pinout Console (Female)*         
  *          _
  * GND   - |O \
  * Clock - |O O| - VCC (5v)  
  * Latch - |O O| - Data N/A (Zapper etc.)
  * Data  - |O O| - Data N/A (Zapper etc.)
  *         ----
  */
  /* *NES protocol ~20ms between each data cycle*
   *           _
   * Latch - _| |___________________________________________________
   *         ______   ___   ___   ___   ___   ___   ___   ___   ____Note1. Last clock does nothing.
   * Clock -       |_|   |_|   |_|   |_|   |_|   |_|   |_|   |_|
   *            _____________________________________________
   *  Data - __|_A_|_|_B_|_|Sel|_|Sta|_|Up_|_|Dow|_|Lef|_|Rig|______
   *  Note2. After Latch goes HIGH, Data goes HIGH and becomes active low (if a button is pushed 
   *  after clock signal, data wire reads low).
   *  Note3. State of A button is read after latch and before first clock.
   */
#include <Keyboard.h>
//Constants for the pinout in the pro micro board (+5V).
const int nesClock = 2;
const int nesLatch = 3;
const int nesData = 4;
void setup() {
  // put your setup code here, to run once:
  pinMode(nesData,INPUT_PULLUP);
  pinMode(nesClock,OUTPUT);
  pinMode(nesLatch,OUTPUT);
  digitalWrite(nesClock, LOW);
  digitalWrite(nesLatch, LOW);
  Keyboard.begin();
}
void loop() {
  // put your main code here, to run repeatedly:
  //Pulse Latch wire:
  digitalWrite(nesLatch, HIGH);
  digitalWrite(nesLatch, LOW);
  //After latch pulse, check if A button is pressed:
    //If low, call library Keyboard function press and set a char for it.
      //Else release all key presses for that char.
  if(digitalRead(nesData)==LOW){
        Keyboard.press('a');
      }else{
        Keyboard.release('a');
      }     
  // 1st clock.
  digitalWrite(nesClock, LOW);
  digitalWrite(nesClock, HIGH);
  //After 1st clock, check if B button is pressed:
  if(digitalRead(nesData)==LOW){
        Keyboard.press('b');
      }else{
        Keyboard.release('b');
      }
  // 2nd clock.
  digitalWrite(nesClock, LOW);
  digitalWrite(nesClock, HIGH);
  //After 2nd clock, check if SELECT button is pressed:
  if(digitalRead(nesData)==LOW){
        Keyboard.press('c');
      }else{
        Keyboard.release('c');
      }
  // 3rd clock.
  digitalWrite(nesClock, LOW);
  digitalWrite(nesClock, HIGH);
  //After 3rd clock, check if START button is pressed:
  if(digitalRead(nesData)==LOW){
        Keyboard.press('s');
      }else{
        Keyboard.release('s');
      }
  // 4th clock.
  digitalWrite(nesClock, LOW);
  digitalWrite(nesClock, HIGH);
  //After 4th clock, check if UP button is pressed:
  if(digitalRead(nesData)==LOW){
        Keyboard.press('u');
      }else{
        Keyboard.release('u');
      }
  // 5th clock.
  digitalWrite(nesClock, LOW);
  digitalWrite(nesClock, HIGH);
  //After 5th clock, check if DOWN button is pressed:
  if(digitalRead(nesData)==LOW){
        Keyboard.press('d');
      }else{
        Keyboard.release('d');
      }
  // 6th clock.
  digitalWrite(nesClock, LOW);
  digitalWrite(nesClock, HIGH);
  //After 6th clock, check if LEFT button is pressed:
  if(digitalRead(nesData)==LOW){
        Keyboard.press('l');
      }else{
        Keyboard.release('l');
      }
  // 7th clock.
  digitalWrite(nesClock, LOW);
  digitalWrite(nesClock, HIGH);
  //After 7th clock, check if RIGHT button is pressed:
  if(digitalRead(nesData)==LOW){
        Keyboard.press('r');
      }else{
        Keyboard.release('r');
      }
  // 8th clock.
  digitalWrite(nesClock, LOW);
  digitalWrite(nesClock, HIGH); 
  delay(20);//Wait 20ms for next loop.  
}//End loop

/*
	NEScontroller.h - Library for interfacing one or several NES controllers.
	Created by Raspberryfield.life August 2018
*/
#ifndef NEScontroller_h
#define NEScontroller_h
#include "Arduino.h"
class NEScontroller
{
public:
	NEScontroller(int clockPin, int latchPin, int dataPin, char *commandsController);
	int begin();
private:
	int _clockPin;
	int _latchPin;
	int _dataPin;
	char *_commandsController;
	byte _lastDataCycle;
	byte _currentDataCycle;
	void pulseWire(int wire, bool pulse);
	byte dataReadnUpdate(int dataWire, byte dataByte, byte bitValue);
};
#endif

/*
	NEScontroller.cpp - Library for interfacing one or several NES controllers.
	Created by Raspberryfield.life August 2018
*/
#include "Arduino.h"
#include <Keyboard.h>
#include "NEScontroller.h"
NEScontroller::NEScontroller(int clockPin, int latchPin, int dataPin, char *commandsController)
{
	pinMode(clockPin, OUTPUT);
	pinMode(latchPin, OUTPUT);
	pinMode(dataPin, INPUT_PULLUP);
	digitalWrite(clockPin, HIGH);
	digitalWrite(latchPin, LOW);
	_clockPin = clockPin;
	_latchPin = latchPin;
	_dataPin = dataPin;
	_commandsController = commandsController;
	_lastDataCycle = 0b00000000;
	_currentDataCycle = 0b00000000;
}
int NEScontroller::begin()
{
	/*
	* Start by putting the last read data cycle to lastDataCycle variable and
	* then put current DataCycle to zero, ready for a new state read of data (button pushes).
	*/
	_lastDataCycle = _currentDataCycle;
	_currentDataCycle = 0b00000000;

	//Second pulse the latch wire, it resets the IC in the NES controller.
	pulseWire(_latchPin, 1);
	//After latch it is possible to read the A button state.
	_currentDataCycle = dataReadnUpdate(_dataPin, _currentDataCycle, 0b10000000); //0b10000000 = 128, "A" button.

	//Loop the other button states. After each clock it is possible to the read the values.
	for (byte byteValue = 0b01000000; byteValue>0; byteValue = byteValue >> 1) {
		pulseWire(_clockPin, 0);
		_currentDataCycle = dataReadnUpdate(_dataPin, _currentDataCycle, byteValue);
		//delayMicroseconds(2);//Maybe not needed.
	}//End loop.

	//Finish of with the last clock pulse (I don't think it is actually doing anything).
	pulseWire(_clockPin, 0);//One extra (8th) clock is required to follow protocol.
	//Now we are finished with reading the button states.

	//It's time to do something with the data collected:
	//If XOR of current and last is not zero, that means that there is a change in button press/release. Only then Something has to be done.
	if (int(_currentDataCycle ^ _lastDataCycle) != 0) {
		//Start checking what change has occured.
		for (int i = 0; i<8; i++) {
			byte BitcurrentData = _currentDataCycle << i;
			byte BitlastData = _lastDataCycle << i;
			if (int((BitcurrentData >> 7) ^ (BitlastData >> 7)) != 0) {
				if (BitcurrentData >> 7 != 0) {
					//Serial.print("Pushed [i]: ");Serial.print(i);
					//Serial.println();
					Keyboard.press(_commandsController[i]);
				}
				else {
					//Serial.print("Released [i]: ");Serial.print(i);
					//Serial.println();
					Keyboard.release(_commandsController[i]);
				}//End if/else push or release. 
			}//End if check singel bit.
		}//End for loop all bits.  
	}//End if  there is a change at all.
}//End begin();
void NEScontroller::pulseWire(int wire, bool pulse) {
	//If second parameter positive (==1) pulse wire from low to high and back to low. Else opposite.
	if (pulse == 1) {
		digitalWrite(wire, HIGH);
		digitalWrite(wire, LOW);
	}
	else {
		digitalWrite(wire, LOW);
		digitalWrite(wire, HIGH);
	}
}//End pulseWire
byte NEScontroller::dataReadnUpdate(int dataWire, byte dataByte, byte bitValue) {
	if (digitalRead(dataWire) == LOW) {
		return dataByte | bitValue;
	}
	else {
		return dataByte;
	}
}// End dataRead

/* -NESController -
 *  NESController.ino
 * Created by Raspberryfield.life August 2018
 */
 /* *NES Controller Pinout Console (Female)*         
  *          _
  * GND   - |O \
  * Clock - |O O| - VCC (5v)  
  * Latch - |O O| - Data N/A (Zapper etc.)
  * Data  - |O O| - Data N/A (Zapper etc.)
  *         ----
  */
  /* *NES protocol ~20ms between each data cycle*
   *           _
   * Latch - _| |___________________________________________________
   *         ______   ___   ___   ___   ___   ___   ___   ___   ____Note1. Last clock does nothing.
   * Clock -       |_|   |_|   |_|   |_|   |_|   |_|   |_|   |_|
   *            _____________________________________________
   *  Data - __|_A_|_|_B_|_|Sel|_|Sta|_|Up_|_|Dow|_|Lef|_|Rig|______
   *  Note2. After Latch goes HIGH, Data goes HIGH and becomes active low (if a button is pushed 
   *  after clock signal, data wire reads low).
   *  Note3. State of A button is read after latch and before first clock.
   */
#include <Keyboard.h>
#include <NEScontroller.h>
//declare commands Player1
//-------------------------//A         //B             //SELCT         //START   //UP      //DOWN          //LEFT          //RIGHT
char commandsPlayer1[8] = {KEY_RETURN, KEY_BACKSPACE, KEY_RIGHT_SHIFT, ' ', KEY_UP_ARROW, KEY_DOWN_ARROW, KEY_LEFT_ARROW, KEY_RIGHT_ARROW};  
//Parameters: #clockPin, #latchPin, #dataPin, KeyCommands[]
NEScontroller player1(2,3,4, commandsPlayer1);
//declare commands player 2 and inti player 2
char commandsPlayer2[] = {'j', 'h', 'f', 'g', 'w', 's', 'a', 'd'};
NEScontroller player2(5,6,7, commandsPlayer2);
void setup() {
  //Setup is created by the class when init a player. No need for setup here.
}
void loop() {
  // put your main code here, to run repeatedly:
  player1.begin();
  player2.begin();  
  delay(20);
}//End Loop