Proyectos y Diseños Retro ⇒ MegaDuino - MaxDuino basado en Mega2560 Pro Embed

[merlinkv]

Hola droman,

Va por la 2.0 que es del año pasado, mejoré la respuesta de visualización con distintas pantallas, la velocidad de carga de los TZX Turbo, etc.

- MegaDuino Firmware

Espero que te guste.

[droman]

Gracias merlinkv

Seguro que me gusta jejeje

[merlinkv]

Hola de nuevo droman ... y a todos, claro.

Acabo de subir una nueva versión del Firmware, la 2.5 -> MegaDuino Firmware

Ya me salen las líneas de código por las orejas ...

Me estoy haciendo viejo, lo que antes hacía en unas horas, ahora me lleva casi un par de días ...

[Pingui]

lo que antes hacía en unas horas, ahora me lleva casi un par de días ...

Pero lo sigues haciendo, que es lo interesante jejeje

[merlinkv]

Hoy tengo el día libre y estoy haciendo algunas pruebas con el último firmware de @rcmolina y mi versión.

Equipo: Omega MSX2
Tape Player: MegaDuino 4.7 (Mega 2560 Pro Embed)
Amplificador: OFF
Archivos:

• Afteroids (1988)(Zigurat Software)(ES)[RUN'CAS-'].cas
• Alien 8 (1985)(Ultimate Play The Game)(GB)[BLOAD'CAS-',R].cas
• Batman (1986)(Erbe Software)[RUN'CAS-'].cas
• Blasteroids (1987)(Image Works)[BLOAD'CAS-',R].cas

Velocidad de carga: 3600

Cargan perfectamente con el firmware MegaDuino, pero fallan con el de rcmolina. No sé si con el de rcmolina hay que configurar algún parámetro extra para los CAS, pero si es así, no he visto cual puede ser.

#define Use_CAS está activo en ambos casos.

Por si el tío droman lo quiere revisar ...

[msxmakers]

Hola peña.
Gracias merlinkv
He encontrado por internet esto:
Arduino UNO data recorder
Estoy intentando construirlo pero debido a la dificultad de conseguir algún componente como esa pantalla, de momento no lo he conseguido poner en marcha.
A lo mejor a alguien como tú le cuesta un arrebato reemplazar esa pantalla/librería por otra más común y probarlo.
En cualquier caso, seguro que el código te interesa y/o te es útil.
Os informo si avanzo con la construcción.
Saludos.

[merlinkv]

Pues parece interesante. ¿Tienes descargado el esquema y el código fuente?

[msxmakers]

Pues parece interesante. ¿Tienes descargado el esquema y el código fuente?

si, en el enlace está el codigo ino compartido, el esquema como foto y ... no los gerber porque así les tienes que comprar las pcb a pcbway, pero yo ya tengo pcb, por si quieres que te envie una o por si eso ayuda.
Por supuesto podría recrear el diseño y adaptarlo a nuestras necesidades, aunque siempre me gusta hacer funcionar primero lo que otros han creado para partir de una base solida.
Si no puedes descargar el código o te puedo ayudar de algún modo házmelo saber.
de momento no he conseguido que la pantalla muestre nada, lo tiene todo montado menos el adaptador SD y he intentado conectar una pantalla parecida que compré en ali.
la pantalla que compré es:
display COG 16x02
y ... no tenía un circuito de interconexión pero parece que debería funcionarme con esto:
https://github.com/y2kblog/AQM1602_STM32

A ver saco tiempo y lo vuelvo a probar.
y...
dime como te puedo ayudar.
saludos.

[merlinkv]

Los Gerbers no me interesan, me interesa el .ino y el esquema por si puedo implementar en mi diseño algo parecido.

¿Los puedes poner aquí? Es que, salvo causas de fuerza mayor, paso de registrarme en otra página ...

Por cierto, los mismos juegos CAS del mensaje de antes, he vuelto a probar y todos han cargado a 3.850 bds sin problemas.

[msxmakers]

Los Gerbers no me interesan, me interesa el .ino y el esquema por si puedo implementar en mi diseño algo parecido.

