void user_loop(void)
{
char xdata str[32];
static unsigned char xdata adc_chn = 0;
static char xdata turbo_on_last = -1;
static unsigned long xdata last_read = 0;
/* read one ADC channel */
adc_read(adc_chn, &user_data.adc[adc_chn]);
/* convert voltage to pressure, see data sheets */
if (adc_chn == 0)
user_data.hv_mbar = pow(10, 1.667 * user_data.adc[0] - 11.33); // PKR 251
if (adc_chn == 1)
user_data.vv_mbar = pow(10, user_data.adc[1] - 5.5); // TPR 280
if (adc_chn == 5)
user_data.hv_close = user_data.adc[5] > 5; // ADC as digital input
if (adc_chn == 6)
user_data.bv_open = user_data.adc[6] > 5; // ADC as digital input
if (adc_chn == 7)
user_data.bv_close = user_data.adc[7] > 5; // ADC as digital input
adc_chn = (adc_chn + 1) % 8;
/* read buttons and digital input */
sr_read();
/* read turbo pump parameters once each second */
if (time() > last_read + 100) {
if (user_data.turbo_on != turbo_on_last) {
tc600_write(10, 6, user_data.turbo_on ? 111111 : 0);
turbo_on_last = user_data.turbo_on;
}
if (tc600_read(309, str)) {
user_data.error &= ~ERR_TURBO_COMM;
user_data.rot_speed = atoi(str);
if (tc600_read(310, str))
user_data.tmp_current = atoi(str) / 100.0;
if (tc600_read(303, str)) {
if (atoi(str) != 0) {
user_data.error |= ERR_TURBO;
strcpy(turbo_err, str);
} else {
user_data.error &= ~ERR_TURBO;
turbo_err[0] = 0;
}
}
} else
user_data.error |= ERR_TURBO_COMM;
last_read = time();
}
/* mangae menu on LCD display */
lcd_menu();
}
uint8 NECDSP::read(unsigned addr) {
if(!debugger_access()) cpu.synchronize_coprocessor();
if((addr & srmask) == srtest) return sr_read();
if((addr & drmask) == drtest) return dr_read();
if((addr & dpmask) == dptest) return dp_read(addr);
return 0x00;
}
/* sr9700_android read one word from phy or eeprom */
static int sr_share_read_word(struct usbnet *dev, int phy, u8 reg, __le16 *value)
{
int ret, i;
mutex_lock(&dev->phy_mutex);
sr_write_reg(dev, EPAR, phy ? (reg | 0x40) : reg);
sr_write_reg(dev, EPCR, phy ? 0xc : 0x4);
for (i = 0; i < SR_SHARE_TIMEOUT; i++) {
u8 tmp;
udelay(1);
ret = sr_read_reg(dev, EPCR, &tmp);
if (ret < 0)
goto out;
/* ready */
if ((tmp & 1) == 0)
break;
}
if (i >= SR_SHARE_TIMEOUT) {
netdev_err(dev->net, "%s read timed out!", phy ? "phy" : "eeprom");
ret = -EIO;
goto out;
}
sr_write_reg(dev, EPCR, 0x0);
ret = sr_read(dev, EPDR, 2, value);
netdev_dbg(dev->net, "read shared %d 0x%02x returned 0x%04x, %d",
phy, reg, *value, ret);
out:
mutex_unlock(&dev->phy_mutex);
return ret;
}
static int sr_share_read_word(struct usbnet *dev, int phy, u8 reg,
__le16 *value)
{
int ret;
mutex_lock(&dev->phy_mutex);
sr_write_reg(dev, SR_EPAR, phy ? (reg | EPAR_PHY_ADR) : reg);
sr_write_reg(dev, SR_EPCR, phy ? (EPCR_EPOS | EPCR_ERPRR) : EPCR_ERPRR);
ret = wait_phy_eeprom_ready(dev, phy);
if (ret < 0)
goto out_unlock;
sr_write_reg(dev, SR_EPCR, 0x0);
ret = sr_read(dev, SR_EPDR, 2, value);
netdev_dbg(dev->net, "read shared %d 0x%02x returned 0x%04x, %d\n",
phy, reg, *value, ret);
out_unlock:
mutex_unlock(&dev->phy_mutex);
return ret;
}
/* sr9700_android read one register from MAC */
static int sr_read_reg(struct usbnet *dev, u8 reg, u8 *value)
{
return sr_read(dev, reg, 1, value);
}
unsigned char application_display(bit init)
{
static bit b0_old = 0, b1_old = 0, b2_old = 0, b3_old = 0,
station_on_old = 0, valve_locked_old = 0;
if (init)
lcd_clear();
/* display pressures */
lcd_goto(0, 0);
if (user_data.relais[0] && user_data.relais[1])
printf("P1*: %9.2E mbar", user_data.vv_mbar);
else
printf("P1: %10.2E mbar", user_data.vv_mbar);
lcd_goto(0, 1);
if (user_data.turbo_on && (user_data.relais[2] || user_data.relais[3]))
printf("P2*: %9.2E mbar", user_data.hv_mbar);
else
printf("P2: %10.2E mbar", user_data.hv_mbar);
lcd_goto(0, 2);
if (user_data.error & ERR_TURBO_COMM)
printf("ERROR: turbo comm. ");
else if (user_data.error & ERR_FOREVAC)
printf("ERROR: fore vaccuum ");
else if (user_data.error & ERR_MAINVAC)
printf("ERROR: main vaccuum ");
else if (user_data.error & ERR_TURBO)
printf("TMP ERROR: %s ", turbo_err);
else {
if (user_data.man_mode) {
printf("TMP: %4d Hz, %4.2f A", user_data.rot_speed, user_data.tmp_current);
} else {
if (pump_state == ST_OFF) {
if (user_data.rot_speed > 10)
printf("Rmp down TMP:%4d Hz", user_data.rot_speed);
else
printf("Pump station off ");
} else if (pump_state == ST_START_FORE)
printf("Starting fore pump ");
else if (pump_state == ST_EVAC_FORE)
printf("Pumping buffer tank ");
else if (pump_state == ST_EVAC_MAIN)
printf("Pumping recipient ");
else
printf("TMP: %4d Hz, %4.2f A", user_data.rot_speed, user_data.tmp_current);
}
}
if (user_data.man_mode) {
lcd_goto(0, 3);
printf(user_data.relais[0] ? "FP0" : "FP1");
lcd_goto(5, 3);
printf(user_data.relais[1] ? "VV0" : "VV1");
lcd_goto(11, 3);
printf(user_data.relais[2] ? "HV0" : "HV1");
lcd_goto(16, 3);
printf(user_data.relais[3] ? "BV0" : "BV1");
if (b0 && !b0_old)
user_data.relais[0] = !user_data.relais[0];
if (b1 && !b1_old)
user_data.relais[1] = !user_data.relais[1];
if (b2 && !b2_old)
user_data.relais[2] = !user_data.relais[2];
if (b3 && !b3_old)
user_data.relais[3] = !user_data.relais[3];
user_write(4);
user_write(5);
user_write(6);
user_write(7);
/* enter menu on buttons 2 & 3 */
if (b2 && b3) {
/* wait for buttons to be released */
do {
sr_read();
} while (b2 || b3);
return 1;
}
} else {
lcd_goto(0, 3);
printf(user_data.station_on ? "OFF" : "ON ");
lcd_goto(4, 3);
printf(user_data.valve_locked ? "UNLOCK" : " LOCK ");
/* toggle main switch with button 0 */
if (b0 && !b0_old)
user_data.station_on = !user_data.station_on;
/* toggle locking with button 1 */
if (b1 && !b1_old)
user_data.valve_locked = !user_data.valve_locked;
/* enter menu on release of button 3 */
if (!init)
if (!b3 && b3_old)
return 1;
}
b0_old = b0;
b1_old = b1;
b2_old = b2;
b3_old = b3;
/*---- Pump station turn on logic ----*/
if (user_data.station_on && !station_on_old) {
/* start station */
/* vent enable off */
tc600_write(12, 6, 0);
set_mainvalve(0);
set_bypassvalve(0);
set_forepump(1);
pump_state = ST_START_FORE;
start_time = time(); // remember start time
}
/* wait 5s for forepump to start (turbo could be still rotating!) */
if (pump_state == ST_START_FORE && time() > start_time + 5*100) {
set_forevalve(1);
start_time = time(); // remember start time
pump_state = ST_EVAC_FORE;
}
/* check if buffer tank gets evacuated in less than 15 min */
if (pump_state == ST_EVAC_FORE && time() > start_time + 15*60*100) {
pump_state = ST_ERROR;
user_data.error = ERR_FOREVAC;
set_forevalve(0);
set_forepump(0);
}
/* check if evacuation of forepump and buffer tank is ready */
if (pump_state == ST_EVAC_FORE && user_data.vv_mbar < 1) {
if (user_data.hv_mbar < 1) {
/* recipient is already evacuated, go to running mode */
start_time = time(); // remember start time
pump_state = ST_EVAC_MAIN ;
} else {
if (user_data.valve_locked) {
/* go immediately to running mode */
user_data.turbo_on = 1;
set_forevalve(1);
start_time = time(); // remember start time
pump_state = ST_RAMP_TURBO;
} else {
/* evacuate recipient through bypass valve */
set_forevalve(0);
delay_ms(2000); // wait 2s
set_bypassvalve(1);
start_time = time(); // remember start time
pump_state = ST_EVAC_MAIN;
}
}
}
/* check if recipient gets evacuated in less than evac_timeout minutes */
if (pump_state == ST_EVAC_MAIN &&
user_data.evac_timeout > 0 &&
time() > start_time + (unsigned long)user_data.evac_timeout*60*100) {
pump_state = ST_ERROR;
user_data.error = ERR_MAINVAC;
set_forevalve(0);
set_forepump(0);
}
/* check if evacuation of main recipient is ready, may take very long time */
if (pump_state == ST_EVAC_MAIN && user_data.hv_mbar < 1) {
set_forevalve(1); // now evacuate both recipient and buffer tank
}
/* check if vacuum on both sides of main valve is ok */
if (pump_state == ST_EVAC_MAIN && user_data.hv_mbar < 1 && user_data.vv_mbar < 1) {
/* turn on turbo pump */
user_data.turbo_on = 1;
start_time = time(); // remember start time
pump_state = ST_RAMP_TURBO;
}
/* check if vacuum leak after ramping */
if (pump_state == ST_RAMP_TURBO || pump_state == ST_RUN_FPON || pump_state == ST_RUN_FPOFF ||
pump_state == ST_RUN_FPUP || pump_state == ST_RUN_FPDOWN) {
if (user_data.hv_mbar > 4 && user_data.valve_locked == 0) {
/* protect turbo pump */
set_mainvalve(0);
set_forevalve(0);
user_data.turbo_on = 0;
/* force restart of pump station */
if (user_data.station_on) {
station_on_old = 0;
pump_state = ST_OFF;
return 0;
}
}
}
/* check if turbo pump started successfully in unlocked mode */
if (user_data.valve_locked == 0 && pump_state == ST_RAMP_TURBO &&
user_data.rot_speed > user_data.final_speed*0.8 &&
user_data.hv_mbar < 1 && user_data.vv_mbar < 1) {
set_bypassvalve(0);
/* now open main (gate) valve */
set_mainvalve(1);
start_time = time(); // remember start time
pump_state = ST_RUN_FPON;
}
/* check if turbo pump started successfully in locked mode */
if (user_data.valve_locked == 1 && pump_state == ST_RAMP_TURBO &&
user_data.rot_speed > user_data.final_speed*0.8 &&
user_data.vv_mbar < 1) {
start_time = time(); // remember start time
pump_state = ST_RUN_FPON;
}
/* check for fore pump off */
if (pump_state == ST_RUN_FPON) {
if (time() > start_time + user_data.fp_cycle*100 &&
user_data.vv_mbar < user_data.vv_min) {
set_forevalve(0);
pump_state = ST_RUN_FPDOWN;
start_time = time();
}
}
/* turn fore pump off */
if (pump_state == ST_RUN_FPDOWN) {
if (time() > start_time + 3*100) { // wait 3s
set_forepump(0); // turn fore pump off
pump_state = ST_RUN_FPOFF;
}
}
/* check for fore pump on */
if (pump_state == ST_RUN_FPOFF) {
if (user_data.vv_mbar > user_data.vv_max) {
set_forepump(1);
pump_state = ST_RUN_FPUP;
start_time = time();
}
}
/* turn fore pump on */
if (pump_state == ST_RUN_FPUP) {
if (time() > start_time + 10*100) { // wait 10s
set_forevalve(1);
pump_state = ST_RUN_FPON;
}
}
/* set vacuum status */
user_data.vacuum_ok = (user_data.hv_mbar <= user_data.hv_thresh);
user_write(3);
/*---- Pump station turn off logic ----*/
if (!user_data.station_on && station_on_old) {
/* close all valves */
set_forevalve(0);
set_mainvalve(0);
set_bypassvalve(0);
set_forepump(0);
/* stop turbo pump */
user_data.turbo_on = 0;
/* vent enable on */
tc600_write(12, 6, 111111);
/* vent mode auto */
tc600_write(30, 3, 0);
pump_state = ST_OFF;
user_data.error = 0;
}
/*---- Lock logic ----*/
if (user_data.valve_locked && !valve_locked_old) {
set_mainvalve(0);
set_bypassvalve(0);
}
if (!user_data.valve_locked && valve_locked_old) {
if (user_data.station_on) {
start_time = time(); // remember start time
pump_state = ST_EVAC_FORE; // start with buffer tank evacuation
set_forepump(1);
delay_ms(1000);
set_forevalve(1);
}
}
station_on_old = user_data.station_on;
valve_locked_old = user_data.valve_locked;
return 0;
}
int main(void (*sr_read)(unsigned int start_sector,
char *buffer, int num_sectors),
void (*ser_puts)(const char *buffer))
{
char *dst = (char *)LINUX_LOADADDR;
const struct mbr_part *part;
unsigned found = 0;
unsigned int i;
BUILD_BUG_ON(sizeof(struct mbr_part) != 16);
BUILD_BUG_ON(sizeof(struct mbr) != SECT_SIZE);
if (mbr->sig != MBR_SIG) {
ser_puts("S");
die();
}
for (i = 0; i < NUM_PE; i++) {
part = &mbr->pe[i];
/* First partition is Linux */
if (part->type != PART_TYPE_OTHER_DATA) {
ser_puts("P");
continue;
}
ser_puts("L");
sr_read(part->lba, dst, part->num_sects);
ser_puts(".\r\n");
found = 1;
break;
}
if (!found) {
dbg_str("N");
die();
}
/* Prepare ATAGS */
atags->hdr.tag = ATAG_CORE;
atags->hdr.size = atag_size(atag_core);
atags->u.core.flags = 1;
atags->u.core.pagesize = 4096;
atags->u.core.rootdev = 0;
atags = atag_next(atags);
#if (SDRAM_SIZE_MB > 32)
#error "Need to add additional ATAG_MEM for second bank!"
#endif
atags->hdr.tag = ATAG_MEM;
atags->hdr.size = atag_size(atag_mem);
atags->u.mem.start = 0;
atags->u.mem.size = 8 << 20;
atags = atag_next(atags);
atags->hdr.tag = ATAG_MEM;
atags->hdr.size = atag_size(atag_mem);
atags->u.mem.start = 0x1000000;
atags->u.mem.size = 8 << 20;
atags = atag_next(atags);
atags->hdr.tag = ATAG_MEM;
atags->hdr.size = atag_size(atag_mem);
atags->u.mem.start = 0x4000000;
atags->u.mem.size = 8 << 20;
atags = atag_next(atags);
atags->hdr.tag = ATAG_MEM;
atags->hdr.size = atag_size(atag_mem);
atags->u.mem.start = 0x5000000;
atags->u.mem.size = 8 << 20;
atags = atag_next(atags);
atags->hdr.tag = ATAG_NONE;
atags->hdr.size = 0;
/* Start kernel, bye! */
ser_puts("G\r\n");
void (*kernel_start)(int, int, uint32_t) = (void *)LINUX_LOADADDR;
kernel_start(0, TS72XX_MACH_NUM, ATAGS_OFFSET);
return 0;
}
