Találtam egy másik megoldást csak sajnos hiányosak az információk.
Ha valaki tudna segíteni egy kapcsolási rajzot készíteni akkor lehet hogy működőképes lenne a dolog illetve ha tudnánk hogy mi hiányzik még a kapcsolásból.
Csatolom a két linket az egyiken látható pár haszon infó "sajnos a cég már nem elérhető"
Kód: Egész kijelölése
#include <Stdio.h>
//-----------------------------------------------------------------------------
// ArduMT MACROs and control parameters
//-----------------------------------------------------------------------------
#define FASTSCAN 1 // Do fast scanning
#define FASTADC 1 // Do fast ADC
#define TIME_CHK 0 // For debugging
// ADC channel
#define ADC_CHANNEL 0
// ADC value
#define MEASUREMENT_DIVIDE 2 // measurement = adc / MEASUREMENT_DIVIDE
// ADC value less than the threshold value is
// regarded as zero
const int encodingThreshold = 20;
// 0: No Test. Run ArduMT firmware
// 1~5: For debugging. See function testArduMT()
#define TEST_ARDUMT 1
// Reserved for future use
#define MIN_ADC 0
#define MAX_ADC 1023
// RS232C BAUD_RATE
#define BAUD_RATE 115200
// Fast ADC code from
// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1208715493/11
// defines for setting and clearing register bits
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
//=============================================================================
// Variables and constants Változók és állandók
//=============================================================================
// Number of driving and sensinig electrodes. Számú vezetési és érzékelő elektródákat.
// Although the current ArduMT panel has 30 sensing electrodes Bár a jelenlegi ArduMT panel 30 érzékelő elektródák
// its sensing electronics supports 40 channels. az érzékelő elektronika támogatja a 40 csatorna.
const int nDriving = 40;
const int nSensing = 30;
const int nDrivingModuleChannel = 40;
const int nSensingModuleChannel = 40;
// Shift register control settings. Shift regiszter beállításokat.
// ArduMT uses shift registers to address a single touch pixel. ArduMT használ váltás nyilvántartások, amelyek foglalkoznak egy képpont felbontású érintőképernyő.
// This addressing method can reduce the required number of Arduino digital Ez a címzési módszer csökkentheti a szükséges számú Arduino digitális
// output pins, especially when there are large number of electrodes. kimeneti csapok, különösen akkor, ha nagy számú elektródák.
// Settings for ArduMT
// Pin connected to latch pin (ST_CP) of 74HC595
const int latchPinD = 8;
const int latchPinS = 11;
// Pin connected to clock pin (SH_CP) of 74HC595
const int clockPinD = 9;
const int clockPinS= 10;
// Pin connected to Data in (DS) of 74HC595
const int dataPinD = 7;
const int dataPinS = 12;
const int latchPinSPORTB = B00001000; // Digital Pin 11
const int clockPinSPORTB = B00000100; // Digital Pin 10
const int dataPinSPORTB = B00010000; // Digital Pin 12
int incomingByte = 0;
// Encoding control parameters
const int MAX_NUM_ENCODED_ZEROS = 254;
const int MAX_MEASUREMENT = 254;
const int END_PACKET = 255;
// Time check variables and functions for debuggin ArduMT Idő ellenőrzés változók és funkciók debuggin ArduMT
#if TIME_CHK
unsigned long begin_time;
unsigned long end_time;
unsigned long elapsed_time;
#endif
//=============================================================================
// Function bodies Funkció szervek
//=============================================================================
#if TIME_CHK
void time_chk_start(void)
{
begin_time = micros();
}
void time_chk_stop(void)
{
end_time = micros();
elapsed_time = end_time - begin_time;
Serial.print("Time (micro s): ");
Serial.println(elapsed_time);
}
#endif
/** Real-time encoding (compression) of ADC measurement */
void encodeData(int measurement, int &count)
{
if( measurement < encodingThreshold ) // consider as 0
{
if(count < (MAX_NUM_ENCODED_ZEROS-1))
{
count++;
}
else
{
#if !TIME_CHK
Serial.print(0, BYTE);
//Serial.print(255, BYTE);
Serial.print(MAX_NUM_ENCODED_ZEROS, BYTE);
#endif
count = 0;
}
}
else
{
if( count != 0 )
{
#if !TIME_CHK
Serial.print(0, BYTE);
Serial.print(count, BYTE);
#endif
count = 0;
}
#if !TIME_CHK
if(MAX_MEASUREMENT < (measurement/MEASUREMENT_DIVIDE))
{
Serial.print(MAX_MEASUREMENT, BYTE);
}
else
{
Serial.print(measurement/MEASUREMENT_DIVIDE, BYTE);
}
#endif
}
}
/** For testting ArduMT, only for development purpose */
void testArduMT(int testNumber)
{
initializeShiftRegisters(dataPinD, clockPinD, latchPinD, nDriving);
initializeShiftRegisters(dataPinS, clockPinS, latchPinS, nSensing);
byte command1 = 'S'; // 83, Uncompressed data transfer. Packet length is nDriving*nSensing bytes
int measurement = 0;
switch (testNumber)
{
case 1: // sensing point (0, 0)
shiftOutBit(dataPinD, clockPinD, latchPinD, 1);
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 1);
while (1) {}
break;
case 2: // sensing point (29, 0)
for (int j = 0 ; j < 29; j++)
{
if (j == 0)
{
initializeShiftRegisters(dataPinS, clockPinS, latchPinS, nSensing);
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 1);
}
else
{
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 0);
}
}
while (1) {}
break;
case 3: // sensing point (30, 0)
for (int j = 0; j < 30; j++)
{
if (j == 0)
{
initializeShiftRegisters(dataPinS, clockPinS, latchPinS, nSensing);
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 1);
}
else
{
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 0);
}
}
while (1) {};
break;
case 4: // low-speed scanning with initialization (zero out sensor shift registers)
while(1)
{
if (Serial.available() > 0)
{
incomingByte = Serial.read();
if (incomingByte == command1)
{
for (int j = 0 ; j < nDriving; j++)
{
if (j == 0)
{
initializeShiftRegisters(dataPinS, clockPinS, latchPinS, nSensing);
shiftOutBit(dataPinS, clockPinS, latchPinS, 1);
}
else
{
shiftOutBit(dataPinS, clockPinS, latchPinS, 0);
}
measurement = analogRead(ADC_CHANNEL);
Serial.print(measurement/MEASUREMENT_DIVIDE, BYTE);
}
}
}
}
break;
case 5: // high-speed scanning with initialization (zero out sensor shift registers)
while(1)
{
if (Serial.available() > 0)
{
incomingByte = Serial.read();
if (incomingByte == command1)
{
for (int j = 0 ; j < nDriving; j++)
{
if (j == 0)
{
initializeShiftRegisters(dataPinS, clockPinS, latchPinS, nSensing);
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 1);
}
else
{
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 0);
}
measurement = analogRead(ADC_CHANNEL);
Serial.print(measurement/MEASUREMENT_DIVIDE, BYTE);
}
}
}
}
break;
default:
break;
}
}
void setup()
{
#if FASTADC
// set prescale to 16
sbi(ADCSRA,ADPS2) ;
cbi(ADCSRA,ADPS1) ;
cbi(ADCSRA,ADPS0) ;
#endif
// Initialize scanning electronics
pinMode(latchPinD, OUTPUT);
pinMode(latchPinS, OUTPUT);
pinMode(dataPinD, OUTPUT);
pinMode(dataPinS, OUTPUT);
pinMode(clockPinD, OUTPUT);
pinMode(clockPinS, OUTPUT);
initializeShiftRegisters(dataPinD, clockPinD, latchPinD, nDriving);
initializeShiftRegisters(dataPinS, clockPinS, latchPinS, nSensing);
// Initialize serial port
Serial.begin(BAUD_RATE);
#if TEST_ARDUMT
testArduMT(TEST_ARDUMT);
#endif
}
void loop()
{
int measurement = 0;
int count = 0;
byte command1 = 'S'; // 83, Uncompressed data transfer. Packet length is nDriving*nSensing bytes
byte command2 = 'F'; // 70, Compressed data transfer. Variable packet length.
byte command_ain = 'A'; // Analog in.
//byte command_ain = 'A'; // Analog in
//byte command_a1 = 'A1'; // Analog in
if (Serial.available() > 0)
{
incomingByte = Serial.read();
if (incomingByte == command1)
{
#if TIME_CHK
time_chk_start();
#endif
for (int i = 0; i < nDriving; i++)
{
/*
if (i == 0) shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 1);
else shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 0);
*/
if (i == 0) shiftOutBit(dataPinD, clockPinD, latchPinD, 1);
else shiftOutBit(dataPinD, clockPinD, latchPinD, 0);
for (int j = 0 ; j < nSensingModuleChannel; j++)
{
#if FASTSCAN
if (j == 0)
{
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 1);
}
else
{
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 0);
}
#else
// Driving, sensing electrode control using 595
if (j == 0)
{
shiftOutBit(dataPinS, clockPinS, latchPinS, 1);
}
else
{
shiftOutBit(dataPinS, clockPinS, latchPinS, 0);
}
#endif
if (j < nSensing)
{
measurement = analogRead(ADC_CHANNEL);
#if !TIME_CHK
if(MAX_MEASUREMENT < (measurement/MEASUREMENT_DIVIDE))
{
Serial.print(MAX_MEASUREMENT, BYTE);
}
else
{
Serial.print(measurement/MEASUREMENT_DIVIDE, BYTE);
}
#endif
}
}
}
#if TIME_CHK
time_chk_stop();
#endif
}
else if (incomingByte == command2)
{
#if TIME_CHK
time_chk_start();
#endif
for (int i = 0; i < nDriving; i++)
{
if (i == 0) shiftOutBit(dataPinD, clockPinD, latchPinD, 1);
else shiftOutBit(dataPinD, clockPinD, latchPinD, 0);
for (int j = 0 ; j < nSensingModuleChannel; j++)
{
#if FASTSCAN
if (j == 0)
{
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 1);
}
else
{
shiftOutBitHighSpeedPORTB(dataPinSPORTB, clockPinSPORTB, latchPinSPORTB, 0);
}
#else
// Driving, sensing electrode control using 595
if (j == 0)
{
shiftOutBit(dataPinS, clockPinS, latchPinS, 1);
}
else
{
shiftOutBit(dataPinS, clockPinS, latchPinS, 0);
}
#endif
if (j < nSensing)
{
measurement = analogRead(ADC_CHANNEL);
encodeData(measurement, count);
}
}
}
// End of encoded packet
if( count != 0)
{
#if !TIME_CHK
Serial.print(0, BYTE);
Serial.print(count, BYTE);
#endif
count = 0;
}
#if !TIME_CHK
Serial.print(END_PACKET, BYTE);
Serial.print(END_PACKET, BYTE);
#endif
#if TIME_CHK
time_chk_stop();
#endif
}
else if (incomingByte == command_ain)
{
//int aport = Serial.read();
//measurement = analogRead(aport);
measurement = analogRead(1);
Serial.print(measurement, BYTE);
measurement = analogRead(2);
Serial.print(measurement, BYTE);
measurement = analogRead(3);
Serial.print(measurement, BYTE);
measurement = analogRead(4);
Serial.print(measurement, BYTE);
measurement = analogRead(5);
Serial.print(measurement, BYTE);
}
/*
else if (incomingByte == command_a2)
{
measurement = analogRead(2);
Serial.print(measurement, BYTE);
}
*/
}
}
void shiftOutBit(int myDataPin, int myClockPin, int myLatchPin, int myDataOut)
{
// This shifts 8 bits out MSB first, on the rising edge of the clock,
// clock idles low
// internal function setup
int i=0;
int pinState;
digitalWrite(myLatchPin, 0);
// clear everything out just in case to
// prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);
// if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut )
{
pinState= 1;
}
else
{
pinState= 0;
}
//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
//stop shifting
digitalWrite(myClockPin, 0);
digitalWrite(myLatchPin, 1);
}
// Highspeed version of shiftOutBit() function for PORTB pins (digital pin 8 ~ 13)
// Therefore, this function can replace shiftOutBit() for sensing electrodes.
// References:
// http://www.arduino.cc/en/Reference/PortManipulation
// http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1230286016
void shiftOutBitHighSpeedPORTB(int myDataPin, int myClockPin, int myLatchPin, int myDataOut)
{
PORTB &= ~(myLatchPin | myDataPin | myClockPin);
// Sets the ddata pin to HIGH or LOW depending on myDataOut
if ( myDataOut )
{
PORTB |= myDataPin;
}
else
{
PORTB &= ~myDataPin;
}
// register shifts bits on upstroke of clock pin
PORTB |= myClockPin;
// zero the data pin after shift to prevent bleed through
PORTB &= ~myDataPin;
// stop shifting
PORTB &= ~myClockPin;
PORTB |= myLatchPin;
}
void initializeShiftRegisters(int whichRegister, int clockPin, int latchPin, int numRegisters)
{
digitalWrite(latchPin, LOW);
for (int i = 0; i < numRegisters; i++)
{
shiftOut(whichRegister, clockPin, MSBFIRST, 0);
}
digitalWrite(latchPin, HIGH);
}