¿Los puedes poner aquí? Es que, salvo causas de fuerza mayor, paso de registrarme en otra página ...

Por cierto, los mismos juegos CAS del mensaje de antes, he vuelto a probar y todos han cargado a 3.850 bds sin problemas.

perdona, no recordaba que había tenido que registrarme.
fichero datarec.ino
codigo:

Código: Seleccionar todo

//------------------------------------------------------------
// DIY DATA RECORDER
// for ATmega328 5V 16MHz(Arduino Pro)
// by takuya matsubara

// 3 modos
// ・Modo PLAY: Convierta el archivo binario (CAS/P6) en la tarjeta SD para emitir un pitido y enviar
// ・Modo REMOTE PLAY: Reproduce un pitido cuando REMOTE está ON
// ・Modo REC: convierte el sonido recibido en un archivo binario y lo guarda en la tarjeta SD

// Terminal de casete de PC-6001mkII(4)CMTOUT --> DATIN D2(PD2)
// Terminal de casete de PC-6001mkII(5)CMTIN <-- DATOUT D3(PD3)
// Terminal de casete de PC-6001mkII(6)REMOTE+ --> REMOTE D9(PB1)
// Terminal de casete de PC-6001mkII(7)REMOTE- --- GND
// Terminal de casete de PC-6001mkII(2)GND --- GND
// Terminal de casete de PC-6001mkII(8)GND --- GND
// El REMOTO no tiene polaridad, por lo que +/- inversa está bien

// SDCARD SDI <-- D11(PB3)
// SDCARD SDO --> D12(PB4)
// SDCARD CLK <-- D13(PB5)
// SDCARD CS  <-- D4(PD4)

// AQM1602XA SCL <-- D19(PC5)
// AQM1602XA SDA <-- D18(PC4)

// SPEAKER <-- D14(PC0)

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

#define DATIN     2   //pin number:data input "activada la función de grabación"
//#define DATIN     0   //pin number:desactivada la función de grabación

#define REMOTE    9   //pin number:remote "terminal"
//#define REMOTE    0   //pin number:remote "desactivar terminal"

#define SPEAKER   14  //pin number:speaker
//#define SPEAKER   0  //pin number:"desactivar altavoz"

#define DATOUT    3   //pin number:data output
#define BTN_UP    5   //pin number:up button
#define BTN_DOWN  6   //pin number:down button
#define BTN_PLAY  7   //pin number:play button
#define BTN_STOP  8   //pin number:stop button

#define CPUHZ  16000000
#define PRS1  8
#define PRS2  64

char seq = 0; //menu seq(Comience con la selección de modo)

char targetfile[14];  //nombre de archivo 8+.1+extensión 3+null1
unsigned int targetsize;  //tamaño archivo
unsigned int pion;  //contador de pitidos
unsigned int tape_counter;  //contador de cinta
unsigned int pulse_work;
unsigned char pulse_waveform;
#define RINGBUFMAX 64
unsigned char ringbuff[RINGBUFMAX]; //buffer de anillo o "ring"
volatile char ring_a = 0; //RINGBUFFER contador A
volatile char ring_b = 0; //RINGBUFFER contador B
unsigned int idx = 0;  //read file index

//------------------------------------------------------------
//Interrupción cambio pin DATIN subida/bajada
SIGNAL (PCINT2_vect)
{
  char onebit;
  int hz;
  if(digitalRead(DATIN)==HIGH){ //rising
    #if SPEAKER!=0
    digitalWrite(SPEAKER, HIGH);
    #endif
    TCNT1 =0;
  }else{
    hz = ((CPUHZ/PRS1)/2)/TCNT1;  //falling
    #if SPEAKER!=0
    digitalWrite(SPEAKER, LOW);
    #endif
    if(hz<600)return;
    if(hz>1800){
      pulse_waveform <<= 2;
      pulse_waveform |= 0b10;  //2400Hz(1)
    }else{
      pulse_waveform = 0b1100; //1200Hz(0)
    }
    if(pulse_waveform & 0b1000){//1bit recepcion
      if(pulse_waveform == 0b1100) onebit=0; else onebit=1; 

      if(pulse_work == 0xFFFF){ //startbit espera
        if(onebit==0)pulse_work = 0x7FFF;  //startbit deteccion
      }else{
        //0b111dddddddd01111
        pulse_work >>= 1;
        if(onebit)pulse_work |= 0x8000;
        if((pulse_work & (1<<4))==0){//12bit envio terminado
          ringbuff_push((pulse_work >> 5) & 0xFF);          
          pulse_work = 0xFFFF;
        }
      }
      pulse_waveform = 0;
    }
  }
}

//------------------------------------------------------------
// Interrupción del temporizador 4800 veces/seg.
SIGNAL (TIMER1_OVF_vect)
{
  char state;
  TCNT1 = 0x10000-((CPUHZ/PRS1)/4800);
  if(tape_counter == 0xffff)return;

  if(pulse_work == 0x0000){  //Transmisión de 1 byte (12 bits) completada
#if REMOTE!=0    
    if(seq==5){
      if( digitalRead(REMOTE) == HIGH){
        pion = 0;   // contador de pitidos (o tiempo de pitido)
        return; //REMOTE terminal OFF
      }
    }
#endif
    if(((pion>=0)&&(pion<340))||((pion>=356)&&(pion<456))){
      //Pite durante 3,4 segundos antes de enviar datos 3,4 segundos/(12bit/1200hz)=340
      //Pitido durante 1 segundo después de enviar 16 bytes de datos  1/(12/1200)=100
      pulse_work = 0b111111111111; //12bit
    }else{
      if(ringbuff_datacnt()==0){ //si el bufer circular (anillo) está vacio
        return;        
      }
      pulse_work = ringbuff_pop(); //los siguientes datos
      pulse_work = (pulse_work | 0b11100000000)<< 1; //12bit
      tape_counter++; //incrementa contador de cinta
    }
    if(pion < 0xffff)pion++;
  }
  if(pulse_waveform==0){  //1bit=1/1200sec progreso
    if(pulse_work & 1){
      pulse_waveform = 0b1010;   // 2400Hz(1) 
    }else{
      pulse_waveform = 0b1100;   // 1200Hz(0) 
    }
    pulse_work >>=1;
  }
  if((pulse_waveform & 1)==0) state=HIGH; else state=LOW;
  digitalWrite(DATOUT, state);
  #if SPEAKER!=0
  digitalWrite(SPEAKER, state);
  #endif
  pulse_waveform >>= 1;
}
//------------------------------------------------------------
//RING BUFFER:PUSH numero de datos
int ringbuff_datacnt(void)
{
  if(ring_a < ring_b){
    return((ring_a + RINGBUFMAX) - ring_b);
  }else{
    return(ring_a - ring_b);
  }
}
//------------------------------------------------------------
//RING BUFFER:PUSH "hacer"
void ringbuff_push(unsigned char pushdata)
{
  ringbuff[ring_a] = pushdata;
  ring_a = (ring_a+1) & (RINGBUFMAX-1);
}
//------------------------------------------------------------
//RING BUFFER:POPする
unsigned char ringbuff_pop(void)
{
  unsigned char work;
  if (ring_a==ring_b)return(0x00);  //no data
  work = ringbuff[ring_b];
  ring_b = (ring_b+1) & (RINGBUFMAX-1);
  return(work);
}
//------------------------------------------------------------
//AQM1602XA:init
void lcd_init(void)
{
#define LCDCNTR 12   //contrast(0-63)
  Wire.begin();
  delay(150);
  lcd_cmdwrite(0x38);  //function set(normal instruction)
  lcd_cmdwrite(0x39);  //function set(extension instruction)
  lcd_cmdwrite(0x14);  //internal osc freq.
  lcd_cmdwrite(0x70+(LCDCNTR & 0xF)); //contrast set
  lcd_cmdwrite(0x54+(LCDCNTR >> 4));  //power/icon/contrast control
  lcd_cmdwrite(0x6C);  //follower control
  lcd_cmdwrite(0x38);  //function set(normal instruction)
  lcd_cmdwrite(0x01);  //clear display
  lcd_cmdwrite(0x08+4+2+1);  //display on/off control(disp=on/cursor=on/blink=on)
}
//------------------------------------------------------------
//AQM1602XA
void lcd_write(unsigned char temp1,unsigned char temp2)
{
#define LCDADDR  (0x7C >> 1)  //slave address // canviar por el puerto del display I2C (segun fabricante es el puerto 0x3C)
  Wire.beginTransmission(LCDADDR);
  Wire.write(temp1);             
  Wire.write(temp2);             
  Wire.endTransmission();
}
//------------------------------------------------------------
//AQM1602XA:locate
void lcd_locate(char x,char y){
  unsigned char cmd=0x80;
  if((x>=16)||(y>=2))return;
  cmd += x;
  cmd += (0x40*y);
  lcd_cmdwrite(cmd);
}
//------------------------------------------------------------
//AQM1602XA:write character
void lcd_cmdwrite(unsigned char command)
{
  lcd_write(0x00,command);
  delay(1);
}
//------------------------------------------------------------
//AQM1602XA
void lcd_datawrite(unsigned char data)
{
  lcd_write(0x40,data);
  delay(1);
}
//------------------------------------------------------------
//AQM1602XA
void lcd_cls(void)
{
  char i;
  lcd_locate(0,0);
  for(i=0;i<16;i++){
    lcd_datawrite(' ');
  }  
  lcd_locate(0,1);
  for(i=0;i<16;i++){
    lcd_datawrite(' ');
  }  
}
//------------------------------------------------------------
//AQM1602XA
void lcd_putstr(char x,char y,char *p)
{
  lcd_locate(x,y);
  while(*p!=0){
    lcd_datawrite(*p++);
  }  
}
//------------------------------------------------------------
//AQM1602XA:pantalla decimal de 5 digitos
void lcd_putnum(char x,char y,unsigned int num)
{
  unsigned int keta=10000;
  char temp;
  lcd_locate(x,y);
  while(keta>0){
    temp = (num/keta)% 10;
    lcd_datawrite('0'+temp);
    keta /= 10;
  }  
}

//------------------------------------------------------------
PROGMEM const unsigned char message[12][16]={
  "DATA RECORDER",    //0
  "SD CARD ERROR",    //1
  "FILE OPEN ERROR",  //2
  "WRITE ERROR",      //3
  "MENU",             //4
  "PLAY MODE",        //5
  "REC MODE",         //6
  "PLAY LIST",        //7
  "SELECT NUMBER",    //8
  "PLAYING...",       //9
  "RECORDING..",      //10
  "REMOTE PLAY"       //11
};

void lcd_putmessage(int x,int y,int number)
{
  PGM_P pSrc;
  unsigned char ch;
  pSrc = message[number];

  lcd_locate(x,y);
  while(1){
    ch = pgm_read_byte(pSrc++);
    if(ch==0)break;
    lcd_datawrite(ch);
  }
}

//------------------------------------------------------------
//"sin usar o sin uso" send 1byte
void pulsesend(int work){
  char bitcnt;
  char pulse;
  int hz;
  
  work <<= 1; //start bit(0) 
  work |=  (0b111 << 9); // stop bit
  digitalWrite(DATOUT, 1);
  TCNT2 = 0;
  for(bitcnt=0; bitcnt<12; bitcnt++){
    if(work & (1<<bitcnt)){
      hz = 2400;  //2400Hz(1)
      pulse = 4;
    }else{
      hz = 1200;  //1200Hz(0)
      pulse = 2;
    }
    while(pulse>0){
      if(TCNT2 >= (((CPUHZ/PRS2)/2)/hz)){
        TCNT2 = 0;
        digitalWrite(DATOUT, digitalRead(DATOUT) ^ 1);
        pulse--;
      }
    }
  }
  digitalWrite(DATOUT, 0);
}
//------------------------------------------------------------
// receive 1byte de "sin uso"
//          +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
//  pulsecnt| -1  |00 01|02 03|04 05|06 07|08 09|10 11|12 13|14 15|16 17|18 19|20 21|
//          +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
//          |start| bit0| bit1| bit2| bit3| bit4| bit5| bit6| bit7| stop| stop| stop|  
int pulserecv2(void){
  char pulsecnt=-1;
  unsigned char work=0;
  unsigned int hz;
  static int edge=0;
  int edgenow;
  unsigned long timeout;

  timeout=0;
  hz = 0;
  while(pulsecnt < 22){
    edgenow = digitalRead(DATIN);
    if(edge != edgenow){  //find pin change
      edge = edgenow;
      if(edge){
        TCNT1 = 0;  //pulse start
      }else{
        hz = ((CPUHZ/PRS1)/2)/TCNT1;      //pulse end
      }
    }else{
      timeout ++;
      if(timeout == 0xfffff)return(-1);
    }
    if(hz==0)continue;
    if(pulsecnt ==-1){      //find start bit(1200Hz)
      if(hz > 1800){
        pulsecnt = -1;  //error
        continue;
      }
      if(hz < 600){
        pulsecnt = -1;  //error
        continue;
      }
      pulsecnt = 0;
    }else if(pulsecnt < 16){        // b0-b7
      if(hz > 1800){
        work |= (1<<(pulsecnt>>1));  //2400Hz
        pulsecnt += 1;
      }else{
        pulsecnt += 2;  //1200Hz
      }
    }else{        //stop bit
      pulsecnt += 1;
    }
    hz = 0;      
  }
  return(work);
}
//------------------------------------------------------------
//sin usar receive
void recvtest(void) {
  int cmd;
  char pos=0; 

  while(1){
    if (pos==0) Serial.write('\n');
    cmd = pulserecv2();  //get command
    if (cmd==-1){ //timeout
      pos = 0;
    }else{
      Serial.print(cmd >> 4, HEX); 
      Serial.print(cmd & 0x0f, HEX); 
      Serial.write(' ');
      pos = (pos+1)% 16;
    }
  }
}
//------------------------------------------------------------
// record image file
void recimagefile(void) {
  File myFile;
  unsigned char tempbyte;
  char gomiflag=1;  //Indicador de eliminación de polvo (1 = detección de polvo) supongo que se refiere a "ruido"

  lcd_cls();
  myFile = SD.open(targetfile, FILE_WRITE);
  if (myFile==0) {    //error
    lcd_putmessage(0,0,3);
    delay(1000);
    return;
  }
  lcd_putmessage(0,0,10);

  PCMSK2 |= (1<<PCINT18); //Interrupción de cambio de pin DATIN
  PCICR |= (1<<PCIE2);  // Interrupción de cambio de pin enable

  pulse_work = 0xFFFF;
  pulse_waveform = 0;
  tape_counter = 0;
  sei();

  while(1){
    if (digitalRead(BTN_STOP) == LOW)break;   //cancelar con el botón STOP
    if(ringbuff_datacnt() == 0){
      lcd_putnum(0,1,tape_counter); //contador de cinta
      continue;
    }
    tempbyte = (unsigned char)ringbuff_pop();
    if(gomiflag){//deteccion de ruido (o polvo/basura)
      if(tempbyte != 0xD3)continue; //si no comienza con D3 se considera basura
      gomiflag = 0;
    }
//      Serial.print(tempbyte >> 4, HEX);   //debug
//      Serial.print(tempbyte & 0x0f, HEX); //debug 
//      Serial.write(' '); //debug
      myFile.write(&tempbyte, 1); //write sd card
      tape_counter++;
  }
  myFile.close();

//  cli();
  PCICR &= ~(1<<PCIE2);  // interrupción de cambio de pin "disable"
  targetsize = tape_counter;
  lcd_putnum(0,1,tape_counter); //contador de cinta
  delay(1000);
}

//------------------------------------------------------------
// SD CARD FILENAME
void getfilename(int index) {
  File myFile;
  str_copy(targetfile,"");
  myFile = SD.open("/");
  if(myFile==0){
    lcd_putmessage(0,1,2);//ERROR
    delay(1000);
    return;
  }
  
  while(targetfile[0]==0) {
    File entry =  myFile.openNextFile();
    if (! entry) {
      // no more files
      break;
    }
//    Serial.println(entry.name()); //debug

    if (entry.isDirectory()) { //skip
    } else {
      if (index==0){
        str_copy(targetfile,entry.name());  //copy file name
        targetsize = entry.size();
      }
      index--;
    }
    entry.close();
  }
  myFile.close();
}
//------------------------------------------------------------
void str_num2str(char *p,unsigned int num)
{
  unsigned int keta=10000;
  char temp;

  while(keta > 0){
    temp = (num/keta)% 10;
    *p++ = ('0'+temp);
    keta /= 10;
  }  
}
//------------------------------------------------------------
// string:copy
//pSrc:origen de la copia
//pDst:destino de la copia
void str_copy(char *pDst,char *pSrc)
{
  while(1){
    *pDst = *pSrc;
    if(*pDst == 0)break;
    pDst++;
    pSrc++;
  }
}
//--------------------------------------------------------------
// string:Compare
char str_ncmp(char *p1,char *p2,char cnt)
{
  while(*p1 == *p2)
  {
    cnt--;
    if(cnt <= 0)return(0);  //equal
    p1++;
    p2++;
  }
  return(1);  //not equal
}
//------------------------------------------------------------
// string:upper case
unsigned char str_ucase(unsigned char chrcode)
{
  if((chrcode >= 'a')&&(chrcode <= 'z'))
    chrcode -= 0x20;

  return(chrcode);
}
//------------------------------------------------------------
//play Tape image
void playimagefile(void)
{
  File myFile;
  char i;

  lcd_cls();
  myFile = SD.open(targetfile);
  if (myFile == 0) {
    lcd_putmessage(0,0,2);//ERROR
    delay(1000);
    return;
  }
  lcd_putmessage(0,0,9);  //PLAYING
  lcd_putnum(11,1,targetsize);

  for(i=0;i<16;i++){
    if (myFile.available()) {
      ringbuff_push(myFile.read()); //lectura de tarjetas SD
    }
  }
  pion = 0;   // contador de pitidos
  pulse_work = 0;
  pulse_waveform = 0;
  tape_counter = 0;

  TCNT1 = 0x10000-((CPUHZ/PRS1)/4800);
  TIMSK1 |= (1<<TOIE1); // Interrupción de desbordamiento del temporizador 1 "enable"
  sei();

  while(1){
    if(ringbuff_datacnt() < RINGBUFMAX-3){
      if(myFile.available()){
        ringbuff_push(myFile.read());
      }
    }else{
      lcd_putnum(0,1,tape_counter); //contador de cinta
    }
    if(ringbuff_datacnt()==0)break; //buffer anillo vacio
    if(tape_counter >= targetsize)break;  //end of tape
    if(digitalRead(BTN_STOP) == LOW)break;   //cancelar con el botón STOP
  }
  
  myFile.close();
  lcd_putnum(0,1,tape_counter); //contador de cinta
  tape_counter = 0xffff;
//  cli();
  TIMSK1 &= ~(1<<TOIE1); // Interrupción de desbordamiento del temporizador 1 desactivado (disable)
  delay(1000);
}
//------------------------------------------------------------
void swoffwait(void)
{
  while(1){
    delay(10); 
    if (digitalRead(BTN_UP) == HIGH){
      if (digitalRead(BTN_DOWN) == HIGH){
        if (digitalRead(BTN_PLAY) == HIGH){
          if (digitalRead(BTN_STOP) == HIGH){
            break;
          }
        }
      }
    }
  }
}
//------------------------------------------------------------
void setup() {
  pinMode(BTN_UP, INPUT_PULLUP);
  pinMode(BTN_DOWN, INPUT_PULLUP);
  pinMode(BTN_PLAY, INPUT_PULLUP);
  pinMode(BTN_STOP, INPUT_PULLUP);

  #if DATIN!=0
  pinMode(DATIN, INPUT);  //Con función de grabación
  #endif
  pinMode(DATOUT, OUTPUT);
  digitalWrite(DATOUT, LOW);

  #if SPEAKER!=0
  pinMode(SPEAKER, OUTPUT); //con altavoz
  digitalWrite(SPEAKER, LOW);
  #endif

  #if REMOTE!=0
  pinMode(REMOTE, INPUT_PULLUP);  //con REMOTE
  #endif

  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  lcd_init();

  if (!SD.begin(4)) {
    lcd_putmessage(0,0,1);  //ERROR
    delay(1000);
    return;
  }
 
  TCCR1A = 0;
  TCCR1B = 2;
// 0 No clock source (Timer/Counter stopped).
// 1 clkI/O/1 (No prescaling)
// 2 clkI/O/8 (From prescaler)
// 3 clkI/O/64 (From prescaler)
// 4 clkI/O/256 (From prescaler)
// 5 clkI/O/1024 (From prescaler)
//  TCNT1  = 0;
//  TIMSK1 |= (1 << OCIE1A);  // enable timer compare interrupt
//  TIFR1 |= (1<<TOV1);

  TCCR2A = 0;
  TCCR2B = 4;
// 1 clk/(No prescaling)
// 2 clk/8 (From prescaler)
// 3 clk/32 (From prescaler)
// 4 clk/64 (From prescaler)
// 5 clk/128 (From prescaler)
// 6 clk/256 (From prescaler)
// 7 clk/1024 (From prescaler)

  lcd_putmessage(0,0,0);
  delay(1000);
}
//------------------------------------------------------------
void loop() {
  switch(seq){
  case 0: //mode select 1
  case 1: //mode select 2
  case 2: //mode select 3
#if DATIN==0
  seq=4;  //Si no hay función de grabación, se verá forzado al PLAY MODE
  break;
#endif
    lcd_cls();
    lcd_putmessage(0,0,4);
    if(seq==0) lcd_putmessage(0,1,5);  //PLAY MODE
    if(seq==1) lcd_putmessage(0,1,11);  //remote PLAY MODE
    if(seq==2) lcd_putmessage(0,1,6);  //rec MODE
    swoffwait();
    while(1){
      delay(100);
      if(digitalRead(BTN_UP) == LOW){
        seq++;
        if(seq>2)seq=0;
        break;
      }
      if(digitalRead(BTN_DOWN) == LOW){
        if(seq==0)seq=2; else seq--;
        break;
      }
      if(digitalRead(BTN_PLAY) == LOW){
        if(seq==0)seq=4;  //start play mode
        if(seq==1)seq=5;  //start remote play mode
        if(seq==2)seq=6;  //start rec mode
        break;
      }
    }
    break;
    
  case 4: //play mode
    getfilename(idx);
    delay(200);
    swoffwait();
    if(targetfile[0]==0){//Error al obtener el nombre del archivo
      idx=0;
      break;  //retry 
    }else{
      lcd_cls();
      lcd_putmessage(0,0,7);  //PLAY LIST
      lcd_putnum(10,0,idx);   //index
      lcd_putstr(0,1,targetfile);
    }
    while(1){
      delay(100);
      if (digitalRead(BTN_UP) == LOW){  //index+1
        idx++;
        break;
      }
      if (digitalRead(BTN_DOWN) == LOW){  //index-1
        idx--;
        break;
      }
      if (digitalRead(BTN_PLAY) == LOW){
        playimagefile();  //play image file
        break;
      }
      if( digitalRead(BTN_STOP) == LOW){
        seq = 0; //back to mode select
        break;
      }
    }
    break;

  case 5: //remote play mode
#if REMOTE==0
  seq=4;  //Fuerza PLAY MODE si no hay función REMOTE
  break;
#endif
    getfilename(idx);
    delay(200);
    swoffwait();
    if(targetfile[0]==0){//error al obtener el nombre de archivo
      idx=0;
      break;  //retry 
    }else{
      lcd_cls();
      lcd_putmessage(0,0,7);  //PLAY LIST
      lcd_putnum(10,0,idx);   //index
      lcd_putstr(0,1,targetfile);
    }
    while(1){
      delay(100);
      if (digitalRead(BTN_UP) == LOW){  //index+1
        idx++;
        break;
      }
      if (digitalRead(BTN_DOWN) == LOW){  //index-1
        idx--;
        break;
      }
      if (digitalRead(REMOTE) == LOW){  //REMOTE es ON
        playimagefile();  //play image file
        break;
      }
      if( digitalRead(BTN_STOP) == LOW){
        seq = 1; //back to mode select
        break;
      }
    }
    break;

  case 6: //rec mode
#if DATIN==0
  seq=4;  //Si no hay función de grabación, se verá forzado al PLAY MODE
  break;
#endif
    str_copy(targetfile,"SAV*****.CAS");
    str_num2str(targetfile+3,idx);
    lcd_cls();
    lcd_putmessage(0,0,8);  //SELECT NUMBER
    lcd_putstr(0,1,targetfile);
    delay(100);
    swoffwait();
    while(1){
      if (digitalRead(BTN_UP) == LOW){
        idx++;
        break;
      }
      if (digitalRead(BTN_DOWN) == LOW){
        idx--;
        break;
      }
      if (digitalRead(BTN_PLAY) == LOW){
        recimagefile(); //record image file
        break;
      }
      if( digitalRead(BTN_STOP) == LOW){
        idx = 0;
        seq = 2; //back to mode select
        break;
      }
    }
    break;
  }
}

//hasta aqui.
esquema

[P6mkII] Peeper Sound Player 3_PCBWay Community.png

la foto de la pantallita utilizada:

K-08896.JPG

saludos

AE-AQM1602-I2C_sch_castellano.pdf

[droman]

Por si el tío droman lo quiere revisar ...

Me encantaría decirte que si... pero no se si voy a tener tiempo... ni cabeza para entenderlo, ahora mismo estoy un poco desorientado con toda la medicación que tomo y no atino la derecha con la izquierda...

[merlinkv]

Me encantaría decirte que si... pero no se si voy a tener tiempo... ni cabeza para entenderlo, ahora mismo estoy un poco desorientado con toda la medicación que tomo y no atino la derecha con la izquierda...

No te preocupes, a mi me pasa lo mismo y ... sin medicación ...

Espero que te mejores. Un abrazo.

[TINGIS53]

Hace mucho tiempo que este hilo está muy callado. ¿Hay alguna novedad sobre el tema?
Me interesa mucho el tema de la grabación de los ficheros en Maxduino-Megaduino
¡Saludos!

[merlinkv]

Hola, sí, llevaba mucho tiempo muerto.

De momento lo único que hay es una versión Beta de la placa a la que he llamado MegaDuino 5.0.

Está en fase Beta hasta que reciba placas y pueda hacxer pruebas. Si todo va bien, la daré por definitiva y me pondré con el tema de incluir la opción de grabación desde equipos retro (wav).

Un saludote.

[TINGIS53]

Bueno a ver si por fin lo consigues , ya sabes que tengo uno de tus aparatos y desde entonces estoy interesado en la grabación
Gracias
Saludos

[NacherasTM]

Ya tengo el cacharrejo montado y funcionando:




Lo que pasa es que no se si he comprado otra LCD porque en el diseño de la carcasa el hueco es mucho más grande, no la puedo pegar
¿Puede que sea otra pantalla más grande?

[merlinkv]

Lo que pasa es que no se si he comprado otra LCD porque en el diseño de la carcasa el hueco es mucho más grande, no la puedo pegar
¿Puede que sea otra pantalla más grande?

Hola:

Ante todo perdona el retraso en contestar, pero ando con muchos frentes abiertos y poquísimo tiempo.

Pues no lo sé .. mis OLED's son de 1.3" 128x64

Por cierto, he publicado la última versión de mi firmware, la 3.0; entre otras mejoras está el soporte de TAP's nativos del Jupiter ACE.

- MegaDuino Firmware

[NacherasTM]

Lo que pasa es que no se si he comprado otra LCD porque en el diseño de la carcasa el hueco es mucho más grande, no la puedo pegar
¿Puede que sea otra pantalla más grande?

Pues no lo sé .. mis OLED's son de 1.3" 128x64

Por cierto, he publicado la última versión de mi firmware, la 3.0; entre otras mejoras está el soporte de TAP's nativos del Jupiter ACE.

- MegaDuino Firmware

Buenas maestro!

Pues miraré a ver pantallas de 1.3", que esta me da la sensación de que es muy pequeña, y ya de paso le meto el nuevo firmware
Gracias